12172 lines
288 KiB
Zig
12172 lines
288 KiB
Zig
const std = @import("std");
|
|
const raylib = @cImport({
|
|
@cInclude("raylib.h");
|
|
|
|
@cDefine("GRAPHICS_API_OPENGL_11", {});
|
|
// @cDefine("RLGL_IMPLEMENTATION", {});
|
|
@cInclude("rlgl.h");
|
|
|
|
@cDefine("RAYMATH_IMPLEMENTATION", {});
|
|
@cInclude("raymath.h");
|
|
|
|
@cInclude("marshal.h");
|
|
});
|
|
|
|
//--- structs -------------------------------------------------------------------------------------
|
|
|
|
/// System/Window config flags
|
|
pub const ConfigFlags = packed struct(u32) {
|
|
FLAG_UNKNOWN_1: bool = false, // 0x0001
|
|
/// Set to run program in fullscreen
|
|
FLAG_FULLSCREEN_MODE: bool = false, // 0x0002,
|
|
/// Set to allow resizable window
|
|
FLAG_WINDOW_RESIZABLE: bool = false, // 0x0004,
|
|
/// Set to disable window decoration (frame and buttons)
|
|
FLAG_WINDOW_UNDECORATED: bool = false, // 0x0008,
|
|
/// Set to allow transparent framebuffer
|
|
FLAG_WINDOW_TRANSPARENT: bool = false, // 0x0010,
|
|
/// Set to try enabling MSAA 4X
|
|
FLAG_MSAA_4X_HINT: bool = false, // 0x0020,
|
|
/// Set to try enabling V-Sync on GPU
|
|
FLAG_VSYNC_HINT: bool = false, // 0x0040,
|
|
/// Set to hide window
|
|
FLAG_WINDOW_HIDDEN: bool = false, // 0x0080,
|
|
/// Set to allow windows running while minimized
|
|
FLAG_WINDOW_ALWAYS_RUN: bool = false, // 0x0100,
|
|
/// Set to minimize window (iconify)
|
|
FLAG_WINDOW_MINIMIZED: bool = false, // 0x0200,
|
|
/// Set to maximize window (expanded to monitor)
|
|
FLAG_WINDOW_MAXIMIZED: bool = false, // 0x0400,
|
|
/// Set to window non focused
|
|
FLAG_WINDOW_UNFOCUSED: bool = false, // 0x0800,
|
|
/// Set to window always on top
|
|
FLAG_WINDOW_TOPMOST: bool = false, // 0x1000,
|
|
/// Set to support HighDPI
|
|
FLAG_WINDOW_HIGHDPI: bool = false, // 0x2000,
|
|
/// Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED
|
|
FLAG_WINDOW_MOUSE_PASSTHROUGH: bool = false, // 0x4000,
|
|
FLAG_UNKNOWN_2: bool = false, // 0x8000
|
|
/// Set to try enabling interlaced video format (for V3D)
|
|
FLAG_INTERLACED_HINT: bool = false, // 0x10000
|
|
FLAG_PADDING: u15 = 0, // 0xFFFE0000
|
|
};
|
|
|
|
/// Transform, vectex transformation data
|
|
pub const Transform = extern struct {
|
|
/// Translation
|
|
translation: Vector3,
|
|
/// Rotation
|
|
rotation: Vector4,
|
|
/// Scale
|
|
scale: Vector3,
|
|
};
|
|
|
|
/// Matrix, 4x4 components, column major, OpenGL style, right handed
|
|
pub const Matrix = extern struct {
|
|
/// Matrix first row (4 components) [m0, m4, m8, m12]
|
|
m0: f32,
|
|
m4: f32,
|
|
m8: f32,
|
|
m12: f32,
|
|
/// Matrix second row (4 components) [m1, m5, m9, m13]
|
|
m1: f32,
|
|
m5: f32,
|
|
m9: f32,
|
|
m13: f32,
|
|
/// Matrix third row (4 components) [m2, m6, m10, m14]
|
|
m2: f32,
|
|
m6: f32,
|
|
m10: f32,
|
|
m14: f32,
|
|
/// Matrix fourth row (4 components) [m3, m7, m11, m15]
|
|
m3: f32,
|
|
m7: f32,
|
|
m11: f32,
|
|
m15: f32,
|
|
|
|
pub fn zero() @This() {
|
|
return @This(){
|
|
.m0 = 0,
|
|
.m1 = 0,
|
|
.m2 = 0,
|
|
.m3 = 0,
|
|
.m4 = 0,
|
|
.m5 = 0,
|
|
.m6 = 0,
|
|
.m7 = 0,
|
|
.m8 = 0,
|
|
.m9 = 0,
|
|
.m10 = 0,
|
|
.m11 = 0,
|
|
.m12 = 0,
|
|
.m13 = 0,
|
|
.m14 = 0,
|
|
.m15 = 0,
|
|
};
|
|
}
|
|
|
|
pub fn identity() @This() {
|
|
return MatrixIdentity();
|
|
}
|
|
};
|
|
|
|
pub const Rectangle = extern struct {
|
|
x: f32 = 0,
|
|
y: f32 = 0,
|
|
width: f32 = 0,
|
|
height: f32 = 0,
|
|
|
|
pub fn toI32(self: @This()) RectangleI {
|
|
return .{
|
|
.x = @as(i32, @intFromFloat(self.x)),
|
|
.y = @as(i32, @intFromFloat(self.y)),
|
|
.width = @as(i32, @intFromFloat(self.width)),
|
|
.height = @as(i32, @intFromFloat(self.height)),
|
|
};
|
|
}
|
|
|
|
pub fn pos(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x,
|
|
.y = self.y,
|
|
};
|
|
}
|
|
|
|
pub fn size(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.width,
|
|
.y = self.height,
|
|
};
|
|
}
|
|
|
|
pub fn topLeft(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x,
|
|
.y = self.y,
|
|
};
|
|
}
|
|
|
|
pub fn topCenter(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + self.width / 2,
|
|
.y = self.y,
|
|
};
|
|
}
|
|
|
|
pub fn topRight(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + self.width,
|
|
.y = self.y,
|
|
};
|
|
}
|
|
|
|
pub fn centerLeft(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x,
|
|
.y = self.y + self.height / 2,
|
|
};
|
|
}
|
|
|
|
pub fn center(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + self.width / 2,
|
|
.y = self.y + self.height / 2,
|
|
};
|
|
}
|
|
|
|
pub fn centerRight(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + self.width,
|
|
.y = self.y + self.height / 2,
|
|
};
|
|
}
|
|
|
|
pub fn bottomLeft(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + 0,
|
|
.y = self.y + self.height,
|
|
};
|
|
}
|
|
|
|
pub fn bottomCenter(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + self.width / 2,
|
|
.y = self.y + self.height,
|
|
};
|
|
}
|
|
|
|
pub fn bottomRight(self: @This()) Vector2 {
|
|
return .{
|
|
.x = self.x + self.width,
|
|
.y = self.y + self.height,
|
|
};
|
|
}
|
|
|
|
pub fn area(self: @This()) f32 {
|
|
return self.width * self.height;
|
|
}
|
|
|
|
pub fn include(self: @This(), other: @This()) @This() {
|
|
return self.includePoint(other.topLeft()).includePoint(other.bottomRight());
|
|
}
|
|
|
|
pub fn includePoint(self: @This(), point: Vector2) @This() {
|
|
const minX = @min(self.x, point.x);
|
|
const minY = @min(self.y, point.y);
|
|
const maxX = @max(self.x + self.width, point.x);
|
|
const maxY = @max(self.y + self.height, point.y);
|
|
|
|
return .{
|
|
.x = minX,
|
|
.y = minY,
|
|
.width = maxX - minX,
|
|
.height = maxY - minY,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const RectangleI = extern struct {
|
|
x: i32 = 0,
|
|
y: i32 = 0,
|
|
width: i32 = 0,
|
|
height: i32 = 0,
|
|
|
|
pub fn toF32(self: @This()) Rectangle {
|
|
return .{
|
|
.x = @as(f32, @floatFromInt(self.x)),
|
|
.y = @as(f32, @floatFromInt(self.y)),
|
|
.width = @as(f32, @floatFromInt(self.width)),
|
|
.height = @as(f32, @floatFromInt(self.height)),
|
|
};
|
|
}
|
|
|
|
pub fn pos(self: @This()) Vector2i {
|
|
return .{
|
|
.x = self.x,
|
|
.y = self.y,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Vector2 = extern struct {
|
|
x: f32 = 0,
|
|
y: f32 = 0,
|
|
|
|
pub fn zero() @This() {
|
|
return .{ .x = 0, .y = 0 };
|
|
}
|
|
|
|
pub fn setZero(self: *@This()) void {
|
|
self.x = 0;
|
|
self.y = 0;
|
|
}
|
|
|
|
pub fn one() @This() {
|
|
return @This(){ .x = 1, .y = 1 };
|
|
}
|
|
|
|
pub fn neg(self: @This()) @This() {
|
|
return @This(){ .x = -self.x, .y = -self.y };
|
|
}
|
|
|
|
pub fn length2(self: @This()) f32 {
|
|
var sum = self.x * self.x;
|
|
sum += self.y * self.y;
|
|
return sum;
|
|
}
|
|
|
|
pub fn length(self: @This()) f32 {
|
|
return std.math.sqrt(self.length2());
|
|
}
|
|
|
|
pub fn distanceTo(self: @This(), other: @This()) f32 {
|
|
return self.sub(other).length();
|
|
}
|
|
|
|
pub fn distanceToSquared(self: @This(), other: @This()) f32 {
|
|
return self.sub(other).length2();
|
|
}
|
|
|
|
pub fn normalize(self: @This()) @This() {
|
|
const l = self.length();
|
|
if (l == 0.0) return @This().zero();
|
|
return self.scale(1.0 / l);
|
|
}
|
|
|
|
pub fn scale(self: @This(), factor: f32) @This() {
|
|
return @This(){
|
|
.x = self.x * factor,
|
|
.y = self.y * factor,
|
|
};
|
|
}
|
|
|
|
pub fn add(self: @This(), other: @This()) @This() {
|
|
return @This(){
|
|
.x = self.x + other.x,
|
|
.y = self.y + other.y,
|
|
};
|
|
}
|
|
|
|
/// same as add but assign result directly to this
|
|
pub fn addSet(self: *@This(), other: @This()) void {
|
|
self.x += other.x;
|
|
self.y += other.y;
|
|
}
|
|
|
|
pub fn sub(self: @This(), other: @This()) @This() {
|
|
return @This(){
|
|
.x = self.x - other.x,
|
|
.y = self.y - other.y,
|
|
};
|
|
}
|
|
|
|
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
|
return self.scale(1 - t).add(other.scale(t));
|
|
}
|
|
|
|
pub fn randomInUnitCircle(rng: std.rand.Random) @This() {
|
|
return randomOnUnitCircle(rng).scale(randomF32(rng, 0, 1));
|
|
}
|
|
|
|
pub fn randomOnUnitCircle(rng: std.rand.Random) @This() {
|
|
return (Vector2{ .x = 1 }).rotate(randomF32(rng, -PI, PI));
|
|
}
|
|
|
|
pub fn clampX(self: @This(), minX: f32, maxX: f32) @This() {
|
|
return .{
|
|
.x = std.math.clamp(self.x, minX, maxX),
|
|
.y = self.y,
|
|
};
|
|
}
|
|
pub fn clampY(self: @This(), minY: f32, maxY: f32) @This() {
|
|
return .{
|
|
.x = self.x,
|
|
.y = std.math.clamp(self.y, minY, maxY),
|
|
};
|
|
}
|
|
|
|
pub fn int(self: @This()) Vector2i {
|
|
return .{ .x = @as(i32, @intFromFloat(self.x)), .y = @as(i32, @intFromFloat(self.y)) };
|
|
}
|
|
|
|
/// Cross product
|
|
pub fn cross(self: @This(), other: @This()) f32 {
|
|
return self.x * other.y - self.y * other.x;
|
|
}
|
|
|
|
/// Dot product.
|
|
pub fn dot(self: @This(), other: @This()) f32 {
|
|
return self.x * other.x + self.y * other.y;
|
|
}
|
|
|
|
pub fn rotate(self: @This(), a: f32) @This() {
|
|
return Vector2Rotate(self, a);
|
|
}
|
|
|
|
pub fn fromAngle(a: f32) @This() {
|
|
return Vector2Rotate(.{ .x = 1 }, a);
|
|
}
|
|
|
|
pub fn angle(this: @This()) f32 {
|
|
const zeroRotation: Vector2 = .{ .x = 1, .y = 0 };
|
|
if (this.x == zeroRotation.x and this.y == zeroRotation.y) return 0;
|
|
|
|
const c = zeroRotation.cross(this);
|
|
const d = zeroRotation.dot(this);
|
|
return std.math.atan2(f32, c, d);
|
|
}
|
|
|
|
pub fn xy0(self: @This()) Vector3 {
|
|
return .{ .x = self.x, .y = self.y };
|
|
}
|
|
|
|
pub fn x0z(self: @This()) Vector3 {
|
|
return .{ .x = self.x, .z = self.y };
|
|
}
|
|
|
|
pub fn set(self: @This(), setter: struct { x: ?f32 = null, y: ?f32 = null }) Vector2 {
|
|
var copy = self;
|
|
if (setter.x) |x| copy.x = x;
|
|
if (setter.y) |y| copy.y = y;
|
|
return copy;
|
|
}
|
|
};
|
|
|
|
pub const Vector2i = extern struct {
|
|
x: i32 = 0,
|
|
y: i32 = 0,
|
|
|
|
pub fn float(self: @This()) Vector2 {
|
|
return .{ .x = @as(f32, @floatFromInt(self.x)), .y = @as(f32, @floatFromInt(self.y)) };
|
|
}
|
|
};
|
|
|
|
pub const Vector3 = extern struct {
|
|
x: f32 = 0,
|
|
y: f32 = 0,
|
|
z: f32 = 0,
|
|
|
|
pub fn new(x: f32, y: f32, z: f32) @This() {
|
|
return @This(){ .x = x, .y = y, .z = z };
|
|
}
|
|
|
|
pub fn zero() @This() {
|
|
return @This(){ .x = 0, .y = 0, .z = 0 };
|
|
}
|
|
|
|
pub fn one() @This() {
|
|
return @This(){ .x = 1, .y = 1, .z = 1 };
|
|
}
|
|
|
|
pub fn length2(self: @This()) f32 {
|
|
var sum = self.x * self.x;
|
|
sum += self.y * self.y;
|
|
sum += self.z * self.z;
|
|
return sum;
|
|
}
|
|
|
|
pub fn length(self: @This()) f32 {
|
|
return std.math.sqrt(self.length2());
|
|
}
|
|
|
|
pub fn normalize(self: @This()) @This() {
|
|
const l = self.length();
|
|
if (l == 0.0) return @This().zero();
|
|
return self.scale(1.0 / l);
|
|
}
|
|
|
|
pub fn scale(self: @This(), factor: f32) @This() {
|
|
return @This(){
|
|
.x = self.x * factor,
|
|
.y = self.y * factor,
|
|
.z = self.z * factor,
|
|
};
|
|
}
|
|
|
|
pub fn add(self: @This(), other: @This()) @This() {
|
|
return @This(){
|
|
.x = self.x + other.x,
|
|
.y = self.y + other.y,
|
|
.z = self.z + other.z,
|
|
};
|
|
}
|
|
pub fn sub(self: @This(), other: @This()) @This() {
|
|
return @This(){
|
|
.x = self.x - other.x,
|
|
.y = self.y - other.y,
|
|
.z = self.z - other.z,
|
|
};
|
|
}
|
|
|
|
pub fn neg(this: @This()) @This() {
|
|
return .{
|
|
.x = -this.x,
|
|
.y = -this.y,
|
|
.z = -this.z,
|
|
};
|
|
}
|
|
|
|
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
|
return self.scale(1 - t).add(other.scale(t));
|
|
}
|
|
|
|
pub fn forward() @This() {
|
|
return @This().new(0, 0, 1);
|
|
}
|
|
|
|
pub fn rotate(self: @This(), quaternion: Vector4) @This() {
|
|
return Vector3RotateByQuaternion(self, quaternion);
|
|
}
|
|
|
|
pub fn angleBetween(self: @This(), other: Vector3) f32 {
|
|
return Vector3Angle(self, other);
|
|
// return std.math.acos(self.dot(other) / (self.length() * other.length()));
|
|
}
|
|
|
|
/// Dot product.
|
|
pub fn dot(self: @This(), other: @This()) f32 {
|
|
return self.x * other.x + self.y * other.y + self.z * other.z;
|
|
}
|
|
|
|
pub fn xy(self: @This()) Vector2 {
|
|
return .{ .x = self.x, .y = self.y };
|
|
}
|
|
|
|
pub fn set(self: @This(), setter: struct { x: ?f32 = null, y: ?f32 = null, z: ?f32 = null }) Vector3 {
|
|
var copy = self;
|
|
if (setter.x) |x| copy.x = x;
|
|
if (setter.y) |y| copy.y = y;
|
|
if (setter.z) |z| copy.z = z;
|
|
return copy;
|
|
}
|
|
};
|
|
|
|
pub const Vector4 = extern struct {
|
|
x: f32 = 0,
|
|
y: f32 = 0,
|
|
z: f32 = 0,
|
|
w: f32 = 0,
|
|
|
|
pub fn zero() @This() {
|
|
return @This(){ .x = 0, .y = 0, .z = 0 };
|
|
}
|
|
|
|
pub fn one() @This() {
|
|
return @This(){ .x = 1, .y = 1, .z = 1 };
|
|
}
|
|
|
|
pub fn length2(self: @This()) f32 {
|
|
var sum = self.x * self.x;
|
|
sum += self.y * self.y;
|
|
sum += self.z * self.z;
|
|
sum += self.w * self.w;
|
|
return sum;
|
|
}
|
|
|
|
pub fn length(self: @This()) f32 {
|
|
return std.math.sqrt(self.length2());
|
|
}
|
|
|
|
pub fn normalize(self: @This()) @This() {
|
|
const l = self.length();
|
|
if (l == 0.0) return @This().zero();
|
|
return self.scale(1.0 / l);
|
|
}
|
|
|
|
pub fn scale(self: @This(), factor: f32) @This() {
|
|
return @This(){
|
|
.x = self.x * factor,
|
|
.y = self.y * factor,
|
|
.z = self.z * factor,
|
|
.w = self.w * factor,
|
|
};
|
|
}
|
|
|
|
pub fn add(self: @This(), other: @This()) @This() {
|
|
return @This(){
|
|
.x = self.x + other.x,
|
|
.y = self.y + other.y,
|
|
.z = self.z + other.z,
|
|
.w = self.w + other.w,
|
|
};
|
|
}
|
|
pub fn sub(self: @This(), other: @This()) @This() {
|
|
return @This(){
|
|
.x = self.x - other.x,
|
|
.y = self.y - other.y,
|
|
.z = self.z - other.z,
|
|
.w = self.w - other.w,
|
|
};
|
|
}
|
|
|
|
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
|
return self.scale(1 - t).add(other.scale(t));
|
|
}
|
|
|
|
pub fn toColor(self: @This()) Color {
|
|
return .{
|
|
.r = @as(u8, @intFromFloat(std.math.clamp(self.x * 255, 0, 255))),
|
|
.g = @as(u8, @intFromFloat(std.math.clamp(self.y * 255, 0, 255))),
|
|
.b = @as(u8, @intFromFloat(std.math.clamp(self.z * 255, 0, 255))),
|
|
.a = @as(u8, @intFromFloat(std.math.clamp(self.w * 255, 0, 255))),
|
|
};
|
|
}
|
|
|
|
pub fn fromAngleAxis(axis: Vector3, angle: f32) @This() {
|
|
return QuaternionFromAxisAngle(axis, angle);
|
|
}
|
|
};
|
|
|
|
/// Color type, RGBA (32bit)
|
|
pub const Color = extern struct {
|
|
r: u8 = 0,
|
|
g: u8 = 0,
|
|
b: u8 = 0,
|
|
a: u8 = 255,
|
|
|
|
pub const ColorChangeConfig = struct {
|
|
r: ?u8 = null,
|
|
g: ?u8 = null,
|
|
b: ?u8 = null,
|
|
a: ?u8 = null,
|
|
};
|
|
|
|
pub fn set(self: @This(), c: ColorChangeConfig) Color {
|
|
return .{
|
|
.r = if (c.r) |_r| _r else self.r,
|
|
.g = if (c.g) |_g| _g else self.g,
|
|
.b = if (c.b) |_b| _b else self.b,
|
|
.a = if (c.a) |_a| _a else self.a,
|
|
};
|
|
}
|
|
|
|
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
|
return self.toVector4().lerp(other.toVector4(), t).toColor();
|
|
}
|
|
|
|
pub fn lerpA(self: @This(), targetAlpha: u8, t: f32) @This() {
|
|
var copy = self;
|
|
const a = @as(f32, @floatFromInt(self.a));
|
|
copy.a = @as(u8, @intFromFloat(a * (1 - t) + @as(f32, @floatFromInt(targetAlpha)) * t));
|
|
return copy;
|
|
}
|
|
|
|
pub fn toVector4(self: @This()) Vector4 {
|
|
return .{
|
|
.x = @as(f32, @floatFromInt(self.r)) / 255.0,
|
|
.y = @as(f32, @floatFromInt(self.g)) / 255.0,
|
|
.z = @as(f32, @floatFromInt(self.b)) / 255.0,
|
|
.w = @as(f32, @floatFromInt(self.a)) / 255.0,
|
|
};
|
|
}
|
|
|
|
/// negate color (keep alpha)
|
|
pub fn neg(self: @This()) @This() {
|
|
return .{
|
|
.r = 255 - self.r,
|
|
.g = 255 - self.g,
|
|
.b = 255 - self.b,
|
|
.a = self.a,
|
|
};
|
|
}
|
|
};
|
|
|
|
/// Camera2D, defines position/orientation in 2d space
|
|
pub const Camera2D = extern struct {
|
|
/// Camera offset (displacement from target)
|
|
offset: Vector2 = Vector2.zero(),
|
|
/// Camera target (rotation and zoom origin)
|
|
target: Vector2,
|
|
/// Camera rotation in degrees
|
|
rotation: f32 = 0,
|
|
/// Camera zoom (scaling), should be 1.0f by default
|
|
zoom: f32 = 1,
|
|
};
|
|
|
|
pub const MATERIAL_MAP_DIFFUSE = @as(usize, @intCast(@intFromEnum(MaterialMapIndex.MATERIAL_MAP_ALBEDO)));
|
|
pub const MATERIAL_MAP_SPECULAR = @as(usize, @intCast(@intFromEnum(MaterialMapIndex.MATERIAL_MAP_METALNESS)));
|
|
|
|
//--- callbacks -----------------------------------------------------------------------------------
|
|
|
|
/// Logging: Redirect trace log messages
|
|
pub const TraceLogCallback = *const fn (logLevel: c_int, text: [*c]const u8, args: ?*anyopaque) void;
|
|
|
|
/// FileIO: Load binary data
|
|
pub const LoadFileDataCallback = *const fn (fileName: [*c]const u8, bytesRead: [*c]c_uint) [*c]u8;
|
|
|
|
/// FileIO: Save binary data
|
|
pub const SaveFileDataCallback = *const fn (fileName: [*c]const u8, data: ?*anyopaque, bytesToWrite: c_uint) bool;
|
|
|
|
/// FileIO: Load text data
|
|
pub const LoadFileTextCallback = *const fn (fileName: [*c]const u8) [*c]u8;
|
|
|
|
/// FileIO: Save text data
|
|
pub const SaveFileTextCallback = *const fn (fileName: [*c]const u8, text: [*c]const u8) bool;
|
|
|
|
/// Audio Loading and Playing Functions (Module: audio)
|
|
pub const AudioCallback = *const fn (bufferData: ?*anyopaque, frames: u32) void;
|
|
|
|
//--- utils ---------------------------------------------------------------------------------------
|
|
|
|
// Camera global state context data [56 bytes]
|
|
pub const CameraData = extern struct {
|
|
/// Current camera mode
|
|
mode: u32,
|
|
/// Camera distance from position to target
|
|
targetDistance: f32,
|
|
/// Player eyes position from ground (in meters)
|
|
playerEyesPosition: f32,
|
|
/// Camera angle in plane XZ
|
|
angle: Vector2,
|
|
/// Previous mouse position
|
|
previousMousePosition: Vector2,
|
|
|
|
// Camera movement control keys
|
|
|
|
/// Move controls (CAMERA_FIRST_PERSON)
|
|
moveControl: i32[6],
|
|
/// Smooth zoom control key
|
|
smoothZoomControl: i32,
|
|
/// Alternative control key
|
|
altControl: i32,
|
|
/// Pan view control key
|
|
panControl: i32,
|
|
};
|
|
|
|
pub fn randomF32(rng: std.rand.Random, min: f32, max: f32) f32 {
|
|
return rng.float(f32) * (max - min) + min;
|
|
}
|
|
|
|
//--- functions -----------------------------------------------------------------------------------
|
|
|
|
/// Setup init configuration flags (view FLAGS)
|
|
pub fn SetConfigFlags(
|
|
flags: ConfigFlags,
|
|
) void {
|
|
raylib.SetConfigFlags(@as(c_uint, @bitCast(flags)));
|
|
}
|
|
|
|
/// Load file data as byte array (read)
|
|
pub fn LoadFileData(fileName: [*:0]const u8) ![]const u8 {
|
|
var bytesRead: u32 = undefined;
|
|
const data = raylib.LoadFileData(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
@as([*c]c_int, @ptrCast(&bytesRead)),
|
|
);
|
|
|
|
if (data == null) return error.FileNotFound;
|
|
|
|
return data[0..bytesRead];
|
|
}
|
|
|
|
/// Unload file data allocated by LoadFileData()
|
|
pub fn UnloadFileData(
|
|
data: []const u8,
|
|
) void {
|
|
raylib.UnloadFileData(
|
|
@as([*c]u8, @ptrFromInt(@intFromPtr(data.ptr))),
|
|
);
|
|
}
|
|
|
|
/// Set custom trace log
|
|
pub fn SetTraceLogCallback(
|
|
_: TraceLogCallback,
|
|
) void {
|
|
@panic("use log.zig for that");
|
|
}
|
|
|
|
/// Generate image font atlas using chars info
|
|
pub fn GenImageFontAtlas(
|
|
chars: [*]const GlyphInfo,
|
|
recs: [*]const [*]const Rectangle,
|
|
glyphCount: i32,
|
|
fontSize: i32,
|
|
padding: i32,
|
|
packMethod: i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
mGenImageFontAtlas(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]raylib.GlyphInfo, @ptrCast(chars)),
|
|
@as([*c][*c]raylib.Rectangle, @ptrCast(recs)),
|
|
glyphCount,
|
|
fontSize,
|
|
padding,
|
|
packMethod,
|
|
);
|
|
return out;
|
|
}
|
|
export fn mGenImageFontAtlas(
|
|
out: [*c]raylib.Image,
|
|
chars: [*c]raylib.GlyphInfo,
|
|
recs: [*c][*c]raylib.Rectangle,
|
|
glyphCount: i32,
|
|
fontSize: i32,
|
|
padding: i32,
|
|
packMethod: i32,
|
|
) void {
|
|
out.* = raylib.GenImageFontAtlas(
|
|
chars,
|
|
recs,
|
|
glyphCount,
|
|
fontSize,
|
|
padding,
|
|
packMethod,
|
|
);
|
|
}
|
|
|
|
/// Get native window handle
|
|
pub fn GetWindowHandle() ?*anyopaque {
|
|
return raylib.GetWindowHandle();
|
|
}
|
|
|
|
/// Internal memory allocator
|
|
pub fn MemAlloc(
|
|
size: i32,
|
|
) ?*anyopaque {
|
|
return raylib.MemAlloc(size);
|
|
}
|
|
|
|
/// Internal memory reallocator
|
|
pub fn MemRealloc(
|
|
ptr: ?*anyopaque,
|
|
size: i32,
|
|
) ?*anyopaque {
|
|
return raylib.MemRealloc(ptr, size);
|
|
}
|
|
|
|
/// Internal memory free
|
|
pub fn MemFree(
|
|
ptr: ?*anyopaque,
|
|
) void {
|
|
raylib.MemFree(ptr);
|
|
}
|
|
|
|
/// Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
|
|
pub fn TraceLog(
|
|
logLevel: i32,
|
|
text: [*:0]const u8,
|
|
) void {
|
|
raylib.TraceLog(logLevel, text);
|
|
}
|
|
|
|
/// Text formatting with variables (sprintf() style)
|
|
/// caller owns memory
|
|
pub fn TextFormat(allocator: std.mem.Allocator, comptime fmt: []const u8, args: anytype) std.fmt.AllocPrintError![*:0]const u8 {
|
|
return (try std.fmt.allocPrintZ(allocator, fmt, args)).ptr;
|
|
}
|
|
|
|
/// Split text into multiple strings
|
|
pub fn TextSplit(allocator: std.mem.Allocator, text: []const u8, delimiter: []const u8, count: i32) ![]const []const u8 {
|
|
var list = std.ArrayList([]const u8).init(allocator);
|
|
var it = std.mem.split(u8, text, delimiter);
|
|
var i = 0;
|
|
var n = 0;
|
|
while (it.next()) |slice| : (i += 1) {
|
|
if (i >= count) {
|
|
break;
|
|
}
|
|
|
|
try list.append(slice);
|
|
n += slice.len;
|
|
}
|
|
if (n < text.len) {
|
|
try list.append(text[n..]);
|
|
}
|
|
return list.toOwnedSlice();
|
|
}
|
|
|
|
/// Join text strings with delimiter
|
|
pub fn TextJoin(allocator: std.mem.Allocator, textList: []const []const u8, delimiter: []const u8) ![:0]const u8 {
|
|
return (try std.mem.joinZ(allocator, delimiter, textList)).ptr;
|
|
}
|
|
|
|
/// Append text at specific position and move cursor!
|
|
pub fn TextAppend(allocator: std.mem.Allocator, text: []const u8, append: []const u8, position: i32) std.fmt.AllocPrintError![:0]u8 {
|
|
return (try std.fmt.allocPrintZ(allocator, "{s}{s}{s}", .{
|
|
text[0..position],
|
|
append,
|
|
text[position..],
|
|
})).ptr;
|
|
}
|
|
|
|
//--- RLGL ----------------------------------------------------------------------------------------
|
|
|
|
pub const DEG2RAD: f32 = PI / 180;
|
|
pub const RAD2DEG: f32 = 180 / PI;
|
|
|
|
///
|
|
pub const rlglData = extern struct {
|
|
/// Current render batch
|
|
currentBatch: ?*rlRenderBatch,
|
|
/// Default internal render batch
|
|
defaultBatch: rlRenderBatch,
|
|
|
|
pub const State = extern struct {
|
|
/// Current active render batch vertex counter (generic, used for all batches)
|
|
vertexCounter: i32,
|
|
/// Current active texture coordinate X (added on glVertex*())
|
|
texcoordx: f32,
|
|
/// Current active texture coordinate Y (added on glVertex*())
|
|
texcoordy: f32,
|
|
/// Current active normal X (added on glVertex*())
|
|
normalx: f32,
|
|
/// Current active normal Y (added on glVertex*())
|
|
normaly: f32,
|
|
/// Current active normal Z (added on glVertex*())
|
|
normalz: f32,
|
|
/// Current active color R (added on glVertex*())
|
|
colorr: u8,
|
|
/// Current active color G (added on glVertex*())
|
|
colorg: u8,
|
|
/// Current active color B (added on glVertex*())
|
|
colorb: u8,
|
|
/// Current active color A (added on glVertex*())
|
|
colora: u8,
|
|
/// Current matrix mode
|
|
currentMatrixMode: i32,
|
|
/// Current matrix pointer
|
|
currentMatrix: ?*Matrix,
|
|
/// Default modelview matrix
|
|
modelview: Matrix,
|
|
/// Default projection matrix
|
|
projection: Matrix,
|
|
/// Transform matrix to be used with rlTranslate, rlRotate, rlScale
|
|
transform: Matrix,
|
|
/// Require transform matrix application to current draw-call vertex (if required)
|
|
transformRequired: bool,
|
|
/// Matrix stack for push/pop
|
|
stack: [RL_MAX_MATRIX_STACK_SIZE]Matrix,
|
|
/// Matrix stack counter
|
|
stackCounter: i32,
|
|
/// Default texture used on shapes/poly drawing (required by shader)
|
|
defaultTextureId: u32,
|
|
/// Active texture ids to be enabled on batch drawing (0 active by default)
|
|
activeTextureId: [RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]u32,
|
|
/// Default vertex shader id (used by default shader program)
|
|
defaultVShaderId: u32,
|
|
/// Default fragment shader id (used by default shader program)
|
|
defaultFShaderId: u32,
|
|
/// Default shader program id, supports vertex color and diffuse texture
|
|
defaultShaderId: u32,
|
|
/// Default shader locations pointer to be used on rendering
|
|
defaultShaderLocs: [*]i32,
|
|
/// Current shader id to be used on rendering (by default, defaultShaderId)
|
|
currentShaderId: u32,
|
|
/// Current shader locations pointer to be used on rendering (by default, defaultShaderLocs)
|
|
currentShaderLocs: [*]i32,
|
|
/// Stereo rendering flag
|
|
stereoRender: bool,
|
|
/// VR stereo rendering eyes projection matrices
|
|
projectionStereo: [2]Matrix,
|
|
/// VR stereo rendering eyes view offset matrices
|
|
viewOffsetStereo: [2]Matrix,
|
|
/// Blending mode active
|
|
currentBlendMode: i32,
|
|
/// Blending source factor
|
|
glBlendSrcFactor: i32,
|
|
/// Blending destination factor
|
|
glBlendDstFactor: i32,
|
|
/// Blending equation
|
|
glBlendEquation: i32,
|
|
/// Current framebuffer width
|
|
framebufferWidth: i32,
|
|
/// Current framebuffer height
|
|
framebufferHeight: i32,
|
|
};
|
|
|
|
pub const ExtSupported = extern struct {
|
|
/// VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object)
|
|
vao: bool,
|
|
/// Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
|
|
instancing: bool,
|
|
/// NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
|
|
texNPOT: bool,
|
|
/// Depth textures supported (GL_ARB_depth_texture, GL_WEBGL_depth_texture, GL_OES_depth_texture)
|
|
texDepth: bool,
|
|
/// float textures support (32 bit per channel) (GL_OES_texture_float)
|
|
texFloat32: bool,
|
|
/// DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc)
|
|
texCompDXT: bool,
|
|
/// ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1)
|
|
texCompETC1: bool,
|
|
/// ETC2/EAC texture compression support (GL_ARB_ES3_compatibility)
|
|
texCompETC2: bool,
|
|
/// PVR texture compression support (GL_IMG_texture_compression_pvrtc)
|
|
texCompPVRT: bool,
|
|
/// ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr)
|
|
texCompASTC: bool,
|
|
/// Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp)
|
|
texMirrorClamp: bool,
|
|
/// Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic)
|
|
texAnisoFilter: bool,
|
|
/// Compute shaders support (GL_ARB_compute_shader)
|
|
computeShader: bool,
|
|
/// Shader storage buffer object support (GL_ARB_shader_storage_buffer_object)
|
|
ssbo: bool,
|
|
/// Maximum anisotropy level supported (minimum is 2.0f)
|
|
maxAnisotropyLevel: f32,
|
|
/// Maximum bits for depth component
|
|
maxDepthBits: i32,
|
|
};
|
|
};
|
|
|
|
/// Enable attribute state pointer
|
|
pub fn rlEnableStatePointer(
|
|
vertexAttribType: i32,
|
|
buffer: *anyopaque,
|
|
) void {
|
|
raylib.rlEnableStatePointer(
|
|
vertexAttribType,
|
|
@as([*c]anyopaque, @ptrCast(buffer)),
|
|
);
|
|
}
|
|
|
|
/// Disable attribute state pointer
|
|
pub fn rlDisableStatePointer(
|
|
vertexAttribType: i32,
|
|
) void {
|
|
raylib.rlDisableStatePointer(
|
|
vertexAttribType,
|
|
);
|
|
}
|
|
|
|
/// Get the last gamepad button pressed
|
|
pub fn GetGamepadButtonPressed() ?GamepadButton {
|
|
if (raylib.GetGamepadButtonPressed() == -1) return null;
|
|
|
|
return @as(GamepadButton, @enumFromInt(raylib.GetGamepadButtonPressed()));
|
|
}
|
|
|
|
/// Initialize window and OpenGL context
|
|
pub fn InitWindow(
|
|
width: i32,
|
|
height: i32,
|
|
title: [*:0]const u8,
|
|
) void {
|
|
raylib.mInitWindow(
|
|
width,
|
|
height,
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(title))),
|
|
);
|
|
}
|
|
|
|
/// Close window and unload OpenGL context
|
|
pub fn CloseWindow() void {
|
|
raylib.mCloseWindow();
|
|
}
|
|
|
|
/// Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
|
|
pub fn WindowShouldClose() bool {
|
|
return raylib.mWindowShouldClose();
|
|
}
|
|
|
|
/// Check if window has been initialized successfully
|
|
pub fn IsWindowReady() bool {
|
|
return raylib.mIsWindowReady();
|
|
}
|
|
|
|
/// Check if window is currently fullscreen
|
|
pub fn IsWindowFullscreen() bool {
|
|
return raylib.mIsWindowFullscreen();
|
|
}
|
|
|
|
/// Check if window is currently hidden (only PLATFORM_DESKTOP)
|
|
pub fn IsWindowHidden() bool {
|
|
return raylib.mIsWindowHidden();
|
|
}
|
|
|
|
/// Check if window is currently minimized (only PLATFORM_DESKTOP)
|
|
pub fn IsWindowMinimized() bool {
|
|
return raylib.mIsWindowMinimized();
|
|
}
|
|
|
|
/// Check if window is currently maximized (only PLATFORM_DESKTOP)
|
|
pub fn IsWindowMaximized() bool {
|
|
return raylib.mIsWindowMaximized();
|
|
}
|
|
|
|
/// Check if window is currently focused (only PLATFORM_DESKTOP)
|
|
pub fn IsWindowFocused() bool {
|
|
return raylib.mIsWindowFocused();
|
|
}
|
|
|
|
/// Check if window has been resized last frame
|
|
pub fn IsWindowResized() bool {
|
|
return raylib.mIsWindowResized();
|
|
}
|
|
|
|
/// Check if one specific window flag is enabled
|
|
pub fn IsWindowState(
|
|
flag: u32,
|
|
) bool {
|
|
return raylib.mIsWindowState(
|
|
flag,
|
|
);
|
|
}
|
|
|
|
/// Set window configuration state using flags (only PLATFORM_DESKTOP)
|
|
pub fn SetWindowState(
|
|
flags: u32,
|
|
) void {
|
|
raylib.mSetWindowState(
|
|
flags,
|
|
);
|
|
}
|
|
|
|
/// Clear window configuration state flags
|
|
pub fn ClearWindowState(
|
|
flags: u32,
|
|
) void {
|
|
raylib.mClearWindowState(
|
|
flags,
|
|
);
|
|
}
|
|
|
|
/// Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
|
|
pub fn ToggleFullscreen() void {
|
|
raylib.mToggleFullscreen();
|
|
}
|
|
|
|
/// Toggle window state: borderless windowed (only PLATFORM_DESKTOP)
|
|
pub fn ToggleBorderlessWindowed() void {
|
|
raylib.mToggleBorderlessWindowed();
|
|
}
|
|
|
|
/// Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
|
|
pub fn MaximizeWindow() void {
|
|
raylib.mMaximizeWindow();
|
|
}
|
|
|
|
/// Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
|
|
pub fn MinimizeWindow() void {
|
|
raylib.mMinimizeWindow();
|
|
}
|
|
|
|
/// Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
|
|
pub fn RestoreWindow() void {
|
|
raylib.mRestoreWindow();
|
|
}
|
|
|
|
/// Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP)
|
|
pub fn SetWindowIcon(
|
|
image: Image,
|
|
) void {
|
|
raylib.mSetWindowIcon(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
);
|
|
}
|
|
|
|
/// Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP)
|
|
pub fn SetWindowIcons(
|
|
images: *Image,
|
|
count: i32,
|
|
) void {
|
|
raylib.mSetWindowIcons(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(images))),
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)
|
|
pub fn SetWindowTitle(
|
|
title: [*:0]const u8,
|
|
) void {
|
|
raylib.mSetWindowTitle(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(title))),
|
|
);
|
|
}
|
|
|
|
/// Set window position on screen (only PLATFORM_DESKTOP)
|
|
pub fn SetWindowPosition(
|
|
x: i32,
|
|
y: i32,
|
|
) void {
|
|
raylib.mSetWindowPosition(
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
/// Set monitor for the current window
|
|
pub fn SetWindowMonitor(
|
|
monitor: i32,
|
|
) void {
|
|
raylib.mSetWindowMonitor(
|
|
monitor,
|
|
);
|
|
}
|
|
|
|
/// Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
|
|
pub fn SetWindowMinSize(
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mSetWindowMinSize(
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)
|
|
pub fn SetWindowMaxSize(
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mSetWindowMaxSize(
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Set window dimensions
|
|
pub fn SetWindowSize(
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mSetWindowSize(
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
|
|
pub fn SetWindowOpacity(
|
|
opacity: f32,
|
|
) void {
|
|
raylib.mSetWindowOpacity(
|
|
opacity,
|
|
);
|
|
}
|
|
|
|
/// Set window focused (only PLATFORM_DESKTOP)
|
|
pub fn SetWindowFocused() void {
|
|
raylib.mSetWindowFocused();
|
|
}
|
|
|
|
/// Get current screen width
|
|
pub fn GetScreenWidth() i32 {
|
|
return raylib.mGetScreenWidth();
|
|
}
|
|
|
|
/// Get current screen height
|
|
pub fn GetScreenHeight() i32 {
|
|
return raylib.mGetScreenHeight();
|
|
}
|
|
|
|
/// Get current render width (it considers HiDPI)
|
|
pub fn GetRenderWidth() i32 {
|
|
return raylib.mGetRenderWidth();
|
|
}
|
|
|
|
/// Get current render height (it considers HiDPI)
|
|
pub fn GetRenderHeight() i32 {
|
|
return raylib.mGetRenderHeight();
|
|
}
|
|
|
|
/// Get number of connected monitors
|
|
pub fn GetMonitorCount() i32 {
|
|
return raylib.mGetMonitorCount();
|
|
}
|
|
|
|
/// Get current connected monitor
|
|
pub fn GetCurrentMonitor() i32 {
|
|
return raylib.mGetCurrentMonitor();
|
|
}
|
|
|
|
/// Get specified monitor position
|
|
pub fn GetMonitorPosition(
|
|
monitor: i32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetMonitorPosition(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
monitor,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get specified monitor width (current video mode used by monitor)
|
|
pub fn GetMonitorWidth(
|
|
monitor: i32,
|
|
) i32 {
|
|
return raylib.mGetMonitorWidth(
|
|
monitor,
|
|
);
|
|
}
|
|
|
|
/// Get specified monitor height (current video mode used by monitor)
|
|
pub fn GetMonitorHeight(
|
|
monitor: i32,
|
|
) i32 {
|
|
return raylib.mGetMonitorHeight(
|
|
monitor,
|
|
);
|
|
}
|
|
|
|
/// Get specified monitor physical width in millimetres
|
|
pub fn GetMonitorPhysicalWidth(
|
|
monitor: i32,
|
|
) i32 {
|
|
return raylib.mGetMonitorPhysicalWidth(
|
|
monitor,
|
|
);
|
|
}
|
|
|
|
/// Get specified monitor physical height in millimetres
|
|
pub fn GetMonitorPhysicalHeight(
|
|
monitor: i32,
|
|
) i32 {
|
|
return raylib.mGetMonitorPhysicalHeight(
|
|
monitor,
|
|
);
|
|
}
|
|
|
|
/// Get specified monitor refresh rate
|
|
pub fn GetMonitorRefreshRate(
|
|
monitor: i32,
|
|
) i32 {
|
|
return raylib.mGetMonitorRefreshRate(
|
|
monitor,
|
|
);
|
|
}
|
|
|
|
/// Get window position XY on monitor
|
|
pub fn GetWindowPosition() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetWindowPosition(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get window scale DPI factor
|
|
pub fn GetWindowScaleDPI() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetWindowScaleDPI(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get the human-readable, UTF-8 encoded name of the specified monitor
|
|
pub fn GetMonitorName(
|
|
monitor: i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetMonitorName(
|
|
monitor,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Set clipboard text content
|
|
pub fn SetClipboardText(
|
|
text: [*:0]const u8,
|
|
) void {
|
|
raylib.mSetClipboardText(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
);
|
|
}
|
|
|
|
/// Get clipboard text content
|
|
pub fn GetClipboardText() [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetClipboardText()),
|
|
);
|
|
}
|
|
|
|
/// Enable waiting for events on EndDrawing(), no automatic event polling
|
|
pub fn EnableEventWaiting() void {
|
|
raylib.mEnableEventWaiting();
|
|
}
|
|
|
|
/// Disable waiting for events on EndDrawing(), automatic events polling
|
|
pub fn DisableEventWaiting() void {
|
|
raylib.mDisableEventWaiting();
|
|
}
|
|
|
|
/// Shows cursor
|
|
pub fn ShowCursor() void {
|
|
raylib.mShowCursor();
|
|
}
|
|
|
|
/// Hides cursor
|
|
pub fn HideCursor() void {
|
|
raylib.mHideCursor();
|
|
}
|
|
|
|
/// Check if cursor is not visible
|
|
pub fn IsCursorHidden() bool {
|
|
return raylib.mIsCursorHidden();
|
|
}
|
|
|
|
/// Enables cursor (unlock cursor)
|
|
pub fn EnableCursor() void {
|
|
raylib.mEnableCursor();
|
|
}
|
|
|
|
/// Disables cursor (lock cursor)
|
|
pub fn DisableCursor() void {
|
|
raylib.mDisableCursor();
|
|
}
|
|
|
|
/// Check if cursor is on the screen
|
|
pub fn IsCursorOnScreen() bool {
|
|
return raylib.mIsCursorOnScreen();
|
|
}
|
|
|
|
/// Set background color (framebuffer clear color)
|
|
pub fn ClearBackground(
|
|
color: Color,
|
|
) void {
|
|
raylib.mClearBackground(
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Setup canvas (framebuffer) to start drawing
|
|
pub fn BeginDrawing() void {
|
|
raylib.mBeginDrawing();
|
|
}
|
|
|
|
/// End canvas drawing and swap buffers (double buffering)
|
|
pub fn EndDrawing() void {
|
|
raylib.mEndDrawing();
|
|
}
|
|
|
|
/// Begin 2D mode with custom camera (2D)
|
|
pub fn BeginMode2D(
|
|
camera: Camera2D,
|
|
) void {
|
|
raylib.mBeginMode2D(
|
|
@as([*c]raylib.Camera2D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
}
|
|
|
|
/// Ends 2D mode with custom camera
|
|
pub fn EndMode2D() void {
|
|
raylib.mEndMode2D();
|
|
}
|
|
|
|
/// Begin 3D mode with custom camera (3D)
|
|
pub fn BeginMode3D(
|
|
camera: Camera3D,
|
|
) void {
|
|
raylib.mBeginMode3D(
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
}
|
|
|
|
/// Ends 3D mode and returns to default 2D orthographic mode
|
|
pub fn EndMode3D() void {
|
|
raylib.mEndMode3D();
|
|
}
|
|
|
|
/// Begin drawing to render texture
|
|
pub fn BeginTextureMode(
|
|
target: RenderTexture2D,
|
|
) void {
|
|
raylib.mBeginTextureMode(
|
|
@as([*c]raylib.RenderTexture2D, @ptrFromInt(@intFromPtr(&target))),
|
|
);
|
|
}
|
|
|
|
/// Ends drawing to render texture
|
|
pub fn EndTextureMode() void {
|
|
raylib.mEndTextureMode();
|
|
}
|
|
|
|
/// Begin custom shader drawing
|
|
pub fn BeginShaderMode(
|
|
shader: Shader,
|
|
) void {
|
|
raylib.mBeginShaderMode(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
);
|
|
}
|
|
|
|
/// End custom shader drawing (use default shader)
|
|
pub fn EndShaderMode() void {
|
|
raylib.mEndShaderMode();
|
|
}
|
|
|
|
/// Begin blending mode (alpha, additive, multiplied, subtract, custom)
|
|
pub fn BeginBlendMode(
|
|
mode: i32,
|
|
) void {
|
|
raylib.mBeginBlendMode(
|
|
mode,
|
|
);
|
|
}
|
|
|
|
/// End blending mode (reset to default: alpha blending)
|
|
pub fn EndBlendMode() void {
|
|
raylib.mEndBlendMode();
|
|
}
|
|
|
|
/// Begin scissor mode (define screen area for following drawing)
|
|
pub fn BeginScissorMode(
|
|
x: i32,
|
|
y: i32,
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mBeginScissorMode(
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// End scissor mode
|
|
pub fn EndScissorMode() void {
|
|
raylib.mEndScissorMode();
|
|
}
|
|
|
|
/// Begin stereo rendering (requires VR simulator)
|
|
pub fn BeginVrStereoMode(
|
|
config: VrStereoConfig,
|
|
) void {
|
|
raylib.mBeginVrStereoMode(
|
|
@as([*c]raylib.VrStereoConfig, @ptrFromInt(@intFromPtr(&config))),
|
|
);
|
|
}
|
|
|
|
/// End stereo rendering (requires VR simulator)
|
|
pub fn EndVrStereoMode() void {
|
|
raylib.mEndVrStereoMode();
|
|
}
|
|
|
|
/// Load VR stereo config for VR simulator device parameters
|
|
pub fn LoadVrStereoConfig(
|
|
device: VrDeviceInfo,
|
|
) VrStereoConfig {
|
|
var out: VrStereoConfig = undefined;
|
|
raylib.mLoadVrStereoConfig(
|
|
@as([*c]raylib.VrStereoConfig, @ptrCast(&out)),
|
|
@as([*c]raylib.VrDeviceInfo, @ptrFromInt(@intFromPtr(&device))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Unload VR stereo config
|
|
pub fn UnloadVrStereoConfig(
|
|
config: VrStereoConfig,
|
|
) void {
|
|
raylib.mUnloadVrStereoConfig(
|
|
@as([*c]raylib.VrStereoConfig, @ptrFromInt(@intFromPtr(&config))),
|
|
);
|
|
}
|
|
|
|
/// Load shader from files and bind default locations
|
|
pub fn LoadShader(
|
|
vsFileName: [*:0]const u8,
|
|
fsFileName: [*:0]const u8,
|
|
) Shader {
|
|
var out: Shader = undefined;
|
|
raylib.mLoadShader(
|
|
@as([*c]raylib.Shader, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(vsFileName))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fsFileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load shader from code strings and bind default locations
|
|
pub fn LoadShaderFromMemory(
|
|
vsCode: [*:0]const u8,
|
|
fsCode: [*:0]const u8,
|
|
) Shader {
|
|
var out: Shader = undefined;
|
|
raylib.mLoadShaderFromMemory(
|
|
@as([*c]raylib.Shader, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(vsCode))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fsCode))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check if a shader is ready
|
|
pub fn IsShaderReady(
|
|
shader: Shader,
|
|
) bool {
|
|
return raylib.mIsShaderReady(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
);
|
|
}
|
|
|
|
/// Get shader uniform location
|
|
pub fn GetShaderLocation(
|
|
shader: Shader,
|
|
uniformName: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mGetShaderLocation(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(uniformName))),
|
|
);
|
|
}
|
|
|
|
/// Get shader attribute location
|
|
pub fn GetShaderLocationAttrib(
|
|
shader: Shader,
|
|
attribName: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mGetShaderLocationAttrib(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(attribName))),
|
|
);
|
|
}
|
|
|
|
/// Set shader uniform value
|
|
pub fn SetShaderValue(
|
|
shader: Shader,
|
|
locIndex: i32,
|
|
value: *const anyopaque,
|
|
uniformType: ShaderUniformDataType,
|
|
) void {
|
|
raylib.mSetShaderValue(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
locIndex,
|
|
value,
|
|
@intFromEnum(uniformType),
|
|
);
|
|
}
|
|
|
|
/// Set shader uniform value vector
|
|
pub fn SetShaderValueV(
|
|
shader: Shader,
|
|
locIndex: i32,
|
|
value: *const anyopaque,
|
|
uniformType: i32,
|
|
count: i32,
|
|
) void {
|
|
raylib.mSetShaderValueV(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
locIndex,
|
|
value,
|
|
uniformType,
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Set shader uniform value (matrix 4x4)
|
|
pub fn SetShaderValueMatrix(
|
|
shader: Shader,
|
|
locIndex: i32,
|
|
mat: Matrix,
|
|
) void {
|
|
raylib.mSetShaderValueMatrix(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
locIndex,
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
}
|
|
|
|
/// Set shader uniform value for texture (sampler2d)
|
|
pub fn SetShaderValueTexture(
|
|
shader: Shader,
|
|
locIndex: i32,
|
|
texture: Texture2D,
|
|
) void {
|
|
raylib.mSetShaderValueTexture(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
locIndex,
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
);
|
|
}
|
|
|
|
/// Unload shader from GPU memory (VRAM)
|
|
pub fn UnloadShader(
|
|
shader: Shader,
|
|
) void {
|
|
raylib.mUnloadShader(
|
|
@as([*c]raylib.Shader, @ptrFromInt(@intFromPtr(&shader))),
|
|
);
|
|
}
|
|
|
|
/// Get a ray trace from mouse position
|
|
pub fn GetMouseRay(
|
|
mousePosition: Vector2,
|
|
camera: Camera3D,
|
|
) Ray {
|
|
var out: Ray = undefined;
|
|
raylib.mGetMouseRay(
|
|
@as([*c]raylib.Ray, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&mousePosition))),
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get camera transform matrix (view matrix)
|
|
pub fn GetCameraMatrix(
|
|
camera: Camera3D,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mGetCameraMatrix(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get camera 2d transform matrix
|
|
pub fn GetCameraMatrix2D(
|
|
camera: Camera2D,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mGetCameraMatrix2D(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Camera2D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get the screen space position for a 3d world space position
|
|
pub fn GetWorldToScreen(
|
|
position: Vector3,
|
|
camera: Camera3D,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetWorldToScreen(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get the world space position for a 2d camera screen space position
|
|
pub fn GetScreenToWorld2D(
|
|
position: Vector2,
|
|
camera: Camera2D,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetScreenToWorld2D(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Camera2D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get size position for a 3d world space position
|
|
pub fn GetWorldToScreenEx(
|
|
position: Vector3,
|
|
camera: Camera3D,
|
|
width: i32,
|
|
height: i32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetWorldToScreenEx(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
width,
|
|
height,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get the screen space position for a 2d camera world space position
|
|
pub fn GetWorldToScreen2D(
|
|
position: Vector2,
|
|
camera: Camera2D,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetWorldToScreen2D(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Camera2D, @ptrFromInt(@intFromPtr(&camera))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Set target FPS (maximum)
|
|
pub fn SetTargetFPS(
|
|
fps: i32,
|
|
) void {
|
|
raylib.mSetTargetFPS(
|
|
fps,
|
|
);
|
|
}
|
|
|
|
/// Get time in seconds for last frame drawn (delta time)
|
|
pub fn GetFrameTime() f32 {
|
|
return raylib.mGetFrameTime();
|
|
}
|
|
|
|
/// Get elapsed time in seconds since InitWindow()
|
|
pub fn GetTime() f64 {
|
|
return raylib.mGetTime();
|
|
}
|
|
|
|
/// Get current FPS
|
|
pub fn GetFPS() i32 {
|
|
return raylib.mGetFPS();
|
|
}
|
|
|
|
/// Swap back buffer with front buffer (screen drawing)
|
|
pub fn SwapScreenBuffer() void {
|
|
raylib.mSwapScreenBuffer();
|
|
}
|
|
|
|
/// Register all input events
|
|
pub fn PollInputEvents() void {
|
|
raylib.mPollInputEvents();
|
|
}
|
|
|
|
/// Wait for some time (halt program execution)
|
|
pub fn WaitTime(
|
|
seconds: f64,
|
|
) void {
|
|
raylib.mWaitTime(
|
|
seconds,
|
|
);
|
|
}
|
|
|
|
/// Set the seed for the random number generator
|
|
pub fn SetRandomSeed(
|
|
seed: u32,
|
|
) void {
|
|
raylib.mSetRandomSeed(
|
|
seed,
|
|
);
|
|
}
|
|
|
|
/// Get a random value between min and max (both included)
|
|
pub fn GetRandomValue(
|
|
min: i32,
|
|
max: i32,
|
|
) i32 {
|
|
return raylib.mGetRandomValue(
|
|
min,
|
|
max,
|
|
);
|
|
}
|
|
|
|
/// Load random values sequence, no values repeated
|
|
pub fn LoadRandomSequence(
|
|
count: u32,
|
|
min: i32,
|
|
max: i32,
|
|
) ?[*]i32 {
|
|
return @as(
|
|
?[*]i32,
|
|
@ptrCast(raylib.mLoadRandomSequence(
|
|
count,
|
|
min,
|
|
max,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload random values sequence
|
|
pub fn UnloadRandomSequence(
|
|
sequence: ?[*]i32,
|
|
) void {
|
|
raylib.mUnloadRandomSequence(
|
|
@as([*c]i32, @ptrCast(sequence)),
|
|
);
|
|
}
|
|
|
|
/// Takes a screenshot of current screen (filename extension defines format)
|
|
pub fn TakeScreenshot(
|
|
fileName: [*:0]const u8,
|
|
) void {
|
|
raylib.mTakeScreenshot(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Open URL with default system browser (if available)
|
|
pub fn OpenURL(
|
|
url: [*:0]const u8,
|
|
) void {
|
|
raylib.mOpenURL(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(url))),
|
|
);
|
|
}
|
|
|
|
/// Set the current threshold (minimum) log level
|
|
pub fn SetTraceLogLevel(
|
|
logLevel: i32,
|
|
) void {
|
|
raylib.mSetTraceLogLevel(
|
|
logLevel,
|
|
);
|
|
}
|
|
|
|
/// Set custom file binary data loader
|
|
pub fn SetLoadFileDataCallback(
|
|
callback: LoadFileDataCallback,
|
|
) void {
|
|
raylib.mSetLoadFileDataCallback(
|
|
@ptrCast(callback),
|
|
);
|
|
}
|
|
|
|
/// Set custom file binary data saver
|
|
pub fn SetSaveFileDataCallback(
|
|
callback: SaveFileDataCallback,
|
|
) void {
|
|
raylib.mSetSaveFileDataCallback(
|
|
@ptrCast(callback),
|
|
);
|
|
}
|
|
|
|
/// Set custom file text data loader
|
|
pub fn SetLoadFileTextCallback(
|
|
callback: LoadFileTextCallback,
|
|
) void {
|
|
raylib.mSetLoadFileTextCallback(
|
|
@ptrCast(callback),
|
|
);
|
|
}
|
|
|
|
/// Set custom file text data saver
|
|
pub fn SetSaveFileTextCallback(
|
|
callback: SaveFileTextCallback,
|
|
) void {
|
|
raylib.mSetSaveFileTextCallback(
|
|
@ptrCast(callback),
|
|
);
|
|
}
|
|
|
|
/// Save data to file from byte array (write), returns true on success
|
|
pub fn SaveFileData(
|
|
fileName: [*:0]const u8,
|
|
data: *anyopaque,
|
|
dataSize: i32,
|
|
) bool {
|
|
return raylib.mSaveFileData(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
data,
|
|
dataSize,
|
|
);
|
|
}
|
|
|
|
/// Export data to code (.h), returns true on success
|
|
pub fn ExportDataAsCode(
|
|
data: [*:0]const u8,
|
|
dataSize: i32,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportDataAsCode(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(data))),
|
|
dataSize,
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Load text data from file (read), returns a '\0' terminated string
|
|
pub fn LoadFileText(
|
|
fileName: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mLoadFileText(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload file text data allocated by LoadFileText()
|
|
pub fn UnloadFileText(
|
|
text: ?[*]u8,
|
|
) void {
|
|
raylib.mUnloadFileText(
|
|
@as([*c]u8, @ptrCast(text)),
|
|
);
|
|
}
|
|
|
|
/// Save text data to file (write), string must be '\0' terminated, returns true on success
|
|
pub fn SaveFileText(
|
|
fileName: [*:0]const u8,
|
|
text: ?[*]u8,
|
|
) bool {
|
|
return raylib.mSaveFileText(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
@as([*c]u8, @ptrCast(text)),
|
|
);
|
|
}
|
|
|
|
/// Check if file exists
|
|
pub fn FileExists(
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mFileExists(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Check if a directory path exists
|
|
pub fn DirectoryExists(
|
|
dirPath: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mDirectoryExists(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(dirPath))),
|
|
);
|
|
}
|
|
|
|
/// Check file extension (including point: .png, .wav)
|
|
pub fn IsFileExtension(
|
|
fileName: [*:0]const u8,
|
|
ext: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mIsFileExtension(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(ext))),
|
|
);
|
|
}
|
|
|
|
/// Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
|
|
pub fn GetFileLength(
|
|
fileName: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mGetFileLength(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Get pointer to extension for a filename string (includes dot: '.png')
|
|
pub fn GetFileExtension(
|
|
fileName: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetFileExtension(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get pointer to filename for a path string
|
|
pub fn GetFileName(
|
|
filePath: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetFileName(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(filePath))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get filename string without extension (uses static string)
|
|
pub fn GetFileNameWithoutExt(
|
|
filePath: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetFileNameWithoutExt(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(filePath))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get full path for a given fileName with path (uses static string)
|
|
pub fn GetDirectoryPath(
|
|
filePath: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetDirectoryPath(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(filePath))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get previous directory path for a given path (uses static string)
|
|
pub fn GetPrevDirectoryPath(
|
|
dirPath: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetPrevDirectoryPath(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(dirPath))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get current working directory (uses static string)
|
|
pub fn GetWorkingDirectory() [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetWorkingDirectory()),
|
|
);
|
|
}
|
|
|
|
/// Get the directory of the running application (uses static string)
|
|
pub fn GetApplicationDirectory() [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetApplicationDirectory()),
|
|
);
|
|
}
|
|
|
|
/// Change working directory, return true on success
|
|
pub fn ChangeDirectory(
|
|
dir: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mChangeDirectory(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(dir))),
|
|
);
|
|
}
|
|
|
|
/// Check if a given path is a file or a directory
|
|
pub fn IsPathFile(
|
|
path: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mIsPathFile(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(path))),
|
|
);
|
|
}
|
|
|
|
/// Load directory filepaths
|
|
pub fn LoadDirectoryFiles(
|
|
dirPath: [*:0]const u8,
|
|
) FilePathList {
|
|
var out: FilePathList = undefined;
|
|
raylib.mLoadDirectoryFiles(
|
|
@as([*c]raylib.FilePathList, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(dirPath))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load directory filepaths with extension filtering and recursive directory scan
|
|
pub fn LoadDirectoryFilesEx(
|
|
basePath: [*:0]const u8,
|
|
filter: [*:0]const u8,
|
|
scanSubdirs: bool,
|
|
) FilePathList {
|
|
var out: FilePathList = undefined;
|
|
raylib.mLoadDirectoryFilesEx(
|
|
@as([*c]raylib.FilePathList, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(basePath))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(filter))),
|
|
scanSubdirs,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Unload filepaths
|
|
pub fn UnloadDirectoryFiles(
|
|
files: FilePathList,
|
|
) void {
|
|
raylib.mUnloadDirectoryFiles(
|
|
@as([*c]raylib.FilePathList, @ptrFromInt(@intFromPtr(&files))),
|
|
);
|
|
}
|
|
|
|
/// Check if a file has been dropped into window
|
|
pub fn IsFileDropped() bool {
|
|
return raylib.mIsFileDropped();
|
|
}
|
|
|
|
/// Load dropped filepaths
|
|
pub fn LoadDroppedFiles() FilePathList {
|
|
var out: FilePathList = undefined;
|
|
raylib.mLoadDroppedFiles(
|
|
@as([*c]raylib.FilePathList, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Unload dropped filepaths
|
|
pub fn UnloadDroppedFiles(
|
|
files: FilePathList,
|
|
) void {
|
|
raylib.mUnloadDroppedFiles(
|
|
@as([*c]raylib.FilePathList, @ptrFromInt(@intFromPtr(&files))),
|
|
);
|
|
}
|
|
|
|
/// Get file modification time (last write time)
|
|
pub fn GetFileModTime(
|
|
fileName: [*:0]const u8,
|
|
) i64 {
|
|
return raylib.mGetFileModTime(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Compress data (DEFLATE algorithm), memory must be MemFree()
|
|
pub fn CompressData(
|
|
data: [*:0]const u8,
|
|
dataSize: i32,
|
|
compDataSize: ?[*]i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mCompressData(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(data))),
|
|
dataSize,
|
|
@as([*c]i32, @ptrCast(compDataSize)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Decompress data (DEFLATE algorithm), memory must be MemFree()
|
|
pub fn DecompressData(
|
|
compData: [*:0]const u8,
|
|
compDataSize: i32,
|
|
dataSize: ?[*]i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mDecompressData(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(compData))),
|
|
compDataSize,
|
|
@as([*c]i32, @ptrCast(dataSize)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Encode data to Base64 string, memory must be MemFree()
|
|
pub fn EncodeDataBase64(
|
|
data: [*:0]const u8,
|
|
dataSize: i32,
|
|
outputSize: ?[*]i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mEncodeDataBase64(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(data))),
|
|
dataSize,
|
|
@as([*c]i32, @ptrCast(outputSize)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Decode Base64 string data, memory must be MemFree()
|
|
pub fn DecodeDataBase64(
|
|
data: [*:0]const u8,
|
|
outputSize: ?[*]i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mDecodeDataBase64(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(data))),
|
|
@as([*c]i32, @ptrCast(outputSize)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
|
|
pub fn LoadAutomationEventList(
|
|
fileName: [*:0]const u8,
|
|
) AutomationEventList {
|
|
var out: AutomationEventList = undefined;
|
|
raylib.mLoadAutomationEventList(
|
|
@as([*c]raylib.AutomationEventList, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Unload automation events list from file
|
|
pub fn UnloadAutomationEventList(
|
|
list: AutomationEventList,
|
|
) void {
|
|
raylib.mUnloadAutomationEventList(
|
|
@as([*c]raylib.AutomationEventList, @ptrFromInt(@intFromPtr(&list))),
|
|
);
|
|
}
|
|
|
|
/// Export automation events list as text file
|
|
pub fn ExportAutomationEventList(
|
|
list: AutomationEventList,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportAutomationEventList(
|
|
@as([*c]raylib.AutomationEventList, @ptrFromInt(@intFromPtr(&list))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Set automation event list to record to
|
|
pub fn SetAutomationEventList(
|
|
list: ?[*]AutomationEventList,
|
|
) void {
|
|
raylib.mSetAutomationEventList(
|
|
@as([*c]raylib.AutomationEventList, @ptrFromInt(@intFromPtr(list))),
|
|
);
|
|
}
|
|
|
|
/// Set automation event internal base frame to start recording
|
|
pub fn SetAutomationEventBaseFrame(
|
|
frame: i32,
|
|
) void {
|
|
raylib.mSetAutomationEventBaseFrame(
|
|
frame,
|
|
);
|
|
}
|
|
|
|
/// Start recording automation events (AutomationEventList must be set)
|
|
pub fn StartAutomationEventRecording() void {
|
|
raylib.mStartAutomationEventRecording();
|
|
}
|
|
|
|
/// Stop recording automation events
|
|
pub fn StopAutomationEventRecording() void {
|
|
raylib.mStopAutomationEventRecording();
|
|
}
|
|
|
|
/// Play a recorded automation event
|
|
pub fn PlayAutomationEvent(
|
|
event: AutomationEvent,
|
|
) void {
|
|
raylib.mPlayAutomationEvent(
|
|
@as([*c]raylib.AutomationEvent, @ptrFromInt(@intFromPtr(&event))),
|
|
);
|
|
}
|
|
|
|
/// Check if a key has been pressed once
|
|
pub fn IsKeyPressed(
|
|
key: KeyboardKey,
|
|
) bool {
|
|
return raylib.mIsKeyPressed(
|
|
@intFromEnum(key),
|
|
);
|
|
}
|
|
|
|
/// Check if a key has been pressed again (Only PLATFORM_DESKTOP)
|
|
pub fn IsKeyPressedRepeat(
|
|
key: i32,
|
|
) bool {
|
|
return raylib.mIsKeyPressedRepeat(
|
|
key,
|
|
);
|
|
}
|
|
|
|
/// Check if a key is being pressed
|
|
pub fn IsKeyDown(
|
|
key: KeyboardKey,
|
|
) bool {
|
|
return raylib.mIsKeyDown(
|
|
@intFromEnum(key),
|
|
);
|
|
}
|
|
|
|
/// Check if a key has been released once
|
|
pub fn IsKeyReleased(
|
|
key: KeyboardKey,
|
|
) bool {
|
|
return raylib.mIsKeyReleased(
|
|
@intFromEnum(key),
|
|
);
|
|
}
|
|
|
|
/// Check if a key is NOT being pressed
|
|
pub fn IsKeyUp(
|
|
key: KeyboardKey,
|
|
) bool {
|
|
return raylib.mIsKeyUp(
|
|
@intFromEnum(key),
|
|
);
|
|
}
|
|
|
|
/// Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
|
|
pub fn GetKeyPressed() i32 {
|
|
return raylib.mGetKeyPressed();
|
|
}
|
|
|
|
/// Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
|
|
pub fn GetCharPressed() i32 {
|
|
return raylib.mGetCharPressed();
|
|
}
|
|
|
|
/// Set a custom key to exit program (default is ESC)
|
|
pub fn SetExitKey(
|
|
key: KeyboardKey,
|
|
) void {
|
|
raylib.mSetExitKey(
|
|
@intFromEnum(key),
|
|
);
|
|
}
|
|
|
|
/// Check if a gamepad is available
|
|
pub fn IsGamepadAvailable(
|
|
gamepad: i32,
|
|
) bool {
|
|
return raylib.mIsGamepadAvailable(
|
|
gamepad,
|
|
);
|
|
}
|
|
|
|
/// Get gamepad internal name id
|
|
pub fn GetGamepadName(
|
|
gamepad: i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mGetGamepadName(
|
|
gamepad,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Check if a gamepad button has been pressed once
|
|
pub fn IsGamepadButtonPressed(
|
|
gamepad: i32,
|
|
button: GamepadButton,
|
|
) bool {
|
|
return raylib.mIsGamepadButtonPressed(
|
|
gamepad,
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Check if a gamepad button is being pressed
|
|
pub fn IsGamepadButtonDown(
|
|
gamepad: i32,
|
|
button: GamepadButton,
|
|
) bool {
|
|
return raylib.mIsGamepadButtonDown(
|
|
gamepad,
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Check if a gamepad button has been released once
|
|
pub fn IsGamepadButtonReleased(
|
|
gamepad: i32,
|
|
button: GamepadButton,
|
|
) bool {
|
|
return raylib.mIsGamepadButtonReleased(
|
|
gamepad,
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Check if a gamepad button is NOT being pressed
|
|
pub fn IsGamepadButtonUp(
|
|
gamepad: i32,
|
|
button: GamepadButton,
|
|
) bool {
|
|
return raylib.mIsGamepadButtonUp(
|
|
gamepad,
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Get gamepad axis count for a gamepad
|
|
pub fn GetGamepadAxisCount(
|
|
gamepad: i32,
|
|
) i32 {
|
|
return raylib.mGetGamepadAxisCount(
|
|
gamepad,
|
|
);
|
|
}
|
|
|
|
/// Get axis movement value for a gamepad axis
|
|
pub fn GetGamepadAxisMovement(
|
|
gamepad: i32,
|
|
axis: GamepadAxis,
|
|
) f32 {
|
|
return raylib.mGetGamepadAxisMovement(
|
|
gamepad,
|
|
@intFromEnum(axis),
|
|
);
|
|
}
|
|
|
|
/// Set internal gamepad mappings (SDL_GameControllerDB)
|
|
pub fn SetGamepadMappings(
|
|
mappings: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mSetGamepadMappings(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(mappings))),
|
|
);
|
|
}
|
|
|
|
/// Check if a mouse button has been pressed once
|
|
pub fn IsMouseButtonPressed(
|
|
button: MouseButton,
|
|
) bool {
|
|
return raylib.mIsMouseButtonPressed(
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Check if a mouse button is being pressed
|
|
pub fn IsMouseButtonDown(
|
|
button: MouseButton,
|
|
) bool {
|
|
return raylib.mIsMouseButtonDown(
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Check if a mouse button has been released once
|
|
pub fn IsMouseButtonReleased(
|
|
button: MouseButton,
|
|
) bool {
|
|
return raylib.mIsMouseButtonReleased(
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Check if a mouse button is NOT being pressed
|
|
pub fn IsMouseButtonUp(
|
|
button: MouseButton,
|
|
) bool {
|
|
return raylib.mIsMouseButtonUp(
|
|
@intFromEnum(button),
|
|
);
|
|
}
|
|
|
|
/// Get mouse position X
|
|
pub fn GetMouseX() i32 {
|
|
return raylib.mGetMouseX();
|
|
}
|
|
|
|
/// Get mouse position Y
|
|
pub fn GetMouseY() i32 {
|
|
return raylib.mGetMouseY();
|
|
}
|
|
|
|
/// Get mouse position XY
|
|
pub fn GetMousePosition() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetMousePosition(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get mouse delta between frames
|
|
pub fn GetMouseDelta() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetMouseDelta(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Set mouse position XY
|
|
pub fn SetMousePosition(
|
|
x: i32,
|
|
y: i32,
|
|
) void {
|
|
raylib.mSetMousePosition(
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
/// Set mouse offset
|
|
pub fn SetMouseOffset(
|
|
offsetX: i32,
|
|
offsetY: i32,
|
|
) void {
|
|
raylib.mSetMouseOffset(
|
|
offsetX,
|
|
offsetY,
|
|
);
|
|
}
|
|
|
|
/// Set mouse scaling
|
|
pub fn SetMouseScale(
|
|
scaleX: f32,
|
|
scaleY: f32,
|
|
) void {
|
|
raylib.mSetMouseScale(
|
|
scaleX,
|
|
scaleY,
|
|
);
|
|
}
|
|
|
|
/// Get mouse wheel movement for X or Y, whichever is larger
|
|
pub fn GetMouseWheelMove() f32 {
|
|
return raylib.mGetMouseWheelMove();
|
|
}
|
|
|
|
/// Get mouse wheel movement for both X and Y
|
|
pub fn GetMouseWheelMoveV() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetMouseWheelMoveV(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Set mouse cursor
|
|
pub fn SetMouseCursor(
|
|
cursor: MouseCursor,
|
|
) void {
|
|
raylib.mSetMouseCursor(
|
|
@intFromEnum(cursor),
|
|
);
|
|
}
|
|
|
|
/// Get touch position X for touch point 0 (relative to screen size)
|
|
pub fn GetTouchX() i32 {
|
|
return raylib.mGetTouchX();
|
|
}
|
|
|
|
/// Get touch position Y for touch point 0 (relative to screen size)
|
|
pub fn GetTouchY() i32 {
|
|
return raylib.mGetTouchY();
|
|
}
|
|
|
|
/// Get touch position XY for a touch point index (relative to screen size)
|
|
pub fn GetTouchPosition(
|
|
index: i32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetTouchPosition(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
index,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get touch point identifier for given index
|
|
pub fn GetTouchPointId(
|
|
index: i32,
|
|
) i32 {
|
|
return raylib.mGetTouchPointId(
|
|
index,
|
|
);
|
|
}
|
|
|
|
/// Get number of touch points
|
|
pub fn GetTouchPointCount() i32 {
|
|
return raylib.mGetTouchPointCount();
|
|
}
|
|
|
|
/// Enable a set of gestures using flags
|
|
pub fn SetGesturesEnabled(
|
|
flags: u32,
|
|
) void {
|
|
raylib.mSetGesturesEnabled(
|
|
flags,
|
|
);
|
|
}
|
|
|
|
/// Check if a gesture have been detected
|
|
pub fn IsGestureDetected(
|
|
gesture: u32,
|
|
) bool {
|
|
return raylib.mIsGestureDetected(
|
|
gesture,
|
|
);
|
|
}
|
|
|
|
/// Get latest detected gesture
|
|
pub fn GetGestureDetected() i32 {
|
|
return raylib.mGetGestureDetected();
|
|
}
|
|
|
|
/// Get gesture hold time in milliseconds
|
|
pub fn GetGestureHoldDuration() f32 {
|
|
return raylib.mGetGestureHoldDuration();
|
|
}
|
|
|
|
/// Get gesture drag vector
|
|
pub fn GetGestureDragVector() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetGestureDragVector(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get gesture drag angle
|
|
pub fn GetGestureDragAngle() f32 {
|
|
return raylib.mGetGestureDragAngle();
|
|
}
|
|
|
|
/// Get gesture pinch delta
|
|
pub fn GetGesturePinchVector() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetGesturePinchVector(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get gesture pinch angle
|
|
pub fn GetGesturePinchAngle() f32 {
|
|
return raylib.mGetGesturePinchAngle();
|
|
}
|
|
|
|
/// Update camera position for selected mode
|
|
pub fn UpdateCamera(
|
|
camera: *Camera3D,
|
|
mode: CameraMode,
|
|
) void {
|
|
raylib.mUpdateCamera(
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(camera))),
|
|
@intFromEnum(mode),
|
|
);
|
|
}
|
|
|
|
/// Update camera movement/rotation
|
|
pub fn UpdateCameraPro(
|
|
camera: ?[*]Camera3D,
|
|
movement: Vector3,
|
|
rotation: Vector3,
|
|
zoom: f32,
|
|
) void {
|
|
raylib.mUpdateCameraPro(
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(camera))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&movement))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&rotation))),
|
|
zoom,
|
|
);
|
|
}
|
|
|
|
/// Set texture and rectangle to be used on shapes drawing
|
|
pub fn SetShapesTexture(
|
|
texture: Texture2D,
|
|
source: Rectangle,
|
|
) void {
|
|
raylib.mSetShapesTexture(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&source))),
|
|
);
|
|
}
|
|
|
|
/// Get texture that is used for shapes drawing
|
|
pub fn GetShapesTexture() Texture2D {
|
|
var out: Texture2D = undefined;
|
|
raylib.mGetShapesTexture(
|
|
@as([*c]raylib.Texture2D, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get texture source rectangle that is used for shapes drawing
|
|
pub fn GetShapesTextureRectangle() Rectangle {
|
|
var out: Rectangle = undefined;
|
|
raylib.mGetShapesTextureRectangle(
|
|
@as([*c]raylib.Rectangle, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Draw a pixel
|
|
pub fn DrawPixel(
|
|
posX: i32,
|
|
posY: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPixel(
|
|
posX,
|
|
posY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a pixel (Vector version)
|
|
pub fn DrawPixelV(
|
|
position: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPixelV(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a line
|
|
pub fn DrawLine(
|
|
startPosX: i32,
|
|
startPosY: i32,
|
|
endPosX: i32,
|
|
endPosY: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawLine(
|
|
startPosX,
|
|
startPosY,
|
|
endPosX,
|
|
endPosY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a line (using gl lines)
|
|
pub fn DrawLineV(
|
|
startPos: Vector2,
|
|
endPos: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawLineV(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&endPos))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a line (using triangles/quads)
|
|
pub fn DrawLineEx(
|
|
startPos: Vector2,
|
|
endPos: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawLineEx(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&endPos))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw lines sequence (using gl lines)
|
|
pub fn DrawLineStrip(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawLineStrip(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw line segment cubic-bezier in-out interpolation
|
|
pub fn DrawLineBezier(
|
|
startPos: Vector2,
|
|
endPos: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawLineBezier(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&endPos))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled circle
|
|
pub fn DrawCircle(
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radius: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircle(
|
|
centerX,
|
|
centerY,
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a piece of a circle
|
|
pub fn DrawCircleSector(
|
|
center: Vector2,
|
|
radius: f32,
|
|
startAngle: f32,
|
|
endAngle: f32,
|
|
segments: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircleSector(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
startAngle,
|
|
endAngle,
|
|
segments,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw circle sector outline
|
|
pub fn DrawCircleSectorLines(
|
|
center: Vector2,
|
|
radius: f32,
|
|
startAngle: f32,
|
|
endAngle: f32,
|
|
segments: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircleSectorLines(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
startAngle,
|
|
endAngle,
|
|
segments,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a gradient-filled circle
|
|
pub fn DrawCircleGradient(
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radius: f32,
|
|
color1: Color,
|
|
color2: Color,
|
|
) void {
|
|
raylib.mDrawCircleGradient(
|
|
centerX,
|
|
centerY,
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color1))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color2))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled circle (Vector version)
|
|
pub fn DrawCircleV(
|
|
center: Vector2,
|
|
radius: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircleV(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw circle outline
|
|
pub fn DrawCircleLines(
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radius: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircleLines(
|
|
centerX,
|
|
centerY,
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw circle outline (Vector version)
|
|
pub fn DrawCircleLinesV(
|
|
center: Vector2,
|
|
radius: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircleLinesV(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw ellipse
|
|
pub fn DrawEllipse(
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radiusH: f32,
|
|
radiusV: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawEllipse(
|
|
centerX,
|
|
centerY,
|
|
radiusH,
|
|
radiusV,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw ellipse outline
|
|
pub fn DrawEllipseLines(
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radiusH: f32,
|
|
radiusV: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawEllipseLines(
|
|
centerX,
|
|
centerY,
|
|
radiusH,
|
|
radiusV,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw ring
|
|
pub fn DrawRing(
|
|
center: Vector2,
|
|
innerRadius: f32,
|
|
outerRadius: f32,
|
|
startAngle: f32,
|
|
endAngle: f32,
|
|
segments: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRing(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
innerRadius,
|
|
outerRadius,
|
|
startAngle,
|
|
endAngle,
|
|
segments,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw ring outline
|
|
pub fn DrawRingLines(
|
|
center: Vector2,
|
|
innerRadius: f32,
|
|
outerRadius: f32,
|
|
startAngle: f32,
|
|
endAngle: f32,
|
|
segments: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRingLines(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
innerRadius,
|
|
outerRadius,
|
|
startAngle,
|
|
endAngle,
|
|
segments,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled rectangle
|
|
pub fn DrawRectangle(
|
|
posX: i32,
|
|
posY: i32,
|
|
width: i32,
|
|
height: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangle(
|
|
posX,
|
|
posY,
|
|
width,
|
|
height,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled rectangle (Vector version)
|
|
pub fn DrawRectangleV(
|
|
position: Vector2,
|
|
size: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangleV(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled rectangle
|
|
pub fn DrawRectangleRec(
|
|
rec: Rectangle,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangleRec(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled rectangle with pro parameters
|
|
pub fn DrawRectanglePro(
|
|
rec: Rectangle,
|
|
origin: Vector2,
|
|
rotation: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectanglePro(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&origin))),
|
|
rotation,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a vertical-gradient-filled rectangle
|
|
pub fn DrawRectangleGradientV(
|
|
posX: i32,
|
|
posY: i32,
|
|
width: i32,
|
|
height: i32,
|
|
color1: Color,
|
|
color2: Color,
|
|
) void {
|
|
raylib.mDrawRectangleGradientV(
|
|
posX,
|
|
posY,
|
|
width,
|
|
height,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color1))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color2))),
|
|
);
|
|
}
|
|
|
|
/// Draw a horizontal-gradient-filled rectangle
|
|
pub fn DrawRectangleGradientH(
|
|
posX: i32,
|
|
posY: i32,
|
|
width: i32,
|
|
height: i32,
|
|
color1: Color,
|
|
color2: Color,
|
|
) void {
|
|
raylib.mDrawRectangleGradientH(
|
|
posX,
|
|
posY,
|
|
width,
|
|
height,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color1))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color2))),
|
|
);
|
|
}
|
|
|
|
/// Draw a gradient-filled rectangle with custom vertex colors
|
|
pub fn DrawRectangleGradientEx(
|
|
rec: Rectangle,
|
|
col1: Color,
|
|
col2: Color,
|
|
col3: Color,
|
|
col4: Color,
|
|
) void {
|
|
raylib.mDrawRectangleGradientEx(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&col1))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&col2))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&col3))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&col4))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle outline
|
|
pub fn DrawRectangleLines(
|
|
posX: i32,
|
|
posY: i32,
|
|
width: i32,
|
|
height: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangleLines(
|
|
posX,
|
|
posY,
|
|
width,
|
|
height,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle outline with extended parameters
|
|
pub fn DrawRectangleLinesEx(
|
|
rec: Rectangle,
|
|
lineThick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangleLinesEx(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
lineThick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle with rounded edges
|
|
pub fn DrawRectangleRounded(
|
|
rec: Rectangle,
|
|
roundness: f32,
|
|
segments: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangleRounded(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
roundness,
|
|
segments,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle with rounded edges outline
|
|
pub fn DrawRectangleRoundedLines(
|
|
rec: Rectangle,
|
|
roundness: f32,
|
|
segments: i32,
|
|
lineThick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRectangleRoundedLines(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
roundness,
|
|
segments,
|
|
lineThick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled triangle (vertex in counter-clockwise order!)
|
|
pub fn DrawTriangle(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
v3: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawTriangle(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v3))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw triangle outline (vertex in counter-clockwise order!)
|
|
pub fn DrawTriangleLines(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
v3: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawTriangleLines(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v3))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a triangle fan defined by points (first vertex is the center)
|
|
pub fn DrawTriangleFan(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawTriangleFan(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a triangle strip defined by points
|
|
pub fn DrawTriangleStrip(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawTriangleStrip(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a regular polygon (Vector version)
|
|
pub fn DrawPoly(
|
|
center: Vector2,
|
|
sides: i32,
|
|
radius: f32,
|
|
rotation: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPoly(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
sides,
|
|
radius,
|
|
rotation,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a polygon outline of n sides
|
|
pub fn DrawPolyLines(
|
|
center: Vector2,
|
|
sides: i32,
|
|
radius: f32,
|
|
rotation: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPolyLines(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
sides,
|
|
radius,
|
|
rotation,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a polygon outline of n sides with extended parameters
|
|
pub fn DrawPolyLinesEx(
|
|
center: Vector2,
|
|
sides: i32,
|
|
radius: f32,
|
|
rotation: f32,
|
|
lineThick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPolyLinesEx(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
sides,
|
|
radius,
|
|
rotation,
|
|
lineThick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline: Linear, minimum 2 points
|
|
pub fn DrawSplineLinear(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineLinear(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline: B-Spline, minimum 4 points
|
|
pub fn DrawSplineBasis(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineBasis(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline: Catmull-Rom, minimum 4 points
|
|
pub fn DrawSplineCatmullRom(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineCatmullRom(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]
|
|
pub fn DrawSplineBezierQuadratic(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineBezierQuadratic(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]
|
|
pub fn DrawSplineBezierCubic(
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineBezierCubic(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline segment: Linear, 2 points
|
|
pub fn DrawSplineSegmentLinear(
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineSegmentLinear(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline segment: B-Spline, 4 points
|
|
pub fn DrawSplineSegmentBasis(
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
p3: Vector2,
|
|
p4: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineSegmentBasis(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p4))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline segment: Catmull-Rom, 4 points
|
|
pub fn DrawSplineSegmentCatmullRom(
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
p3: Vector2,
|
|
p4: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineSegmentCatmullRom(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p4))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline segment: Quadratic Bezier, 2 points, 1 control point
|
|
pub fn DrawSplineSegmentBezierQuadratic(
|
|
p1: Vector2,
|
|
c2: Vector2,
|
|
p3: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineSegmentBezierQuadratic(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&c2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw spline segment: Cubic Bezier, 2 points, 2 control points
|
|
pub fn DrawSplineSegmentBezierCubic(
|
|
p1: Vector2,
|
|
c2: Vector2,
|
|
c3: Vector2,
|
|
p4: Vector2,
|
|
thick: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSplineSegmentBezierCubic(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&c2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&c3))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p4))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Get (evaluate) spline point: Linear
|
|
pub fn GetSplinePointLinear(
|
|
startPos: Vector2,
|
|
endPos: Vector2,
|
|
t: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetSplinePointLinear(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&endPos))),
|
|
t,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get (evaluate) spline point: B-Spline
|
|
pub fn GetSplinePointBasis(
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
p3: Vector2,
|
|
p4: Vector2,
|
|
t: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetSplinePointBasis(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p4))),
|
|
t,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get (evaluate) spline point: Catmull-Rom
|
|
pub fn GetSplinePointCatmullRom(
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
p3: Vector2,
|
|
p4: Vector2,
|
|
t: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetSplinePointCatmullRom(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p4))),
|
|
t,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get (evaluate) spline point: Quadratic Bezier
|
|
pub fn GetSplinePointBezierQuad(
|
|
p1: Vector2,
|
|
c2: Vector2,
|
|
p3: Vector2,
|
|
t: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetSplinePointBezierQuad(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&c2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
t,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get (evaluate) spline point: Cubic Bezier
|
|
pub fn GetSplinePointBezierCubic(
|
|
p1: Vector2,
|
|
c2: Vector2,
|
|
c3: Vector2,
|
|
p4: Vector2,
|
|
t: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mGetSplinePointBezierCubic(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&c2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&c3))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p4))),
|
|
t,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check collision between two rectangles
|
|
pub fn CheckCollisionRecs(
|
|
rec1: Rectangle,
|
|
rec2: Rectangle,
|
|
) bool {
|
|
return raylib.mCheckCollisionRecs(
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec1))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec2))),
|
|
);
|
|
}
|
|
|
|
/// Check collision between two circles
|
|
pub fn CheckCollisionCircles(
|
|
center1: Vector2,
|
|
radius1: f32,
|
|
center2: Vector2,
|
|
radius2: f32,
|
|
) bool {
|
|
return raylib.mCheckCollisionCircles(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er1))),
|
|
radius1,
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er2))),
|
|
radius2,
|
|
);
|
|
}
|
|
|
|
/// Check collision between circle and rectangle
|
|
pub fn CheckCollisionCircleRec(
|
|
center: Vector2,
|
|
radius: f32,
|
|
rec: Rectangle,
|
|
) bool {
|
|
return raylib.mCheckCollisionCircleRec(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
);
|
|
}
|
|
|
|
/// Check if point is inside rectangle
|
|
pub fn CheckCollisionPointRec(
|
|
point: Vector2,
|
|
rec: Rectangle,
|
|
) bool {
|
|
return raylib.mCheckCollisionPointRec(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&point))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
);
|
|
}
|
|
|
|
/// Check if point is inside circle
|
|
pub fn CheckCollisionPointCircle(
|
|
point: Vector2,
|
|
center: Vector2,
|
|
radius: f32,
|
|
) bool {
|
|
return raylib.mCheckCollisionPointCircle(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&point))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
);
|
|
}
|
|
|
|
/// Check if point is inside a triangle
|
|
pub fn CheckCollisionPointTriangle(
|
|
point: Vector2,
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
p3: Vector2,
|
|
) bool {
|
|
return raylib.mCheckCollisionPointTriangle(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&point))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p3))),
|
|
);
|
|
}
|
|
|
|
/// Check if point is within a polygon described by array of vertices
|
|
pub fn CheckCollisionPointPoly(
|
|
point: Vector2,
|
|
points: ?[*]Vector2,
|
|
pointCount: i32,
|
|
) bool {
|
|
return raylib.mCheckCollisionPointPoly(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&point))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
);
|
|
}
|
|
|
|
/// Check the collision between two lines defined by two points each, returns collision point by reference
|
|
pub fn CheckCollisionLines(
|
|
startPos1: Vector2,
|
|
endPos1: Vector2,
|
|
startPos2: Vector2,
|
|
endPos2: Vector2,
|
|
collisionPoint: ?[*]Vector2,
|
|
) bool {
|
|
return raylib.mCheckCollisionLines(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&startPos1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&endPos1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&startPos2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&endPos2))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(collisionPoint))),
|
|
);
|
|
}
|
|
|
|
/// Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
|
|
pub fn CheckCollisionPointLine(
|
|
point: Vector2,
|
|
p1: Vector2,
|
|
p2: Vector2,
|
|
threshold: i32,
|
|
) bool {
|
|
return raylib.mCheckCollisionPointLine(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&point))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p2))),
|
|
threshold,
|
|
);
|
|
}
|
|
|
|
/// Get collision rectangle for two rectangles collision
|
|
pub fn GetCollisionRec(
|
|
rec1: Rectangle,
|
|
rec2: Rectangle,
|
|
) Rectangle {
|
|
var out: Rectangle = undefined;
|
|
raylib.mGetCollisionRec(
|
|
@as([*c]raylib.Rectangle, @ptrCast(&out)),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec1))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image from file into CPU memory (RAM)
|
|
pub fn LoadImage(
|
|
fileName: [*:0]const u8,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImage(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image from RAW file data
|
|
pub fn LoadImageRaw(
|
|
fileName: [*:0]const u8,
|
|
width: i32,
|
|
height: i32,
|
|
format: i32,
|
|
headerSize: i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageRaw(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
width,
|
|
height,
|
|
format,
|
|
headerSize,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image from SVG file data or string with specified size
|
|
pub fn LoadImageSvg(
|
|
fileNameOrString: [*:0]const u8,
|
|
width: i32,
|
|
height: i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageSvg(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileNameOrString))),
|
|
width,
|
|
height,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image sequence from file (frames appended to image.data)
|
|
pub fn LoadImageAnim(
|
|
fileName: [*:0]const u8,
|
|
frames: ?[*]i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageAnim(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
@as([*c]i32, @ptrCast(frames)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image sequence from memory buffer
|
|
pub fn LoadImageAnimFromMemory(
|
|
fileType: [*:0]const u8,
|
|
fileData: [*:0]const u8,
|
|
dataSize: i32,
|
|
frames: ?[*]i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageAnimFromMemory(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileType))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileData))),
|
|
dataSize,
|
|
@as([*c]i32, @ptrCast(frames)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image from memory buffer, fileType refers to extension: i.e. '.png'
|
|
pub fn LoadImageFromMemory(
|
|
fileType: [*:0]const u8,
|
|
fileData: [*:0]const u8,
|
|
dataSize: i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageFromMemory(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileType))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileData))),
|
|
dataSize,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image from GPU texture data
|
|
pub fn LoadImageFromTexture(
|
|
texture: Texture2D,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageFromTexture(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load image from screen buffer and (screenshot)
|
|
pub fn LoadImageFromScreen() Image {
|
|
var out: Image = undefined;
|
|
raylib.mLoadImageFromScreen(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check if an image is ready
|
|
pub fn IsImageReady(
|
|
image: Image,
|
|
) bool {
|
|
return raylib.mIsImageReady(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
);
|
|
}
|
|
|
|
/// Unload image from CPU memory (RAM)
|
|
pub fn UnloadImage(
|
|
image: Image,
|
|
) void {
|
|
raylib.mUnloadImage(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
);
|
|
}
|
|
|
|
/// Export image data to file, returns true on success
|
|
pub fn ExportImage(
|
|
image: Image,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportImage(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Export image to memory buffer
|
|
pub fn ExportImageToMemory(
|
|
image: Image,
|
|
fileType: [*:0]const u8,
|
|
fileSize: ?[*]i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mExportImageToMemory(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileType))),
|
|
@as([*c]i32, @ptrCast(fileSize)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Export image as code file defining an array of bytes, returns true on success
|
|
pub fn ExportImageAsCode(
|
|
image: Image,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportImageAsCode(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Generate image: plain color
|
|
pub fn GenImageColor(
|
|
width: i32,
|
|
height: i32,
|
|
color: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageColor(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient
|
|
pub fn GenImageGradientLinear(
|
|
width: i32,
|
|
height: i32,
|
|
direction: i32,
|
|
start: Color,
|
|
end: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageGradientLinear(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
direction,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&start))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&end))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: radial gradient
|
|
pub fn GenImageGradientRadial(
|
|
width: i32,
|
|
height: i32,
|
|
density: f32,
|
|
inner: Color,
|
|
outer: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageGradientRadial(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
density,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&inner))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&outer))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: square gradient
|
|
pub fn GenImageGradientSquare(
|
|
width: i32,
|
|
height: i32,
|
|
density: f32,
|
|
inner: Color,
|
|
outer: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageGradientSquare(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
density,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&inner))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&outer))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: checked
|
|
pub fn GenImageChecked(
|
|
width: i32,
|
|
height: i32,
|
|
checksX: i32,
|
|
checksY: i32,
|
|
col1: Color,
|
|
col2: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageChecked(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
checksX,
|
|
checksY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&col1))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&col2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: white noise
|
|
pub fn GenImageWhiteNoise(
|
|
width: i32,
|
|
height: i32,
|
|
factor: f32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageWhiteNoise(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
factor,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: perlin noise
|
|
pub fn GenImagePerlinNoise(
|
|
width: i32,
|
|
height: i32,
|
|
offsetX: i32,
|
|
offsetY: i32,
|
|
scale: f32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImagePerlinNoise(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
offsetX,
|
|
offsetY,
|
|
scale,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: cellular algorithm, bigger tileSize means bigger cells
|
|
pub fn GenImageCellular(
|
|
width: i32,
|
|
height: i32,
|
|
tileSize: i32,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageCellular(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
tileSize,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate image: grayscale image from text data
|
|
pub fn GenImageText(
|
|
width: i32,
|
|
height: i32,
|
|
text: [*:0]const u8,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mGenImageText(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Create an image duplicate (useful for transformations)
|
|
pub fn ImageCopy(
|
|
image: Image,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mImageCopy(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Create an image from another image piece
|
|
pub fn ImageFromImage(
|
|
image: Image,
|
|
rec: Rectangle,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mImageFromImage(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Create an image from text (default font)
|
|
pub fn ImageText(
|
|
text: [*:0]const u8,
|
|
fontSize: i32,
|
|
color: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mImageText(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
fontSize,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Create an image from text (custom sprite font)
|
|
pub fn ImageTextEx(
|
|
font: Font,
|
|
text: [*:0]const u8,
|
|
fontSize: f32,
|
|
spacing: f32,
|
|
tint: Color,
|
|
) Image {
|
|
var out: Image = undefined;
|
|
raylib.mImageTextEx(
|
|
@as([*c]raylib.Image, @ptrCast(&out)),
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
fontSize,
|
|
spacing,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Convert image data to desired format
|
|
pub fn ImageFormat(
|
|
image: *Image,
|
|
newFormat: i32,
|
|
) void {
|
|
raylib.mImageFormat(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
newFormat,
|
|
);
|
|
}
|
|
|
|
/// Convert image to POT (power-of-two)
|
|
pub fn ImageToPOT(
|
|
image: *Image,
|
|
fill: Color,
|
|
) void {
|
|
raylib.mImageToPOT(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&fill))),
|
|
);
|
|
}
|
|
|
|
/// Crop an image to a defined rectangle
|
|
pub fn ImageCrop(
|
|
image: *Image,
|
|
crop: Rectangle,
|
|
) void {
|
|
raylib.mImageCrop(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&crop))),
|
|
);
|
|
}
|
|
|
|
/// Crop image depending on alpha value
|
|
pub fn ImageAlphaCrop(
|
|
image: *Image,
|
|
threshold: f32,
|
|
) void {
|
|
raylib.mImageAlphaCrop(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
threshold,
|
|
);
|
|
}
|
|
|
|
/// Clear alpha channel to desired color
|
|
pub fn ImageAlphaClear(
|
|
image: *Image,
|
|
color: Color,
|
|
threshold: f32,
|
|
) void {
|
|
raylib.mImageAlphaClear(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
threshold,
|
|
);
|
|
}
|
|
|
|
/// Apply alpha mask to image
|
|
pub fn ImageAlphaMask(
|
|
image: *Image,
|
|
alphaMask: Image,
|
|
) void {
|
|
raylib.mImageAlphaMask(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&alphaMask))),
|
|
);
|
|
}
|
|
|
|
/// Premultiply alpha channel
|
|
pub fn ImageAlphaPremultiply(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageAlphaPremultiply(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Apply Gaussian blur using a box blur approximation
|
|
pub fn ImageBlurGaussian(
|
|
image: *Image,
|
|
blurSize: i32,
|
|
) void {
|
|
raylib.mImageBlurGaussian(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
blurSize,
|
|
);
|
|
}
|
|
|
|
/// Apply Custom Square image convolution kernel
|
|
pub fn ImageKernelConvolution(
|
|
image: *Image,
|
|
kernel: ?[*]f32,
|
|
kernelSize: i32,
|
|
) void {
|
|
raylib.mImageKernelConvolution(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]f32, @ptrCast(kernel)),
|
|
kernelSize,
|
|
);
|
|
}
|
|
|
|
/// Resize image (Bicubic scaling algorithm)
|
|
pub fn ImageResize(
|
|
image: *Image,
|
|
newWidth: i32,
|
|
newHeight: i32,
|
|
) void {
|
|
raylib.mImageResize(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
newWidth,
|
|
newHeight,
|
|
);
|
|
}
|
|
|
|
/// Resize image (Nearest-Neighbor scaling algorithm)
|
|
pub fn ImageResizeNN(
|
|
image: *Image,
|
|
newWidth: i32,
|
|
newHeight: i32,
|
|
) void {
|
|
raylib.mImageResizeNN(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
newWidth,
|
|
newHeight,
|
|
);
|
|
}
|
|
|
|
/// Resize canvas and fill with color
|
|
pub fn ImageResizeCanvas(
|
|
image: *Image,
|
|
newWidth: i32,
|
|
newHeight: i32,
|
|
offsetX: i32,
|
|
offsetY: i32,
|
|
fill: Color,
|
|
) void {
|
|
raylib.mImageResizeCanvas(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
newWidth,
|
|
newHeight,
|
|
offsetX,
|
|
offsetY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&fill))),
|
|
);
|
|
}
|
|
|
|
/// Compute all mipmap levels for a provided image
|
|
pub fn ImageMipmaps(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageMipmaps(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
|
|
pub fn ImageDither(
|
|
image: *Image,
|
|
rBpp: i32,
|
|
gBpp: i32,
|
|
bBpp: i32,
|
|
aBpp: i32,
|
|
) void {
|
|
raylib.mImageDither(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
rBpp,
|
|
gBpp,
|
|
bBpp,
|
|
aBpp,
|
|
);
|
|
}
|
|
|
|
/// Flip image vertically
|
|
pub fn ImageFlipVertical(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageFlipVertical(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Flip image horizontally
|
|
pub fn ImageFlipHorizontal(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageFlipHorizontal(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Rotate image by input angle in degrees (-359 to 359)
|
|
pub fn ImageRotate(
|
|
image: *Image,
|
|
degrees: i32,
|
|
) void {
|
|
raylib.mImageRotate(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
degrees,
|
|
);
|
|
}
|
|
|
|
/// Rotate image clockwise 90deg
|
|
pub fn ImageRotateCW(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageRotateCW(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Rotate image counter-clockwise 90deg
|
|
pub fn ImageRotateCCW(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageRotateCCW(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Modify image color: tint
|
|
pub fn ImageColorTint(
|
|
image: *Image,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageColorTint(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Modify image color: invert
|
|
pub fn ImageColorInvert(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageColorInvert(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Modify image color: grayscale
|
|
pub fn ImageColorGrayscale(
|
|
image: *Image,
|
|
) void {
|
|
raylib.mImageColorGrayscale(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
);
|
|
}
|
|
|
|
/// Modify image color: contrast (-100 to 100)
|
|
pub fn ImageColorContrast(
|
|
image: *Image,
|
|
contrast: f32,
|
|
) void {
|
|
raylib.mImageColorContrast(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
contrast,
|
|
);
|
|
}
|
|
|
|
/// Modify image color: brightness (-255 to 255)
|
|
pub fn ImageColorBrightness(
|
|
image: *Image,
|
|
brightness: i32,
|
|
) void {
|
|
raylib.mImageColorBrightness(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
brightness,
|
|
);
|
|
}
|
|
|
|
/// Modify image color: replace color
|
|
pub fn ImageColorReplace(
|
|
image: *Image,
|
|
color: Color,
|
|
replace: Color,
|
|
) void {
|
|
raylib.mImageColorReplace(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(image))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&replace))),
|
|
);
|
|
}
|
|
|
|
/// Load color data from image as a Color array (RGBA - 32bit)
|
|
pub fn LoadImageColors(
|
|
image: Image,
|
|
) ?[*]Color {
|
|
return @as(
|
|
?[*]Color,
|
|
@ptrCast(raylib.mLoadImageColors(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Load colors palette from image as a Color array (RGBA - 32bit)
|
|
pub fn LoadImagePalette(
|
|
image: Image,
|
|
maxPaletteSize: i32,
|
|
colorCount: ?[*]i32,
|
|
) ?[*]Color {
|
|
return @as(
|
|
?[*]Color,
|
|
@ptrCast(raylib.mLoadImagePalette(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
maxPaletteSize,
|
|
@as([*c]i32, @ptrCast(colorCount)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload color data loaded with LoadImageColors()
|
|
pub fn UnloadImageColors(
|
|
colors: ?[*]Color,
|
|
) void {
|
|
raylib.mUnloadImageColors(
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(colors))),
|
|
);
|
|
}
|
|
|
|
/// Unload colors palette loaded with LoadImagePalette()
|
|
pub fn UnloadImagePalette(
|
|
colors: ?[*]Color,
|
|
) void {
|
|
raylib.mUnloadImagePalette(
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(colors))),
|
|
);
|
|
}
|
|
|
|
/// Get image alpha border rectangle
|
|
pub fn GetImageAlphaBorder(
|
|
image: Image,
|
|
threshold: f32,
|
|
) Rectangle {
|
|
var out: Rectangle = undefined;
|
|
raylib.mGetImageAlphaBorder(
|
|
@as([*c]raylib.Rectangle, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
threshold,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get image pixel color at (x, y) position
|
|
pub fn GetImageColor(
|
|
image: Image,
|
|
x: i32,
|
|
y: i32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mGetImageColor(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
x,
|
|
y,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Clear image background with given color
|
|
pub fn ImageClearBackground(
|
|
dst: *Image,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageClearBackground(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw pixel within an image
|
|
pub fn ImageDrawPixel(
|
|
dst: *Image,
|
|
posX: i32,
|
|
posY: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawPixel(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
posX,
|
|
posY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw pixel within an image (Vector version)
|
|
pub fn ImageDrawPixelV(
|
|
dst: *Image,
|
|
position: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawPixelV(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw line within an image
|
|
pub fn ImageDrawLine(
|
|
dst: *Image,
|
|
startPosX: i32,
|
|
startPosY: i32,
|
|
endPosX: i32,
|
|
endPosY: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawLine(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
startPosX,
|
|
startPosY,
|
|
endPosX,
|
|
endPosY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw line within an image (Vector version)
|
|
pub fn ImageDrawLineV(
|
|
dst: *Image,
|
|
start: Vector2,
|
|
end: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawLineV(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&start))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&end))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a filled circle within an image
|
|
pub fn ImageDrawCircle(
|
|
dst: *Image,
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radius: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawCircle(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
centerX,
|
|
centerY,
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a filled circle within an image (Vector version)
|
|
pub fn ImageDrawCircleV(
|
|
dst: *Image,
|
|
center: Vector2,
|
|
radius: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawCircleV(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw circle outline within an image
|
|
pub fn ImageDrawCircleLines(
|
|
dst: *Image,
|
|
centerX: i32,
|
|
centerY: i32,
|
|
radius: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawCircleLines(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
centerX,
|
|
centerY,
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw circle outline within an image (Vector version)
|
|
pub fn ImageDrawCircleLinesV(
|
|
dst: *Image,
|
|
center: Vector2,
|
|
radius: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawCircleLinesV(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle within an image
|
|
pub fn ImageDrawRectangle(
|
|
dst: *Image,
|
|
posX: i32,
|
|
posY: i32,
|
|
width: i32,
|
|
height: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawRectangle(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
posX,
|
|
posY,
|
|
width,
|
|
height,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle within an image (Vector version)
|
|
pub fn ImageDrawRectangleV(
|
|
dst: *Image,
|
|
position: Vector2,
|
|
size: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawRectangleV(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle within an image
|
|
pub fn ImageDrawRectangleRec(
|
|
dst: *Image,
|
|
rec: Rectangle,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawRectangleRec(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw rectangle lines within an image
|
|
pub fn ImageDrawRectangleLines(
|
|
dst: *Image,
|
|
rec: Rectangle,
|
|
thick: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawRectangleLines(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
thick,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a source image within a destination image (tint applied to source)
|
|
pub fn ImageDraw(
|
|
dst: *Image,
|
|
src: Image,
|
|
srcRec: Rectangle,
|
|
dstRec: Rectangle,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mImageDraw(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&src))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&srcRec))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&dstRec))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw text (using default font) within an image (destination)
|
|
pub fn ImageDrawText(
|
|
dst: *Image,
|
|
text: [*:0]const u8,
|
|
posX: i32,
|
|
posY: i32,
|
|
fontSize: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mImageDrawText(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
posX,
|
|
posY,
|
|
fontSize,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw text (custom sprite font) within an image (destination)
|
|
pub fn ImageDrawTextEx(
|
|
dst: *Image,
|
|
font: Font,
|
|
text: [*:0]const u8,
|
|
position: Vector2,
|
|
fontSize: f32,
|
|
spacing: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mImageDrawTextEx(
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(dst))),
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
fontSize,
|
|
spacing,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Load texture from file into GPU memory (VRAM)
|
|
pub fn LoadTexture(
|
|
fileName: [*:0]const u8,
|
|
) Texture2D {
|
|
var out: Texture2D = undefined;
|
|
raylib.mLoadTexture(
|
|
@as([*c]raylib.Texture2D, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load texture from image data
|
|
pub fn LoadTextureFromImage(
|
|
image: Image,
|
|
) Texture2D {
|
|
var out: Texture2D = undefined;
|
|
raylib.mLoadTextureFromImage(
|
|
@as([*c]raylib.Texture2D, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load cubemap from image, multiple image cubemap layouts supported
|
|
pub fn LoadTextureCubemap(
|
|
image: Image,
|
|
layout: i32,
|
|
) Texture2D {
|
|
var out: Texture2D = undefined;
|
|
raylib.mLoadTextureCubemap(
|
|
@as([*c]raylib.Texture2D, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
layout,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load texture for rendering (framebuffer)
|
|
pub fn LoadRenderTexture(
|
|
width: i32,
|
|
height: i32,
|
|
) RenderTexture2D {
|
|
var out: RenderTexture2D = undefined;
|
|
raylib.mLoadRenderTexture(
|
|
@as([*c]raylib.RenderTexture2D, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check if a texture is ready
|
|
pub fn IsTextureReady(
|
|
texture: Texture2D,
|
|
) bool {
|
|
return raylib.mIsTextureReady(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
);
|
|
}
|
|
|
|
/// Unload texture from GPU memory (VRAM)
|
|
pub fn UnloadTexture(
|
|
texture: Texture2D,
|
|
) void {
|
|
raylib.mUnloadTexture(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
);
|
|
}
|
|
|
|
/// Check if a render texture is ready
|
|
pub fn IsRenderTextureReady(
|
|
target: RenderTexture2D,
|
|
) bool {
|
|
return raylib.mIsRenderTextureReady(
|
|
@as([*c]raylib.RenderTexture2D, @ptrFromInt(@intFromPtr(&target))),
|
|
);
|
|
}
|
|
|
|
/// Unload render texture from GPU memory (VRAM)
|
|
pub fn UnloadRenderTexture(
|
|
target: RenderTexture2D,
|
|
) void {
|
|
raylib.mUnloadRenderTexture(
|
|
@as([*c]raylib.RenderTexture2D, @ptrFromInt(@intFromPtr(&target))),
|
|
);
|
|
}
|
|
|
|
/// Update GPU texture with new data
|
|
pub fn UpdateTexture(
|
|
texture: Texture2D,
|
|
pixels: *const anyopaque,
|
|
) void {
|
|
raylib.mUpdateTexture(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
pixels,
|
|
);
|
|
}
|
|
|
|
/// Update GPU texture rectangle with new data
|
|
pub fn UpdateTextureRec(
|
|
texture: Texture2D,
|
|
rec: Rectangle,
|
|
pixels: *const anyopaque,
|
|
) void {
|
|
raylib.mUpdateTextureRec(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&rec))),
|
|
pixels,
|
|
);
|
|
}
|
|
|
|
/// Set texture scaling filter mode
|
|
pub fn SetTextureFilter(
|
|
texture: Texture2D,
|
|
filter: i32,
|
|
) void {
|
|
raylib.mSetTextureFilter(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
filter,
|
|
);
|
|
}
|
|
|
|
/// Set texture wrapping mode
|
|
pub fn SetTextureWrap(
|
|
texture: Texture2D,
|
|
wrap: i32,
|
|
) void {
|
|
raylib.mSetTextureWrap(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
wrap,
|
|
);
|
|
}
|
|
|
|
/// Draw a Texture2D
|
|
pub fn DrawTexture(
|
|
texture: Texture2D,
|
|
posX: i32,
|
|
posY: i32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTexture(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
posX,
|
|
posY,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a Texture2D with position defined as Vector2
|
|
pub fn DrawTextureV(
|
|
texture: Texture2D,
|
|
position: Vector2,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextureV(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a Texture2D with extended parameters
|
|
pub fn DrawTextureEx(
|
|
texture: Texture2D,
|
|
position: Vector2,
|
|
rotation: f32,
|
|
scale: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextureEx(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
rotation,
|
|
scale,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a part of a texture defined by a rectangle
|
|
pub fn DrawTextureRec(
|
|
texture: Texture2D,
|
|
source: Rectangle,
|
|
position: Vector2,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextureRec(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&source))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a part of a texture defined by a rectangle with 'pro' parameters
|
|
pub fn DrawTexturePro(
|
|
texture: Texture2D,
|
|
source: Rectangle,
|
|
dest: Rectangle,
|
|
origin: Vector2,
|
|
rotation: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTexturePro(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&source))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&dest))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&origin))),
|
|
rotation,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draws a texture (or part of it) that stretches or shrinks nicely
|
|
pub fn DrawTextureNPatch(
|
|
texture: Texture2D,
|
|
nPatchInfo: NPatchInfo,
|
|
dest: Rectangle,
|
|
origin: Vector2,
|
|
rotation: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextureNPatch(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.NPatchInfo, @ptrFromInt(@intFromPtr(&nPatchInfo))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&dest))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&origin))),
|
|
rotation,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Get color with alpha applied, alpha goes from 0.0f to 1.0f
|
|
pub fn Fade(
|
|
color: Color,
|
|
alpha: f32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mFade(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
alpha,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get hexadecimal value for a Color
|
|
pub fn ColorToInt(
|
|
color: Color,
|
|
) i32 {
|
|
return raylib.mColorToInt(
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Get Color normalized as float [0..1]
|
|
pub fn ColorNormalize(
|
|
color: Color,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mColorNormalize(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get Color from normalized values [0..1]
|
|
pub fn ColorFromNormalized(
|
|
normalized: Vector4,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorFromNormalized(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&normalized))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get HSV values for a Color, hue [0..360], saturation/value [0..1]
|
|
pub fn ColorToHSV(
|
|
color: Color,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mColorToHSV(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get a Color from HSV values, hue [0..360], saturation/value [0..1]
|
|
pub fn ColorFromHSV(
|
|
hue: f32,
|
|
saturation: f32,
|
|
value: f32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorFromHSV(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
hue,
|
|
saturation,
|
|
value,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get color multiplied with another color
|
|
pub fn ColorTint(
|
|
color: Color,
|
|
tint: Color,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorTint(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get color with brightness correction, brightness factor goes from -1.0f to 1.0f
|
|
pub fn ColorBrightness(
|
|
color: Color,
|
|
factor: f32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorBrightness(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
factor,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get color with contrast correction, contrast values between -1.0f and 1.0f
|
|
pub fn ColorContrast(
|
|
color: Color,
|
|
contrast: f32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorContrast(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
contrast,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get color with alpha applied, alpha goes from 0.0f to 1.0f
|
|
pub fn ColorAlpha(
|
|
color: Color,
|
|
alpha: f32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorAlpha(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
alpha,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get src alpha-blended into dst color with tint
|
|
pub fn ColorAlphaBlend(
|
|
dst: Color,
|
|
src: Color,
|
|
tint: Color,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mColorAlphaBlend(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&dst))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&src))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get Color structure from hexadecimal value
|
|
pub fn GetColor(
|
|
hexValue: u32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mGetColor(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
hexValue,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get Color from a source pixel pointer of certain format
|
|
pub fn GetPixelColor(
|
|
srcPtr: *anyopaque,
|
|
format: i32,
|
|
) Color {
|
|
var out: Color = undefined;
|
|
raylib.mGetPixelColor(
|
|
@as([*c]raylib.Color, @ptrCast(&out)),
|
|
srcPtr,
|
|
format,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Set color formatted into destination pixel pointer
|
|
pub fn SetPixelColor(
|
|
dstPtr: *anyopaque,
|
|
color: Color,
|
|
format: i32,
|
|
) void {
|
|
raylib.mSetPixelColor(
|
|
dstPtr,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
format,
|
|
);
|
|
}
|
|
|
|
/// Get pixel data size in bytes for certain format
|
|
pub fn GetPixelDataSize(
|
|
width: i32,
|
|
height: i32,
|
|
format: i32,
|
|
) i32 {
|
|
return raylib.mGetPixelDataSize(
|
|
width,
|
|
height,
|
|
format,
|
|
);
|
|
}
|
|
|
|
/// Get the default Font
|
|
pub fn GetFontDefault() Font {
|
|
var out: Font = undefined;
|
|
raylib.mGetFontDefault(
|
|
@as([*c]raylib.Font, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load font from file into GPU memory (VRAM)
|
|
pub fn LoadFont(
|
|
fileName: [*:0]const u8,
|
|
) Font {
|
|
var out: Font = undefined;
|
|
raylib.mLoadFont(
|
|
@as([*c]raylib.Font, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character setFont
|
|
pub fn LoadFontEx(
|
|
fileName: [*:0]const u8,
|
|
fontSize: i32,
|
|
codepoints: ?[*]i32,
|
|
codepointCount: i32,
|
|
) Font {
|
|
var out: Font = undefined;
|
|
raylib.mLoadFontEx(
|
|
@as([*c]raylib.Font, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
fontSize,
|
|
@as([*c]i32, @ptrCast(codepoints)),
|
|
codepointCount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load font from Image (XNA style)
|
|
pub fn LoadFontFromImage(
|
|
image: Image,
|
|
key: Color,
|
|
firstChar: i32,
|
|
) Font {
|
|
var out: Font = undefined;
|
|
raylib.mLoadFontFromImage(
|
|
@as([*c]raylib.Font, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&image))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&key))),
|
|
firstChar,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
|
|
pub fn LoadFontFromMemory(
|
|
fileType: [*:0]const u8,
|
|
fileData: [*:0]const u8,
|
|
dataSize: i32,
|
|
fontSize: i32,
|
|
codepoints: ?[*]i32,
|
|
codepointCount: i32,
|
|
) Font {
|
|
var out: Font = undefined;
|
|
raylib.mLoadFontFromMemory(
|
|
@as([*c]raylib.Font, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileType))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileData))),
|
|
dataSize,
|
|
fontSize,
|
|
@as([*c]i32, @ptrCast(codepoints)),
|
|
codepointCount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check if a font is ready
|
|
pub fn IsFontReady(
|
|
font: Font,
|
|
) bool {
|
|
return raylib.mIsFontReady(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
);
|
|
}
|
|
|
|
/// Unload font chars info data (RAM)
|
|
pub fn UnloadFontData(
|
|
glyphs: ?[*]GlyphInfo,
|
|
glyphCount: i32,
|
|
) void {
|
|
raylib.mUnloadFontData(
|
|
@as([*c]raylib.GlyphInfo, @ptrFromInt(@intFromPtr(glyphs))),
|
|
glyphCount,
|
|
);
|
|
}
|
|
|
|
/// Unload font from GPU memory (VRAM)
|
|
pub fn UnloadFont(
|
|
font: Font,
|
|
) void {
|
|
raylib.mUnloadFont(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
);
|
|
}
|
|
|
|
/// Export font as code file, returns true on success
|
|
pub fn ExportFontAsCode(
|
|
font: Font,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportFontAsCode(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Draw current FPS
|
|
pub fn DrawFPS(
|
|
posX: i32,
|
|
posY: i32,
|
|
) void {
|
|
raylib.mDrawFPS(
|
|
posX,
|
|
posY,
|
|
);
|
|
}
|
|
|
|
/// Draw text (using default font)
|
|
pub fn DrawText(
|
|
text: [*:0]const u8,
|
|
posX: i32,
|
|
posY: i32,
|
|
fontSize: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawText(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
posX,
|
|
posY,
|
|
fontSize,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw text using font and additional parameters
|
|
pub fn DrawTextEx(
|
|
font: Font,
|
|
text: [*:0]const u8,
|
|
position: Vector2,
|
|
fontSize: f32,
|
|
spacing: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextEx(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
fontSize,
|
|
spacing,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw text using Font and pro parameters (rotation)
|
|
pub fn DrawTextPro(
|
|
font: Font,
|
|
text: [*:0]const u8,
|
|
position: Vector2,
|
|
origin: Vector2,
|
|
rotation: f32,
|
|
fontSize: f32,
|
|
spacing: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextPro(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&origin))),
|
|
rotation,
|
|
fontSize,
|
|
spacing,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw one character (codepoint)
|
|
pub fn DrawTextCodepoint(
|
|
font: Font,
|
|
codepoint: i32,
|
|
position: Vector2,
|
|
fontSize: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextCodepoint(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
codepoint,
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
fontSize,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw multiple character (codepoint)
|
|
pub fn DrawTextCodepoints(
|
|
font: Font,
|
|
codepoints: ?[*]const i32,
|
|
codepointCount: i32,
|
|
position: Vector2,
|
|
fontSize: f32,
|
|
spacing: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawTextCodepoints(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const i32, @ptrFromInt(@intFromPtr(codepoints))),
|
|
codepointCount,
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&position))),
|
|
fontSize,
|
|
spacing,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Set vertical line spacing when drawing with line-breaks
|
|
pub fn SetTextLineSpacing(
|
|
spacing: i32,
|
|
) void {
|
|
raylib.mSetTextLineSpacing(
|
|
spacing,
|
|
);
|
|
}
|
|
|
|
/// Measure string width for default font
|
|
pub fn MeasureText(
|
|
text: [*:0]const u8,
|
|
fontSize: i32,
|
|
) i32 {
|
|
return raylib.mMeasureText(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
fontSize,
|
|
);
|
|
}
|
|
|
|
/// Measure string size for Font
|
|
pub fn MeasureTextEx(
|
|
font: Font,
|
|
text: [*:0]const u8,
|
|
fontSize: f32,
|
|
spacing: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mMeasureTextEx(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
fontSize,
|
|
spacing,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
|
|
pub fn GetGlyphIndex(
|
|
font: Font,
|
|
codepoint: i32,
|
|
) i32 {
|
|
return raylib.mGetGlyphIndex(
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
codepoint,
|
|
);
|
|
}
|
|
|
|
/// Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
|
|
pub fn GetGlyphInfo(
|
|
font: Font,
|
|
codepoint: i32,
|
|
) GlyphInfo {
|
|
var out: GlyphInfo = undefined;
|
|
raylib.mGetGlyphInfo(
|
|
@as([*c]raylib.GlyphInfo, @ptrCast(&out)),
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
codepoint,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
|
|
pub fn GetGlyphAtlasRec(
|
|
font: Font,
|
|
codepoint: i32,
|
|
) Rectangle {
|
|
var out: Rectangle = undefined;
|
|
raylib.mGetGlyphAtlasRec(
|
|
@as([*c]raylib.Rectangle, @ptrCast(&out)),
|
|
@as([*c]raylib.Font, @ptrFromInt(@intFromPtr(&font))),
|
|
codepoint,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load UTF-8 text encoded from codepoints array
|
|
pub fn LoadUTF8(
|
|
codepoints: ?[*]const i32,
|
|
length: i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mLoadUTF8(
|
|
@as([*c]const i32, @ptrFromInt(@intFromPtr(codepoints))),
|
|
length,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload UTF-8 text encoded from codepoints array
|
|
pub fn UnloadUTF8(
|
|
text: ?[*]u8,
|
|
) void {
|
|
raylib.mUnloadUTF8(
|
|
@as([*c]u8, @ptrCast(text)),
|
|
);
|
|
}
|
|
|
|
/// Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
|
|
pub fn LoadCodepoints(
|
|
text: [*:0]const u8,
|
|
count: ?[*]i32,
|
|
) ?[*]i32 {
|
|
return @as(
|
|
?[*]i32,
|
|
@ptrCast(raylib.mLoadCodepoints(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]i32, @ptrCast(count)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload codepoints data from memory
|
|
pub fn UnloadCodepoints(
|
|
codepoints: ?[*]i32,
|
|
) void {
|
|
raylib.mUnloadCodepoints(
|
|
@as([*c]i32, @ptrCast(codepoints)),
|
|
);
|
|
}
|
|
|
|
/// Get total number of codepoints in a UTF-8 encoded string
|
|
pub fn GetCodepointCount(
|
|
text: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mGetCodepointCount(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
);
|
|
}
|
|
|
|
/// Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
|
|
pub fn GetCodepoint(
|
|
text: [*:0]const u8,
|
|
codepointSize: ?[*]i32,
|
|
) i32 {
|
|
return raylib.mGetCodepoint(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]i32, @ptrCast(codepointSize)),
|
|
);
|
|
}
|
|
|
|
/// Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
|
|
pub fn GetCodepointNext(
|
|
text: [*:0]const u8,
|
|
codepointSize: ?[*]i32,
|
|
) i32 {
|
|
return raylib.mGetCodepointNext(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]i32, @ptrCast(codepointSize)),
|
|
);
|
|
}
|
|
|
|
/// Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
|
|
pub fn GetCodepointPrevious(
|
|
text: [*:0]const u8,
|
|
codepointSize: ?[*]i32,
|
|
) i32 {
|
|
return raylib.mGetCodepointPrevious(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]i32, @ptrCast(codepointSize)),
|
|
);
|
|
}
|
|
|
|
/// Encode one codepoint into UTF-8 byte array (array length returned as parameter)
|
|
pub fn CodepointToUTF8(
|
|
codepoint: i32,
|
|
utf8Size: ?[*]i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mCodepointToUTF8(
|
|
codepoint,
|
|
@as([*c]i32, @ptrCast(utf8Size)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Copy one string to another, returns bytes copied
|
|
pub fn TextCopy(
|
|
dst: ?[*]u8,
|
|
src: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mTextCopy(
|
|
@as([*c]u8, @ptrCast(dst)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(src))),
|
|
);
|
|
}
|
|
|
|
/// Check if two text string are equal
|
|
pub fn TextIsEqual(
|
|
text1: [*:0]const u8,
|
|
text2: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mTextIsEqual(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text1))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text2))),
|
|
);
|
|
}
|
|
|
|
/// Get text length, checks for '\0' ending
|
|
pub fn TextLength(
|
|
text: [*:0]const u8,
|
|
) u32 {
|
|
return raylib.mTextLength(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
);
|
|
}
|
|
|
|
/// Generate GPU mipmaps for a texture
|
|
pub fn GenTextureMipmaps(
|
|
texture: *Texture2D,
|
|
) void {
|
|
raylib.mGenTextureMipmaps(
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(texture))),
|
|
);
|
|
}
|
|
|
|
/// Get a piece of a text string
|
|
pub fn TextSubtext(
|
|
text: [*:0]const u8,
|
|
position: i32,
|
|
length: i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mTextSubtext(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
position,
|
|
length,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Replace text string (WARNING: memory must be freed!)
|
|
pub fn TextReplace(
|
|
text: [*:0]const u8,
|
|
replace: [*:0]const u8,
|
|
by: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mTextReplace(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(replace))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(by))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Insert text in a position (WARNING: memory must be freed!)
|
|
pub fn TextInsert(
|
|
text: [*:0]const u8,
|
|
insert: [*:0]const u8,
|
|
position: i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mTextInsert(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(insert))),
|
|
position,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Load font data for further use
|
|
pub fn LoadFontData(
|
|
fileData: [*:0]const u8,
|
|
dataSize: i32,
|
|
fontSize: i32,
|
|
fontChars: [*]i32,
|
|
glyphCount: i32,
|
|
typ: i32,
|
|
) [*]GlyphInfo {
|
|
return @as(
|
|
[*]GlyphInfo,
|
|
@ptrCast(raylib.mLoadFontData(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileData))),
|
|
dataSize,
|
|
fontSize,
|
|
@as([*c]i32, @ptrCast(fontChars)),
|
|
glyphCount,
|
|
typ,
|
|
)),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn rlSetVertexAttribute(
|
|
index: u32,
|
|
compSize: i32,
|
|
typ: i32,
|
|
normalized: bool,
|
|
stride: i32,
|
|
pointer: *anyopaque,
|
|
) void {
|
|
raylib.mrlSetVertexAttribute(
|
|
index,
|
|
compSize,
|
|
typ,
|
|
normalized,
|
|
stride,
|
|
pointer,
|
|
);
|
|
}
|
|
|
|
/// Find first text occurrence within a string
|
|
pub fn TextFindIndex(
|
|
text: [*:0]const u8,
|
|
find: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mTextFindIndex(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(find))),
|
|
);
|
|
}
|
|
|
|
/// Get upper case version of provided string
|
|
pub fn TextToUpper(
|
|
text: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mTextToUpper(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get lower case version of provided string
|
|
pub fn TextToLower(
|
|
text: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mTextToLower(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get Pascal case notation version of provided string
|
|
pub fn TextToPascal(
|
|
text: [*:0]const u8,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mTextToPascal(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Get integer value from text (negative values not supported)
|
|
pub fn TextToInteger(
|
|
text: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mTextToInteger(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
);
|
|
}
|
|
|
|
/// Get float value from text (negative values not supported)
|
|
pub fn TextToFloat(
|
|
text: [*:0]const u8,
|
|
) f32 {
|
|
return raylib.mTextToFloat(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(text))),
|
|
);
|
|
}
|
|
|
|
/// Draw a line in 3D world space
|
|
pub fn DrawLine3D(
|
|
startPos: Vector3,
|
|
endPos: Vector3,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawLine3D(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&endPos))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a point in 3D space, actually a small line
|
|
pub fn DrawPoint3D(
|
|
position: Vector3,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPoint3D(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a circle in 3D world space
|
|
pub fn DrawCircle3D(
|
|
center: Vector3,
|
|
radius: f32,
|
|
rotationAxis: Vector3,
|
|
rotationAngle: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCircle3D(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&rotationAxis))),
|
|
rotationAngle,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a color-filled triangle (vertex in counter-clockwise order!)
|
|
pub fn DrawTriangle3D(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
v3: Vector3,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawTriangle3D(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v3))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a triangle strip defined by points
|
|
pub fn DrawTriangleStrip3D(
|
|
points: ?[*]Vector3,
|
|
pointCount: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawTriangleStrip3D(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(points))),
|
|
pointCount,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw cube
|
|
pub fn DrawCube(
|
|
position: Vector3,
|
|
width: f32,
|
|
height: f32,
|
|
length: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCube(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
width,
|
|
height,
|
|
length,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw cube (Vector version)
|
|
pub fn DrawCubeV(
|
|
position: Vector3,
|
|
size: Vector3,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCubeV(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw cube wires
|
|
pub fn DrawCubeWires(
|
|
position: Vector3,
|
|
width: f32,
|
|
height: f32,
|
|
length: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCubeWires(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
width,
|
|
height,
|
|
length,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw cube wires (Vector version)
|
|
pub fn DrawCubeWiresV(
|
|
position: Vector3,
|
|
size: Vector3,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCubeWiresV(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw sphere
|
|
pub fn DrawSphere(
|
|
centerPos: Vector3,
|
|
radius: f32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSphere(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢erPos))),
|
|
radius,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw sphere with extended parameters
|
|
pub fn DrawSphereEx(
|
|
centerPos: Vector3,
|
|
radius: f32,
|
|
rings: i32,
|
|
slices: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSphereEx(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢erPos))),
|
|
radius,
|
|
rings,
|
|
slices,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw sphere wires
|
|
pub fn DrawSphereWires(
|
|
centerPos: Vector3,
|
|
radius: f32,
|
|
rings: i32,
|
|
slices: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawSphereWires(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢erPos))),
|
|
radius,
|
|
rings,
|
|
slices,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a cylinder/cone
|
|
pub fn DrawCylinder(
|
|
position: Vector3,
|
|
radiusTop: f32,
|
|
radiusBottom: f32,
|
|
height: f32,
|
|
slices: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCylinder(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
radiusTop,
|
|
radiusBottom,
|
|
height,
|
|
slices,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a cylinder with base at startPos and top at endPos
|
|
pub fn DrawCylinderEx(
|
|
startPos: Vector3,
|
|
endPos: Vector3,
|
|
startRadius: f32,
|
|
endRadius: f32,
|
|
sides: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCylinderEx(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&endPos))),
|
|
startRadius,
|
|
endRadius,
|
|
sides,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a cylinder/cone wires
|
|
pub fn DrawCylinderWires(
|
|
position: Vector3,
|
|
radiusTop: f32,
|
|
radiusBottom: f32,
|
|
height: f32,
|
|
slices: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCylinderWires(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
radiusTop,
|
|
radiusBottom,
|
|
height,
|
|
slices,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a cylinder wires with base at startPos and top at endPos
|
|
pub fn DrawCylinderWiresEx(
|
|
startPos: Vector3,
|
|
endPos: Vector3,
|
|
startRadius: f32,
|
|
endRadius: f32,
|
|
sides: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCylinderWiresEx(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&endPos))),
|
|
startRadius,
|
|
endRadius,
|
|
sides,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a capsule with the center of its sphere caps at startPos and endPos
|
|
pub fn DrawCapsule(
|
|
startPos: Vector3,
|
|
endPos: Vector3,
|
|
radius: f32,
|
|
slices: i32,
|
|
rings: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCapsule(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&endPos))),
|
|
radius,
|
|
slices,
|
|
rings,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw capsule wireframe with the center of its sphere caps at startPos and endPos
|
|
pub fn DrawCapsuleWires(
|
|
startPos: Vector3,
|
|
endPos: Vector3,
|
|
radius: f32,
|
|
slices: i32,
|
|
rings: i32,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawCapsuleWires(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&startPos))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&endPos))),
|
|
radius,
|
|
slices,
|
|
rings,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a plane XZ
|
|
pub fn DrawPlane(
|
|
centerPos: Vector3,
|
|
size: Vector2,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawPlane(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢erPos))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a ray line
|
|
pub fn DrawRay(
|
|
ray: Ray,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawRay(
|
|
@as([*c]raylib.Ray, @ptrFromInt(@intFromPtr(&ray))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a grid (centered at (0, 0, 0))
|
|
pub fn DrawGrid(
|
|
slices: i32,
|
|
spacing: f32,
|
|
) void {
|
|
raylib.mDrawGrid(
|
|
slices,
|
|
spacing,
|
|
);
|
|
}
|
|
|
|
/// Load model from files (meshes and materials)
|
|
pub fn LoadModel(
|
|
fileName: [*:0]const u8,
|
|
) Model {
|
|
var out: Model = undefined;
|
|
raylib.mLoadModel(
|
|
@as([*c]raylib.Model, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load model from generated mesh (default material)
|
|
pub fn LoadModelFromMesh(
|
|
mesh: Mesh,
|
|
) Model {
|
|
var out: Model = undefined;
|
|
raylib.mLoadModelFromMesh(
|
|
@as([*c]raylib.Model, @ptrCast(&out)),
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check if a model is ready
|
|
pub fn IsModelReady(
|
|
model: Model,
|
|
) bool {
|
|
return raylib.mIsModelReady(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
);
|
|
}
|
|
|
|
/// Unload model (including meshes) from memory (RAM and/or VRAM)
|
|
pub fn UnloadModel(
|
|
model: Model,
|
|
) void {
|
|
raylib.mUnloadModel(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
);
|
|
}
|
|
|
|
/// Compute model bounding box limits (considers all meshes)
|
|
pub fn GetModelBoundingBox(
|
|
model: Model,
|
|
) BoundingBox {
|
|
var out: BoundingBox = undefined;
|
|
raylib.mGetModelBoundingBox(
|
|
@as([*c]raylib.BoundingBox, @ptrCast(&out)),
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Draw a model (with texture if set)
|
|
pub fn DrawModel(
|
|
model: Model,
|
|
position: Vector3,
|
|
scale: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawModel(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
scale,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a model with extended parameters
|
|
pub fn DrawModelEx(
|
|
model: Model,
|
|
position: Vector3,
|
|
rotationAxis: Vector3,
|
|
rotationAngle: f32,
|
|
scale: Vector3,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawModelEx(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&rotationAxis))),
|
|
rotationAngle,
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&scale))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a model wires (with texture if set)
|
|
pub fn DrawModelWires(
|
|
model: Model,
|
|
position: Vector3,
|
|
scale: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawModelWires(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
scale,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a model wires (with texture if set) with extended parameters
|
|
pub fn DrawModelWiresEx(
|
|
model: Model,
|
|
position: Vector3,
|
|
rotationAxis: Vector3,
|
|
rotationAngle: f32,
|
|
scale: Vector3,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawModelWiresEx(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&rotationAxis))),
|
|
rotationAngle,
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&scale))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw bounding box (wires)
|
|
pub fn DrawBoundingBox(
|
|
box: BoundingBox,
|
|
color: Color,
|
|
) void {
|
|
raylib.mDrawBoundingBox(
|
|
@as([*c]raylib.BoundingBox, @ptrFromInt(@intFromPtr(&box))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&color))),
|
|
);
|
|
}
|
|
|
|
/// Draw a billboard texture
|
|
pub fn DrawBillboard(
|
|
camera: Camera3D,
|
|
texture: Texture2D,
|
|
position: Vector3,
|
|
size: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawBillboard(
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
size,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a billboard texture defined by source
|
|
pub fn DrawBillboardRec(
|
|
camera: Camera3D,
|
|
texture: Texture2D,
|
|
source: Rectangle,
|
|
position: Vector3,
|
|
size: Vector2,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawBillboardRec(
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&source))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Draw a billboard texture defined by source and rotation
|
|
pub fn DrawBillboardPro(
|
|
camera: Camera3D,
|
|
texture: Texture2D,
|
|
source: Rectangle,
|
|
position: Vector3,
|
|
up: Vector3,
|
|
size: Vector2,
|
|
origin: Vector2,
|
|
rotation: f32,
|
|
tint: Color,
|
|
) void {
|
|
raylib.mDrawBillboardPro(
|
|
@as([*c]raylib.Camera3D, @ptrFromInt(@intFromPtr(&camera))),
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
@as([*c]raylib.Rectangle, @ptrFromInt(@intFromPtr(&source))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&position))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&up))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&size))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&origin))),
|
|
rotation,
|
|
@as([*c]raylib.Color, @ptrFromInt(@intFromPtr(&tint))),
|
|
);
|
|
}
|
|
|
|
/// Upload mesh vertex data in GPU and provide VAO/VBO ids
|
|
pub fn UploadMesh(
|
|
mesh: ?[*]Mesh,
|
|
dynamic: bool,
|
|
) void {
|
|
raylib.mUploadMesh(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(mesh))),
|
|
dynamic,
|
|
);
|
|
}
|
|
|
|
/// Update mesh vertex data in GPU for a specific buffer index
|
|
pub fn UpdateMeshBuffer(
|
|
mesh: Mesh,
|
|
index: i32,
|
|
data: *const anyopaque,
|
|
dataSize: i32,
|
|
offset: i32,
|
|
) void {
|
|
raylib.mUpdateMeshBuffer(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
index,
|
|
data,
|
|
dataSize,
|
|
offset,
|
|
);
|
|
}
|
|
|
|
/// Unload mesh data from CPU and GPU
|
|
pub fn UnloadMesh(
|
|
mesh: Mesh,
|
|
) void {
|
|
raylib.mUnloadMesh(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
);
|
|
}
|
|
|
|
/// Draw a 3d mesh with material and transform
|
|
pub fn DrawMesh(
|
|
mesh: Mesh,
|
|
material: Material,
|
|
transform: Matrix,
|
|
) void {
|
|
raylib.mDrawMesh(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
@as([*c]raylib.Material, @ptrFromInt(@intFromPtr(&material))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&transform))),
|
|
);
|
|
}
|
|
|
|
/// Draw multiple mesh instances with material and different transforms
|
|
pub fn DrawMeshInstanced(
|
|
mesh: Mesh,
|
|
material: Material,
|
|
transforms: ?[*]const Matrix,
|
|
instances: i32,
|
|
) void {
|
|
raylib.mDrawMeshInstanced(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
@as([*c]raylib.Material, @ptrFromInt(@intFromPtr(&material))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(transforms))),
|
|
instances,
|
|
);
|
|
}
|
|
|
|
/// Compute mesh bounding box limits
|
|
pub fn GetMeshBoundingBox(
|
|
mesh: Mesh,
|
|
) BoundingBox {
|
|
var out: BoundingBox = undefined;
|
|
raylib.mGetMeshBoundingBox(
|
|
@as([*c]raylib.BoundingBox, @ptrCast(&out)),
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Compute mesh tangents
|
|
pub fn GenMeshTangents(
|
|
mesh: ?[*]Mesh,
|
|
) void {
|
|
raylib.mGenMeshTangents(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(mesh))),
|
|
);
|
|
}
|
|
|
|
/// Export mesh data to file, returns true on success
|
|
pub fn ExportMesh(
|
|
mesh: Mesh,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportMesh(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Export mesh as code file (.h) defining multiple arrays of vertex attributes
|
|
pub fn ExportMeshAsCode(
|
|
mesh: Mesh,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportMeshAsCode(
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Generate polygonal mesh
|
|
pub fn GenMeshPoly(
|
|
sides: i32,
|
|
radius: f32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshPoly(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
sides,
|
|
radius,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate plane mesh (with subdivisions)
|
|
pub fn GenMeshPlane(
|
|
width: f32,
|
|
length: f32,
|
|
resX: i32,
|
|
resZ: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshPlane(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
width,
|
|
length,
|
|
resX,
|
|
resZ,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate cuboid mesh
|
|
pub fn GenMeshCube(
|
|
width: f32,
|
|
height: f32,
|
|
length: f32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshCube(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
width,
|
|
height,
|
|
length,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate sphere mesh (standard sphere)
|
|
pub fn GenMeshSphere(
|
|
radius: f32,
|
|
rings: i32,
|
|
slices: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshSphere(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
radius,
|
|
rings,
|
|
slices,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate half-sphere mesh (no bottom cap)
|
|
pub fn GenMeshHemiSphere(
|
|
radius: f32,
|
|
rings: i32,
|
|
slices: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshHemiSphere(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
radius,
|
|
rings,
|
|
slices,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate cylinder mesh
|
|
pub fn GenMeshCylinder(
|
|
radius: f32,
|
|
height: f32,
|
|
slices: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshCylinder(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
radius,
|
|
height,
|
|
slices,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate cone/pyramid mesh
|
|
pub fn GenMeshCone(
|
|
radius: f32,
|
|
height: f32,
|
|
slices: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshCone(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
radius,
|
|
height,
|
|
slices,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate torus mesh
|
|
pub fn GenMeshTorus(
|
|
radius: f32,
|
|
size: f32,
|
|
radSeg: i32,
|
|
sides: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshTorus(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
radius,
|
|
size,
|
|
radSeg,
|
|
sides,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate trefoil knot mesh
|
|
pub fn GenMeshKnot(
|
|
radius: f32,
|
|
size: f32,
|
|
radSeg: i32,
|
|
sides: i32,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshKnot(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
radius,
|
|
size,
|
|
radSeg,
|
|
sides,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate heightmap mesh from image data
|
|
pub fn GenMeshHeightmap(
|
|
heightmap: Image,
|
|
size: Vector3,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshHeightmap(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&heightmap))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&size))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Generate cubes-based map mesh from image data
|
|
pub fn GenMeshCubicmap(
|
|
cubicmap: Image,
|
|
cubeSize: Vector3,
|
|
) Mesh {
|
|
var out: Mesh = undefined;
|
|
raylib.mGenMeshCubicmap(
|
|
@as([*c]raylib.Mesh, @ptrCast(&out)),
|
|
@as([*c]raylib.Image, @ptrFromInt(@intFromPtr(&cubicmap))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&cubeSize))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load materials from model file
|
|
pub fn LoadMaterials(
|
|
fileName: [*:0]const u8,
|
|
materialCount: ?[*]i32,
|
|
) ?[*]Material {
|
|
return @as(
|
|
?[*]Material,
|
|
@ptrCast(raylib.mLoadMaterials(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
@as([*c]i32, @ptrCast(materialCount)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
|
|
pub fn LoadMaterialDefault() Material {
|
|
var out: Material = undefined;
|
|
raylib.mLoadMaterialDefault(
|
|
@as([*c]raylib.Material, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Check if a material is ready
|
|
pub fn IsMaterialReady(
|
|
material: Material,
|
|
) bool {
|
|
return raylib.mIsMaterialReady(
|
|
@as([*c]raylib.Material, @ptrFromInt(@intFromPtr(&material))),
|
|
);
|
|
}
|
|
|
|
/// Unload material from GPU memory (VRAM)
|
|
pub fn UnloadMaterial(
|
|
material: Material,
|
|
) void {
|
|
raylib.mUnloadMaterial(
|
|
@as([*c]raylib.Material, @ptrFromInt(@intFromPtr(&material))),
|
|
);
|
|
}
|
|
|
|
/// Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
|
|
pub fn SetMaterialTexture(
|
|
material: ?[*]Material,
|
|
mapType: i32,
|
|
texture: Texture2D,
|
|
) void {
|
|
raylib.mSetMaterialTexture(
|
|
@as([*c]raylib.Material, @ptrFromInt(@intFromPtr(material))),
|
|
mapType,
|
|
@as([*c]raylib.Texture2D, @ptrFromInt(@intFromPtr(&texture))),
|
|
);
|
|
}
|
|
|
|
/// Set material for a mesh
|
|
pub fn SetModelMeshMaterial(
|
|
model: ?[*]Model,
|
|
meshId: i32,
|
|
materialId: i32,
|
|
) void {
|
|
raylib.mSetModelMeshMaterial(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(model))),
|
|
meshId,
|
|
materialId,
|
|
);
|
|
}
|
|
|
|
/// Load model animations from file
|
|
pub fn LoadModelAnimations(
|
|
fileName: [*:0]const u8,
|
|
animCount: ?[*]i32,
|
|
) ?[*]ModelAnimation {
|
|
return @as(
|
|
?[*]ModelAnimation,
|
|
@ptrCast(raylib.mLoadModelAnimations(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
@as([*c]i32, @ptrCast(animCount)),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Update model animation pose
|
|
pub fn UpdateModelAnimation(
|
|
model: Model,
|
|
anim: ModelAnimation,
|
|
frame: i32,
|
|
) void {
|
|
raylib.mUpdateModelAnimation(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
@as([*c]raylib.ModelAnimation, @ptrFromInt(@intFromPtr(&anim))),
|
|
frame,
|
|
);
|
|
}
|
|
|
|
/// Unload animation data
|
|
pub fn UnloadModelAnimation(
|
|
anim: ModelAnimation,
|
|
) void {
|
|
raylib.mUnloadModelAnimation(
|
|
@as([*c]raylib.ModelAnimation, @ptrFromInt(@intFromPtr(&anim))),
|
|
);
|
|
}
|
|
|
|
/// Unload animation array data
|
|
pub fn UnloadModelAnimations(
|
|
animations: ?[*]ModelAnimation,
|
|
animCount: i32,
|
|
) void {
|
|
raylib.mUnloadModelAnimations(
|
|
@as([*c]raylib.ModelAnimation, @ptrFromInt(@intFromPtr(animations))),
|
|
animCount,
|
|
);
|
|
}
|
|
|
|
/// Check model animation skeleton match
|
|
pub fn IsModelAnimationValid(
|
|
model: Model,
|
|
anim: ModelAnimation,
|
|
) bool {
|
|
return raylib.mIsModelAnimationValid(
|
|
@as([*c]raylib.Model, @ptrFromInt(@intFromPtr(&model))),
|
|
@as([*c]raylib.ModelAnimation, @ptrFromInt(@intFromPtr(&anim))),
|
|
);
|
|
}
|
|
|
|
/// Check collision between two spheres
|
|
pub fn CheckCollisionSpheres(
|
|
center1: Vector3,
|
|
radius1: f32,
|
|
center2: Vector3,
|
|
radius2: f32,
|
|
) bool {
|
|
return raylib.mCheckCollisionSpheres(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢er1))),
|
|
radius1,
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢er2))),
|
|
radius2,
|
|
);
|
|
}
|
|
|
|
/// Check collision between two bounding boxes
|
|
pub fn CheckCollisionBoxes(
|
|
box1: BoundingBox,
|
|
box2: BoundingBox,
|
|
) bool {
|
|
return raylib.mCheckCollisionBoxes(
|
|
@as([*c]raylib.BoundingBox, @ptrFromInt(@intFromPtr(&box1))),
|
|
@as([*c]raylib.BoundingBox, @ptrFromInt(@intFromPtr(&box2))),
|
|
);
|
|
}
|
|
|
|
/// Check collision between box and sphere
|
|
pub fn CheckCollisionBoxSphere(
|
|
box: BoundingBox,
|
|
center: Vector3,
|
|
radius: f32,
|
|
) bool {
|
|
return raylib.mCheckCollisionBoxSphere(
|
|
@as([*c]raylib.BoundingBox, @ptrFromInt(@intFromPtr(&box))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
);
|
|
}
|
|
|
|
/// Get collision info between ray and sphere
|
|
pub fn GetRayCollisionSphere(
|
|
ray: Ray,
|
|
center: Vector3,
|
|
radius: f32,
|
|
) RayCollision {
|
|
var out: RayCollision = undefined;
|
|
raylib.mGetRayCollisionSphere(
|
|
@as([*c]raylib.RayCollision, @ptrCast(&out)),
|
|
@as([*c]raylib.Ray, @ptrFromInt(@intFromPtr(&ray))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(¢er))),
|
|
radius,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get collision info between ray and box
|
|
pub fn GetRayCollisionBox(
|
|
ray: Ray,
|
|
box: BoundingBox,
|
|
) RayCollision {
|
|
var out: RayCollision = undefined;
|
|
raylib.mGetRayCollisionBox(
|
|
@as([*c]raylib.RayCollision, @ptrCast(&out)),
|
|
@as([*c]raylib.Ray, @ptrFromInt(@intFromPtr(&ray))),
|
|
@as([*c]raylib.BoundingBox, @ptrFromInt(@intFromPtr(&box))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get collision info between ray and mesh
|
|
pub fn GetRayCollisionMesh(
|
|
ray: Ray,
|
|
mesh: Mesh,
|
|
transform: Matrix,
|
|
) RayCollision {
|
|
var out: RayCollision = undefined;
|
|
raylib.mGetRayCollisionMesh(
|
|
@as([*c]raylib.RayCollision, @ptrCast(&out)),
|
|
@as([*c]raylib.Ray, @ptrFromInt(@intFromPtr(&ray))),
|
|
@as([*c]raylib.Mesh, @ptrFromInt(@intFromPtr(&mesh))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&transform))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get collision info between ray and triangle
|
|
pub fn GetRayCollisionTriangle(
|
|
ray: Ray,
|
|
p1: Vector3,
|
|
p2: Vector3,
|
|
p3: Vector3,
|
|
) RayCollision {
|
|
var out: RayCollision = undefined;
|
|
raylib.mGetRayCollisionTriangle(
|
|
@as([*c]raylib.RayCollision, @ptrCast(&out)),
|
|
@as([*c]raylib.Ray, @ptrFromInt(@intFromPtr(&ray))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p3))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get collision info between ray and quad
|
|
pub fn GetRayCollisionQuad(
|
|
ray: Ray,
|
|
p1: Vector3,
|
|
p2: Vector3,
|
|
p3: Vector3,
|
|
p4: Vector3,
|
|
) RayCollision {
|
|
var out: RayCollision = undefined;
|
|
raylib.mGetRayCollisionQuad(
|
|
@as([*c]raylib.RayCollision, @ptrCast(&out)),
|
|
@as([*c]raylib.Ray, @ptrFromInt(@intFromPtr(&ray))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p2))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p3))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p4))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Initialize audio device and context
|
|
pub fn InitAudioDevice() void {
|
|
raylib.mInitAudioDevice();
|
|
}
|
|
|
|
/// Close the audio device and context
|
|
pub fn CloseAudioDevice() void {
|
|
raylib.mCloseAudioDevice();
|
|
}
|
|
|
|
/// Check if audio device has been initialized successfully
|
|
pub fn IsAudioDeviceReady() bool {
|
|
return raylib.mIsAudioDeviceReady();
|
|
}
|
|
|
|
/// Set master volume (listener)
|
|
pub fn SetMasterVolume(
|
|
volume: f32,
|
|
) void {
|
|
raylib.mSetMasterVolume(
|
|
volume,
|
|
);
|
|
}
|
|
|
|
/// Get master volume (listener)
|
|
pub fn GetMasterVolume() f32 {
|
|
return raylib.mGetMasterVolume();
|
|
}
|
|
|
|
/// Load wave data from file
|
|
pub fn LoadWave(
|
|
fileName: [*:0]const u8,
|
|
) Wave {
|
|
var out: Wave = undefined;
|
|
raylib.mLoadWave(
|
|
@as([*c]raylib.Wave, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
|
|
pub fn LoadWaveFromMemory(
|
|
fileType: [*:0]const u8,
|
|
fileData: [*:0]const u8,
|
|
dataSize: i32,
|
|
) Wave {
|
|
var out: Wave = undefined;
|
|
raylib.mLoadWaveFromMemory(
|
|
@as([*c]raylib.Wave, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileType))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileData))),
|
|
dataSize,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Checks if wave data is ready
|
|
pub fn IsWaveReady(
|
|
wave: Wave,
|
|
) bool {
|
|
return raylib.mIsWaveReady(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
);
|
|
}
|
|
|
|
/// Load sound from file
|
|
pub fn LoadSound(
|
|
fileName: [*:0]const u8,
|
|
) Sound {
|
|
var out: Sound = undefined;
|
|
raylib.mLoadSound(
|
|
@as([*c]raylib.Sound, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load sound from wave data
|
|
pub fn LoadSoundFromWave(
|
|
wave: Wave,
|
|
) Sound {
|
|
var out: Sound = undefined;
|
|
raylib.mLoadSoundFromWave(
|
|
@as([*c]raylib.Sound, @ptrCast(&out)),
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Create a new sound that shares the same sample data as the source sound, does not own the sound data
|
|
pub fn LoadSoundAlias(
|
|
source: Sound,
|
|
) Sound {
|
|
var out: Sound = undefined;
|
|
raylib.mLoadSoundAlias(
|
|
@as([*c]raylib.Sound, @ptrCast(&out)),
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&source))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Checks if a sound is ready
|
|
pub fn IsSoundReady(
|
|
sound: Sound,
|
|
) bool {
|
|
return raylib.mIsSoundReady(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Update sound buffer with new data
|
|
pub fn UpdateSound(
|
|
sound: Sound,
|
|
data: *const anyopaque,
|
|
sampleCount: i32,
|
|
) void {
|
|
raylib.mUpdateSound(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
data,
|
|
sampleCount,
|
|
);
|
|
}
|
|
|
|
/// Unload wave data
|
|
pub fn UnloadWave(
|
|
wave: Wave,
|
|
) void {
|
|
raylib.mUnloadWave(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
);
|
|
}
|
|
|
|
/// Unload sound
|
|
pub fn UnloadSound(
|
|
sound: Sound,
|
|
) void {
|
|
raylib.mUnloadSound(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Unload a sound alias (does not deallocate sample data)
|
|
pub fn UnloadSoundAlias(
|
|
alias: Sound,
|
|
) void {
|
|
raylib.mUnloadSoundAlias(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&alias))),
|
|
);
|
|
}
|
|
|
|
/// Export wave data to file, returns true on success
|
|
pub fn ExportWave(
|
|
wave: Wave,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportWave(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Export wave sample data to code (.h), returns true on success
|
|
pub fn ExportWaveAsCode(
|
|
wave: Wave,
|
|
fileName: [*:0]const u8,
|
|
) bool {
|
|
return raylib.mExportWaveAsCode(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
}
|
|
|
|
/// Play a sound
|
|
pub fn PlaySound(
|
|
sound: Sound,
|
|
) void {
|
|
raylib.mPlaySound(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Stop playing a sound
|
|
pub fn StopSound(
|
|
sound: Sound,
|
|
) void {
|
|
raylib.mStopSound(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Pause a sound
|
|
pub fn PauseSound(
|
|
sound: Sound,
|
|
) void {
|
|
raylib.mPauseSound(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Resume a paused sound
|
|
pub fn ResumeSound(
|
|
sound: Sound,
|
|
) void {
|
|
raylib.mResumeSound(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Check if a sound is currently playing
|
|
pub fn IsSoundPlaying(
|
|
sound: Sound,
|
|
) bool {
|
|
return raylib.mIsSoundPlaying(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
);
|
|
}
|
|
|
|
/// Set volume for a sound (1.0 is max level)
|
|
pub fn SetSoundVolume(
|
|
sound: Sound,
|
|
volume: f32,
|
|
) void {
|
|
raylib.mSetSoundVolume(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
volume,
|
|
);
|
|
}
|
|
|
|
/// Set pitch for a sound (1.0 is base level)
|
|
pub fn SetSoundPitch(
|
|
sound: Sound,
|
|
pitch: f32,
|
|
) void {
|
|
raylib.mSetSoundPitch(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
pitch,
|
|
);
|
|
}
|
|
|
|
/// Set pan for a sound (0.5 is center)
|
|
pub fn SetSoundPan(
|
|
sound: Sound,
|
|
pan: f32,
|
|
) void {
|
|
raylib.mSetSoundPan(
|
|
@as([*c]raylib.Sound, @ptrFromInt(@intFromPtr(&sound))),
|
|
pan,
|
|
);
|
|
}
|
|
|
|
/// Copy a wave to a new wave
|
|
pub fn WaveCopy(
|
|
wave: Wave,
|
|
) Wave {
|
|
var out: Wave = undefined;
|
|
raylib.mWaveCopy(
|
|
@as([*c]raylib.Wave, @ptrCast(&out)),
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Crop a wave to defined samples range
|
|
pub fn WaveCrop(
|
|
wave: ?[*]Wave,
|
|
initSample: i32,
|
|
finalSample: i32,
|
|
) void {
|
|
raylib.mWaveCrop(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(wave))),
|
|
initSample,
|
|
finalSample,
|
|
);
|
|
}
|
|
|
|
/// Convert wave data to desired format
|
|
pub fn WaveFormat(
|
|
wave: ?[*]Wave,
|
|
sampleRate: i32,
|
|
sampleSize: i32,
|
|
channels: i32,
|
|
) void {
|
|
raylib.mWaveFormat(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(wave))),
|
|
sampleRate,
|
|
sampleSize,
|
|
channels,
|
|
);
|
|
}
|
|
|
|
/// Load samples data from wave as a 32bit float data array
|
|
pub fn LoadWaveSamples(
|
|
wave: Wave,
|
|
) ?[*]f32 {
|
|
return @as(
|
|
?[*]f32,
|
|
@ptrCast(raylib.mLoadWaveSamples(
|
|
@as([*c]raylib.Wave, @ptrFromInt(@intFromPtr(&wave))),
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload samples data loaded with LoadWaveSamples()
|
|
pub fn UnloadWaveSamples(
|
|
samples: ?[*]f32,
|
|
) void {
|
|
raylib.mUnloadWaveSamples(
|
|
@as([*c]f32, @ptrCast(samples)),
|
|
);
|
|
}
|
|
|
|
/// Load music stream from file
|
|
pub fn LoadMusicStream(
|
|
fileName: [*:0]const u8,
|
|
) Music {
|
|
var out: Music = undefined;
|
|
raylib.mLoadMusicStream(
|
|
@as([*c]raylib.Music, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Load music stream from data
|
|
pub fn LoadMusicStreamFromMemory(
|
|
fileType: [*:0]const u8,
|
|
data: [*:0]const u8,
|
|
dataSize: i32,
|
|
) Music {
|
|
var out: Music = undefined;
|
|
raylib.mLoadMusicStreamFromMemory(
|
|
@as([*c]raylib.Music, @ptrCast(&out)),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileType))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(data))),
|
|
dataSize,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Checks if a music stream is ready
|
|
pub fn IsMusicReady(
|
|
music: Music,
|
|
) bool {
|
|
return raylib.mIsMusicReady(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Unload music stream
|
|
pub fn UnloadMusicStream(
|
|
music: Music,
|
|
) void {
|
|
raylib.mUnloadMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Start music playing
|
|
pub fn PlayMusicStream(
|
|
music: Music,
|
|
) void {
|
|
raylib.mPlayMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Check if music is playing
|
|
pub fn IsMusicStreamPlaying(
|
|
music: Music,
|
|
) bool {
|
|
return raylib.mIsMusicStreamPlaying(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Updates buffers for music streaming
|
|
pub fn UpdateMusicStream(
|
|
music: Music,
|
|
) void {
|
|
raylib.mUpdateMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Stop music playing
|
|
pub fn StopMusicStream(
|
|
music: Music,
|
|
) void {
|
|
raylib.mStopMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Pause music playing
|
|
pub fn PauseMusicStream(
|
|
music: Music,
|
|
) void {
|
|
raylib.mPauseMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Resume playing paused music
|
|
pub fn ResumeMusicStream(
|
|
music: Music,
|
|
) void {
|
|
raylib.mResumeMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Seek music to a position (in seconds)
|
|
pub fn SeekMusicStream(
|
|
music: Music,
|
|
position: f32,
|
|
) void {
|
|
raylib.mSeekMusicStream(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
position,
|
|
);
|
|
}
|
|
|
|
/// Set volume for music (1.0 is max level)
|
|
pub fn SetMusicVolume(
|
|
music: Music,
|
|
volume: f32,
|
|
) void {
|
|
raylib.mSetMusicVolume(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
volume,
|
|
);
|
|
}
|
|
|
|
/// Set pitch for a music (1.0 is base level)
|
|
pub fn SetMusicPitch(
|
|
music: Music,
|
|
pitch: f32,
|
|
) void {
|
|
raylib.mSetMusicPitch(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
pitch,
|
|
);
|
|
}
|
|
|
|
/// Set pan for a music (0.5 is center)
|
|
pub fn SetMusicPan(
|
|
music: Music,
|
|
pan: f32,
|
|
) void {
|
|
raylib.mSetMusicPan(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
pan,
|
|
);
|
|
}
|
|
|
|
/// Get music time length (in seconds)
|
|
pub fn GetMusicTimeLength(
|
|
music: Music,
|
|
) f32 {
|
|
return raylib.mGetMusicTimeLength(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Get current music time played (in seconds)
|
|
pub fn GetMusicTimePlayed(
|
|
music: Music,
|
|
) f32 {
|
|
return raylib.mGetMusicTimePlayed(
|
|
@as([*c]raylib.Music, @ptrFromInt(@intFromPtr(&music))),
|
|
);
|
|
}
|
|
|
|
/// Load audio stream (to stream raw audio pcm data)
|
|
pub fn LoadAudioStream(
|
|
sampleRate: u32,
|
|
sampleSize: u32,
|
|
channels: u32,
|
|
) AudioStream {
|
|
var out: AudioStream = undefined;
|
|
raylib.mLoadAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrCast(&out)),
|
|
sampleRate,
|
|
sampleSize,
|
|
channels,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Checks if an audio stream is ready
|
|
pub fn IsAudioStreamReady(
|
|
stream: AudioStream,
|
|
) bool {
|
|
return raylib.mIsAudioStreamReady(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Unload audio stream and free memory
|
|
pub fn UnloadAudioStream(
|
|
stream: AudioStream,
|
|
) void {
|
|
raylib.mUnloadAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Update audio stream buffers with data
|
|
pub fn UpdateAudioStream(
|
|
stream: AudioStream,
|
|
data: *const anyopaque,
|
|
frameCount: i32,
|
|
) void {
|
|
raylib.mUpdateAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
data,
|
|
frameCount,
|
|
);
|
|
}
|
|
|
|
/// Check if any audio stream buffers requires refill
|
|
pub fn IsAudioStreamProcessed(
|
|
stream: AudioStream,
|
|
) bool {
|
|
return raylib.mIsAudioStreamProcessed(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Play audio stream
|
|
pub fn PlayAudioStream(
|
|
stream: AudioStream,
|
|
) void {
|
|
raylib.mPlayAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Pause audio stream
|
|
pub fn PauseAudioStream(
|
|
stream: AudioStream,
|
|
) void {
|
|
raylib.mPauseAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Resume audio stream
|
|
pub fn ResumeAudioStream(
|
|
stream: AudioStream,
|
|
) void {
|
|
raylib.mResumeAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Check if audio stream is playing
|
|
pub fn IsAudioStreamPlaying(
|
|
stream: AudioStream,
|
|
) bool {
|
|
return raylib.mIsAudioStreamPlaying(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Stop audio stream
|
|
pub fn StopAudioStream(
|
|
stream: AudioStream,
|
|
) void {
|
|
raylib.mStopAudioStream(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
);
|
|
}
|
|
|
|
/// Set volume for audio stream (1.0 is max level)
|
|
pub fn SetAudioStreamVolume(
|
|
stream: AudioStream,
|
|
volume: f32,
|
|
) void {
|
|
raylib.mSetAudioStreamVolume(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
volume,
|
|
);
|
|
}
|
|
|
|
/// Set pitch for audio stream (1.0 is base level)
|
|
pub fn SetAudioStreamPitch(
|
|
stream: AudioStream,
|
|
pitch: f32,
|
|
) void {
|
|
raylib.mSetAudioStreamPitch(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
pitch,
|
|
);
|
|
}
|
|
|
|
/// Set pan for audio stream (0.5 is centered)
|
|
pub fn SetAudioStreamPan(
|
|
stream: AudioStream,
|
|
pan: f32,
|
|
) void {
|
|
raylib.mSetAudioStreamPan(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
pan,
|
|
);
|
|
}
|
|
|
|
/// Default size for new audio streams
|
|
pub fn SetAudioStreamBufferSizeDefault(
|
|
size: i32,
|
|
) void {
|
|
raylib.mSetAudioStreamBufferSizeDefault(
|
|
size,
|
|
);
|
|
}
|
|
|
|
/// Audio thread callback to request new data
|
|
pub fn SetAudioStreamCallback(
|
|
stream: AudioStream,
|
|
callback: AudioCallback,
|
|
) void {
|
|
raylib.mSetAudioStreamCallback(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
@ptrCast(callback),
|
|
);
|
|
}
|
|
|
|
/// Attach audio stream processor to stream, receives the samples as <float>s
|
|
pub fn AttachAudioStreamProcessor(
|
|
stream: AudioStream,
|
|
processor: AudioCallback,
|
|
) void {
|
|
raylib.mAttachAudioStreamProcessor(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
@ptrCast(processor),
|
|
);
|
|
}
|
|
|
|
/// Detach audio stream processor from stream
|
|
pub fn DetachAudioStreamProcessor(
|
|
stream: AudioStream,
|
|
processor: AudioCallback,
|
|
) void {
|
|
raylib.mDetachAudioStreamProcessor(
|
|
@as([*c]raylib.AudioStream, @ptrFromInt(@intFromPtr(&stream))),
|
|
@ptrCast(processor),
|
|
);
|
|
}
|
|
|
|
/// Attach audio stream processor to the entire audio pipeline, receives the samples as <float>s
|
|
pub fn AttachAudioMixedProcessor(
|
|
processor: AudioCallback,
|
|
) void {
|
|
raylib.mAttachAudioMixedProcessor(
|
|
@ptrCast(processor),
|
|
);
|
|
}
|
|
|
|
/// Detach audio stream processor from the entire audio pipeline
|
|
pub fn DetachAudioMixedProcessor(
|
|
processor: AudioCallback,
|
|
) void {
|
|
raylib.mDetachAudioMixedProcessor(
|
|
@ptrCast(processor),
|
|
);
|
|
}
|
|
|
|
/// Choose the current matrix to be transformed
|
|
pub fn rlMatrixMode(
|
|
mode: i32,
|
|
) void {
|
|
raylib.mrlMatrixMode(
|
|
mode,
|
|
);
|
|
}
|
|
|
|
/// Push the current matrix to stack
|
|
pub fn rlPushMatrix() void {
|
|
raylib.mrlPushMatrix();
|
|
}
|
|
|
|
/// Pop latest inserted matrix from stack
|
|
pub fn rlPopMatrix() void {
|
|
raylib.mrlPopMatrix();
|
|
}
|
|
|
|
/// Reset current matrix to identity matrix
|
|
pub fn rlLoadIdentity() void {
|
|
raylib.mrlLoadIdentity();
|
|
}
|
|
|
|
/// Multiply the current matrix by a translation matrix
|
|
pub fn rlTranslatef(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) void {
|
|
raylib.mrlTranslatef(
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
}
|
|
|
|
/// Multiply the current matrix by a rotation matrix
|
|
pub fn rlRotatef(
|
|
angle: f32,
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) void {
|
|
raylib.mrlRotatef(
|
|
angle,
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
}
|
|
|
|
/// Multiply the current matrix by a scaling matrix
|
|
pub fn rlScalef(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) void {
|
|
raylib.mrlScalef(
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
}
|
|
|
|
/// Multiply the current matrix by another matrix
|
|
pub fn rlMultMatrixf(
|
|
matf: ?[*]const f32,
|
|
) void {
|
|
raylib.mrlMultMatrixf(
|
|
@as([*c]const f32, @ptrFromInt(@intFromPtr(matf))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn rlFrustum(
|
|
left: f64,
|
|
right: f64,
|
|
bottom: f64,
|
|
top: f64,
|
|
znear: f64,
|
|
zfar: f64,
|
|
) void {
|
|
raylib.mrlFrustum(
|
|
left,
|
|
right,
|
|
bottom,
|
|
top,
|
|
znear,
|
|
zfar,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn rlOrtho(
|
|
left: f64,
|
|
right: f64,
|
|
bottom: f64,
|
|
top: f64,
|
|
znear: f64,
|
|
zfar: f64,
|
|
) void {
|
|
raylib.mrlOrtho(
|
|
left,
|
|
right,
|
|
bottom,
|
|
top,
|
|
znear,
|
|
zfar,
|
|
);
|
|
}
|
|
|
|
/// Set the viewport area
|
|
pub fn rlViewport(
|
|
x: i32,
|
|
y: i32,
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mrlViewport(
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Initialize drawing mode (how to organize vertex)
|
|
pub fn rlBegin(
|
|
mode: i32,
|
|
) void {
|
|
raylib.mrlBegin(
|
|
mode,
|
|
);
|
|
}
|
|
|
|
/// Finish vertex providing
|
|
pub fn rlEnd() void {
|
|
raylib.mrlEnd();
|
|
}
|
|
|
|
/// Define one vertex (position) - 2 int
|
|
pub fn rlVertex2i(
|
|
x: i32,
|
|
y: i32,
|
|
) void {
|
|
raylib.mrlVertex2i(
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (position) - 2 float
|
|
pub fn rlVertex2f(
|
|
x: f32,
|
|
y: f32,
|
|
) void {
|
|
raylib.mrlVertex2f(
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (position) - 3 float
|
|
pub fn rlVertex3f(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) void {
|
|
raylib.mrlVertex3f(
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (texture coordinate) - 2 float
|
|
pub fn rlTexCoord2f(
|
|
x: f32,
|
|
y: f32,
|
|
) void {
|
|
raylib.mrlTexCoord2f(
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (normal) - 3 float
|
|
pub fn rlNormal3f(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) void {
|
|
raylib.mrlNormal3f(
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (color) - 4 byte
|
|
pub fn rlColor4ub(
|
|
r: u8,
|
|
g: u8,
|
|
b: u8,
|
|
a: u8,
|
|
) void {
|
|
raylib.mrlColor4ub(
|
|
r,
|
|
g,
|
|
b,
|
|
a,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (color) - 3 float
|
|
pub fn rlColor3f(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) void {
|
|
raylib.mrlColor3f(
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
}
|
|
|
|
/// Define one vertex (color) - 4 float
|
|
pub fn rlColor4f(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
w: f32,
|
|
) void {
|
|
raylib.mrlColor4f(
|
|
x,
|
|
y,
|
|
z,
|
|
w,
|
|
);
|
|
}
|
|
|
|
/// Enable vertex array (VAO, if supported)
|
|
pub fn rlEnableVertexArray(
|
|
vaoId: u32,
|
|
) bool {
|
|
return raylib.mrlEnableVertexArray(
|
|
vaoId,
|
|
);
|
|
}
|
|
|
|
/// Disable vertex array (VAO, if supported)
|
|
pub fn rlDisableVertexArray() void {
|
|
raylib.mrlDisableVertexArray();
|
|
}
|
|
|
|
/// Enable vertex buffer (VBO)
|
|
pub fn rlEnableVertexBuffer(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlEnableVertexBuffer(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Disable vertex buffer (VBO)
|
|
pub fn rlDisableVertexBuffer() void {
|
|
raylib.mrlDisableVertexBuffer();
|
|
}
|
|
|
|
/// Enable vertex buffer element (VBO element)
|
|
pub fn rlEnableVertexBufferElement(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlEnableVertexBufferElement(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Disable vertex buffer element (VBO element)
|
|
pub fn rlDisableVertexBufferElement() void {
|
|
raylib.mrlDisableVertexBufferElement();
|
|
}
|
|
|
|
/// Enable vertex attribute index
|
|
pub fn rlEnableVertexAttribute(
|
|
index: u32,
|
|
) void {
|
|
raylib.mrlEnableVertexAttribute(
|
|
index,
|
|
);
|
|
}
|
|
|
|
/// Disable vertex attribute index
|
|
pub fn rlDisableVertexAttribute(
|
|
index: u32,
|
|
) void {
|
|
raylib.mrlDisableVertexAttribute(
|
|
index,
|
|
);
|
|
}
|
|
|
|
/// Select and active a texture slot
|
|
pub fn rlActiveTextureSlot(
|
|
slot: i32,
|
|
) void {
|
|
raylib.mrlActiveTextureSlot(
|
|
slot,
|
|
);
|
|
}
|
|
|
|
/// Enable texture
|
|
pub fn rlEnableTexture(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlEnableTexture(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Disable texture
|
|
pub fn rlDisableTexture() void {
|
|
raylib.mrlDisableTexture();
|
|
}
|
|
|
|
/// Enable texture cubemap
|
|
pub fn rlEnableTextureCubemap(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlEnableTextureCubemap(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Disable texture cubemap
|
|
pub fn rlDisableTextureCubemap() void {
|
|
raylib.mrlDisableTextureCubemap();
|
|
}
|
|
|
|
/// Set texture parameters (filter, wrap)
|
|
pub fn rlTextureParameters(
|
|
id: u32,
|
|
param: i32,
|
|
value: i32,
|
|
) void {
|
|
raylib.mrlTextureParameters(
|
|
id,
|
|
param,
|
|
value,
|
|
);
|
|
}
|
|
|
|
/// Set cubemap parameters (filter, wrap)
|
|
pub fn rlCubemapParameters(
|
|
id: u32,
|
|
param: i32,
|
|
value: i32,
|
|
) void {
|
|
raylib.mrlCubemapParameters(
|
|
id,
|
|
param,
|
|
value,
|
|
);
|
|
}
|
|
|
|
/// Enable shader program
|
|
pub fn rlEnableShader(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlEnableShader(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Disable shader program
|
|
pub fn rlDisableShader() void {
|
|
raylib.mrlDisableShader();
|
|
}
|
|
|
|
/// Enable render texture (fbo)
|
|
pub fn rlEnableFramebuffer(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlEnableFramebuffer(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Disable render texture (fbo), return to default framebuffer
|
|
pub fn rlDisableFramebuffer() void {
|
|
raylib.mrlDisableFramebuffer();
|
|
}
|
|
|
|
/// Activate multiple draw color buffers
|
|
pub fn rlActiveDrawBuffers(
|
|
count: i32,
|
|
) void {
|
|
raylib.mrlActiveDrawBuffers(
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Blit active framebuffer to main framebuffer
|
|
pub fn rlBlitFramebuffer(
|
|
srcX: i32,
|
|
srcY: i32,
|
|
srcWidth: i32,
|
|
srcHeight: i32,
|
|
dstX: i32,
|
|
dstY: i32,
|
|
dstWidth: i32,
|
|
dstHeight: i32,
|
|
bufferMask: i32,
|
|
) void {
|
|
raylib.mrlBlitFramebuffer(
|
|
srcX,
|
|
srcY,
|
|
srcWidth,
|
|
srcHeight,
|
|
dstX,
|
|
dstY,
|
|
dstWidth,
|
|
dstHeight,
|
|
bufferMask,
|
|
);
|
|
}
|
|
|
|
/// Bind framebuffer (FBO)
|
|
pub fn rlBindFramebuffer(
|
|
target: u32,
|
|
framebuffer: u32,
|
|
) void {
|
|
raylib.mrlBindFramebuffer(
|
|
target,
|
|
framebuffer,
|
|
);
|
|
}
|
|
|
|
/// Enable color blending
|
|
pub fn rlEnableColorBlend() void {
|
|
raylib.mrlEnableColorBlend();
|
|
}
|
|
|
|
/// Disable color blending
|
|
pub fn rlDisableColorBlend() void {
|
|
raylib.mrlDisableColorBlend();
|
|
}
|
|
|
|
/// Enable depth test
|
|
pub fn rlEnableDepthTest() void {
|
|
raylib.mrlEnableDepthTest();
|
|
}
|
|
|
|
/// Disable depth test
|
|
pub fn rlDisableDepthTest() void {
|
|
raylib.mrlDisableDepthTest();
|
|
}
|
|
|
|
/// Enable depth write
|
|
pub fn rlEnableDepthMask() void {
|
|
raylib.mrlEnableDepthMask();
|
|
}
|
|
|
|
/// Disable depth write
|
|
pub fn rlDisableDepthMask() void {
|
|
raylib.mrlDisableDepthMask();
|
|
}
|
|
|
|
/// Enable backface culling
|
|
pub fn rlEnableBackfaceCulling() void {
|
|
raylib.mrlEnableBackfaceCulling();
|
|
}
|
|
|
|
/// Disable backface culling
|
|
pub fn rlDisableBackfaceCulling() void {
|
|
raylib.mrlDisableBackfaceCulling();
|
|
}
|
|
|
|
/// Color mask control
|
|
pub fn rlColorMask(
|
|
r: bool,
|
|
g: bool,
|
|
b: bool,
|
|
a: bool,
|
|
) void {
|
|
raylib.mrlColorMask(
|
|
r,
|
|
g,
|
|
b,
|
|
a,
|
|
);
|
|
}
|
|
|
|
/// Set face culling mode
|
|
pub fn rlSetCullFace(
|
|
mode: i32,
|
|
) void {
|
|
raylib.mrlSetCullFace(
|
|
mode,
|
|
);
|
|
}
|
|
|
|
/// Enable scissor test
|
|
pub fn rlEnableScissorTest() void {
|
|
raylib.mrlEnableScissorTest();
|
|
}
|
|
|
|
/// Disable scissor test
|
|
pub fn rlDisableScissorTest() void {
|
|
raylib.mrlDisableScissorTest();
|
|
}
|
|
|
|
/// Scissor test
|
|
pub fn rlScissor(
|
|
x: i32,
|
|
y: i32,
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mrlScissor(
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Enable wire mode
|
|
pub fn rlEnableWireMode() void {
|
|
raylib.mrlEnableWireMode();
|
|
}
|
|
|
|
/// Enable point mode
|
|
pub fn rlEnablePointMode() void {
|
|
raylib.mrlEnablePointMode();
|
|
}
|
|
|
|
/// Disable wire mode ( and point ) maybe rename
|
|
pub fn rlDisableWireMode() void {
|
|
raylib.mrlDisableWireMode();
|
|
}
|
|
|
|
/// Set the line drawing width
|
|
pub fn rlSetLineWidth(
|
|
width: f32,
|
|
) void {
|
|
raylib.mrlSetLineWidth(
|
|
width,
|
|
);
|
|
}
|
|
|
|
/// Get the line drawing width
|
|
pub fn rlGetLineWidth() f32 {
|
|
return raylib.mrlGetLineWidth();
|
|
}
|
|
|
|
/// Enable line aliasing
|
|
pub fn rlEnableSmoothLines() void {
|
|
raylib.mrlEnableSmoothLines();
|
|
}
|
|
|
|
/// Disable line aliasing
|
|
pub fn rlDisableSmoothLines() void {
|
|
raylib.mrlDisableSmoothLines();
|
|
}
|
|
|
|
/// Enable stereo rendering
|
|
pub fn rlEnableStereoRender() void {
|
|
raylib.mrlEnableStereoRender();
|
|
}
|
|
|
|
/// Disable stereo rendering
|
|
pub fn rlDisableStereoRender() void {
|
|
raylib.mrlDisableStereoRender();
|
|
}
|
|
|
|
/// Check if stereo render is enabled
|
|
pub fn rlIsStereoRenderEnabled() bool {
|
|
return raylib.mrlIsStereoRenderEnabled();
|
|
}
|
|
|
|
/// Clear color buffer with color
|
|
pub fn rlClearColor(
|
|
r: u8,
|
|
g: u8,
|
|
b: u8,
|
|
a: u8,
|
|
) void {
|
|
raylib.mrlClearColor(
|
|
r,
|
|
g,
|
|
b,
|
|
a,
|
|
);
|
|
}
|
|
|
|
/// Clear used screen buffers (color and depth)
|
|
pub fn rlClearScreenBuffers() void {
|
|
raylib.mrlClearScreenBuffers();
|
|
}
|
|
|
|
/// Check and log OpenGL error codes
|
|
pub fn rlCheckErrors() void {
|
|
raylib.mrlCheckErrors();
|
|
}
|
|
|
|
/// Set blending mode
|
|
pub fn rlSetBlendMode(
|
|
mode: i32,
|
|
) void {
|
|
raylib.mrlSetBlendMode(
|
|
mode,
|
|
);
|
|
}
|
|
|
|
/// Set blending mode factor and equation (using OpenGL factors)
|
|
pub fn rlSetBlendFactors(
|
|
glSrcFactor: i32,
|
|
glDstFactor: i32,
|
|
glEquation: i32,
|
|
) void {
|
|
raylib.mrlSetBlendFactors(
|
|
glSrcFactor,
|
|
glDstFactor,
|
|
glEquation,
|
|
);
|
|
}
|
|
|
|
/// Set blending mode factors and equations separately (using OpenGL factors)
|
|
pub fn rlSetBlendFactorsSeparate(
|
|
glSrcRGB: i32,
|
|
glDstRGB: i32,
|
|
glSrcAlpha: i32,
|
|
glDstAlpha: i32,
|
|
glEqRGB: i32,
|
|
glEqAlpha: i32,
|
|
) void {
|
|
raylib.mrlSetBlendFactorsSeparate(
|
|
glSrcRGB,
|
|
glDstRGB,
|
|
glSrcAlpha,
|
|
glDstAlpha,
|
|
glEqRGB,
|
|
glEqAlpha,
|
|
);
|
|
}
|
|
|
|
/// Initialize rlgl (buffers, shaders, textures, states)
|
|
pub fn rlglInit(
|
|
width: i32,
|
|
height: i32,
|
|
) void {
|
|
raylib.mrlglInit(
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// De-initialize rlgl (buffers, shaders, textures)
|
|
pub fn rlglClose() void {
|
|
raylib.mrlglClose();
|
|
}
|
|
|
|
/// Load OpenGL extensions (loader function required)
|
|
pub fn rlLoadExtensions(
|
|
loader: *anyopaque,
|
|
) void {
|
|
raylib.mrlLoadExtensions(
|
|
loader,
|
|
);
|
|
}
|
|
|
|
/// Get current OpenGL version
|
|
pub fn rlGetVersion() i32 {
|
|
return raylib.mrlGetVersion();
|
|
}
|
|
|
|
/// Set current framebuffer width
|
|
pub fn rlSetFramebufferWidth(
|
|
width: i32,
|
|
) void {
|
|
raylib.mrlSetFramebufferWidth(
|
|
width,
|
|
);
|
|
}
|
|
|
|
/// Get default framebuffer width
|
|
pub fn rlGetFramebufferWidth() i32 {
|
|
return raylib.mrlGetFramebufferWidth();
|
|
}
|
|
|
|
/// Set current framebuffer height
|
|
pub fn rlSetFramebufferHeight(
|
|
height: i32,
|
|
) void {
|
|
raylib.mrlSetFramebufferHeight(
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Get default framebuffer height
|
|
pub fn rlGetFramebufferHeight() i32 {
|
|
return raylib.mrlGetFramebufferHeight();
|
|
}
|
|
|
|
/// Get default texture id
|
|
pub fn rlGetTextureIdDefault() u32 {
|
|
return raylib.mrlGetTextureIdDefault();
|
|
}
|
|
|
|
/// Get default shader id
|
|
pub fn rlGetShaderIdDefault() u32 {
|
|
return raylib.mrlGetShaderIdDefault();
|
|
}
|
|
|
|
/// Get default shader locations
|
|
pub fn rlGetShaderLocsDefault() ?[*]i32 {
|
|
return @as(
|
|
?[*]i32,
|
|
@ptrCast(raylib.mrlGetShaderLocsDefault()),
|
|
);
|
|
}
|
|
|
|
/// Load a render batch system
|
|
pub fn rlLoadRenderBatch(
|
|
numBuffers: i32,
|
|
bufferElements: i32,
|
|
) rlRenderBatch {
|
|
var out: rlRenderBatch = undefined;
|
|
raylib.mrlLoadRenderBatch(
|
|
@as([*c]raylib.rlRenderBatch, @ptrCast(&out)),
|
|
numBuffers,
|
|
bufferElements,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Unload render batch system
|
|
pub fn rlUnloadRenderBatch(
|
|
batch: rlRenderBatch,
|
|
) void {
|
|
raylib.mrlUnloadRenderBatch(
|
|
@as([*c]raylib.rlRenderBatch, @ptrFromInt(@intFromPtr(&batch))),
|
|
);
|
|
}
|
|
|
|
/// Draw render batch data (Update->Draw->Reset)
|
|
pub fn rlDrawRenderBatch(
|
|
batch: ?[*]rlRenderBatch,
|
|
) void {
|
|
raylib.mrlDrawRenderBatch(
|
|
@as([*c]raylib.rlRenderBatch, @ptrFromInt(@intFromPtr(batch))),
|
|
);
|
|
}
|
|
|
|
/// Set the active render batch for rlgl (NULL for default internal)
|
|
pub fn rlSetRenderBatchActive(
|
|
batch: ?[*]rlRenderBatch,
|
|
) void {
|
|
raylib.mrlSetRenderBatchActive(
|
|
@as([*c]raylib.rlRenderBatch, @ptrFromInt(@intFromPtr(batch))),
|
|
);
|
|
}
|
|
|
|
/// Update and draw internal render batch
|
|
pub fn rlDrawRenderBatchActive() void {
|
|
raylib.mrlDrawRenderBatchActive();
|
|
}
|
|
|
|
/// Check internal buffer overflow for a given number of vertex
|
|
pub fn rlCheckRenderBatchLimit(
|
|
vCount: i32,
|
|
) bool {
|
|
return raylib.mrlCheckRenderBatchLimit(
|
|
vCount,
|
|
);
|
|
}
|
|
|
|
/// Set current texture for render batch and check buffers limits
|
|
pub fn rlSetTexture(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlSetTexture(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Load vertex array (vao) if supported
|
|
pub fn rlLoadVertexArray() u32 {
|
|
return raylib.mrlLoadVertexArray();
|
|
}
|
|
|
|
/// Load a vertex buffer object
|
|
pub fn rlLoadVertexBuffer(
|
|
buffer: *const anyopaque,
|
|
size: i32,
|
|
dynamic: bool,
|
|
) u32 {
|
|
return raylib.mrlLoadVertexBuffer(
|
|
buffer,
|
|
size,
|
|
dynamic,
|
|
);
|
|
}
|
|
|
|
/// Load vertex buffer elements object
|
|
pub fn rlLoadVertexBufferElement(
|
|
buffer: *const anyopaque,
|
|
size: i32,
|
|
dynamic: bool,
|
|
) u32 {
|
|
return raylib.mrlLoadVertexBufferElement(
|
|
buffer,
|
|
size,
|
|
dynamic,
|
|
);
|
|
}
|
|
|
|
/// Update vertex buffer object data on GPU buffer
|
|
pub fn rlUpdateVertexBuffer(
|
|
bufferId: u32,
|
|
data: *const anyopaque,
|
|
dataSize: i32,
|
|
offset: i32,
|
|
) void {
|
|
raylib.mrlUpdateVertexBuffer(
|
|
bufferId,
|
|
data,
|
|
dataSize,
|
|
offset,
|
|
);
|
|
}
|
|
|
|
/// Update vertex buffer elements data on GPU buffer
|
|
pub fn rlUpdateVertexBufferElements(
|
|
id: u32,
|
|
data: *const anyopaque,
|
|
dataSize: i32,
|
|
offset: i32,
|
|
) void {
|
|
raylib.mrlUpdateVertexBufferElements(
|
|
id,
|
|
data,
|
|
dataSize,
|
|
offset,
|
|
);
|
|
}
|
|
|
|
/// Unload vertex array (vao)
|
|
pub fn rlUnloadVertexArray(
|
|
vaoId: u32,
|
|
) void {
|
|
raylib.mrlUnloadVertexArray(
|
|
vaoId,
|
|
);
|
|
}
|
|
|
|
/// Unload vertex buffer object
|
|
pub fn rlUnloadVertexBuffer(
|
|
vboId: u32,
|
|
) void {
|
|
raylib.mrlUnloadVertexBuffer(
|
|
vboId,
|
|
);
|
|
}
|
|
|
|
/// Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
|
|
pub fn rlCompileShader(
|
|
shaderCode: [*:0]const u8,
|
|
typ: i32,
|
|
) u32 {
|
|
return raylib.mrlCompileShader(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(shaderCode))),
|
|
typ,
|
|
);
|
|
}
|
|
|
|
/// Set vertex attribute data divisor
|
|
pub fn rlSetVertexAttributeDivisor(
|
|
index: u32,
|
|
divisor: i32,
|
|
) void {
|
|
raylib.mrlSetVertexAttributeDivisor(
|
|
index,
|
|
divisor,
|
|
);
|
|
}
|
|
|
|
/// Set vertex attribute default value, when attribute to provided
|
|
pub fn rlSetVertexAttributeDefault(
|
|
locIndex: i32,
|
|
value: *const anyopaque,
|
|
attribType: i32,
|
|
count: i32,
|
|
) void {
|
|
raylib.mrlSetVertexAttributeDefault(
|
|
locIndex,
|
|
value,
|
|
attribType,
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Draw vertex array (currently active vao)
|
|
pub fn rlDrawVertexArray(
|
|
offset: i32,
|
|
count: i32,
|
|
) void {
|
|
raylib.mrlDrawVertexArray(
|
|
offset,
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Draw vertex array elements
|
|
pub fn rlDrawVertexArrayElements(
|
|
offset: i32,
|
|
count: i32,
|
|
buffer: *const anyopaque,
|
|
) void {
|
|
raylib.mrlDrawVertexArrayElements(
|
|
offset,
|
|
count,
|
|
buffer,
|
|
);
|
|
}
|
|
|
|
/// Draw vertex array (currently active vao) with instancing
|
|
pub fn rlDrawVertexArrayInstanced(
|
|
offset: i32,
|
|
count: i32,
|
|
instances: i32,
|
|
) void {
|
|
raylib.mrlDrawVertexArrayInstanced(
|
|
offset,
|
|
count,
|
|
instances,
|
|
);
|
|
}
|
|
|
|
/// Draw vertex array elements with instancing
|
|
pub fn rlDrawVertexArrayElementsInstanced(
|
|
offset: i32,
|
|
count: i32,
|
|
buffer: *const anyopaque,
|
|
instances: i32,
|
|
) void {
|
|
raylib.mrlDrawVertexArrayElementsInstanced(
|
|
offset,
|
|
count,
|
|
buffer,
|
|
instances,
|
|
);
|
|
}
|
|
|
|
/// Load texture data
|
|
pub fn rlLoadTexture(
|
|
data: *const anyopaque,
|
|
width: i32,
|
|
height: i32,
|
|
format: i32,
|
|
mipmapCount: i32,
|
|
) u32 {
|
|
return raylib.mrlLoadTexture(
|
|
data,
|
|
width,
|
|
height,
|
|
format,
|
|
mipmapCount,
|
|
);
|
|
}
|
|
|
|
/// Load depth texture/renderbuffer (to be attached to fbo)
|
|
pub fn rlLoadTextureDepth(
|
|
width: i32,
|
|
height: i32,
|
|
useRenderBuffer: bool,
|
|
) u32 {
|
|
return raylib.mrlLoadTextureDepth(
|
|
width,
|
|
height,
|
|
useRenderBuffer,
|
|
);
|
|
}
|
|
|
|
/// Load texture cubemap data
|
|
pub fn rlLoadTextureCubemap(
|
|
data: *const anyopaque,
|
|
size: i32,
|
|
format: i32,
|
|
) u32 {
|
|
return raylib.mrlLoadTextureCubemap(
|
|
data,
|
|
size,
|
|
format,
|
|
);
|
|
}
|
|
|
|
/// Update texture with new data on GPU
|
|
pub fn rlUpdateTexture(
|
|
id: u32,
|
|
offsetX: i32,
|
|
offsetY: i32,
|
|
width: i32,
|
|
height: i32,
|
|
format: i32,
|
|
data: *const anyopaque,
|
|
) void {
|
|
raylib.mrlUpdateTexture(
|
|
id,
|
|
offsetX,
|
|
offsetY,
|
|
width,
|
|
height,
|
|
format,
|
|
data,
|
|
);
|
|
}
|
|
|
|
/// Get OpenGL internal formats
|
|
pub fn rlGetGlTextureFormats(
|
|
format: i32,
|
|
glInternalFormat: ?[*]u32,
|
|
glFormat: ?[*]u32,
|
|
glType: ?[*]u32,
|
|
) void {
|
|
raylib.mrlGetGlTextureFormats(
|
|
format,
|
|
@as([*c]u32, @ptrCast(glInternalFormat)),
|
|
@as([*c]u32, @ptrCast(glFormat)),
|
|
@as([*c]u32, @ptrCast(glType)),
|
|
);
|
|
}
|
|
|
|
/// Get name string for pixel format
|
|
pub fn rlGetPixelFormatName(
|
|
format: u32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
[*:0]const u8,
|
|
@ptrCast(raylib.mrlGetPixelFormatName(
|
|
format,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Unload texture from GPU memory
|
|
pub fn rlUnloadTexture(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlUnloadTexture(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Generate mipmap data for selected texture
|
|
pub fn rlGenTextureMipmaps(
|
|
id: u32,
|
|
width: i32,
|
|
height: i32,
|
|
format: i32,
|
|
mipmaps: ?[*]i32,
|
|
) void {
|
|
raylib.mrlGenTextureMipmaps(
|
|
id,
|
|
width,
|
|
height,
|
|
format,
|
|
@as([*c]i32, @ptrCast(mipmaps)),
|
|
);
|
|
}
|
|
|
|
/// Read texture pixel data
|
|
pub fn rlReadTexturePixels(
|
|
id: u32,
|
|
width: i32,
|
|
height: i32,
|
|
format: i32,
|
|
) *anyopaque {
|
|
return @as(
|
|
*anyopaque,
|
|
@ptrCast(raylib.mrlReadTexturePixels(
|
|
id,
|
|
width,
|
|
height,
|
|
format,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Read screen pixel data (color buffer)
|
|
pub fn rlReadScreenPixels(
|
|
width: i32,
|
|
height: i32,
|
|
) [*:0]const u8 {
|
|
return @as(
|
|
?[*]u8,
|
|
@ptrCast(raylib.mrlReadScreenPixels(
|
|
width,
|
|
height,
|
|
)),
|
|
);
|
|
}
|
|
|
|
/// Load an empty framebuffer
|
|
pub fn rlLoadFramebuffer(
|
|
width: i32,
|
|
height: i32,
|
|
) u32 {
|
|
return raylib.mrlLoadFramebuffer(
|
|
width,
|
|
height,
|
|
);
|
|
}
|
|
|
|
/// Attach texture/renderbuffer to a framebuffer
|
|
pub fn rlFramebufferAttach(
|
|
fboId: u32,
|
|
texId: u32,
|
|
attachType: i32,
|
|
texType: i32,
|
|
mipLevel: i32,
|
|
) void {
|
|
raylib.mrlFramebufferAttach(
|
|
fboId,
|
|
texId,
|
|
attachType,
|
|
texType,
|
|
mipLevel,
|
|
);
|
|
}
|
|
|
|
/// Verify framebuffer is complete
|
|
pub fn rlFramebufferComplete(
|
|
id: u32,
|
|
) bool {
|
|
return raylib.mrlFramebufferComplete(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Delete framebuffer from GPU
|
|
pub fn rlUnloadFramebuffer(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlUnloadFramebuffer(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Load shader from code strings
|
|
pub fn rlLoadShaderCode(
|
|
vsCode: [*:0]const u8,
|
|
fsCode: [*:0]const u8,
|
|
) u32 {
|
|
return raylib.mrlLoadShaderCode(
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(vsCode))),
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(fsCode))),
|
|
);
|
|
}
|
|
|
|
/// Load custom shader program
|
|
pub fn rlLoadShaderProgram(
|
|
vShaderId: u32,
|
|
fShaderId: u32,
|
|
) u32 {
|
|
return raylib.mrlLoadShaderProgram(
|
|
vShaderId,
|
|
fShaderId,
|
|
);
|
|
}
|
|
|
|
/// Unload shader program
|
|
pub fn rlUnloadShaderProgram(
|
|
id: u32,
|
|
) void {
|
|
raylib.mrlUnloadShaderProgram(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Get shader location uniform
|
|
pub fn rlGetLocationUniform(
|
|
shaderId: u32,
|
|
uniformName: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mrlGetLocationUniform(
|
|
shaderId,
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(uniformName))),
|
|
);
|
|
}
|
|
|
|
/// Get shader location attribute
|
|
pub fn rlGetLocationAttrib(
|
|
shaderId: u32,
|
|
attribName: [*:0]const u8,
|
|
) i32 {
|
|
return raylib.mrlGetLocationAttrib(
|
|
shaderId,
|
|
@as([*c]const u8, @ptrFromInt(@intFromPtr(attribName))),
|
|
);
|
|
}
|
|
|
|
/// Set shader value uniform
|
|
pub fn rlSetUniform(
|
|
locIndex: i32,
|
|
value: *const anyopaque,
|
|
uniformType: i32,
|
|
count: i32,
|
|
) void {
|
|
raylib.mrlSetUniform(
|
|
locIndex,
|
|
value,
|
|
uniformType,
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Set shader value matrix
|
|
pub fn rlSetUniformMatrix(
|
|
locIndex: i32,
|
|
mat: Matrix,
|
|
) void {
|
|
raylib.mrlSetUniformMatrix(
|
|
locIndex,
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
}
|
|
|
|
/// Set shader value sampler
|
|
pub fn rlSetUniformSampler(
|
|
locIndex: i32,
|
|
textureId: u32,
|
|
) void {
|
|
raylib.mrlSetUniformSampler(
|
|
locIndex,
|
|
textureId,
|
|
);
|
|
}
|
|
|
|
/// Set shader currently active (id and locations)
|
|
pub fn rlSetShader(
|
|
id: u32,
|
|
locs: ?[*]i32,
|
|
) void {
|
|
raylib.mrlSetShader(
|
|
id,
|
|
@as([*c]i32, @ptrCast(locs)),
|
|
);
|
|
}
|
|
|
|
/// Load compute shader program
|
|
pub fn rlLoadComputeShaderProgram(
|
|
shaderId: u32,
|
|
) u32 {
|
|
return raylib.mrlLoadComputeShaderProgram(
|
|
shaderId,
|
|
);
|
|
}
|
|
|
|
/// Dispatch compute shader (equivalent to *draw* for graphics pipeline)
|
|
pub fn rlComputeShaderDispatch(
|
|
groupX: u32,
|
|
groupY: u32,
|
|
groupZ: u32,
|
|
) void {
|
|
raylib.mrlComputeShaderDispatch(
|
|
groupX,
|
|
groupY,
|
|
groupZ,
|
|
);
|
|
}
|
|
|
|
/// Load shader storage buffer object (SSBO)
|
|
pub fn rlLoadShaderBuffer(
|
|
size: u32,
|
|
data: *const anyopaque,
|
|
usageHint: i32,
|
|
) u32 {
|
|
return raylib.mrlLoadShaderBuffer(
|
|
size,
|
|
data,
|
|
usageHint,
|
|
);
|
|
}
|
|
|
|
/// Unload shader storage buffer object (SSBO)
|
|
pub fn rlUnloadShaderBuffer(
|
|
ssboId: u32,
|
|
) void {
|
|
raylib.mrlUnloadShaderBuffer(
|
|
ssboId,
|
|
);
|
|
}
|
|
|
|
/// Update SSBO buffer data
|
|
pub fn rlUpdateShaderBuffer(
|
|
id: u32,
|
|
data: *const anyopaque,
|
|
dataSize: u32,
|
|
offset: u32,
|
|
) void {
|
|
raylib.mrlUpdateShaderBuffer(
|
|
id,
|
|
data,
|
|
dataSize,
|
|
offset,
|
|
);
|
|
}
|
|
|
|
/// Bind SSBO buffer
|
|
pub fn rlBindShaderBuffer(
|
|
id: u32,
|
|
index: u32,
|
|
) void {
|
|
raylib.mrlBindShaderBuffer(
|
|
id,
|
|
index,
|
|
);
|
|
}
|
|
|
|
/// Read SSBO buffer data (GPU->CPU)
|
|
pub fn rlReadShaderBuffer(
|
|
id: u32,
|
|
dest: *anyopaque,
|
|
count: u32,
|
|
offset: u32,
|
|
) void {
|
|
raylib.mrlReadShaderBuffer(
|
|
id,
|
|
dest,
|
|
count,
|
|
offset,
|
|
);
|
|
}
|
|
|
|
/// Copy SSBO data between buffers
|
|
pub fn rlCopyShaderBuffer(
|
|
destId: u32,
|
|
srcId: u32,
|
|
destOffset: u32,
|
|
srcOffset: u32,
|
|
count: u32,
|
|
) void {
|
|
raylib.mrlCopyShaderBuffer(
|
|
destId,
|
|
srcId,
|
|
destOffset,
|
|
srcOffset,
|
|
count,
|
|
);
|
|
}
|
|
|
|
/// Get SSBO buffer size
|
|
pub fn rlGetShaderBufferSize(
|
|
id: u32,
|
|
) u32 {
|
|
return raylib.mrlGetShaderBufferSize(
|
|
id,
|
|
);
|
|
}
|
|
|
|
/// Bind image texture
|
|
pub fn rlBindImageTexture(
|
|
id: u32,
|
|
index: u32,
|
|
format: i32,
|
|
readonly: bool,
|
|
) void {
|
|
raylib.mrlBindImageTexture(
|
|
id,
|
|
index,
|
|
format,
|
|
readonly,
|
|
);
|
|
}
|
|
|
|
/// Get internal modelview matrix
|
|
pub fn rlGetMatrixModelview() Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mrlGetMatrixModelview(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get internal projection matrix
|
|
pub fn rlGetMatrixProjection() Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mrlGetMatrixProjection(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Get internal accumulated transform matrix
|
|
pub fn rlGetMatrixTransform() Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mrlGetMatrixTransform(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn rlGetMatrixProjectionStereo(
|
|
eye: i32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mrlGetMatrixProjectionStereo(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
eye,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn rlGetMatrixViewOffsetStereo(
|
|
eye: i32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mrlGetMatrixViewOffsetStereo(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
eye,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
/// Set a custom projection matrix (replaces internal projection matrix)
|
|
pub fn rlSetMatrixProjection(
|
|
proj: Matrix,
|
|
) void {
|
|
raylib.mrlSetMatrixProjection(
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&proj))),
|
|
);
|
|
}
|
|
|
|
/// Set a custom modelview matrix (replaces internal modelview matrix)
|
|
pub fn rlSetMatrixModelview(
|
|
view: Matrix,
|
|
) void {
|
|
raylib.mrlSetMatrixModelview(
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&view))),
|
|
);
|
|
}
|
|
|
|
/// Set eyes projection matrices for stereo rendering
|
|
pub fn rlSetMatrixProjectionStereo(
|
|
right: Matrix,
|
|
left: Matrix,
|
|
) void {
|
|
raylib.mrlSetMatrixProjectionStereo(
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&right))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&left))),
|
|
);
|
|
}
|
|
|
|
/// Set eyes view offsets matrices for stereo rendering
|
|
pub fn rlSetMatrixViewOffsetStereo(
|
|
right: Matrix,
|
|
left: Matrix,
|
|
) void {
|
|
raylib.mrlSetMatrixViewOffsetStereo(
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&right))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&left))),
|
|
);
|
|
}
|
|
|
|
/// Load and draw a cube
|
|
pub fn rlLoadDrawCube() void {
|
|
raylib.mrlLoadDrawCube();
|
|
}
|
|
|
|
/// Load and draw a quad
|
|
pub fn rlLoadDrawQuad() void {
|
|
raylib.mrlLoadDrawQuad();
|
|
}
|
|
|
|
///
|
|
pub fn Clamp(
|
|
value: f32,
|
|
min: f32,
|
|
max: f32,
|
|
) f32 {
|
|
return raylib.mClamp(
|
|
value,
|
|
min,
|
|
max,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Lerp(
|
|
start: f32,
|
|
end: f32,
|
|
amount: f32,
|
|
) f32 {
|
|
return raylib.mLerp(
|
|
start,
|
|
end,
|
|
amount,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Normalize(
|
|
value: f32,
|
|
start: f32,
|
|
end: f32,
|
|
) f32 {
|
|
return raylib.mNormalize(
|
|
value,
|
|
start,
|
|
end,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Remap(
|
|
value: f32,
|
|
inputStart: f32,
|
|
inputEnd: f32,
|
|
outputStart: f32,
|
|
outputEnd: f32,
|
|
) f32 {
|
|
return raylib.mRemap(
|
|
value,
|
|
inputStart,
|
|
inputEnd,
|
|
outputStart,
|
|
outputEnd,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Wrap(
|
|
value: f32,
|
|
min: f32,
|
|
max: f32,
|
|
) f32 {
|
|
return raylib.mWrap(
|
|
value,
|
|
min,
|
|
max,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn FloatEquals(
|
|
x: f32,
|
|
y: f32,
|
|
) i32 {
|
|
return raylib.mFloatEquals(
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Zero() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Zero(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2One() Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2One(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Add(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Add(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2AddValue(
|
|
v: Vector2,
|
|
add: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2AddValue(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
add,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Subtract(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Subtract(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2SubtractValue(
|
|
v: Vector2,
|
|
sub: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2SubtractValue(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
sub,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Length(
|
|
v: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2Length(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2LengthSqr(
|
|
v: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2LengthSqr(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2DotProduct(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2DotProduct(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Distance(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2Distance(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2DistanceSqr(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2DistanceSqr(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Angle(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2Angle(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2LineAngle(
|
|
start: Vector2,
|
|
end: Vector2,
|
|
) f32 {
|
|
return raylib.mVector2LineAngle(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&start))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&end))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Scale(
|
|
v: Vector2,
|
|
scale: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Scale(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
scale,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Multiply(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Multiply(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Negate(
|
|
v: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Negate(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Divide(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Divide(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Normalize(
|
|
v: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Normalize(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Transform(
|
|
v: Vector2,
|
|
mat: Matrix,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Transform(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Lerp(
|
|
v1: Vector2,
|
|
v2: Vector2,
|
|
amount: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Lerp(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v2))),
|
|
amount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Reflect(
|
|
v: Vector2,
|
|
normal: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Reflect(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&normal))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Rotate(
|
|
v: Vector2,
|
|
angle: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Rotate(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2MoveTowards(
|
|
v: Vector2,
|
|
target: Vector2,
|
|
maxDistance: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2MoveTowards(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&target))),
|
|
maxDistance,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Invert(
|
|
v: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Invert(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Clamp(
|
|
v: Vector2,
|
|
min: Vector2,
|
|
max: Vector2,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2Clamp(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&min))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&max))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2ClampValue(
|
|
v: Vector2,
|
|
min: f32,
|
|
max: f32,
|
|
) Vector2 {
|
|
var out: Vector2 = undefined;
|
|
raylib.mVector2ClampValue(
|
|
@as([*c]raylib.Vector2, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&v))),
|
|
min,
|
|
max,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector2Equals(
|
|
p: Vector2,
|
|
q: Vector2,
|
|
) i32 {
|
|
return raylib.mVector2Equals(
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&p))),
|
|
@as([*c]raylib.Vector2, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Zero() Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Zero(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3One() Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3One(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Add(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Add(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3AddValue(
|
|
v: Vector3,
|
|
add: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3AddValue(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
add,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Subtract(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Subtract(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3SubtractValue(
|
|
v: Vector3,
|
|
sub: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3SubtractValue(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
sub,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Scale(
|
|
v: Vector3,
|
|
scalar: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Scale(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
scalar,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Multiply(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Multiply(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3CrossProduct(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3CrossProduct(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Perpendicular(
|
|
v: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Perpendicular(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Length(
|
|
v: Vector3,
|
|
) f32 {
|
|
return raylib.mVector3Length(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3LengthSqr(
|
|
v: Vector3,
|
|
) f32 {
|
|
return raylib.mVector3LengthSqr(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3DotProduct(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) f32 {
|
|
return raylib.mVector3DotProduct(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Distance(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) f32 {
|
|
return raylib.mVector3Distance(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3DistanceSqr(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) f32 {
|
|
return raylib.mVector3DistanceSqr(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Angle(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) f32 {
|
|
return raylib.mVector3Angle(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Negate(
|
|
v: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Negate(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Divide(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Divide(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Normalize(
|
|
v: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Normalize(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Project(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Project(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Reject(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Reject(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3OrthoNormalize(
|
|
v1: ?[*]Vector3,
|
|
v2: ?[*]Vector3,
|
|
) void {
|
|
raylib.mVector3OrthoNormalize(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(v2))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Transform(
|
|
v: Vector3,
|
|
mat: Matrix,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Transform(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3RotateByQuaternion(
|
|
v: Vector3,
|
|
q: Vector4,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3RotateByQuaternion(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3RotateByAxisAngle(
|
|
v: Vector3,
|
|
axis: Vector3,
|
|
angle: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3RotateByAxisAngle(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&axis))),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Lerp(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
amount: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Lerp(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
amount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Reflect(
|
|
v: Vector3,
|
|
normal: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Reflect(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&normal))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Min(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Min(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Max(
|
|
v1: Vector3,
|
|
v2: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Max(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v1))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Barycenter(
|
|
p: Vector3,
|
|
a: Vector3,
|
|
b: Vector3,
|
|
c: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Barycenter(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&a))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&b))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&c))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Unproject(
|
|
source: Vector3,
|
|
projection: Matrix,
|
|
view: Matrix,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Unproject(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&source))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&projection))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&view))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3ToFloatV(
|
|
v: Vector3,
|
|
) float3 {
|
|
var out: float3 = undefined;
|
|
raylib.mVector3ToFloatV(
|
|
@as([*c]raylib.float3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Invert(
|
|
v: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Invert(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Clamp(
|
|
v: Vector3,
|
|
min: Vector3,
|
|
max: Vector3,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Clamp(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&min))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&max))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3ClampValue(
|
|
v: Vector3,
|
|
min: f32,
|
|
max: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3ClampValue(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
min,
|
|
max,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Equals(
|
|
p: Vector3,
|
|
q: Vector3,
|
|
) i32 {
|
|
return raylib.mVector3Equals(
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&p))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn Vector3Refract(
|
|
v: Vector3,
|
|
n: Vector3,
|
|
r: f32,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mVector3Refract(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&v))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&n))),
|
|
r,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixDeterminant(
|
|
mat: Matrix,
|
|
) f32 {
|
|
return raylib.mMatrixDeterminant(
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn MatrixTrace(
|
|
mat: Matrix,
|
|
) f32 {
|
|
return raylib.mMatrixTrace(
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn MatrixTranspose(
|
|
mat: Matrix,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixTranspose(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixInvert(
|
|
mat: Matrix,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixInvert(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixIdentity() Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixIdentity(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixAdd(
|
|
left: Matrix,
|
|
right: Matrix,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixAdd(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&left))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&right))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixSubtract(
|
|
left: Matrix,
|
|
right: Matrix,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixSubtract(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&left))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&right))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixMultiply(
|
|
left: Matrix,
|
|
right: Matrix,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixMultiply(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&left))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&right))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixTranslate(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixTranslate(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixRotate(
|
|
axis: Vector3,
|
|
angle: f32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixRotate(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&axis))),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixRotateX(
|
|
angle: f32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixRotateX(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixRotateY(
|
|
angle: f32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixRotateY(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixRotateZ(
|
|
angle: f32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixRotateZ(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixRotateXYZ(
|
|
angle: Vector3,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixRotateXYZ(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&angle))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixRotateZYX(
|
|
angle: Vector3,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixRotateZYX(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&angle))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixScale(
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixScale(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
x,
|
|
y,
|
|
z,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixFrustum(
|
|
left: f64,
|
|
right: f64,
|
|
bottom: f64,
|
|
top: f64,
|
|
near: f64,
|
|
far: f64,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixFrustum(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
left,
|
|
right,
|
|
bottom,
|
|
top,
|
|
near,
|
|
far,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixPerspective(
|
|
fovY: f64,
|
|
aspect: f64,
|
|
nearPlane: f64,
|
|
farPlane: f64,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixPerspective(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
fovY,
|
|
aspect,
|
|
nearPlane,
|
|
farPlane,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixOrtho(
|
|
left: f64,
|
|
right: f64,
|
|
bottom: f64,
|
|
top: f64,
|
|
nearPlane: f64,
|
|
farPlane: f64,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixOrtho(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
left,
|
|
right,
|
|
bottom,
|
|
top,
|
|
nearPlane,
|
|
farPlane,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixLookAt(
|
|
eye: Vector3,
|
|
target: Vector3,
|
|
up: Vector3,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mMatrixLookAt(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&eye))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&target))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&up))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn MatrixToFloatV(
|
|
mat: Matrix,
|
|
) float16 {
|
|
var out: float16 = undefined;
|
|
raylib.mMatrixToFloatV(
|
|
@as([*c]raylib.float16, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionAdd(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionAdd(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionAddValue(
|
|
q: Vector4,
|
|
add: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionAddValue(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
add,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionSubtract(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionSubtract(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionSubtractValue(
|
|
q: Vector4,
|
|
sub: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionSubtractValue(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
sub,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionIdentity() Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionIdentity(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionLength(
|
|
q: Vector4,
|
|
) f32 {
|
|
return raylib.mQuaternionLength(
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionNormalize(
|
|
q: Vector4,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionNormalize(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionInvert(
|
|
q: Vector4,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionInvert(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionMultiply(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionMultiply(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionScale(
|
|
q: Vector4,
|
|
mul: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionScale(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
mul,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionDivide(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionDivide(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionLerp(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
amount: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionLerp(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
amount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionNlerp(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
amount: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionNlerp(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
amount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionSlerp(
|
|
q1: Vector4,
|
|
q2: Vector4,
|
|
amount: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionSlerp(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q1))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q2))),
|
|
amount,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionFromVector3ToVector3(
|
|
from: Vector3,
|
|
to: Vector3,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionFromVector3ToVector3(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&from))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&to))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionFromMatrix(
|
|
mat: Matrix,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionFromMatrix(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionToMatrix(
|
|
q: Vector4,
|
|
) Matrix {
|
|
var out: Matrix = undefined;
|
|
raylib.mQuaternionToMatrix(
|
|
@as([*c]raylib.Matrix, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionFromAxisAngle(
|
|
axis: Vector3,
|
|
angle: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionFromAxisAngle(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(&axis))),
|
|
angle,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionToAxisAngle(
|
|
q: Vector4,
|
|
outAxis: ?[*]Vector3,
|
|
outAngle: ?[*]f32,
|
|
) void {
|
|
raylib.mQuaternionToAxisAngle(
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
@as([*c]raylib.Vector3, @ptrFromInt(@intFromPtr(outAxis))),
|
|
@as([*c]f32, @ptrCast(outAngle)),
|
|
);
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionFromEuler(
|
|
pitch: f32,
|
|
yaw: f32,
|
|
roll: f32,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionFromEuler(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
pitch,
|
|
yaw,
|
|
roll,
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionToEuler(
|
|
q: Vector4,
|
|
) Vector3 {
|
|
var out: Vector3 = undefined;
|
|
raylib.mQuaternionToEuler(
|
|
@as([*c]raylib.Vector3, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionTransform(
|
|
q: Vector4,
|
|
mat: Matrix,
|
|
) Vector4 {
|
|
var out: Vector4 = undefined;
|
|
raylib.mQuaternionTransform(
|
|
@as([*c]raylib.Vector4, @ptrCast(&out)),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
@as([*c]raylib.Matrix, @ptrFromInt(@intFromPtr(&mat))),
|
|
);
|
|
return out;
|
|
}
|
|
|
|
///
|
|
pub fn QuaternionEquals(
|
|
p: Vector4,
|
|
q: Vector4,
|
|
) i32 {
|
|
return raylib.mQuaternionEquals(
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&p))),
|
|
@as([*c]raylib.Vector4, @ptrFromInt(@intFromPtr(&q))),
|
|
);
|
|
}
|
|
|
|
/// Image, pixel data stored in CPU memory (RAM)
|
|
pub const Image = extern struct {
|
|
/// Image raw data
|
|
data: *anyopaque,
|
|
/// Image base width
|
|
width: i32,
|
|
/// Image base height
|
|
height: i32,
|
|
/// Mipmap levels, 1 by default
|
|
mipmaps: i32,
|
|
/// Data format (PixelFormat type)
|
|
format: i32,
|
|
};
|
|
|
|
/// Texture, tex data stored in GPU memory (VRAM)
|
|
pub const Texture2D = extern struct {
|
|
/// OpenGL texture id
|
|
id: u32,
|
|
/// Texture base width
|
|
width: i32,
|
|
/// Texture base height
|
|
height: i32,
|
|
/// Mipmap levels, 1 by default
|
|
mipmaps: i32,
|
|
/// Data format (PixelFormat type)
|
|
format: i32,
|
|
};
|
|
|
|
/// RenderTexture, fbo for texture rendering
|
|
pub const RenderTexture2D = extern struct {
|
|
/// OpenGL framebuffer object id
|
|
id: u32,
|
|
/// Color buffer attachment texture
|
|
texture: Texture2D,
|
|
/// Depth buffer attachment texture
|
|
depth: Texture2D,
|
|
};
|
|
|
|
/// NPatchInfo, n-patch layout info
|
|
pub const NPatchInfo = extern struct {
|
|
/// Texture source rectangle
|
|
source: Rectangle,
|
|
/// Left border offset
|
|
left: i32,
|
|
/// Top border offset
|
|
top: i32,
|
|
/// Right border offset
|
|
right: i32,
|
|
/// Bottom border offset
|
|
bottom: i32,
|
|
/// Layout of the n-patch: 3x3, 1x3 or 3x1
|
|
layout: i32,
|
|
};
|
|
|
|
/// GlyphInfo, font characters glyphs info
|
|
pub const GlyphInfo = extern struct {
|
|
/// Character value (Unicode)
|
|
value: i32,
|
|
/// Character offset X when drawing
|
|
offsetX: i32,
|
|
/// Character offset Y when drawing
|
|
offsetY: i32,
|
|
/// Character advance position X
|
|
advanceX: i32,
|
|
/// Character image data
|
|
image: Image,
|
|
};
|
|
|
|
/// Font, font texture and GlyphInfo array data
|
|
pub const Font = extern struct {
|
|
/// Base size (default chars height)
|
|
baseSize: i32,
|
|
/// Number of glyph characters
|
|
glyphCount: i32,
|
|
/// Padding around the glyph characters
|
|
glyphPadding: i32,
|
|
/// Texture atlas containing the glyphs
|
|
texture: Texture2D,
|
|
/// Rectangles in texture for the glyphs
|
|
recs: ?[*]Rectangle,
|
|
/// Glyphs info data
|
|
glyphs: ?[*]GlyphInfo,
|
|
};
|
|
|
|
/// Camera, defines position/orientation in 3d space
|
|
pub const Camera3D = extern struct {
|
|
/// Camera position
|
|
position: Vector3,
|
|
/// Camera target it looks-at
|
|
target: Vector3,
|
|
/// Camera up vector (rotation over its axis)
|
|
up: Vector3,
|
|
/// Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
|
|
fovy: f32,
|
|
/// Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
|
|
projection: CameraProjection,
|
|
};
|
|
|
|
/// Mesh, vertex data and vao/vbo
|
|
pub const Mesh = extern struct {
|
|
/// Number of vertices stored in arrays
|
|
vertexCount: i32,
|
|
/// Number of triangles stored (indexed or not)
|
|
triangleCount: i32,
|
|
/// Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
|
|
vertices: ?[*]f32,
|
|
/// Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
|
|
texcoords: ?[*]f32,
|
|
/// Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
|
|
texcoords2: ?[*]f32,
|
|
/// Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
|
|
normals: ?[*]f32,
|
|
/// Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
|
|
tangents: ?[*]f32,
|
|
/// Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
|
|
colors: ?[*]u8,
|
|
/// Vertex indices (in case vertex data comes indexed)
|
|
indices: ?[*]u16,
|
|
/// Animated vertex positions (after bones transformations)
|
|
animVertices: ?[*]f32,
|
|
/// Animated normals (after bones transformations)
|
|
animNormals: ?[*]f32,
|
|
/// Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
|
|
boneIds: ?[*]u8,
|
|
/// Vertex bone weight, up to 4 bones influence by vertex (skinning)
|
|
boneWeights: ?[*]f32,
|
|
/// OpenGL Vertex Array Object id
|
|
vaoId: u32,
|
|
/// OpenGL Vertex Buffer Objects id (default vertex data)
|
|
vboId: ?[*]u32,
|
|
};
|
|
|
|
/// Shader
|
|
pub const Shader = extern struct {
|
|
/// Shader program id
|
|
id: u32,
|
|
/// Shader locations array (RL_MAX_SHADER_LOCATIONS)
|
|
locs: ?[*]i32,
|
|
};
|
|
|
|
/// MaterialMap
|
|
pub const MaterialMap = extern struct {
|
|
/// Material map texture
|
|
texture: Texture2D,
|
|
/// Material map color
|
|
color: Color,
|
|
/// Material map value
|
|
value: f32,
|
|
};
|
|
|
|
/// Material, includes shader and maps
|
|
pub const Material = extern struct {
|
|
/// Material shader
|
|
shader: Shader,
|
|
/// Material maps array (MAX_MATERIAL_MAPS)
|
|
maps: ?[*]MaterialMap,
|
|
/// Material generic parameters (if required)
|
|
params: [4]f32,
|
|
};
|
|
|
|
/// Bone, skeletal animation bone
|
|
pub const BoneInfo = extern struct {
|
|
/// Bone name
|
|
name: [32]u8,
|
|
/// Bone parent
|
|
parent: i32,
|
|
};
|
|
|
|
/// Model, meshes, materials and animation data
|
|
pub const Model = extern struct {
|
|
/// Local transform matrix
|
|
transform: Matrix,
|
|
/// Number of meshes
|
|
meshCount: i32,
|
|
/// Number of materials
|
|
materialCount: i32,
|
|
/// Meshes array
|
|
meshes: ?[*]Mesh,
|
|
/// Materials array
|
|
materials: ?[*]Material,
|
|
/// Mesh material number
|
|
meshMaterial: ?[*]i32,
|
|
/// Number of bones
|
|
boneCount: i32,
|
|
/// Bones information (skeleton)
|
|
bones: ?[*]BoneInfo,
|
|
/// Bones base transformation (pose)
|
|
bindPose: ?[*]Transform,
|
|
};
|
|
|
|
/// ModelAnimation
|
|
pub const ModelAnimation = extern struct {
|
|
/// Number of bones
|
|
boneCount: i32,
|
|
/// Number of animation frames
|
|
frameCount: i32,
|
|
/// Bones information (skeleton)
|
|
bones: ?[*]BoneInfo,
|
|
/// Poses array by frame
|
|
framePoses: ?[*][*]Transform,
|
|
/// Animation name
|
|
name: [32]u8,
|
|
};
|
|
|
|
/// Ray, ray for raycasting
|
|
pub const Ray = extern struct {
|
|
/// Ray position (origin)
|
|
position: Vector3,
|
|
/// Ray direction
|
|
direction: Vector3,
|
|
};
|
|
|
|
/// RayCollision, ray hit information
|
|
pub const RayCollision = extern struct {
|
|
/// Did the ray hit something?
|
|
hit: bool,
|
|
/// Distance to the nearest hit
|
|
distance: f32,
|
|
/// Point of the nearest hit
|
|
point: Vector3,
|
|
/// Surface normal of hit
|
|
normal: Vector3,
|
|
};
|
|
|
|
/// BoundingBox
|
|
pub const BoundingBox = extern struct {
|
|
/// Minimum vertex box-corner
|
|
min: Vector3,
|
|
/// Maximum vertex box-corner
|
|
max: Vector3,
|
|
};
|
|
|
|
/// Wave, audio wave data
|
|
pub const Wave = extern struct {
|
|
/// Total number of frames (considering channels)
|
|
frameCount: u32,
|
|
/// Frequency (samples per second)
|
|
sampleRate: u32,
|
|
/// Bit depth (bits per sample): 8, 16, 32 (24 not supported)
|
|
sampleSize: u32,
|
|
/// Number of channels (1-mono, 2-stereo, ...)
|
|
channels: u32,
|
|
/// Buffer data pointer
|
|
data: *anyopaque,
|
|
};
|
|
|
|
/// AudioStream, custom audio stream
|
|
pub const AudioStream = extern struct {
|
|
/// Pointer to internal data used by the audio system
|
|
buffer: *anyopaque,
|
|
/// Pointer to internal data processor, useful for audio effects
|
|
processor: *anyopaque,
|
|
/// Frequency (samples per second)
|
|
sampleRate: u32,
|
|
/// Bit depth (bits per sample): 8, 16, 32 (24 not supported)
|
|
sampleSize: u32,
|
|
/// Number of channels (1-mono, 2-stereo, ...)
|
|
channels: u32,
|
|
};
|
|
|
|
/// Sound
|
|
pub const Sound = extern struct {
|
|
/// Audio stream
|
|
stream: AudioStream,
|
|
/// Total number of frames (considering channels)
|
|
frameCount: u32,
|
|
};
|
|
|
|
/// Music, audio stream, anything longer than ~10 seconds should be streamed
|
|
pub const Music = extern struct {
|
|
/// Audio stream
|
|
stream: AudioStream,
|
|
/// Total number of frames (considering channels)
|
|
frameCount: u32,
|
|
/// Music looping enable
|
|
looping: bool,
|
|
/// Type of music context (audio filetype)
|
|
ctxType: i32,
|
|
/// Audio context data, depends on type
|
|
ctxData: *anyopaque,
|
|
};
|
|
|
|
/// VrDeviceInfo, Head-Mounted-Display device parameters
|
|
pub const VrDeviceInfo = extern struct {
|
|
/// Horizontal resolution in pixels
|
|
hResolution: i32,
|
|
/// Vertical resolution in pixels
|
|
vResolution: i32,
|
|
/// Horizontal size in meters
|
|
hScreenSize: f32,
|
|
/// Vertical size in meters
|
|
vScreenSize: f32,
|
|
/// Distance between eye and display in meters
|
|
eyeToScreenDistance: f32,
|
|
/// Lens separation distance in meters
|
|
lensSeparationDistance: f32,
|
|
/// IPD (distance between pupils) in meters
|
|
interpupillaryDistance: f32,
|
|
/// Lens distortion constant parameters
|
|
lensDistortionValues: [4]f32,
|
|
/// Chromatic aberration correction parameters
|
|
chromaAbCorrection: [4]f32,
|
|
};
|
|
|
|
/// VrStereoConfig, VR stereo rendering configuration for simulator
|
|
pub const VrStereoConfig = extern struct {
|
|
/// VR projection matrices (per eye)
|
|
projection: [2]Matrix,
|
|
/// VR view offset matrices (per eye)
|
|
viewOffset: [2]Matrix,
|
|
/// VR left lens center
|
|
leftLensCenter: [2]f32,
|
|
/// VR right lens center
|
|
rightLensCenter: [2]f32,
|
|
/// VR left screen center
|
|
leftScreenCenter: [2]f32,
|
|
/// VR right screen center
|
|
rightScreenCenter: [2]f32,
|
|
/// VR distortion scale
|
|
scale: [2]f32,
|
|
/// VR distortion scale in
|
|
scaleIn: [2]f32,
|
|
};
|
|
|
|
/// File path list
|
|
pub const FilePathList = extern struct {
|
|
/// Filepaths max entries
|
|
capacity: u32,
|
|
/// Filepaths entries count
|
|
count: u32,
|
|
/// Filepaths entries
|
|
paths: [*][*:0]u8,
|
|
};
|
|
|
|
/// Automation event
|
|
pub const AutomationEvent = extern struct {
|
|
/// Event frame
|
|
frame: u32,
|
|
/// Event type (AutomationEventType)
|
|
type: u32,
|
|
/// Event parameters (if required)
|
|
params: [4]i32,
|
|
};
|
|
|
|
/// Automation event list
|
|
pub const AutomationEventList = extern struct {
|
|
/// Events max entries (MAX_AUTOMATION_EVENTS)
|
|
capacity: u32,
|
|
/// Events entries count
|
|
count: u32,
|
|
/// Events entries
|
|
events: ?[*]AutomationEvent,
|
|
};
|
|
|
|
/// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
|
|
pub const rlVertexBuffer = extern struct {
|
|
/// Number of elements in the buffer (QUADS)
|
|
elementCount: i32,
|
|
/// Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
|
|
vertices: [*]f32,
|
|
/// Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
|
|
texcoords: [*]f32,
|
|
/// Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
|
|
colors: [*]u8,
|
|
/// Vertex indices (in case vertex data comes indexed) (6 indices per quad)
|
|
indices: [*]u16,
|
|
/// OpenGL Vertex Array Object id
|
|
vaoId: u32,
|
|
/// OpenGL Vertex Buffer Objects id (4 types of vertex data)
|
|
vboId: [4]u32,
|
|
};
|
|
|
|
/// of those state-change happens (this is done in core module)
|
|
pub const rlDrawCall = extern struct {
|
|
/// Drawing mode: LINES, TRIANGLES, QUADS
|
|
mode: i32,
|
|
/// Number of vertex of the draw
|
|
vertexCount: i32,
|
|
/// Number of vertex required for index alignment (LINES, TRIANGLES)
|
|
vertexAlignment: i32,
|
|
/// Texture id to be used on the draw -> Use to create new draw call if changes
|
|
textureId: u32,
|
|
};
|
|
|
|
/// rlRenderBatch type
|
|
pub const rlRenderBatch = extern struct {
|
|
/// Number of vertex buffers (multi-buffering support)
|
|
bufferCount: i32,
|
|
/// Current buffer tracking in case of multi-buffering
|
|
currentBuffer: i32,
|
|
/// Dynamic buffer(s) for vertex data
|
|
vertexBuffer: ?[*]rlVertexBuffer,
|
|
/// Draw calls array, depends on textureId
|
|
draws: ?[*]rlDrawCall,
|
|
/// Draw calls counter
|
|
drawCounter: i32,
|
|
/// Current depth value for next draw
|
|
currentDepth: f32,
|
|
};
|
|
|
|
/// NOTE: Helper types to be used instead of array return types for *ToFloat functions
|
|
pub const float3 = extern struct {
|
|
///
|
|
v: [3]f32,
|
|
};
|
|
|
|
///
|
|
pub const float16 = extern struct {
|
|
///
|
|
v: [16]f32,
|
|
};
|
|
|
|
/// Trace log level
|
|
pub const TraceLogLevel = enum(i32) {
|
|
/// Display all logs
|
|
LOG_ALL = 0,
|
|
/// Trace logging, intended for internal use only
|
|
LOG_TRACE = 1,
|
|
/// Debug logging, used for internal debugging, it should be disabled on release builds
|
|
LOG_DEBUG = 2,
|
|
/// Info logging, used for program execution info
|
|
LOG_INFO = 3,
|
|
/// Warning logging, used on recoverable failures
|
|
LOG_WARNING = 4,
|
|
/// Error logging, used on unrecoverable failures
|
|
LOG_ERROR = 5,
|
|
/// Fatal logging, used to abort program: exit(EXIT_FAILURE)
|
|
LOG_FATAL = 6,
|
|
/// Disable logging
|
|
LOG_NONE = 7,
|
|
};
|
|
|
|
/// Keyboard keys (US keyboard layout)
|
|
pub const KeyboardKey = enum(i32) {
|
|
/// Key: NULL, used for no key pressed
|
|
KEY_NULL = 0,
|
|
/// Key: '
|
|
KEY_APOSTROPHE = 39,
|
|
/// Key: ,
|
|
KEY_COMMA = 44,
|
|
/// Key: -
|
|
KEY_MINUS = 45,
|
|
/// Key: .
|
|
KEY_PERIOD = 46,
|
|
/// Key: /
|
|
KEY_SLASH = 47,
|
|
/// Key: 0
|
|
KEY_ZERO = 48,
|
|
/// Key: 1
|
|
KEY_ONE = 49,
|
|
/// Key: 2
|
|
KEY_TWO = 50,
|
|
/// Key: 3
|
|
KEY_THREE = 51,
|
|
/// Key: 4
|
|
KEY_FOUR = 52,
|
|
/// Key: 5
|
|
KEY_FIVE = 53,
|
|
/// Key: 6
|
|
KEY_SIX = 54,
|
|
/// Key: 7
|
|
KEY_SEVEN = 55,
|
|
/// Key: 8
|
|
KEY_EIGHT = 56,
|
|
/// Key: 9
|
|
KEY_NINE = 57,
|
|
/// Key: ;
|
|
KEY_SEMICOLON = 59,
|
|
/// Key: =
|
|
KEY_EQUAL = 61,
|
|
/// Key: A | a
|
|
KEY_A = 65,
|
|
/// Key: B | b
|
|
KEY_B = 66,
|
|
/// Key: C | c
|
|
KEY_C = 67,
|
|
/// Key: D | d
|
|
KEY_D = 68,
|
|
/// Key: E | e
|
|
KEY_E = 69,
|
|
/// Key: F | f
|
|
KEY_F = 70,
|
|
/// Key: G | g
|
|
KEY_G = 71,
|
|
/// Key: H | h
|
|
KEY_H = 72,
|
|
/// Key: I | i
|
|
KEY_I = 73,
|
|
/// Key: J | j
|
|
KEY_J = 74,
|
|
/// Key: K | k
|
|
KEY_K = 75,
|
|
/// Key: L | l
|
|
KEY_L = 76,
|
|
/// Key: M | m
|
|
KEY_M = 77,
|
|
/// Key: N | n
|
|
KEY_N = 78,
|
|
/// Key: O | o
|
|
KEY_O = 79,
|
|
/// Key: P | p
|
|
KEY_P = 80,
|
|
/// Key: Q | q
|
|
KEY_Q = 81,
|
|
/// Key: R | r
|
|
KEY_R = 82,
|
|
/// Key: S | s
|
|
KEY_S = 83,
|
|
/// Key: T | t
|
|
KEY_T = 84,
|
|
/// Key: U | u
|
|
KEY_U = 85,
|
|
/// Key: V | v
|
|
KEY_V = 86,
|
|
/// Key: W | w
|
|
KEY_W = 87,
|
|
/// Key: X | x
|
|
KEY_X = 88,
|
|
/// Key: Y | y
|
|
KEY_Y = 89,
|
|
/// Key: Z | z
|
|
KEY_Z = 90,
|
|
/// Key: [
|
|
KEY_LEFT_BRACKET = 91,
|
|
/// Key: '\'
|
|
KEY_BACKSLASH = 92,
|
|
/// Key: ]
|
|
KEY_RIGHT_BRACKET = 93,
|
|
/// Key: `
|
|
KEY_GRAVE = 96,
|
|
/// Key: Space
|
|
KEY_SPACE = 32,
|
|
/// Key: Esc
|
|
KEY_ESCAPE = 256,
|
|
/// Key: Enter
|
|
KEY_ENTER = 257,
|
|
/// Key: Tab
|
|
KEY_TAB = 258,
|
|
/// Key: Backspace
|
|
KEY_BACKSPACE = 259,
|
|
/// Key: Ins
|
|
KEY_INSERT = 260,
|
|
/// Key: Del
|
|
KEY_DELETE = 261,
|
|
/// Key: Cursor right
|
|
KEY_RIGHT = 262,
|
|
/// Key: Cursor left
|
|
KEY_LEFT = 263,
|
|
/// Key: Cursor down
|
|
KEY_DOWN = 264,
|
|
/// Key: Cursor up
|
|
KEY_UP = 265,
|
|
/// Key: Page up
|
|
KEY_PAGE_UP = 266,
|
|
/// Key: Page down
|
|
KEY_PAGE_DOWN = 267,
|
|
/// Key: Home
|
|
KEY_HOME = 268,
|
|
/// Key: End
|
|
KEY_END = 269,
|
|
/// Key: Caps lock
|
|
KEY_CAPS_LOCK = 280,
|
|
/// Key: Scroll down
|
|
KEY_SCROLL_LOCK = 281,
|
|
/// Key: Num lock
|
|
KEY_NUM_LOCK = 282,
|
|
/// Key: Print screen
|
|
KEY_PRINT_SCREEN = 283,
|
|
/// Key: Pause
|
|
KEY_PAUSE = 284,
|
|
/// Key: F1
|
|
KEY_F1 = 290,
|
|
/// Key: F2
|
|
KEY_F2 = 291,
|
|
/// Key: F3
|
|
KEY_F3 = 292,
|
|
/// Key: F4
|
|
KEY_F4 = 293,
|
|
/// Key: F5
|
|
KEY_F5 = 294,
|
|
/// Key: F6
|
|
KEY_F6 = 295,
|
|
/// Key: F7
|
|
KEY_F7 = 296,
|
|
/// Key: F8
|
|
KEY_F8 = 297,
|
|
/// Key: F9
|
|
KEY_F9 = 298,
|
|
/// Key: F10
|
|
KEY_F10 = 299,
|
|
/// Key: F11
|
|
KEY_F11 = 300,
|
|
/// Key: F12
|
|
KEY_F12 = 301,
|
|
/// Key: Shift left
|
|
KEY_LEFT_SHIFT = 340,
|
|
/// Key: Control left
|
|
KEY_LEFT_CONTROL = 341,
|
|
/// Key: Alt left
|
|
KEY_LEFT_ALT = 342,
|
|
/// Key: Super left
|
|
KEY_LEFT_SUPER = 343,
|
|
/// Key: Shift right
|
|
KEY_RIGHT_SHIFT = 344,
|
|
/// Key: Control right
|
|
KEY_RIGHT_CONTROL = 345,
|
|
/// Key: Alt right
|
|
KEY_RIGHT_ALT = 346,
|
|
/// Key: Super right
|
|
KEY_RIGHT_SUPER = 347,
|
|
/// Key: KB menu
|
|
KEY_KB_MENU = 348,
|
|
/// Key: Keypad 0
|
|
KEY_KP_0 = 320,
|
|
/// Key: Keypad 1
|
|
KEY_KP_1 = 321,
|
|
/// Key: Keypad 2
|
|
KEY_KP_2 = 322,
|
|
/// Key: Keypad 3
|
|
KEY_KP_3 = 323,
|
|
/// Key: Keypad 4
|
|
KEY_KP_4 = 324,
|
|
/// Key: Keypad 5
|
|
KEY_KP_5 = 325,
|
|
/// Key: Keypad 6
|
|
KEY_KP_6 = 326,
|
|
/// Key: Keypad 7
|
|
KEY_KP_7 = 327,
|
|
/// Key: Keypad 8
|
|
KEY_KP_8 = 328,
|
|
/// Key: Keypad 9
|
|
KEY_KP_9 = 329,
|
|
/// Key: Keypad .
|
|
KEY_KP_DECIMAL = 330,
|
|
/// Key: Keypad /
|
|
KEY_KP_DIVIDE = 331,
|
|
/// Key: Keypad *
|
|
KEY_KP_MULTIPLY = 332,
|
|
/// Key: Keypad -
|
|
KEY_KP_SUBTRACT = 333,
|
|
/// Key: Keypad +
|
|
KEY_KP_ADD = 334,
|
|
/// Key: Keypad Enter
|
|
KEY_KP_ENTER = 335,
|
|
/// Key: Keypad =
|
|
KEY_KP_EQUAL = 336,
|
|
/// Key: Android back button
|
|
KEY_BACK = 4,
|
|
/// Key: Android volume up button
|
|
KEY_VOLUME_UP = 24,
|
|
/// Key: Android volume down button
|
|
KEY_VOLUME_DOWN = 25,
|
|
};
|
|
|
|
/// Mouse buttons
|
|
pub const MouseButton = enum(i32) {
|
|
/// Mouse button left
|
|
MOUSE_BUTTON_LEFT = 0,
|
|
/// Mouse button right
|
|
MOUSE_BUTTON_RIGHT = 1,
|
|
/// Mouse button middle (pressed wheel)
|
|
MOUSE_BUTTON_MIDDLE = 2,
|
|
/// Mouse button side (advanced mouse device)
|
|
MOUSE_BUTTON_SIDE = 3,
|
|
/// Mouse button extra (advanced mouse device)
|
|
MOUSE_BUTTON_EXTRA = 4,
|
|
/// Mouse button forward (advanced mouse device)
|
|
MOUSE_BUTTON_FORWARD = 5,
|
|
/// Mouse button back (advanced mouse device)
|
|
MOUSE_BUTTON_BACK = 6,
|
|
};
|
|
|
|
/// Mouse cursor
|
|
pub const MouseCursor = enum(i32) {
|
|
/// Default pointer shape
|
|
MOUSE_CURSOR_DEFAULT = 0,
|
|
/// Arrow shape
|
|
MOUSE_CURSOR_ARROW = 1,
|
|
/// Text writing cursor shape
|
|
MOUSE_CURSOR_IBEAM = 2,
|
|
/// Cross shape
|
|
MOUSE_CURSOR_CROSSHAIR = 3,
|
|
/// Pointing hand cursor
|
|
MOUSE_CURSOR_POINTING_HAND = 4,
|
|
/// Horizontal resize/move arrow shape
|
|
MOUSE_CURSOR_RESIZE_EW = 5,
|
|
/// Vertical resize/move arrow shape
|
|
MOUSE_CURSOR_RESIZE_NS = 6,
|
|
/// Top-left to bottom-right diagonal resize/move arrow shape
|
|
MOUSE_CURSOR_RESIZE_NWSE = 7,
|
|
/// The top-right to bottom-left diagonal resize/move arrow shape
|
|
MOUSE_CURSOR_RESIZE_NESW = 8,
|
|
/// The omnidirectional resize/move cursor shape
|
|
MOUSE_CURSOR_RESIZE_ALL = 9,
|
|
/// The operation-not-allowed shape
|
|
MOUSE_CURSOR_NOT_ALLOWED = 10,
|
|
};
|
|
|
|
/// Gamepad buttons
|
|
pub const GamepadButton = enum(i32) {
|
|
/// Unknown button, just for error checking
|
|
GAMEPAD_BUTTON_UNKNOWN = 0,
|
|
/// Gamepad left DPAD up button
|
|
GAMEPAD_BUTTON_LEFT_FACE_UP = 1,
|
|
/// Gamepad left DPAD right button
|
|
GAMEPAD_BUTTON_LEFT_FACE_RIGHT = 2,
|
|
/// Gamepad left DPAD down button
|
|
GAMEPAD_BUTTON_LEFT_FACE_DOWN = 3,
|
|
/// Gamepad left DPAD left button
|
|
GAMEPAD_BUTTON_LEFT_FACE_LEFT = 4,
|
|
/// Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)
|
|
GAMEPAD_BUTTON_RIGHT_FACE_UP = 5,
|
|
/// Gamepad right button right (i.e. PS3: Square, Xbox: X)
|
|
GAMEPAD_BUTTON_RIGHT_FACE_RIGHT = 6,
|
|
/// Gamepad right button down (i.e. PS3: Cross, Xbox: A)
|
|
GAMEPAD_BUTTON_RIGHT_FACE_DOWN = 7,
|
|
/// Gamepad right button left (i.e. PS3: Circle, Xbox: B)
|
|
GAMEPAD_BUTTON_RIGHT_FACE_LEFT = 8,
|
|
/// Gamepad top/back trigger left (first), it could be a trailing button
|
|
GAMEPAD_BUTTON_LEFT_TRIGGER_1 = 9,
|
|
/// Gamepad top/back trigger left (second), it could be a trailing button
|
|
GAMEPAD_BUTTON_LEFT_TRIGGER_2 = 10,
|
|
/// Gamepad top/back trigger right (one), it could be a trailing button
|
|
GAMEPAD_BUTTON_RIGHT_TRIGGER_1 = 11,
|
|
/// Gamepad top/back trigger right (second), it could be a trailing button
|
|
GAMEPAD_BUTTON_RIGHT_TRIGGER_2 = 12,
|
|
/// Gamepad center buttons, left one (i.e. PS3: Select)
|
|
GAMEPAD_BUTTON_MIDDLE_LEFT = 13,
|
|
/// Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)
|
|
GAMEPAD_BUTTON_MIDDLE = 14,
|
|
/// Gamepad center buttons, right one (i.e. PS3: Start)
|
|
GAMEPAD_BUTTON_MIDDLE_RIGHT = 15,
|
|
/// Gamepad joystick pressed button left
|
|
GAMEPAD_BUTTON_LEFT_THUMB = 16,
|
|
/// Gamepad joystick pressed button right
|
|
GAMEPAD_BUTTON_RIGHT_THUMB = 17,
|
|
};
|
|
|
|
/// Gamepad axis
|
|
pub const GamepadAxis = enum(i32) {
|
|
/// Gamepad left stick X axis
|
|
GAMEPAD_AXIS_LEFT_X = 0,
|
|
/// Gamepad left stick Y axis
|
|
GAMEPAD_AXIS_LEFT_Y = 1,
|
|
/// Gamepad right stick X axis
|
|
GAMEPAD_AXIS_RIGHT_X = 2,
|
|
/// Gamepad right stick Y axis
|
|
GAMEPAD_AXIS_RIGHT_Y = 3,
|
|
/// Gamepad back trigger left, pressure level: [1..-1]
|
|
GAMEPAD_AXIS_LEFT_TRIGGER = 4,
|
|
/// Gamepad back trigger right, pressure level: [1..-1]
|
|
GAMEPAD_AXIS_RIGHT_TRIGGER = 5,
|
|
};
|
|
|
|
/// Material map index
|
|
pub const MaterialMapIndex = enum(i32) {
|
|
/// Albedo material (same as: MATERIAL_MAP_DIFFUSE)
|
|
MATERIAL_MAP_ALBEDO = 0,
|
|
/// Metalness material (same as: MATERIAL_MAP_SPECULAR)
|
|
MATERIAL_MAP_METALNESS = 1,
|
|
/// Normal material
|
|
MATERIAL_MAP_NORMAL = 2,
|
|
/// Roughness material
|
|
MATERIAL_MAP_ROUGHNESS = 3,
|
|
/// Ambient occlusion material
|
|
MATERIAL_MAP_OCCLUSION = 4,
|
|
/// Emission material
|
|
MATERIAL_MAP_EMISSION = 5,
|
|
/// Heightmap material
|
|
MATERIAL_MAP_HEIGHT = 6,
|
|
/// Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
|
|
MATERIAL_MAP_CUBEMAP = 7,
|
|
/// Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
|
|
MATERIAL_MAP_IRRADIANCE = 8,
|
|
/// Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
|
|
MATERIAL_MAP_PREFILTER = 9,
|
|
/// Brdf material
|
|
MATERIAL_MAP_BRDF = 10,
|
|
};
|
|
|
|
/// Shader location index
|
|
pub const ShaderLocationIndex = enum(i32) {
|
|
/// Shader location: vertex attribute: position
|
|
SHADER_LOC_VERTEX_POSITION = 0,
|
|
/// Shader location: vertex attribute: texcoord01
|
|
SHADER_LOC_VERTEX_TEXCOORD01 = 1,
|
|
/// Shader location: vertex attribute: texcoord02
|
|
SHADER_LOC_VERTEX_TEXCOORD02 = 2,
|
|
/// Shader location: vertex attribute: normal
|
|
SHADER_LOC_VERTEX_NORMAL = 3,
|
|
/// Shader location: vertex attribute: tangent
|
|
SHADER_LOC_VERTEX_TANGENT = 4,
|
|
/// Shader location: vertex attribute: color
|
|
SHADER_LOC_VERTEX_COLOR = 5,
|
|
/// Shader location: matrix uniform: model-view-projection
|
|
SHADER_LOC_MATRIX_MVP = 6,
|
|
/// Shader location: matrix uniform: view (camera transform)
|
|
SHADER_LOC_MATRIX_VIEW = 7,
|
|
/// Shader location: matrix uniform: projection
|
|
SHADER_LOC_MATRIX_PROJECTION = 8,
|
|
/// Shader location: matrix uniform: model (transform)
|
|
SHADER_LOC_MATRIX_MODEL = 9,
|
|
/// Shader location: matrix uniform: normal
|
|
SHADER_LOC_MATRIX_NORMAL = 10,
|
|
/// Shader location: vector uniform: view
|
|
SHADER_LOC_VECTOR_VIEW = 11,
|
|
/// Shader location: vector uniform: diffuse color
|
|
SHADER_LOC_COLOR_DIFFUSE = 12,
|
|
/// Shader location: vector uniform: specular color
|
|
SHADER_LOC_COLOR_SPECULAR = 13,
|
|
/// Shader location: vector uniform: ambient color
|
|
SHADER_LOC_COLOR_AMBIENT = 14,
|
|
/// Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)
|
|
SHADER_LOC_MAP_ALBEDO = 15,
|
|
/// Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)
|
|
SHADER_LOC_MAP_METALNESS = 16,
|
|
/// Shader location: sampler2d texture: normal
|
|
SHADER_LOC_MAP_NORMAL = 17,
|
|
/// Shader location: sampler2d texture: roughness
|
|
SHADER_LOC_MAP_ROUGHNESS = 18,
|
|
/// Shader location: sampler2d texture: occlusion
|
|
SHADER_LOC_MAP_OCCLUSION = 19,
|
|
/// Shader location: sampler2d texture: emission
|
|
SHADER_LOC_MAP_EMISSION = 20,
|
|
/// Shader location: sampler2d texture: height
|
|
SHADER_LOC_MAP_HEIGHT = 21,
|
|
/// Shader location: samplerCube texture: cubemap
|
|
SHADER_LOC_MAP_CUBEMAP = 22,
|
|
/// Shader location: samplerCube texture: irradiance
|
|
SHADER_LOC_MAP_IRRADIANCE = 23,
|
|
/// Shader location: samplerCube texture: prefilter
|
|
SHADER_LOC_MAP_PREFILTER = 24,
|
|
/// Shader location: sampler2d texture: brdf
|
|
SHADER_LOC_MAP_BRDF = 25,
|
|
};
|
|
|
|
/// Shader uniform data type
|
|
pub const ShaderUniformDataType = enum(i32) {
|
|
/// Shader uniform type: float
|
|
SHADER_UNIFORM_FLOAT = 0,
|
|
/// Shader uniform type: vec2 (2 float)
|
|
SHADER_UNIFORM_VEC2 = 1,
|
|
/// Shader uniform type: vec3 (3 float)
|
|
SHADER_UNIFORM_VEC3 = 2,
|
|
/// Shader uniform type: vec4 (4 float)
|
|
SHADER_UNIFORM_VEC4 = 3,
|
|
/// Shader uniform type: int
|
|
SHADER_UNIFORM_INT = 4,
|
|
/// Shader uniform type: ivec2 (2 int)
|
|
SHADER_UNIFORM_IVEC2 = 5,
|
|
/// Shader uniform type: ivec3 (3 int)
|
|
SHADER_UNIFORM_IVEC3 = 6,
|
|
/// Shader uniform type: ivec4 (4 int)
|
|
SHADER_UNIFORM_IVEC4 = 7,
|
|
/// Shader uniform type: sampler2d
|
|
SHADER_UNIFORM_SAMPLER2D = 8,
|
|
};
|
|
|
|
/// Shader attribute data types
|
|
pub const ShaderAttributeDataType = enum(i32) {
|
|
/// Shader attribute type: float
|
|
SHADER_ATTRIB_FLOAT = 0,
|
|
/// Shader attribute type: vec2 (2 float)
|
|
SHADER_ATTRIB_VEC2 = 1,
|
|
/// Shader attribute type: vec3 (3 float)
|
|
SHADER_ATTRIB_VEC3 = 2,
|
|
/// Shader attribute type: vec4 (4 float)
|
|
SHADER_ATTRIB_VEC4 = 3,
|
|
};
|
|
|
|
/// Pixel formats
|
|
pub const PixelFormat = enum(i32) {
|
|
/// 8 bit per pixel (no alpha)
|
|
PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1,
|
|
/// 8*2 bpp (2 channels)
|
|
PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA = 2,
|
|
/// 16 bpp
|
|
PIXELFORMAT_UNCOMPRESSED_R5G6B5 = 3,
|
|
/// 24 bpp
|
|
PIXELFORMAT_UNCOMPRESSED_R8G8B8 = 4,
|
|
/// 16 bpp (1 bit alpha)
|
|
PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 = 5,
|
|
/// 16 bpp (4 bit alpha)
|
|
PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 = 6,
|
|
/// 32 bpp
|
|
PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = 7,
|
|
/// 32 bpp (1 channel - float)
|
|
PIXELFORMAT_UNCOMPRESSED_R32 = 8,
|
|
/// 32*3 bpp (3 channels - float)
|
|
PIXELFORMAT_UNCOMPRESSED_R32G32B32 = 9,
|
|
/// 32*4 bpp (4 channels - float)
|
|
PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 = 10,
|
|
/// 16 bpp (1 channel - half float)
|
|
PIXELFORMAT_UNCOMPRESSED_R16 = 11,
|
|
/// 16*3 bpp (3 channels - half float)
|
|
PIXELFORMAT_UNCOMPRESSED_R16G16B16 = 12,
|
|
/// 16*4 bpp (4 channels - half float)
|
|
PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 = 13,
|
|
/// 4 bpp (no alpha)
|
|
PIXELFORMAT_COMPRESSED_DXT1_RGB = 14,
|
|
/// 4 bpp (1 bit alpha)
|
|
PIXELFORMAT_COMPRESSED_DXT1_RGBA = 15,
|
|
/// 8 bpp
|
|
PIXELFORMAT_COMPRESSED_DXT3_RGBA = 16,
|
|
/// 8 bpp
|
|
PIXELFORMAT_COMPRESSED_DXT5_RGBA = 17,
|
|
/// 4 bpp
|
|
PIXELFORMAT_COMPRESSED_ETC1_RGB = 18,
|
|
/// 4 bpp
|
|
PIXELFORMAT_COMPRESSED_ETC2_RGB = 19,
|
|
/// 8 bpp
|
|
PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA = 20,
|
|
/// 4 bpp
|
|
PIXELFORMAT_COMPRESSED_PVRT_RGB = 21,
|
|
/// 4 bpp
|
|
PIXELFORMAT_COMPRESSED_PVRT_RGBA = 22,
|
|
/// 8 bpp
|
|
PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA = 23,
|
|
/// 2 bpp
|
|
PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA = 24,
|
|
};
|
|
|
|
/// Texture parameters: filter mode
|
|
pub const TextureFilter = enum(i32) {
|
|
/// No filter, just pixel approximation
|
|
TEXTURE_FILTER_POINT = 0,
|
|
/// Linear filtering
|
|
TEXTURE_FILTER_BILINEAR = 1,
|
|
/// Trilinear filtering (linear with mipmaps)
|
|
TEXTURE_FILTER_TRILINEAR = 2,
|
|
/// Anisotropic filtering 4x
|
|
TEXTURE_FILTER_ANISOTROPIC_4X = 3,
|
|
/// Anisotropic filtering 8x
|
|
TEXTURE_FILTER_ANISOTROPIC_8X = 4,
|
|
/// Anisotropic filtering 16x
|
|
TEXTURE_FILTER_ANISOTROPIC_16X = 5,
|
|
};
|
|
|
|
/// Texture parameters: wrap mode
|
|
pub const TextureWrap = enum(i32) {
|
|
/// Repeats texture in tiled mode
|
|
TEXTURE_WRAP_REPEAT = 0,
|
|
/// Clamps texture to edge pixel in tiled mode
|
|
TEXTURE_WRAP_CLAMP = 1,
|
|
/// Mirrors and repeats the texture in tiled mode
|
|
TEXTURE_WRAP_MIRROR_REPEAT = 2,
|
|
/// Mirrors and clamps to border the texture in tiled mode
|
|
TEXTURE_WRAP_MIRROR_CLAMP = 3,
|
|
};
|
|
|
|
/// Cubemap layouts
|
|
pub const CubemapLayout = enum(i32) {
|
|
/// Automatically detect layout type
|
|
CUBEMAP_LAYOUT_AUTO_DETECT = 0,
|
|
/// Layout is defined by a vertical line with faces
|
|
CUBEMAP_LAYOUT_LINE_VERTICAL = 1,
|
|
/// Layout is defined by a horizontal line with faces
|
|
CUBEMAP_LAYOUT_LINE_HORIZONTAL = 2,
|
|
/// Layout is defined by a 3x4 cross with cubemap faces
|
|
CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR = 3,
|
|
/// Layout is defined by a 4x3 cross with cubemap faces
|
|
CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE = 4,
|
|
/// Layout is defined by a panorama image (equirrectangular map)
|
|
CUBEMAP_LAYOUT_PANORAMA = 5,
|
|
};
|
|
|
|
/// Font type, defines generation method
|
|
pub const FontType = enum(i32) {
|
|
/// Default font generation, anti-aliased
|
|
FONT_DEFAULT = 0,
|
|
/// Bitmap font generation, no anti-aliasing
|
|
FONT_BITMAP = 1,
|
|
/// SDF font generation, requires external shader
|
|
FONT_SDF = 2,
|
|
};
|
|
|
|
/// Color blending modes (pre-defined)
|
|
pub const BlendMode = enum(i32) {
|
|
/// Blend textures considering alpha (default)
|
|
BLEND_ALPHA = 0,
|
|
/// Blend textures adding colors
|
|
BLEND_ADDITIVE = 1,
|
|
/// Blend textures multiplying colors
|
|
BLEND_MULTIPLIED = 2,
|
|
/// Blend textures adding colors (alternative)
|
|
BLEND_ADD_COLORS = 3,
|
|
/// Blend textures subtracting colors (alternative)
|
|
BLEND_SUBTRACT_COLORS = 4,
|
|
/// Blend premultiplied textures considering alpha
|
|
BLEND_ALPHA_PREMULTIPLY = 5,
|
|
/// Blend textures using custom src/dst factors (use rlSetBlendFactors())
|
|
BLEND_CUSTOM = 6,
|
|
/// Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate())
|
|
BLEND_CUSTOM_SEPARATE = 7,
|
|
};
|
|
|
|
/// Gesture
|
|
pub const Gesture = enum(i32) {
|
|
/// No gesture
|
|
GESTURE_NONE = 0,
|
|
/// Tap gesture
|
|
GESTURE_TAP = 1,
|
|
/// Double tap gesture
|
|
GESTURE_DOUBLETAP = 2,
|
|
/// Hold gesture
|
|
GESTURE_HOLD = 4,
|
|
/// Drag gesture
|
|
GESTURE_DRAG = 8,
|
|
/// Swipe right gesture
|
|
GESTURE_SWIPE_RIGHT = 16,
|
|
/// Swipe left gesture
|
|
GESTURE_SWIPE_LEFT = 32,
|
|
/// Swipe up gesture
|
|
GESTURE_SWIPE_UP = 64,
|
|
/// Swipe down gesture
|
|
GESTURE_SWIPE_DOWN = 128,
|
|
/// Pinch in gesture
|
|
GESTURE_PINCH_IN = 256,
|
|
/// Pinch out gesture
|
|
GESTURE_PINCH_OUT = 512,
|
|
};
|
|
|
|
/// Camera system modes
|
|
pub const CameraMode = enum(i32) {
|
|
/// Custom camera
|
|
CAMERA_CUSTOM = 0,
|
|
/// Free camera
|
|
CAMERA_FREE = 1,
|
|
/// Orbital camera
|
|
CAMERA_ORBITAL = 2,
|
|
/// First person camera
|
|
CAMERA_FIRST_PERSON = 3,
|
|
/// Third person camera
|
|
CAMERA_THIRD_PERSON = 4,
|
|
};
|
|
|
|
/// Camera projection
|
|
pub const CameraProjection = enum(i32) {
|
|
/// Perspective projection
|
|
CAMERA_PERSPECTIVE = 0,
|
|
/// Orthographic projection
|
|
CAMERA_ORTHOGRAPHIC = 1,
|
|
};
|
|
|
|
/// N-patch layout
|
|
pub const NPatchLayout = enum(i32) {
|
|
/// Npatch layout: 3x3 tiles
|
|
NPATCH_NINE_PATCH = 0,
|
|
/// Npatch layout: 1x3 tiles
|
|
NPATCH_THREE_PATCH_VERTICAL = 1,
|
|
/// Npatch layout: 3x1 tiles
|
|
NPATCH_THREE_PATCH_HORIZONTAL = 2,
|
|
};
|
|
|
|
/// OpenGL version
|
|
pub const rlGlVersion = enum(i32) {
|
|
/// OpenGL 1.1
|
|
RL_OPENGL_11 = 1,
|
|
/// OpenGL 2.1 (GLSL 120)
|
|
RL_OPENGL_21 = 2,
|
|
/// OpenGL 3.3 (GLSL 330)
|
|
RL_OPENGL_33 = 3,
|
|
/// OpenGL 4.3 (using GLSL 330)
|
|
RL_OPENGL_43 = 4,
|
|
/// OpenGL ES 2.0 (GLSL 100)
|
|
RL_OPENGL_ES_20 = 5,
|
|
/// OpenGL ES 3.0 (GLSL 300 es)
|
|
RL_OPENGL_ES_30 = 6,
|
|
};
|
|
|
|
/// Trace log level
|
|
pub const rlTraceLogLevel = enum(i32) {
|
|
/// Display all logs
|
|
RL_LOG_ALL = 0,
|
|
/// Trace logging, intended for internal use only
|
|
RL_LOG_TRACE = 1,
|
|
/// Debug logging, used for internal debugging, it should be disabled on release builds
|
|
RL_LOG_DEBUG = 2,
|
|
/// Info logging, used for program execution info
|
|
RL_LOG_INFO = 3,
|
|
/// Warning logging, used on recoverable failures
|
|
RL_LOG_WARNING = 4,
|
|
/// Error logging, used on unrecoverable failures
|
|
RL_LOG_ERROR = 5,
|
|
/// Fatal logging, used to abort program: exit(EXIT_FAILURE)
|
|
RL_LOG_FATAL = 6,
|
|
/// Disable logging
|
|
RL_LOG_NONE = 7,
|
|
};
|
|
|
|
/// Texture pixel formats
|
|
pub const rlPixelFormat = enum(i32) {
|
|
/// 8 bit per pixel (no alpha)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1,
|
|
/// 8*2 bpp (2 channels)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA = 2,
|
|
/// 16 bpp
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 = 3,
|
|
/// 24 bpp
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 = 4,
|
|
/// 16 bpp (1 bit alpha)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 = 5,
|
|
/// 16 bpp (4 bit alpha)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 = 6,
|
|
/// 32 bpp
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = 7,
|
|
/// 32 bpp (1 channel - float)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R32 = 8,
|
|
/// 32*3 bpp (3 channels - float)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 = 9,
|
|
/// 32*4 bpp (4 channels - float)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 = 10,
|
|
/// 16 bpp (1 channel - half float)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R16 = 11,
|
|
/// 16*3 bpp (3 channels - half float)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 = 12,
|
|
/// 16*4 bpp (4 channels - half float)
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 = 13,
|
|
/// 4 bpp (no alpha)
|
|
RL_PIXELFORMAT_COMPRESSED_DXT1_RGB = 14,
|
|
/// 4 bpp (1 bit alpha)
|
|
RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA = 15,
|
|
/// 8 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA = 16,
|
|
/// 8 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA = 17,
|
|
/// 4 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_ETC1_RGB = 18,
|
|
/// 4 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_ETC2_RGB = 19,
|
|
/// 8 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA = 20,
|
|
/// 4 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_PVRT_RGB = 21,
|
|
/// 4 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA = 22,
|
|
/// 8 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA = 23,
|
|
/// 2 bpp
|
|
RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA = 24,
|
|
};
|
|
|
|
/// Texture parameters: filter mode
|
|
pub const rlTextureFilter = enum(i32) {
|
|
/// No filter, just pixel approximation
|
|
RL_TEXTURE_FILTER_POINT = 0,
|
|
/// Linear filtering
|
|
RL_TEXTURE_FILTER_BILINEAR = 1,
|
|
/// Trilinear filtering (linear with mipmaps)
|
|
RL_TEXTURE_FILTER_TRILINEAR = 2,
|
|
/// Anisotropic filtering 4x
|
|
RL_TEXTURE_FILTER_ANISOTROPIC_4X = 3,
|
|
/// Anisotropic filtering 8x
|
|
RL_TEXTURE_FILTER_ANISOTROPIC_8X = 4,
|
|
/// Anisotropic filtering 16x
|
|
RL_TEXTURE_FILTER_ANISOTROPIC_16X = 5,
|
|
};
|
|
|
|
/// Color blending modes (pre-defined)
|
|
pub const rlBlendMode = enum(i32) {
|
|
/// Blend textures considering alpha (default)
|
|
RL_BLEND_ALPHA = 0,
|
|
/// Blend textures adding colors
|
|
RL_BLEND_ADDITIVE = 1,
|
|
/// Blend textures multiplying colors
|
|
RL_BLEND_MULTIPLIED = 2,
|
|
/// Blend textures adding colors (alternative)
|
|
RL_BLEND_ADD_COLORS = 3,
|
|
/// Blend textures subtracting colors (alternative)
|
|
RL_BLEND_SUBTRACT_COLORS = 4,
|
|
/// Blend premultiplied textures considering alpha
|
|
RL_BLEND_ALPHA_PREMULTIPLY = 5,
|
|
/// Blend textures using custom src/dst factors (use rlSetBlendFactors())
|
|
RL_BLEND_CUSTOM = 6,
|
|
/// Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate())
|
|
RL_BLEND_CUSTOM_SEPARATE = 7,
|
|
};
|
|
|
|
/// Shader location point type
|
|
pub const rlShaderLocationIndex = enum(i32) {
|
|
/// Shader location: vertex attribute: position
|
|
RL_SHADER_LOC_VERTEX_POSITION = 0,
|
|
/// Shader location: vertex attribute: texcoord01
|
|
RL_SHADER_LOC_VERTEX_TEXCOORD01 = 1,
|
|
/// Shader location: vertex attribute: texcoord02
|
|
RL_SHADER_LOC_VERTEX_TEXCOORD02 = 2,
|
|
/// Shader location: vertex attribute: normal
|
|
RL_SHADER_LOC_VERTEX_NORMAL = 3,
|
|
/// Shader location: vertex attribute: tangent
|
|
RL_SHADER_LOC_VERTEX_TANGENT = 4,
|
|
/// Shader location: vertex attribute: color
|
|
RL_SHADER_LOC_VERTEX_COLOR = 5,
|
|
/// Shader location: matrix uniform: model-view-projection
|
|
RL_SHADER_LOC_MATRIX_MVP = 6,
|
|
/// Shader location: matrix uniform: view (camera transform)
|
|
RL_SHADER_LOC_MATRIX_VIEW = 7,
|
|
/// Shader location: matrix uniform: projection
|
|
RL_SHADER_LOC_MATRIX_PROJECTION = 8,
|
|
/// Shader location: matrix uniform: model (transform)
|
|
RL_SHADER_LOC_MATRIX_MODEL = 9,
|
|
/// Shader location: matrix uniform: normal
|
|
RL_SHADER_LOC_MATRIX_NORMAL = 10,
|
|
/// Shader location: vector uniform: view
|
|
RL_SHADER_LOC_VECTOR_VIEW = 11,
|
|
/// Shader location: vector uniform: diffuse color
|
|
RL_SHADER_LOC_COLOR_DIFFUSE = 12,
|
|
/// Shader location: vector uniform: specular color
|
|
RL_SHADER_LOC_COLOR_SPECULAR = 13,
|
|
/// Shader location: vector uniform: ambient color
|
|
RL_SHADER_LOC_COLOR_AMBIENT = 14,
|
|
/// Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
|
|
RL_SHADER_LOC_MAP_ALBEDO = 15,
|
|
/// Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
|
|
RL_SHADER_LOC_MAP_METALNESS = 16,
|
|
/// Shader location: sampler2d texture: normal
|
|
RL_SHADER_LOC_MAP_NORMAL = 17,
|
|
/// Shader location: sampler2d texture: roughness
|
|
RL_SHADER_LOC_MAP_ROUGHNESS = 18,
|
|
/// Shader location: sampler2d texture: occlusion
|
|
RL_SHADER_LOC_MAP_OCCLUSION = 19,
|
|
/// Shader location: sampler2d texture: emission
|
|
RL_SHADER_LOC_MAP_EMISSION = 20,
|
|
/// Shader location: sampler2d texture: height
|
|
RL_SHADER_LOC_MAP_HEIGHT = 21,
|
|
/// Shader location: samplerCube texture: cubemap
|
|
RL_SHADER_LOC_MAP_CUBEMAP = 22,
|
|
/// Shader location: samplerCube texture: irradiance
|
|
RL_SHADER_LOC_MAP_IRRADIANCE = 23,
|
|
/// Shader location: samplerCube texture: prefilter
|
|
RL_SHADER_LOC_MAP_PREFILTER = 24,
|
|
/// Shader location: sampler2d texture: brdf
|
|
RL_SHADER_LOC_MAP_BRDF = 25,
|
|
};
|
|
|
|
/// Shader uniform data type
|
|
pub const rlShaderUniformDataType = enum(i32) {
|
|
/// Shader uniform type: float
|
|
RL_SHADER_UNIFORM_FLOAT = 0,
|
|
/// Shader uniform type: vec2 (2 float)
|
|
RL_SHADER_UNIFORM_VEC2 = 1,
|
|
/// Shader uniform type: vec3 (3 float)
|
|
RL_SHADER_UNIFORM_VEC3 = 2,
|
|
/// Shader uniform type: vec4 (4 float)
|
|
RL_SHADER_UNIFORM_VEC4 = 3,
|
|
/// Shader uniform type: int
|
|
RL_SHADER_UNIFORM_INT = 4,
|
|
/// Shader uniform type: ivec2 (2 int)
|
|
RL_SHADER_UNIFORM_IVEC2 = 5,
|
|
/// Shader uniform type: ivec3 (3 int)
|
|
RL_SHADER_UNIFORM_IVEC3 = 6,
|
|
/// Shader uniform type: ivec4 (4 int)
|
|
RL_SHADER_UNIFORM_IVEC4 = 7,
|
|
/// Shader uniform type: sampler2d
|
|
RL_SHADER_UNIFORM_SAMPLER2D = 8,
|
|
};
|
|
|
|
/// Shader attribute data types
|
|
pub const rlShaderAttributeDataType = enum(i32) {
|
|
/// Shader attribute type: float
|
|
RL_SHADER_ATTRIB_FLOAT = 0,
|
|
/// Shader attribute type: vec2 (2 float)
|
|
RL_SHADER_ATTRIB_VEC2 = 1,
|
|
/// Shader attribute type: vec3 (3 float)
|
|
RL_SHADER_ATTRIB_VEC3 = 2,
|
|
/// Shader attribute type: vec4 (4 float)
|
|
RL_SHADER_ATTRIB_VEC4 = 3,
|
|
};
|
|
|
|
/// Framebuffer attachment type
|
|
pub const rlFramebufferAttachType = enum(i32) {
|
|
/// Framebuffer attachment type: color 0
|
|
RL_ATTACHMENT_COLOR_CHANNEL0 = 0,
|
|
/// Framebuffer attachment type: color 1
|
|
RL_ATTACHMENT_COLOR_CHANNEL1 = 1,
|
|
/// Framebuffer attachment type: color 2
|
|
RL_ATTACHMENT_COLOR_CHANNEL2 = 2,
|
|
/// Framebuffer attachment type: color 3
|
|
RL_ATTACHMENT_COLOR_CHANNEL3 = 3,
|
|
/// Framebuffer attachment type: color 4
|
|
RL_ATTACHMENT_COLOR_CHANNEL4 = 4,
|
|
/// Framebuffer attachment type: color 5
|
|
RL_ATTACHMENT_COLOR_CHANNEL5 = 5,
|
|
/// Framebuffer attachment type: color 6
|
|
RL_ATTACHMENT_COLOR_CHANNEL6 = 6,
|
|
/// Framebuffer attachment type: color 7
|
|
RL_ATTACHMENT_COLOR_CHANNEL7 = 7,
|
|
/// Framebuffer attachment type: depth
|
|
RL_ATTACHMENT_DEPTH = 100,
|
|
/// Framebuffer attachment type: stencil
|
|
RL_ATTACHMENT_STENCIL = 200,
|
|
};
|
|
|
|
/// Framebuffer texture attachment type
|
|
pub const rlFramebufferAttachTextureType = enum(i32) {
|
|
/// Framebuffer texture attachment type: cubemap, +X side
|
|
RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0,
|
|
/// Framebuffer texture attachment type: cubemap, -X side
|
|
RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1,
|
|
/// Framebuffer texture attachment type: cubemap, +Y side
|
|
RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2,
|
|
/// Framebuffer texture attachment type: cubemap, -Y side
|
|
RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3,
|
|
/// Framebuffer texture attachment type: cubemap, +Z side
|
|
RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4,
|
|
/// Framebuffer texture attachment type: cubemap, -Z side
|
|
RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5,
|
|
/// Framebuffer texture attachment type: texture2d
|
|
RL_ATTACHMENT_TEXTURE2D = 100,
|
|
/// Framebuffer texture attachment type: renderbuffer
|
|
RL_ATTACHMENT_RENDERBUFFER = 200,
|
|
};
|
|
|
|
/// Face culling mode
|
|
pub const rlCullMode = enum(i32) {
|
|
///
|
|
RL_CULL_FACE_FRONT = 0,
|
|
///
|
|
RL_CULL_FACE_BACK = 1,
|
|
};
|
|
|
|
/// circle or polygon
|
|
pub const PhysicsShapeType = enum(i32) {
|
|
/// physics shape is a circle
|
|
PHYSICS_CIRCLE = 0,
|
|
/// physics shape is a polygon
|
|
PHYSICS_POLYGON = 1,
|
|
};
|
|
|
|
///
|
|
pub const RAYLIB_VERSION_MAJOR: i32 = 5;
|
|
|
|
///
|
|
pub const RAYLIB_VERSION_MINOR: i32 = 1;
|
|
|
|
///
|
|
pub const RAYLIB_VERSION_PATCH: i32 = 0;
|
|
|
|
///
|
|
pub const RAYLIB_VERSION: []const u8 = "5.1-dev";
|
|
|
|
///
|
|
pub const PI: f32 = 3.14159265358979323846;
|
|
|
|
/// Light Gray
|
|
pub const LIGHTGRAY: Color = .{ .r = 200, .g = 200, .b = 200, .a = 255 };
|
|
|
|
/// Gray
|
|
pub const GRAY: Color = .{ .r = 130, .g = 130, .b = 130, .a = 255 };
|
|
|
|
/// Dark Gray
|
|
pub const DARKGRAY: Color = .{ .r = 80, .g = 80, .b = 80, .a = 255 };
|
|
|
|
/// Yellow
|
|
pub const YELLOW: Color = .{ .r = 253, .g = 249, .b = 0, .a = 255 };
|
|
|
|
/// Gold
|
|
pub const GOLD: Color = .{ .r = 255, .g = 203, .b = 0, .a = 255 };
|
|
|
|
/// Orange
|
|
pub const ORANGE: Color = .{ .r = 255, .g = 161, .b = 0, .a = 255 };
|
|
|
|
/// Pink
|
|
pub const PINK: Color = .{ .r = 255, .g = 109, .b = 194, .a = 255 };
|
|
|
|
/// Red
|
|
pub const RED: Color = .{ .r = 230, .g = 41, .b = 55, .a = 255 };
|
|
|
|
/// Maroon
|
|
pub const MAROON: Color = .{ .r = 190, .g = 33, .b = 55, .a = 255 };
|
|
|
|
/// Green
|
|
pub const GREEN: Color = .{ .r = 0, .g = 228, .b = 48, .a = 255 };
|
|
|
|
/// Lime
|
|
pub const LIME: Color = .{ .r = 0, .g = 158, .b = 47, .a = 255 };
|
|
|
|
/// Dark Green
|
|
pub const DARKGREEN: Color = .{ .r = 0, .g = 117, .b = 44, .a = 255 };
|
|
|
|
/// Sky Blue
|
|
pub const SKYBLUE: Color = .{ .r = 102, .g = 191, .b = 255, .a = 255 };
|
|
|
|
/// Blue
|
|
pub const BLUE: Color = .{ .r = 0, .g = 121, .b = 241, .a = 255 };
|
|
|
|
/// Dark Blue
|
|
pub const DARKBLUE: Color = .{ .r = 0, .g = 82, .b = 172, .a = 255 };
|
|
|
|
/// Purple
|
|
pub const PURPLE: Color = .{ .r = 200, .g = 122, .b = 255, .a = 255 };
|
|
|
|
/// Violet
|
|
pub const VIOLET: Color = .{ .r = 135, .g = 60, .b = 190, .a = 255 };
|
|
|
|
/// Dark Purple
|
|
pub const DARKPURPLE: Color = .{ .r = 112, .g = 31, .b = 126, .a = 255 };
|
|
|
|
/// Beige
|
|
pub const BEIGE: Color = .{ .r = 211, .g = 176, .b = 131, .a = 255 };
|
|
|
|
/// Brown
|
|
pub const BROWN: Color = .{ .r = 127, .g = 106, .b = 79, .a = 255 };
|
|
|
|
/// Dark Brown
|
|
pub const DARKBROWN: Color = .{ .r = 76, .g = 63, .b = 47, .a = 255 };
|
|
|
|
/// White
|
|
pub const WHITE: Color = .{ .r = 255, .g = 255, .b = 255, .a = 255 };
|
|
|
|
/// Black
|
|
pub const BLACK: Color = .{ .r = 0, .g = 0, .b = 0, .a = 255 };
|
|
|
|
/// Blank (Transparent)
|
|
pub const BLANK: Color = .{ .r = 0, .g = 0, .b = 0, .a = 0 };
|
|
|
|
/// Magenta
|
|
pub const MAGENTA: Color = .{ .r = 255, .g = 0, .b = 255, .a = 255 };
|
|
|
|
/// My own White (raylib logo)
|
|
pub const RAYWHITE: Color = .{ .r = 245, .g = 245, .b = 245, .a = 255 };
|
|
|
|
///
|
|
pub const RLGL_VERSION: []const u8 = "4.5";
|
|
|
|
///
|
|
pub const RL_DEFAULT_BATCH_BUFFER_ELEMENTS: i32 = 8192;
|
|
|
|
/// Default number of batch buffers (multi-buffering)
|
|
pub const RL_DEFAULT_BATCH_BUFFERS: i32 = 1;
|
|
|
|
/// Default number of batch draw calls (by state changes: mode, texture)
|
|
pub const RL_DEFAULT_BATCH_DRAWCALLS: i32 = 256;
|
|
|
|
/// Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
|
|
pub const RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS: i32 = 4;
|
|
|
|
/// Maximum size of Matrix stack
|
|
pub const RL_MAX_MATRIX_STACK_SIZE: i32 = 32;
|
|
|
|
/// Maximum number of shader locations supported
|
|
pub const RL_MAX_SHADER_LOCATIONS: i32 = 32;
|
|
|
|
/// Default near cull distance
|
|
pub const RL_CULL_DISTANCE_NEAR: f64 = 0.01;
|
|
|
|
/// Default far cull distance
|
|
pub const RL_CULL_DISTANCE_FAR: f64 = 1000.0;
|
|
|
|
/// GL_TEXTURE_WRAP_S
|
|
pub const RL_TEXTURE_WRAP_S: i32 = 10242;
|
|
|
|
/// GL_TEXTURE_WRAP_T
|
|
pub const RL_TEXTURE_WRAP_T: i32 = 10243;
|
|
|
|
/// GL_TEXTURE_MAG_FILTER
|
|
pub const RL_TEXTURE_MAG_FILTER: i32 = 10240;
|
|
|
|
/// GL_TEXTURE_MIN_FILTER
|
|
pub const RL_TEXTURE_MIN_FILTER: i32 = 10241;
|
|
|
|
/// GL_NEAREST
|
|
pub const RL_TEXTURE_FILTER_NEAREST: i32 = 9728;
|
|
|
|
/// GL_LINEAR
|
|
pub const RL_TEXTURE_FILTER_LINEAR: i32 = 9729;
|
|
|
|
/// GL_NEAREST_MIPMAP_NEAREST
|
|
pub const RL_TEXTURE_FILTER_MIP_NEAREST: i32 = 9984;
|
|
|
|
/// GL_NEAREST_MIPMAP_LINEAR
|
|
pub const RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR: i32 = 9986;
|
|
|
|
/// GL_LINEAR_MIPMAP_NEAREST
|
|
pub const RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST: i32 = 9985;
|
|
|
|
/// GL_LINEAR_MIPMAP_LINEAR
|
|
pub const RL_TEXTURE_FILTER_MIP_LINEAR: i32 = 9987;
|
|
|
|
/// Anisotropic filter (custom identifier)
|
|
pub const RL_TEXTURE_FILTER_ANISOTROPIC: i32 = 12288;
|
|
|
|
/// Texture mipmap bias, percentage ratio (custom identifier)
|
|
pub const RL_TEXTURE_MIPMAP_BIAS_RATIO: i32 = 16384;
|
|
|
|
/// GL_REPEAT
|
|
pub const RL_TEXTURE_WRAP_REPEAT: i32 = 10497;
|
|
|
|
/// GL_CLAMP_TO_EDGE
|
|
pub const RL_TEXTURE_WRAP_CLAMP: i32 = 33071;
|
|
|
|
/// GL_MIRRORED_REPEAT
|
|
pub const RL_TEXTURE_WRAP_MIRROR_REPEAT: i32 = 33648;
|
|
|
|
/// GL_MIRROR_CLAMP_EXT
|
|
pub const RL_TEXTURE_WRAP_MIRROR_CLAMP: i32 = 34626;
|
|
|
|
/// GL_MODELVIEW
|
|
pub const RL_MODELVIEW: i32 = 5888;
|
|
|
|
/// GL_PROJECTION
|
|
pub const RL_PROJECTION: i32 = 5889;
|
|
|
|
/// GL_TEXTURE
|
|
pub const RL_TEXTURE: i32 = 5890;
|
|
|
|
/// GL_LINES
|
|
pub const RL_LINES: i32 = 1;
|
|
|
|
/// GL_TRIANGLES
|
|
pub const RL_TRIANGLES: i32 = 4;
|
|
|
|
/// GL_QUADS
|
|
pub const RL_QUADS: i32 = 7;
|
|
|
|
/// GL_UNSIGNED_BYTE
|
|
pub const RL_UNSIGNED_BYTE: i32 = 5121;
|
|
|
|
/// GL_FLOAT
|
|
pub const RL_FLOAT: i32 = 5126;
|
|
|
|
/// GL_STREAM_DRAW
|
|
pub const RL_STREAM_DRAW: i32 = 35040;
|
|
|
|
/// GL_STREAM_READ
|
|
pub const RL_STREAM_READ: i32 = 35041;
|
|
|
|
/// GL_STREAM_COPY
|
|
pub const RL_STREAM_COPY: i32 = 35042;
|
|
|
|
/// GL_STATIC_DRAW
|
|
pub const RL_STATIC_DRAW: i32 = 35044;
|
|
|
|
/// GL_STATIC_READ
|
|
pub const RL_STATIC_READ: i32 = 35045;
|
|
|
|
/// GL_STATIC_COPY
|
|
pub const RL_STATIC_COPY: i32 = 35046;
|
|
|
|
/// GL_DYNAMIC_DRAW
|
|
pub const RL_DYNAMIC_DRAW: i32 = 35048;
|
|
|
|
/// GL_DYNAMIC_READ
|
|
pub const RL_DYNAMIC_READ: i32 = 35049;
|
|
|
|
/// GL_DYNAMIC_COPY
|
|
pub const RL_DYNAMIC_COPY: i32 = 35050;
|
|
|
|
/// GL_FRAGMENT_SHADER
|
|
pub const RL_FRAGMENT_SHADER: i32 = 35632;
|
|
|
|
/// GL_VERTEX_SHADER
|
|
pub const RL_VERTEX_SHADER: i32 = 35633;
|
|
|
|
/// GL_COMPUTE_SHADER
|
|
pub const RL_COMPUTE_SHADER: i32 = 37305;
|
|
|
|
/// GL_ZERO
|
|
pub const RL_ZERO: i32 = 0;
|
|
|
|
/// GL_ONE
|
|
pub const RL_ONE: i32 = 1;
|
|
|
|
/// GL_SRC_COLOR
|
|
pub const RL_SRC_COLOR: i32 = 768;
|
|
|
|
/// GL_ONE_MINUS_SRC_COLOR
|
|
pub const RL_ONE_MINUS_SRC_COLOR: i32 = 769;
|
|
|
|
/// GL_SRC_ALPHA
|
|
pub const RL_SRC_ALPHA: i32 = 770;
|
|
|
|
/// GL_ONE_MINUS_SRC_ALPHA
|
|
pub const RL_ONE_MINUS_SRC_ALPHA: i32 = 771;
|
|
|
|
/// GL_DST_ALPHA
|
|
pub const RL_DST_ALPHA: i32 = 772;
|
|
|
|
/// GL_ONE_MINUS_DST_ALPHA
|
|
pub const RL_ONE_MINUS_DST_ALPHA: i32 = 773;
|
|
|
|
/// GL_DST_COLOR
|
|
pub const RL_DST_COLOR: i32 = 774;
|
|
|
|
/// GL_ONE_MINUS_DST_COLOR
|
|
pub const RL_ONE_MINUS_DST_COLOR: i32 = 775;
|
|
|
|
/// GL_SRC_ALPHA_SATURATE
|
|
pub const RL_SRC_ALPHA_SATURATE: i32 = 776;
|
|
|
|
/// GL_CONSTANT_COLOR
|
|
pub const RL_CONSTANT_COLOR: i32 = 32769;
|
|
|
|
/// GL_ONE_MINUS_CONSTANT_COLOR
|
|
pub const RL_ONE_MINUS_CONSTANT_COLOR: i32 = 32770;
|
|
|
|
/// GL_CONSTANT_ALPHA
|
|
pub const RL_CONSTANT_ALPHA: i32 = 32771;
|
|
|
|
/// GL_ONE_MINUS_CONSTANT_ALPHA
|
|
pub const RL_ONE_MINUS_CONSTANT_ALPHA: i32 = 32772;
|
|
|
|
/// GL_FUNC_ADD
|
|
pub const RL_FUNC_ADD: i32 = 32774;
|
|
|
|
/// GL_MIN
|
|
pub const RL_MIN: i32 = 32775;
|
|
|
|
/// GL_MAX
|
|
pub const RL_MAX: i32 = 32776;
|
|
|
|
/// GL_FUNC_SUBTRACT
|
|
pub const RL_FUNC_SUBTRACT: i32 = 32778;
|
|
|
|
/// GL_FUNC_REVERSE_SUBTRACT
|
|
pub const RL_FUNC_REVERSE_SUBTRACT: i32 = 32779;
|
|
|
|
/// GL_BLEND_EQUATION
|
|
pub const RL_BLEND_EQUATION: i32 = 32777;
|
|
|
|
/// GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION)
|
|
pub const RL_BLEND_EQUATION_RGB: i32 = 32777;
|
|
|
|
/// GL_BLEND_EQUATION_ALPHA
|
|
pub const RL_BLEND_EQUATION_ALPHA: i32 = 34877;
|
|
|
|
/// GL_BLEND_DST_RGB
|
|
pub const RL_BLEND_DST_RGB: i32 = 32968;
|
|
|
|
/// GL_BLEND_SRC_RGB
|
|
pub const RL_BLEND_SRC_RGB: i32 = 32969;
|
|
|
|
/// GL_BLEND_DST_ALPHA
|
|
pub const RL_BLEND_DST_ALPHA: i32 = 32970;
|
|
|
|
/// GL_BLEND_SRC_ALPHA
|
|
pub const RL_BLEND_SRC_ALPHA: i32 = 32971;
|
|
|
|
/// GL_BLEND_COLOR
|
|
pub const RL_BLEND_COLOR: i32 = 32773;
|
|
|
|
/// GL_READ_FRAMEBUFFER
|
|
pub const RL_READ_FRAMEBUFFER: i32 = 36008;
|
|
|
|
/// GL_DRAW_FRAMEBUFFER
|
|
pub const RL_DRAW_FRAMEBUFFER: i32 = 36009;
|
|
|
|
///
|
|
pub const GL_SHADING_LANGUAGE_VERSION: i32 = 35724;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGB_S3TC_DXT1_EXT: i32 = 33776;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: i32 = 33777;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: i32 = 33778;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: i32 = 33779;
|
|
|
|
///
|
|
pub const GL_ETC1_RGB8_OES: i32 = 36196;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGB8_ETC2: i32 = 37492;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA8_ETC2_EAC: i32 = 37496;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG: i32 = 35840;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: i32 = 35842;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA_ASTC_4x4_KHR: i32 = 37808;
|
|
|
|
///
|
|
pub const GL_COMPRESSED_RGBA_ASTC_8x8_KHR: i32 = 37815;
|
|
|
|
///
|
|
pub const GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: i32 = 34047;
|
|
|
|
///
|
|
pub const GL_TEXTURE_MAX_ANISOTROPY_EXT: i32 = 34046;
|
|
|
|
///
|
|
pub const GL_UNSIGNED_SHORT_5_6_5: i32 = 33635;
|
|
|
|
///
|
|
pub const GL_UNSIGNED_SHORT_5_5_5_1: i32 = 32820;
|
|
|
|
///
|
|
pub const GL_UNSIGNED_SHORT_4_4_4_4: i32 = 32819;
|
|
|
|
///
|
|
pub const GL_LUMINANCE: i32 = 6409;
|
|
|
|
///
|
|
pub const GL_LUMINANCE_ALPHA: i32 = 6410;
|
|
|
|
/// Bound by default to shader location: 0
|
|
pub const RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION: []const u8 = "vertexPosition";
|
|
|
|
/// Bound by default to shader location: 1
|
|
pub const RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD: []const u8 = "vertexTexCoord";
|
|
|
|
/// Bound by default to shader location: 2
|
|
pub const RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL: []const u8 = "vertexNormal";
|
|
|
|
/// Bound by default to shader location: 3
|
|
pub const RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR: []const u8 = "vertexColor";
|
|
|
|
/// Bound by default to shader location: 4
|
|
pub const RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT: []const u8 = "vertexTangent";
|
|
|
|
/// Bound by default to shader location: 5
|
|
pub const RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2: []const u8 = "vertexTexCoord2";
|
|
|
|
/// model-view-projection matrix
|
|
pub const RL_DEFAULT_SHADER_UNIFORM_NAME_MVP: []const u8 = "mvp";
|
|
|
|
/// view matrix
|
|
pub const RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW: []const u8 = "matView";
|
|
|
|
/// projection matrix
|
|
pub const RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION: []const u8 = "matProjection";
|
|
|
|
/// model matrix
|
|
pub const RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL: []const u8 = "matModel";
|
|
|
|
/// normal matrix (transpose(inverse(matModelView))
|
|
pub const RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL: []const u8 = "matNormal";
|
|
|
|
/// color diffuse (base tint color, multiplied by texture color)
|
|
pub const RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR: []const u8 = "colDiffuse";
|
|
|
|
/// texture0 (texture slot active 0)
|
|
pub const RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0: []const u8 = "texture0";
|
|
|
|
/// texture1 (texture slot active 1)
|
|
pub const RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1: []const u8 = "texture1";
|
|
|
|
/// texture2 (texture slot active 2)
|
|
pub const RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2: []const u8 = "texture2";
|
|
|
|
///
|
|
pub const EPSILON: f32 = 0.000001;
|