mt-lang 0.2.0 → 0.2.2

data/std/raymath.mt

@@ -0,0 +1,153 @@
+# generated by mtc imported-bindings from std.c.raymath using bindings/imported/raymath.binding.json
+
+import std.c.raymath as c
+import std.c.raylib as rl
+
+public const EPSILON: float = c.EPSILON
+
+public foreign function clamp(value: float, min: float, max: float) -> float = c.Clamp
+public foreign function lerp(start: float, end: float, amount: float) -> float = c.Lerp
+public foreign function normalize(value: float, start: float, end: float) -> float = c.Normalize
+public foreign function remap(value: float, input_start: float, input_end: float, output_start: float, output_end: float) -> float = c.Remap
+public foreign function wrap(value: float, min: float, max: float) -> float = c.Wrap
+public foreign function float_equals(x: float, y: float) -> int = c.FloatEquals
+public foreign function vector2_zero() -> rl.Vector2 = c.Vector2Zero
+public foreign function vector2_one() -> rl.Vector2 = c.Vector2One
+public foreign function vector2_add(v1: rl.Vector2, v2: rl.Vector2) -> rl.Vector2 = c.Vector2Add
+public foreign function vector2_add_value(v: rl.Vector2, add: float) -> rl.Vector2 = c.Vector2AddValue
+public foreign function vector2_subtract(v1: rl.Vector2, v2: rl.Vector2) -> rl.Vector2 = c.Vector2Subtract
+public foreign function vector2_subtract_value(v: rl.Vector2, sub: float) -> rl.Vector2 = c.Vector2SubtractValue
+public foreign function vector2_length(v: rl.Vector2) -> float = c.Vector2Length
+public foreign function vector2_length_sqr(v: rl.Vector2) -> float = c.Vector2LengthSqr
+public foreign function vector2_dot_product(v1: rl.Vector2, v2: rl.Vector2) -> float = c.Vector2DotProduct
+public foreign function vector2_cross_product(v1: rl.Vector2, v2: rl.Vector2) -> float = c.Vector2CrossProduct
+public foreign function vector2_distance(v1: rl.Vector2, v2: rl.Vector2) -> float = c.Vector2Distance
+public foreign function vector2_distance_sqr(v1: rl.Vector2, v2: rl.Vector2) -> float = c.Vector2DistanceSqr
+public foreign function vector2_angle(v1: rl.Vector2, v2: rl.Vector2) -> float = c.Vector2Angle
+public foreign function vector2_line_angle(start: rl.Vector2, end: rl.Vector2) -> float = c.Vector2LineAngle
+public foreign function vector2_scale(v: rl.Vector2, scale: float) -> rl.Vector2 = c.Vector2Scale
+public foreign function vector2_multiply(v1: rl.Vector2, v2: rl.Vector2) -> rl.Vector2 = c.Vector2Multiply
+public foreign function vector2_negate(v: rl.Vector2) -> rl.Vector2 = c.Vector2Negate
+public foreign function vector2_divide(v1: rl.Vector2, v2: rl.Vector2) -> rl.Vector2 = c.Vector2Divide
+public foreign function vector2_normalize(v: rl.Vector2) -> rl.Vector2 = c.Vector2Normalize
+public foreign function vector2_transform(v: rl.Vector2, mat: rl.Matrix) -> rl.Vector2 = c.Vector2Transform
+public foreign function vector2_lerp(v1: rl.Vector2, v2: rl.Vector2, amount: float) -> rl.Vector2 = c.Vector2Lerp
+public foreign function vector2_reflect(v: rl.Vector2, normal: rl.Vector2) -> rl.Vector2 = c.Vector2Reflect
+public foreign function vector2_min(v1: rl.Vector2, v2: rl.Vector2) -> rl.Vector2 = c.Vector2Min
+public foreign function vector2_max(v1: rl.Vector2, v2: rl.Vector2) -> rl.Vector2 = c.Vector2Max
+public foreign function vector2_rotate(v: rl.Vector2, angle: float) -> rl.Vector2 = c.Vector2Rotate
+public foreign function vector2_move_towards(v: rl.Vector2, target: rl.Vector2, max_distance: float) -> rl.Vector2 = c.Vector2MoveTowards
+public foreign function vector2_invert(v: rl.Vector2) -> rl.Vector2 = c.Vector2Invert
+public foreign function vector2_clamp(v: rl.Vector2, min: rl.Vector2, max: rl.Vector2) -> rl.Vector2 = c.Vector2Clamp
+public foreign function vector2_clamp_value(v: rl.Vector2, min: float, max: float) -> rl.Vector2 = c.Vector2ClampValue
+public foreign function vector2_equals(p: rl.Vector2, q: rl.Vector2) -> int = c.Vector2Equals
+public foreign function vector2_refract(v: rl.Vector2, n: rl.Vector2, r: float) -> rl.Vector2 = c.Vector2Refract
+public foreign function vector3_zero() -> rl.Vector3 = c.Vector3Zero
+public foreign function vector3_one() -> rl.Vector3 = c.Vector3One
+public foreign function vector3_add(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Add
+public foreign function vector3_add_value(v: rl.Vector3, add: float) -> rl.Vector3 = c.Vector3AddValue
+public foreign function vector3_subtract(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Subtract
+public foreign function vector3_subtract_value(v: rl.Vector3, sub: float) -> rl.Vector3 = c.Vector3SubtractValue
+public foreign function vector3_scale(v: rl.Vector3, scalar: float) -> rl.Vector3 = c.Vector3Scale
+public foreign function vector3_multiply(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Multiply
+public foreign function vector3_cross_product(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3CrossProduct
+public foreign function vector3_perpendicular(v: rl.Vector3) -> rl.Vector3 = c.Vector3Perpendicular
+public foreign function vector3_length(v: rl.Vector3) -> float = c.Vector3Length
+public foreign function vector3_length_sqr(v: rl.Vector3) -> float = c.Vector3LengthSqr
+public foreign function vector3_dot_product(v1: rl.Vector3, v2: rl.Vector3) -> float = c.Vector3DotProduct
+public foreign function vector3_distance(v1: rl.Vector3, v2: rl.Vector3) -> float = c.Vector3Distance
+public foreign function vector3_distance_sqr(v1: rl.Vector3, v2: rl.Vector3) -> float = c.Vector3DistanceSqr
+public foreign function vector3_angle(v1: rl.Vector3, v2: rl.Vector3) -> float = c.Vector3Angle
+public foreign function vector3_negate(v: rl.Vector3) -> rl.Vector3 = c.Vector3Negate
+public foreign function vector3_divide(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Divide
+public foreign function vector3_normalize(v: rl.Vector3) -> rl.Vector3 = c.Vector3Normalize
+public foreign function vector3_project(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Project
+public foreign function vector3_reject(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Reject
+public foreign function vector3_ortho_normalize(inout v1: rl.Vector3, inout v2: rl.Vector3) -> void = c.Vector3OrthoNormalize
+public foreign function vector3_transform(v: rl.Vector3, mat: rl.Matrix) -> rl.Vector3 = c.Vector3Transform
+public foreign function vector3_rotate_by_quaternion(v: rl.Vector3, q: rl.Vector4) -> rl.Vector3 = c.Vector3RotateByQuaternion
+public foreign function vector3_rotate_by_axis_angle(v: rl.Vector3, axis: rl.Vector3, angle: float) -> rl.Vector3 = c.Vector3RotateByAxisAngle
+public foreign function vector3_move_towards(v: rl.Vector3, target: rl.Vector3, max_distance: float) -> rl.Vector3 = c.Vector3MoveTowards
+public foreign function vector3_lerp(v1: rl.Vector3, v2: rl.Vector3, amount: float) -> rl.Vector3 = c.Vector3Lerp
+public foreign function vector3_cubic_hermite(v1: rl.Vector3, tangent1: rl.Vector3, v2: rl.Vector3, tangent2: rl.Vector3, amount: float) -> rl.Vector3 = c.Vector3CubicHermite
+public foreign function vector3_reflect(v: rl.Vector3, normal: rl.Vector3) -> rl.Vector3 = c.Vector3Reflect
+public foreign function vector3_min(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Min
+public foreign function vector3_max(v1: rl.Vector3, v2: rl.Vector3) -> rl.Vector3 = c.Vector3Max
+public foreign function vector3_barycenter(p: rl.Vector3, a: rl.Vector3, b: rl.Vector3, c: rl.Vector3) -> rl.Vector3 = c.Vector3Barycenter
+public foreign function vector3_unproject(source: rl.Vector3, projection: rl.Matrix, view: rl.Matrix) -> rl.Vector3 = c.Vector3Unproject
+public foreign function vector3_to_float_v(v: rl.Vector3) -> array[float, 3] = c.Vector3ToFloatV(v).v
+public foreign function vector3_invert(v: rl.Vector3) -> rl.Vector3 = c.Vector3Invert
+public foreign function vector3_clamp(v: rl.Vector3, min: rl.Vector3, max: rl.Vector3) -> rl.Vector3 = c.Vector3Clamp
+public foreign function vector3_clamp_value(v: rl.Vector3, min: float, max: float) -> rl.Vector3 = c.Vector3ClampValue
+public foreign function vector3_equals(p: rl.Vector3, q: rl.Vector3) -> int = c.Vector3Equals
+public foreign function vector3_refract(v: rl.Vector3, n: rl.Vector3, r: float) -> rl.Vector3 = c.Vector3Refract
+public foreign function vector4_zero() -> rl.Vector4 = c.Vector4Zero
+public foreign function vector4_one() -> rl.Vector4 = c.Vector4One
+public foreign function vector4_add(v1: rl.Vector4, v2: rl.Vector4) -> rl.Vector4 = c.Vector4Add
+public foreign function vector4_add_value(v: rl.Vector4, add: float) -> rl.Vector4 = c.Vector4AddValue
+public foreign function vector4_subtract(v1: rl.Vector4, v2: rl.Vector4) -> rl.Vector4 = c.Vector4Subtract
+public foreign function vector4_subtract_value(v: rl.Vector4, add: float) -> rl.Vector4 = c.Vector4SubtractValue
+public foreign function vector4_length(v: rl.Vector4) -> float = c.Vector4Length
+public foreign function vector4_length_sqr(v: rl.Vector4) -> float = c.Vector4LengthSqr
+public foreign function vector4_dot_product(v1: rl.Vector4, v2: rl.Vector4) -> float = c.Vector4DotProduct
+public foreign function vector4_distance(v1: rl.Vector4, v2: rl.Vector4) -> float = c.Vector4Distance
+public foreign function vector4_distance_sqr(v1: rl.Vector4, v2: rl.Vector4) -> float = c.Vector4DistanceSqr
+public foreign function vector4_scale(v: rl.Vector4, scale: float) -> rl.Vector4 = c.Vector4Scale
+public foreign function vector4_multiply(v1: rl.Vector4, v2: rl.Vector4) -> rl.Vector4 = c.Vector4Multiply
+public foreign function vector4_negate(v: rl.Vector4) -> rl.Vector4 = c.Vector4Negate
+public foreign function vector4_divide(v1: rl.Vector4, v2: rl.Vector4) -> rl.Vector4 = c.Vector4Divide
+public foreign function vector4_normalize(v: rl.Vector4) -> rl.Vector4 = c.Vector4Normalize
+public foreign function vector4_min(v1: rl.Vector4, v2: rl.Vector4) -> rl.Vector4 = c.Vector4Min
+public foreign function vector4_max(v1: rl.Vector4, v2: rl.Vector4) -> rl.Vector4 = c.Vector4Max
+public foreign function vector4_lerp(v1: rl.Vector4, v2: rl.Vector4, amount: float) -> rl.Vector4 = c.Vector4Lerp
+public foreign function vector4_move_towards(v: rl.Vector4, target: rl.Vector4, max_distance: float) -> rl.Vector4 = c.Vector4MoveTowards
+public foreign function vector4_invert(v: rl.Vector4) -> rl.Vector4 = c.Vector4Invert
+public foreign function vector4_equals(p: rl.Vector4, q: rl.Vector4) -> int = c.Vector4Equals
+public foreign function matrix_determinant(mat: rl.Matrix) -> float = c.MatrixDeterminant
+public foreign function matrix_trace(mat: rl.Matrix) -> float = c.MatrixTrace
+public foreign function matrix_transpose(mat: rl.Matrix) -> rl.Matrix = c.MatrixTranspose
+public foreign function matrix_invert(mat: rl.Matrix) -> rl.Matrix = c.MatrixInvert
+public foreign function matrix_identity() -> rl.Matrix = c.MatrixIdentity
+public foreign function matrix_add(left: rl.Matrix, right: rl.Matrix) -> rl.Matrix = c.MatrixAdd
+public foreign function matrix_subtract(left: rl.Matrix, right: rl.Matrix) -> rl.Matrix = c.MatrixSubtract
+public foreign function matrix_multiply(left: rl.Matrix, right: rl.Matrix) -> rl.Matrix = c.MatrixMultiply
+public foreign function matrix_multiply_value(left: rl.Matrix, value: float) -> rl.Matrix = c.MatrixMultiplyValue
+public foreign function matrix_translate(x: float, y: float, z: float) -> rl.Matrix = c.MatrixTranslate
+public foreign function matrix_rotate(axis: rl.Vector3, angle: float) -> rl.Matrix = c.MatrixRotate
+public foreign function matrix_rotate_x(angle: float) -> rl.Matrix = c.MatrixRotateX
+public foreign function matrix_rotate_y(angle: float) -> rl.Matrix = c.MatrixRotateY
+public foreign function matrix_rotate_z(angle: float) -> rl.Matrix = c.MatrixRotateZ
+public foreign function matrix_rotate_xyz(angle: rl.Vector3) -> rl.Matrix = c.MatrixRotateXYZ
+public foreign function matrix_rotate_zyx(angle: rl.Vector3) -> rl.Matrix = c.MatrixRotateZYX
+public foreign function matrix_scale(x: float, y: float, z: float) -> rl.Matrix = c.MatrixScale
+public foreign function matrix_frustum(left: double, right: double, bottom: double, top: double, near_plane: double, far_plane: double) -> rl.Matrix = c.MatrixFrustum
+public foreign function matrix_perspective(fov_y: double, aspect: double, near_plane: double, far_plane: double) -> rl.Matrix = c.MatrixPerspective
+public foreign function matrix_ortho(left: double, right: double, bottom: double, top: double, near_plane: double, far_plane: double) -> rl.Matrix = c.MatrixOrtho
+public foreign function matrix_look_at(eye: rl.Vector3, target: rl.Vector3, up: rl.Vector3) -> rl.Matrix = c.MatrixLookAt
+public foreign function matrix_to_float_v(mat: rl.Matrix) -> array[float, 16] = c.MatrixToFloatV(mat).v
+public foreign function quaternion_add(q1: rl.Vector4, q2: rl.Vector4) -> rl.Quaternion = c.QuaternionAdd
+public foreign function quaternion_add_value(q: rl.Vector4, add: float) -> rl.Quaternion = c.QuaternionAddValue
+public foreign function quaternion_subtract(q1: rl.Vector4, q2: rl.Vector4) -> rl.Quaternion = c.QuaternionSubtract
+public foreign function quaternion_subtract_value(q: rl.Vector4, sub: float) -> rl.Quaternion = c.QuaternionSubtractValue
+public foreign function quaternion_identity() -> rl.Quaternion = c.QuaternionIdentity
+public foreign function quaternion_length(q: rl.Vector4) -> float = c.QuaternionLength
+public foreign function quaternion_normalize(q: rl.Vector4) -> rl.Quaternion = c.QuaternionNormalize
+public foreign function quaternion_invert(q: rl.Vector4) -> rl.Quaternion = c.QuaternionInvert
+public foreign function quaternion_multiply(q1: rl.Vector4, q2: rl.Vector4) -> rl.Quaternion = c.QuaternionMultiply
+public foreign function quaternion_scale(q: rl.Vector4, mul: float) -> rl.Quaternion = c.QuaternionScale
+public foreign function quaternion_divide(q1: rl.Vector4, q2: rl.Vector4) -> rl.Quaternion = c.QuaternionDivide
+public foreign function quaternion_lerp(q1: rl.Vector4, q2: rl.Vector4, amount: float) -> rl.Quaternion = c.QuaternionLerp
+public foreign function quaternion_nlerp(q1: rl.Vector4, q2: rl.Vector4, amount: float) -> rl.Quaternion = c.QuaternionNlerp
+public foreign function quaternion_slerp(q1: rl.Vector4, q2: rl.Vector4, amount: float) -> rl.Quaternion = c.QuaternionSlerp
+public foreign function quaternion_cubic_hermite_spline(q1: rl.Vector4, out_tangent1: rl.Vector4, q2: rl.Vector4, in_tangent2: rl.Vector4, t: float) -> rl.Quaternion = c.QuaternionCubicHermiteSpline
+public foreign function quaternion_from_vector3_to_vector3(from: rl.Vector3, to: rl.Vector3) -> rl.Quaternion = c.QuaternionFromVector3ToVector3
+public foreign function quaternion_from_matrix(mat: rl.Matrix) -> rl.Quaternion = c.QuaternionFromMatrix
+public foreign function quaternion_to_matrix(q: rl.Vector4) -> rl.Matrix = c.QuaternionToMatrix
+public foreign function quaternion_from_axis_angle(axis: rl.Vector3, angle: float) -> rl.Quaternion = c.QuaternionFromAxisAngle
+public foreign function quaternion_to_axis_angle(q: rl.Quaternion, out axis: rl.Vector3, out angle: float) -> void = c.QuaternionToAxisAngle
+public foreign function quaternion_from_euler(pitch: float, yaw: float, roll: float) -> rl.Quaternion = c.QuaternionFromEuler
+public foreign function quaternion_to_euler(q: rl.Vector4) -> rl.Vector3 = c.QuaternionToEuler
+public foreign function quaternion_transform(q: rl.Vector4, mat: rl.Matrix) -> rl.Quaternion = c.QuaternionTransform
+public foreign function quaternion_equals(p: rl.Vector4, q: rl.Vector4) -> int = c.QuaternionEquals
+public foreign function matrix_compose(translation: rl.Vector3, rotation: rl.Vector4, scale: rl.Vector3) -> rl.Matrix = c.MatrixCompose
+public foreign function matrix_decompose(mat: rl.Matrix, out translation: rl.Vector3, out rotation: rl.Quaternion, out scale: rl.Vector3) -> void = c.MatrixDecompose

data/std/result.mt

@@ -0,0 +1,89 @@
+# Standard library: Result type
+#
+# Result[T, E] represents a fallible computation:
+# either Success(T) or Failure(E).
+# Imported automatically as part of the language prelude.
+
+import std.option
+
+public variant Result[T, E]:
+    success(value: T)
+    failure(error: E)
+
+extending Result[T, E]:
+    public function is_success() -> bool:
+        match this:
+            Result.success:
+                return true
+            Result.failure:
+                return false
+
+    public function is_failure() -> bool:
+        match this:
+            Result.success:
+                return false
+            Result.failure:
+                return true
+
+    public function unwrap() -> T:
+        match this:
+            Result.success as payload:
+                return payload.value
+            Result.failure:
+                fatal(c"called Result.unwrap on a failure value")
+
+    public function expect(msg: str) -> T:
+        match this:
+            Result.success as payload:
+                return payload.value
+            Result.failure:
+                fatal(msg)
+
+    public function unwrap_error() -> E:
+        match this:
+            Result.success:
+                fatal(c"called Result.unwrap_error on a success value")
+            Result.failure as payload:
+                return payload.error
+
+    public function expect_error(msg: str) -> E:
+        match this:
+            Result.success:
+                fatal(msg)
+            Result.failure as payload:
+                return payload.error
+
+    public function unwrap_or(default: T) -> T:
+        match this:
+            Result.success as payload:
+                return payload.value
+            Result.failure:
+                return default
+
+    public function unwrap_or_else(f: proc(error: E) -> T) -> T:
+        match this:
+            Result.success as payload:
+                return payload.value
+            Result.failure as payload:
+                return f(error=payload.error)
+
+    public function map_error[F](f: proc(error: E) -> F) -> Result[T, F]:
+        match this:
+            Result.success as payload:
+                return Result[T, F].success(value = payload.value)
+            Result.failure as payload:
+                return Result[T, F].failure(error = f(payload.error))
+
+    public function ok() -> Option[T]:
+        match this:
+            Result.success as payload:
+                return Option[T].some(value = payload.value)
+            Result.failure:
+                return Option[T].none
+
+    public function error() -> Option[E]:
+        match this:
+            Result.success:
+                return Option[E].none
+            Result.failure as payload:
+                return Option[E].some(value = payload.error)

data/std/rlgl.mt

@@ -0,0 +1,268 @@
+# generated by mtc imported-bindings from std.c.rlgl using bindings/imported/rlgl.binding.json
+
+import std.c.rlgl as c
+
+public type Matrix = c.Matrix
+public type VertexBuffer = c.rlVertexBuffer
+public type DrawCall = c.rlDrawCall
+public type RenderBatch = c.rlRenderBatch
+public type GlVersion = c.rlGlVersion
+public type TraceLogLevel = c.rlTraceLogLevel
+public type PixelFormat = c.rlPixelFormat
+public type TextureFilter = c.rlTextureFilter
+public type BlendMode = c.rlBlendMode
+public type ShaderLocationIndex = c.rlShaderLocationIndex
+public type ShaderUniformDataType = c.rlShaderUniformDataType
+public type ShaderAttributeDataType = c.rlShaderAttributeDataType
+public type FramebufferAttachType = c.rlFramebufferAttachType
+public type FramebufferAttachTextureType = c.rlFramebufferAttachTextureType
+public type CullMode = c.rlCullMode
+
+public const RL_DEFAULT_BATCH_BUFFER_ELEMENTS: int = c.RL_DEFAULT_BATCH_BUFFER_ELEMENTS
+public const RL_DEFAULT_BATCH_BUFFERS: int = c.RL_DEFAULT_BATCH_BUFFERS
+public const RL_DEFAULT_BATCH_DRAWCALLS: int = c.RL_DEFAULT_BATCH_DRAWCALLS
+public const RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS: int = c.RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS
+public const RL_MAX_MATRIX_STACK_SIZE: int = c.RL_MAX_MATRIX_STACK_SIZE
+public const RL_MAX_SHADER_LOCATIONS: int = c.RL_MAX_SHADER_LOCATIONS
+public const RL_CULL_DISTANCE_NEAR: double = c.RL_CULL_DISTANCE_NEAR
+public const RL_CULL_DISTANCE_FAR: double = c.RL_CULL_DISTANCE_FAR
+public const RL_TEXTURE_WRAP_S: int = c.RL_TEXTURE_WRAP_S
+public const RL_TEXTURE_WRAP_T: int = c.RL_TEXTURE_WRAP_T
+public const RL_TEXTURE_MAG_FILTER: int = c.RL_TEXTURE_MAG_FILTER
+public const RL_TEXTURE_MIN_FILTER: int = c.RL_TEXTURE_MIN_FILTER
+public const RL_TEXTURE_FILTER_NEAREST: int = c.RL_TEXTURE_FILTER_NEAREST
+public const RL_TEXTURE_FILTER_LINEAR: int = c.RL_TEXTURE_FILTER_LINEAR
+public const RL_TEXTURE_FILTER_MIP_NEAREST: int = c.RL_TEXTURE_FILTER_MIP_NEAREST
+public const RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR: int = c.RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR
+public const RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST: int = c.RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST
+public const RL_TEXTURE_FILTER_MIP_LINEAR: int = c.RL_TEXTURE_FILTER_MIP_LINEAR
+public const RL_TEXTURE_FILTER_ANISOTROPIC: int = c.RL_TEXTURE_FILTER_ANISOTROPIC
+public const RL_TEXTURE_MIPMAP_BIAS_RATIO: int = c.RL_TEXTURE_MIPMAP_BIAS_RATIO
+public const RL_TEXTURE_WRAP_REPEAT: int = c.RL_TEXTURE_WRAP_REPEAT
+public const RL_TEXTURE_WRAP_CLAMP: int = c.RL_TEXTURE_WRAP_CLAMP
+public const RL_TEXTURE_WRAP_MIRROR_REPEAT: int = c.RL_TEXTURE_WRAP_MIRROR_REPEAT
+public const RL_TEXTURE_WRAP_MIRROR_CLAMP: int = c.RL_TEXTURE_WRAP_MIRROR_CLAMP
+public const RL_MODELVIEW: int = c.RL_MODELVIEW
+public const RL_PROJECTION: int = c.RL_PROJECTION
+public const RL_TEXTURE: int = c.RL_TEXTURE
+public const RL_LINES: int = c.RL_LINES
+public const RL_TRIANGLES: int = c.RL_TRIANGLES
+public const RL_QUADS: int = c.RL_QUADS
+public const RL_UNSIGNED_BYTE: int = c.RL_UNSIGNED_BYTE
+public const RL_FLOAT: int = c.RL_FLOAT
+public const RL_STREAM_DRAW: int = c.RL_STREAM_DRAW
+public const RL_STREAM_READ: int = c.RL_STREAM_READ
+public const RL_STREAM_COPY: int = c.RL_STREAM_COPY
+public const RL_STATIC_DRAW: int = c.RL_STATIC_DRAW
+public const RL_STATIC_READ: int = c.RL_STATIC_READ
+public const RL_STATIC_COPY: int = c.RL_STATIC_COPY
+public const RL_DYNAMIC_DRAW: int = c.RL_DYNAMIC_DRAW
+public const RL_DYNAMIC_READ: int = c.RL_DYNAMIC_READ
+public const RL_DYNAMIC_COPY: int = c.RL_DYNAMIC_COPY
+public const RL_FRAGMENT_SHADER: int = c.RL_FRAGMENT_SHADER
+public const RL_VERTEX_SHADER: int = c.RL_VERTEX_SHADER
+public const RL_COMPUTE_SHADER: int = c.RL_COMPUTE_SHADER
+public const RL_ZERO: int = c.RL_ZERO
+public const RL_ONE: int = c.RL_ONE
+public const RL_SRC_COLOR: int = c.RL_SRC_COLOR
+public const RL_ONE_MINUS_SRC_COLOR: int = c.RL_ONE_MINUS_SRC_COLOR
+public const RL_SRC_ALPHA: int = c.RL_SRC_ALPHA
+public const RL_ONE_MINUS_SRC_ALPHA: int = c.RL_ONE_MINUS_SRC_ALPHA
+public const RL_DST_ALPHA: int = c.RL_DST_ALPHA
+public const RL_ONE_MINUS_DST_ALPHA: int = c.RL_ONE_MINUS_DST_ALPHA
+public const RL_DST_COLOR: int = c.RL_DST_COLOR
+public const RL_ONE_MINUS_DST_COLOR: int = c.RL_ONE_MINUS_DST_COLOR
+public const RL_SRC_ALPHA_SATURATE: int = c.RL_SRC_ALPHA_SATURATE
+public const RL_CONSTANT_COLOR: int = c.RL_CONSTANT_COLOR
+public const RL_ONE_MINUS_CONSTANT_COLOR: int = c.RL_ONE_MINUS_CONSTANT_COLOR
+public const RL_CONSTANT_ALPHA: int = c.RL_CONSTANT_ALPHA
+public const RL_ONE_MINUS_CONSTANT_ALPHA: int = c.RL_ONE_MINUS_CONSTANT_ALPHA
+public const RL_FUNC_ADD: int = c.RL_FUNC_ADD
+public const RL_MIN: int = c.RL_MIN
+public const RL_MAX: int = c.RL_MAX
+public const RL_FUNC_SUBTRACT: int = c.RL_FUNC_SUBTRACT
+public const RL_FUNC_REVERSE_SUBTRACT: int = c.RL_FUNC_REVERSE_SUBTRACT
+public const RL_BLEND_EQUATION: int = c.RL_BLEND_EQUATION
+public const RL_BLEND_EQUATION_RGB: int = c.RL_BLEND_EQUATION_RGB
+public const RL_BLEND_EQUATION_ALPHA: int = c.RL_BLEND_EQUATION_ALPHA
+public const RL_BLEND_DST_RGB: int = c.RL_BLEND_DST_RGB
+public const RL_BLEND_SRC_RGB: int = c.RL_BLEND_SRC_RGB
+public const RL_BLEND_DST_ALPHA: int = c.RL_BLEND_DST_ALPHA
+public const RL_BLEND_SRC_ALPHA: int = c.RL_BLEND_SRC_ALPHA
+public const RL_BLEND_COLOR: int = c.RL_BLEND_COLOR
+public const RL_READ_FRAMEBUFFER: int = c.RL_READ_FRAMEBUFFER
+public const RL_DRAW_FRAMEBUFFER: int = c.RL_DRAW_FRAMEBUFFER
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
+public const RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM: int = c.RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
+
+public foreign function matrix_mode(mode: int) -> void = c.rlMatrixMode
+public foreign function push_matrix() -> void = c.rlPushMatrix
+public foreign function pop_matrix() -> void = c.rlPopMatrix
+public foreign function load_identity() -> void = c.rlLoadIdentity
+public foreign function translatef(x: float, y: float, z: float) -> void = c.rlTranslatef
+public foreign function rotatef(angle: float, x: float, y: float, z: float) -> void = c.rlRotatef
+public foreign function scalef(x: float, y: float, z: float) -> void = c.rlScalef
+public foreign function mult_matrixf(matf: const_ptr[float]) -> void = c.rlMultMatrixf
+public foreign function frustum(left: double, right: double, bottom: double, top: double, znear: double, zfar: double) -> void = c.rlFrustum
+public foreign function ortho(left: double, right: double, bottom: double, top: double, znear: double, zfar: double) -> void = c.rlOrtho
+public foreign function viewport(x: int, y: int, width: int, height: int) -> void = c.rlViewport
+public foreign function set_clip_planes(near_plane: double, far_plane: double) -> void = c.rlSetClipPlanes
+public foreign function get_cull_distance_near() -> double = c.rlGetCullDistanceNear
+public foreign function get_cull_distance_far() -> double = c.rlGetCullDistanceFar
+public foreign function begin(mode: int) -> void = c.rlBegin
+public foreign function end() -> void = c.rlEnd
+public foreign function vertex2i(x: int, y: int) -> void = c.rlVertex2i
+public foreign function vertex2f(x: float, y: float) -> void = c.rlVertex2f
+public foreign function vertex3f(x: float, y: float, z: float) -> void = c.rlVertex3f
+public foreign function tex_coord2f(x: float, y: float) -> void = c.rlTexCoord2f
+public foreign function normal3f(x: float, y: float, z: float) -> void = c.rlNormal3f
+public foreign function color4ub(r: ubyte, g: ubyte, b: ubyte, a: ubyte) -> void = c.rlColor4ub
+public foreign function color3f(x: float, y: float, z: float) -> void = c.rlColor3f
+public foreign function color4f(x: float, y: float, z: float, w: float) -> void = c.rlColor4f
+public foreign function enable_vertex_array(vao_id: uint) -> bool = c.rlEnableVertexArray
+public foreign function disable_vertex_array() -> void = c.rlDisableVertexArray
+public foreign function enable_vertex_buffer(id: uint) -> void = c.rlEnableVertexBuffer
+public foreign function disable_vertex_buffer() -> void = c.rlDisableVertexBuffer
+public foreign function enable_vertex_buffer_element(id: uint) -> void = c.rlEnableVertexBufferElement
+public foreign function disable_vertex_buffer_element() -> void = c.rlDisableVertexBufferElement
+public foreign function enable_vertex_attribute(index: uint) -> void = c.rlEnableVertexAttribute
+public foreign function disable_vertex_attribute(index: uint) -> void = c.rlDisableVertexAttribute
+public foreign function enable_state_pointer(vertex_attrib_type: int, buffer: ptr[void]) -> void = c.rlEnableStatePointer
+public foreign function disable_state_pointer(vertex_attrib_type: int) -> void = c.rlDisableStatePointer
+public foreign function active_texture_slot(slot: int) -> void = c.rlActiveTextureSlot
+public foreign function enable_texture(id: uint) -> void = c.rlEnableTexture
+public foreign function disable_texture() -> void = c.rlDisableTexture
+public foreign function enable_texture_cubemap(id: uint) -> void = c.rlEnableTextureCubemap
+public foreign function disable_texture_cubemap() -> void = c.rlDisableTextureCubemap
+public foreign function texture_parameters(id: uint, param: int, value: int) -> void = c.rlTextureParameters
+public foreign function cubemap_parameters(id: uint, param: int, value: int) -> void = c.rlCubemapParameters
+public foreign function enable_shader(id: uint) -> void = c.rlEnableShader
+public foreign function disable_shader() -> void = c.rlDisableShader
+public foreign function enable_framebuffer(id: uint) -> void = c.rlEnableFramebuffer
+public foreign function disable_framebuffer() -> void = c.rlDisableFramebuffer
+public foreign function get_active_framebuffer() -> uint = c.rlGetActiveFramebuffer
+public foreign function active_draw_buffers(count: int) -> void = c.rlActiveDrawBuffers
+public foreign function blit_framebuffer(src_x: int, src_y: int, src_width: int, src_height: int, dst_x: int, dst_y: int, dst_width: int, dst_height: int, buffer_mask: int) -> void = c.rlBlitFramebuffer
+public foreign function bind_framebuffer(target: uint, framebuffer: uint) -> void = c.rlBindFramebuffer
+public foreign function enable_color_blend() -> void = c.rlEnableColorBlend
+public foreign function disable_color_blend() -> void = c.rlDisableColorBlend
+public foreign function enable_depth_test() -> void = c.rlEnableDepthTest
+public foreign function disable_depth_test() -> void = c.rlDisableDepthTest
+public foreign function enable_depth_mask() -> void = c.rlEnableDepthMask
+public foreign function disable_depth_mask() -> void = c.rlDisableDepthMask
+public foreign function enable_backface_culling() -> void = c.rlEnableBackfaceCulling
+public foreign function disable_backface_culling() -> void = c.rlDisableBackfaceCulling
+public foreign function color_mask(r: bool, g: bool, b: bool, a: bool) -> void = c.rlColorMask
+public foreign function set_cull_face(mode: int) -> void = c.rlSetCullFace
+public foreign function enable_scissor_test() -> void = c.rlEnableScissorTest
+public foreign function disable_scissor_test() -> void = c.rlDisableScissorTest
+public foreign function scissor(x: int, y: int, width: int, height: int) -> void = c.rlScissor
+public foreign function enable_point_mode() -> void = c.rlEnablePointMode
+public foreign function disable_point_mode() -> void = c.rlDisablePointMode
+public foreign function set_point_size(size: float) -> void = c.rlSetPointSize
+public foreign function get_point_size() -> float = c.rlGetPointSize
+public foreign function enable_wire_mode() -> void = c.rlEnableWireMode
+public foreign function disable_wire_mode() -> void = c.rlDisableWireMode
+public foreign function set_line_width(width: float) -> void = c.rlSetLineWidth
+public foreign function get_line_width() -> float = c.rlGetLineWidth
+public foreign function enable_smooth_lines() -> void = c.rlEnableSmoothLines
+public foreign function disable_smooth_lines() -> void = c.rlDisableSmoothLines
+public foreign function enable_stereo_render() -> void = c.rlEnableStereoRender
+public foreign function disable_stereo_render() -> void = c.rlDisableStereoRender
+public foreign function is_stereo_render_enabled() -> bool = c.rlIsStereoRenderEnabled
+public foreign function clear_color(r: ubyte, g: ubyte, b: ubyte, a: ubyte) -> void = c.rlClearColor
+public foreign function clear_screen_buffers() -> void = c.rlClearScreenBuffers
+public foreign function check_errors() -> void = c.rlCheckErrors
+public foreign function set_blend_mode(mode: int) -> void = c.rlSetBlendMode
+public foreign function set_blend_factors(gl_src_factor: int, gl_dst_factor: int, gl_equation: int) -> void = c.rlSetBlendFactors
+public foreign function set_blend_factors_separate(gl_src_rgb: int, gl_dst_rgb: int, gl_src_alpha: int, gl_dst_alpha: int, gl_eq_rgb: int, gl_eq_alpha: int) -> void = c.rlSetBlendFactorsSeparate
+public foreign function gl_init(width: int, height: int) -> void = c.rlglInit
+public foreign function gl_close() -> void = c.rlglClose
+public foreign function load_extensions(loader: ptr[void]) -> void = c.rlLoadExtensions
+public foreign function get_proc_address(proc_name: str as cstr) -> ptr[void]? = c.rlGetProcAddress
+public foreign function get_version() -> int = c.rlGetVersion
+public foreign function set_framebuffer_width(width: int) -> void = c.rlSetFramebufferWidth
+public foreign function get_framebuffer_width() -> int = c.rlGetFramebufferWidth
+public foreign function set_framebuffer_height(height: int) -> void = c.rlSetFramebufferHeight
+public foreign function get_framebuffer_height() -> int = c.rlGetFramebufferHeight
+public foreign function get_texture_id_default() -> uint = c.rlGetTextureIdDefault
+public foreign function get_shader_id_default() -> uint = c.rlGetShaderIdDefault
+public foreign function get_shader_locs_default() -> ptr[int] = c.rlGetShaderLocsDefault
+public foreign function load_render_batch(num_buffers: int, buffer_elements: int) -> RenderBatch = c.rlLoadRenderBatch
+public foreign function unload_render_batch(batch: RenderBatch) -> void = c.rlUnloadRenderBatch
+public foreign function draw_render_batch(batch: ptr[RenderBatch]) -> void = c.rlDrawRenderBatch
+public foreign function set_render_batch_active(batch: ptr[RenderBatch]?) -> void = c.rlSetRenderBatchActive
+public foreign function draw_render_batch_active() -> void = c.rlDrawRenderBatchActive
+public foreign function check_render_batch_limit(v_count: int) -> bool = c.rlCheckRenderBatchLimit
+public foreign function set_texture(id: uint) -> void = c.rlSetTexture
+public foreign function load_vertex_array() -> uint = c.rlLoadVertexArray
+public foreign function load_vertex_buffer[T](buffer: ptr[T] as const_ptr[void], size: int, dynamic: bool) -> uint = c.rlLoadVertexBuffer
+public foreign function load_vertex_buffer_element[T](buffer: ptr[T] as const_ptr[void], size: int, dynamic: bool) -> uint = c.rlLoadVertexBufferElement
+public foreign function update_vertex_buffer[T](buffer_id: uint, data: ptr[T] as const_ptr[void], data_size: int, offset: int) -> void = c.rlUpdateVertexBuffer
+public foreign function update_vertex_buffer_elements[T](id: uint, data: ptr[T] as const_ptr[void], data_size: int, offset: int) -> void = c.rlUpdateVertexBufferElements
+public foreign function unload_vertex_array(vao_id: uint) -> void = c.rlUnloadVertexArray
+public foreign function unload_vertex_buffer(vbo_id: uint) -> void = c.rlUnloadVertexBuffer
+public foreign function set_vertex_attribute(index: uint, comp_size: int, type_: int, normalized: bool, stride: int, offset: int) -> void = c.rlSetVertexAttribute
+public foreign function set_vertex_attribute_divisor(index: uint, divisor: int) -> void = c.rlSetVertexAttributeDivisor
+public foreign function set_vertex_attribute_default[T](loc_index: int, value: ptr[T] as const_ptr[void], attrib_type: int, count: int) -> void = c.rlSetVertexAttributeDefault
+public foreign function draw_vertex_array(offset: int, count: int) -> void = c.rlDrawVertexArray
+public foreign function draw_vertex_array_elements(offset: int, count: int, buffer: const_ptr[void]) -> void = c.rlDrawVertexArrayElements
+public foreign function draw_vertex_array_instanced(offset: int, count: int, instances: int) -> void = c.rlDrawVertexArrayInstanced
+public foreign function draw_vertex_array_elements_instanced(offset: int, count: int, buffer: const_ptr[void], instances: int) -> void = c.rlDrawVertexArrayElementsInstanced
+public foreign function load_texture(data: const_ptr[void]?, width: int, height: int, format: int, mipmap_count: int) -> uint = c.rlLoadTexture
+public foreign function load_texture_depth(width: int, height: int, use_render_buffer: bool) -> uint = c.rlLoadTextureDepth
+public foreign function load_texture_cubemap(data: const_ptr[void]?, size: int, format: int, mipmap_count: int) -> uint = c.rlLoadTextureCubemap
+public foreign function update_texture[T](id: uint, offset_x: int, offset_y: int, width: int, height: int, format: int, data: ptr[T] as const_ptr[void]) -> void = c.rlUpdateTexture
+public foreign function get_gl_texture_formats(format: int, out gl_internal_format: uint, out gl_format: uint, out gl_type: uint) -> void = c.rlGetGlTextureFormats
+public foreign function get_pixel_format_name(format: uint) -> cstr = c.rlGetPixelFormatName
+public foreign function unload_texture(id: uint) -> void = c.rlUnloadTexture
+public foreign function gen_texture_mipmaps(id: uint, width: int, height: int, format: int, out mipmaps: int) -> void = c.rlGenTextureMipmaps
+public foreign function read_texture_pixels(id: uint, width: int, height: int, format: int) -> ptr[void] = c.rlReadTexturePixels
+public foreign function read_screen_pixels(width: int, height: int) -> ptr[ubyte] = c.rlReadScreenPixels
+public foreign function load_framebuffer() -> uint = c.rlLoadFramebuffer
+public foreign function framebuffer_attach(id: uint, tex_id: uint, attach_type: int, tex_type: int, mip_level: int) -> void = c.rlFramebufferAttach
+public foreign function framebuffer_complete(id: uint) -> bool = c.rlFramebufferComplete
+public foreign function unload_framebuffer(id: uint) -> void = c.rlUnloadFramebuffer
+public foreign function copy_framebuffer(x: int, y: int, width: int, height: int, format: int, pixels: ptr[void]) -> void = c.rlCopyFramebuffer
+public foreign function resize_framebuffer(width: int, height: int) -> void = c.rlResizeFramebuffer
+public foreign function load_shader(code: str as cstr, type_: int) -> uint = c.rlLoadShader
+public foreign function load_shader_program(vs_code: cstr?, fs_code: cstr?) -> uint = c.rlLoadShaderProgram
+public foreign function load_shader_program_ex(vs_id: uint, fs_id: uint) -> uint = c.rlLoadShaderProgramEx
+public foreign function load_shader_program_compute(cs_id: uint) -> uint = c.rlLoadShaderProgramCompute
+public foreign function unload_shader(id: uint) -> void = c.rlUnloadShader
+public foreign function unload_shader_program(id: uint) -> void = c.rlUnloadShaderProgram
+public foreign function get_location_uniform(id: uint, uniform_name: str as cstr) -> int = c.rlGetLocationUniform
+public foreign function get_location_attrib(id: uint, attrib_name: str as cstr) -> int = c.rlGetLocationAttrib
+public foreign function set_uniform[T](loc_index: int, value: ptr[T] as const_ptr[void], uniform_type: int, count: int) -> void = c.rlSetUniform
+public foreign function set_uniform_matrix(loc_index: int, mat: Matrix) -> void = c.rlSetUniformMatrix
+public foreign function set_uniform_matrices(loc_index: int, mat: const_ptr[Matrix], count: int) -> void = c.rlSetUniformMatrices
+public foreign function set_uniform_sampler(loc_index: int, texture_id: uint) -> void = c.rlSetUniformSampler
+public foreign function set_shader(id: uint, locs: ptr[int]) -> void = c.rlSetShader
+public foreign function compute_shader_dispatch(group_x: uint, group_y: uint, group_z: uint) -> void = c.rlComputeShaderDispatch
+public foreign function load_shader_buffer(size: uint, data: const_ptr[void]?, usage_hint: int) -> uint = c.rlLoadShaderBuffer
+public foreign function unload_shader_buffer(ssbo_id: uint) -> void = c.rlUnloadShaderBuffer
+public foreign function update_shader_buffer[T](id: uint, data: ptr[T] as const_ptr[void], data_size: uint, offset: uint) -> void = c.rlUpdateShaderBuffer
+public foreign function bind_shader_buffer(id: uint, index: uint) -> void = c.rlBindShaderBuffer
+public foreign function read_shader_buffer[T](id: uint, dest: ptr[T] as ptr[void], count: uint, offset: uint) -> void = c.rlReadShaderBuffer
+public foreign function copy_shader_buffer(dest_id: uint, src_id: uint, dest_offset: uint, src_offset: uint, count: uint) -> void = c.rlCopyShaderBuffer
+public foreign function get_shader_buffer_size(id: uint) -> uint = c.rlGetShaderBufferSize
+public foreign function bind_image_texture(id: uint, index: uint, format: int, readonly: bool) -> void = c.rlBindImageTexture
+public foreign function get_matrix_modelview() -> Matrix = c.rlGetMatrixModelview
+public foreign function get_matrix_projection() -> Matrix = c.rlGetMatrixProjection
+public foreign function get_matrix_transform() -> Matrix = c.rlGetMatrixTransform
+public foreign function get_matrix_projection_stereo(eye: int) -> Matrix = c.rlGetMatrixProjectionStereo
+public foreign function get_matrix_view_offset_stereo(eye: int) -> Matrix = c.rlGetMatrixViewOffsetStereo
+public foreign function set_matrix_projection(proj: Matrix) -> void = c.rlSetMatrixProjection
+public foreign function set_matrix_modelview(view: Matrix) -> void = c.rlSetMatrixModelview
+public foreign function set_matrix_projection_stereo(right: Matrix, left: Matrix) -> void = c.rlSetMatrixProjectionStereo
+public foreign function set_matrix_view_offset_stereo(right: Matrix, left: Matrix) -> void = c.rlSetMatrixViewOffsetStereo
+public foreign function load_draw_cube() -> void = c.rlLoadDrawCube
+public foreign function load_draw_quad() -> void = c.rlLoadDrawQuad

data/std/rpng.mt

@@ -0,0 +1,46 @@
+# generated by mtc imported-bindings from std.c.rpng using bindings/imported/rpng.binding.json
+
+import std.c.rpng as c
+
+public type chunk = c.rpng_chunk
+public type color = c.rpng_color
+public type palette = c.rpng_palette
+
+public const MAX_CHUNKS_COUNT: int = c.RPNG_MAX_CHUNKS_COUNT
+public const SUCCESS: int = c.RPNG_SUCCESS
+public const ERROR_FILE_OPEN: int = c.RPNG_ERROR_FILE_OPEN
+public const ERROR_PIXEL_FORMAT: int = c.RPNG_ERROR_PIXEL_FORMAT
+public const ERROR_MEMORY_ALLOC: int = c.RPNG_ERROR_MEMORY_ALLOC
+
+public foreign function load_image(filename: cstr, width: ptr[int], height: ptr[int], color_channels: ptr[int], bit_depth: ptr[int]) -> ptr[char]? = c.rpng_load_image
+public foreign function load_image_indexed(filename: cstr, width: ptr[int], height: ptr[int], palette: ptr[palette]) -> ptr[char]? = c.rpng_load_image_indexed
+public foreign function save_image(filename: str as cstr, data: str as cstr, width: int, height: int, color_channels: int, bit_depth: int) -> int = c.rpng_save_image
+public foreign function save_image_indexed(filename: str as cstr, indexed_data: str as cstr, width: int, height: int, palette: palette) -> int = c.rpng_save_image_indexed
+public foreign function load_image_from_memory(buffer: cstr, width: ptr[int], height: ptr[int], color_channels: ptr[int], bit_depth: ptr[int]) -> ptr[char]? = c.rpng_load_image_from_memory
+public foreign function load_image_indexed_from_memory(buffer: cstr, width: ptr[int], height: ptr[int], palette: ptr[palette]) -> ptr[char]? = c.rpng_load_image_indexed_from_memory
+public foreign function save_image_to_memory(data: cstr, width: int, height: int, color_channels: int, bit_depth: int, output_size: ptr[int]) -> ptr[char]? = c.rpng_save_image_to_memory
+public foreign function save_image_indexed_to_memory(indexed_data: cstr, width: int, height: int, palette: palette, output_size: ptr[int]) -> ptr[char]? = c.rpng_save_image_indexed_to_memory
+public foreign function chunk_count(filename: str as cstr) -> int = c.rpng_chunk_count
+public foreign function chunk_read(filename: str as cstr, chunk_type: str as cstr) -> chunk = c.rpng_chunk_read
+public foreign function chunk_read_all(filename: cstr, count: ptr[int]) -> ptr[chunk]? = c.rpng_chunk_read_all
+public foreign function chunk_remove(filename: str as cstr, chunk_type: str as cstr) -> void = c.rpng_chunk_remove
+public foreign function chunk_remove_ancillary(filename: str as cstr) -> void = c.rpng_chunk_remove_ancillary
+public foreign function chunk_write(filename: str as cstr, data: chunk) -> void = c.rpng_chunk_write
+public foreign function chunk_write_text(filename: str as cstr, keyword: ptr[char], text: ptr[char]) -> void = c.rpng_chunk_write_text
+public foreign function chunk_write_comp_text(filename: str as cstr, keyword: ptr[char], text: ptr[char]) -> void = c.rpng_chunk_write_comp_text
+public foreign function chunk_write_gamma(filename: str as cstr, gamma: float) -> void = c.rpng_chunk_write_gamma
+public foreign function chunk_write_srgb(filename: str as cstr, srgb_type: char) -> void = c.rpng_chunk_write_srgb
+public foreign function chunk_write_time(filename: str as cstr, year: short, month: char, day: char, hour: char, min: char, sec: char) -> void = c.rpng_chunk_write_time
+public foreign function chunk_write_physical_size(filename: str as cstr, pixels_unit_x: int, pixels_unit_y: int, meters: bool) -> void = c.rpng_chunk_write_physical_size
+public foreign function chunk_write_chroma(filename: str as cstr, white_x: float, white_y: float, red_x: float, red_y: float, green_x: float, green_y: float, blue_x: float, blue_y: float) -> void = c.rpng_chunk_write_chroma
+public foreign function chunk_check_all_valid(filename: str as cstr) -> bool = c.rpng_chunk_check_all_valid
+public foreign function chunk_combine_image_data(filename: str as cstr) -> void = c.rpng_chunk_combine_image_data
+public foreign function chunk_split_image_data(filename: str as cstr, split_size: int) -> void = c.rpng_chunk_split_image_data
+public foreign function chunk_count_from_memory(buffer: str as cstr) -> int = c.rpng_chunk_count_from_memory
+public foreign function chunk_read_from_memory(buffer: str as cstr, chunk_type: str as cstr) -> chunk = c.rpng_chunk_read_from_memory
+public foreign function chunk_read_all_from_memory(buffer: cstr, count: ptr[int]) -> ptr[chunk]? = c.rpng_chunk_read_all_from_memory
+public foreign function chunk_remove_from_memory(buffer: cstr, chunk_type: cstr, output_size: ptr[int]) -> ptr[char]? = c.rpng_chunk_remove_from_memory
+public foreign function chunk_remove_ancillary_from_memory(buffer: cstr, output_size: ptr[int]) -> ptr[char]? = c.rpng_chunk_remove_ancillary_from_memory
+public foreign function chunk_write_from_memory(buffer: cstr, chunk: chunk, output_size: ptr[int]) -> ptr[char]? = c.rpng_chunk_write_from_memory
+public foreign function chunk_combine_image_data_from_memory(buffer: ptr[char], output_size: ptr[int]) -> ptr[char]? = c.rpng_chunk_combine_image_data_from_memory
+public foreign function chunk_split_image_data_from_memory(buffer: ptr[char], split_size: int, output_size: ptr[int]) -> ptr[char]? = c.rpng_chunk_split_image_data_from_memory

data/std/rres.mt

@@ -0,0 +1,36 @@
+# generated by mtc imported-bindings from std.c.rres using bindings/imported/rres.binding.json
+
+import std.c.rres as c
+
+public type FileHeader = c.rresFileHeader
+public type ResourceChunkInfo = c.rresResourceChunkInfo
+public type ResourceChunkData = c.rresResourceChunkData
+public type ResourceChunk = c.rresResourceChunk
+public type ResourceMulti = c.rresResourceMulti
+public type DirEntry = c.rresDirEntry
+public type CentralDir = c.rresCentralDir
+public type FontGlyphInfo = c.rresFontGlyphInfo
+public type ResourceDataType = c.rresResourceDataType
+public type CompressionType = c.rresCompressionType
+public type EncryptionType = c.rresEncryptionType
+public type ErrorType = c.rresErrorType
+public type TextEncoding = c.rresTextEncoding
+public type CodeLang = c.rresCodeLang
+public type PixelFormat = c.rresPixelFormat
+public type VertexAttribute = c.rresVertexAttribute
+public type VertexFormat = c.rresVertexFormat
+public type FontStyle = c.rresFontStyle
+
+public foreign function load_resource_chunk(file_name: str as cstr, rres_id: int) -> ResourceChunk = c.rresLoadResourceChunk
+public foreign function unload_resource_chunk(chunk: ResourceChunk) -> void = c.rresUnloadResourceChunk
+public foreign function load_resource_multi(file_name: str as cstr, rres_id: int) -> ResourceMulti = c.rresLoadResourceMulti
+public foreign function unload_resource_multi(multi: ResourceMulti) -> void = c.rresUnloadResourceMulti
+public foreign function load_resource_chunk_info(file_name: str as cstr, rres_id: int) -> ResourceChunkInfo = c.rresLoadResourceChunkInfo
+public foreign function load_resource_chunk_info_all(file_name: str as cstr, chunk_count: ptr[uint]) -> ptr[ResourceChunkInfo]? = c.rresLoadResourceChunkInfoAll
+public foreign function load_central_directory(file_name: str as cstr) -> CentralDir = c.rresLoadCentralDirectory
+public foreign function unload_central_directory(dir: CentralDir) -> void = c.rresUnloadCentralDirectory
+public foreign function get_data_type(four_cc: const_ptr[ubyte]) -> uint = c.rresGetDataType
+public foreign function get_resource_id(dir: CentralDir, file_name: str as cstr) -> int = c.rresGetResourceId
+public foreign function compute_crc32(data: ptr[ubyte], len: int) -> uint = c.rresComputeCRC32
+public foreign function set_cipher_password(password: str as cstr) -> void = c.rresSetCipherPassword
+public foreign function get_cipher_password() -> cstr? = c.rresGetCipherPassword