124 lines
4.5 KiB
Zig
124 lines
4.5 KiB
Zig
const std = @import("std");
|
|
const vm = @import("root");
|
|
|
|
pub const Matrix4x4 = extern struct {
|
|
ix: f32,
|
|
iy: f32,
|
|
iz: f32,
|
|
iw: f32,
|
|
jx: f32,
|
|
jy: f32,
|
|
jz: f32,
|
|
jw: f32,
|
|
kx: f32,
|
|
ky: f32,
|
|
kz: f32,
|
|
kw: f32,
|
|
tx: f32,
|
|
ty: f32,
|
|
tz: f32,
|
|
tw: f32,
|
|
|
|
pub const Array = [16]f32;
|
|
|
|
pub const identity = init(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
|
|
|
|
// --- INIT ---
|
|
|
|
pub inline fn init(ix: f32, iy: f32, iz: f32, iw: f32, jx: f32, jy: f32, jz: f32, jw: f32, kx: f32, ky: f32, kz: f32, kw: f32, tx: f32, ty: f32, tz: f32, tw: f32) Matrix4x4 {
|
|
return .{ .ix = ix, .iy = iy, .iz = iz, .iw = iw, .jx = jx, .jy = jy, .jz = jz, .jw = jw, .kx = kx, .ky = ky, .kz = kz, .kw = kw, .tx = tx, .ty = ty, .tz = tz, .tw = tw };
|
|
}
|
|
|
|
pub inline fn initTranslation(t: Vector3) Matrix4x4 {
|
|
return .{ .ix = 1, .iy = 0, .iz = 0, .iw = 0, .jx = 0, .jy = 1, .jz = 0, .jw = 0, .kx = 0, .ky = 0, .kz = 1, .kw = 0, .tx = t.x, .ty = t.y, .tz = t.z, .tw = 1 };
|
|
}
|
|
|
|
pub inline fn initRotation(q: Quaternion) Matrix4x4 {
|
|
const xx = q.x * q.x;
|
|
const xy = q.x * q.y;
|
|
const xz = q.x * q.z;
|
|
const xw = q.x * q.w;
|
|
const yy = q.y * q.y;
|
|
const yz = q.y * q.z;
|
|
const yw = q.y * q.w;
|
|
const zz = q.z * q.z;
|
|
const zw = q.z * q.w;
|
|
|
|
return .{ .ix = 1 - 2 * (yy + zz), .jx = 2 * (xy + zw), .kx = 2 * (xz - yw), .tx = 0, .iy = 2 * (xy - zw), .jy = 1 - 2 * (xx + zz), .ky = 2 * (yz + xw), .ty = 0, .iz = 2 * (xz + yw), .jz = 2 * (yz - xw), .kz = 1 - 2 * (xx + yy), .tz = 0, .iw = 0, .jw = 0, .kw = 0, .tw = 1 };
|
|
}
|
|
|
|
pub inline fn initScale(s: Vector3) Matrix4x4 {
|
|
return .{ .ix = s.x, .iy = 0, .iz = 0, .iw = 0, .jx = 0, .jy = s.y, .jz = 0, .jw = 0, .kx = 0, .ky = 0, .kz = s.z, .kw = 0, .tx = 0, .ty = 0, .tz = 0, .tw = 1 };
|
|
}
|
|
|
|
pub inline fn initArray(array: Array) Matrix4x4 {
|
|
return @bitCast(array);
|
|
}
|
|
|
|
// --- CONVERSION ---
|
|
|
|
pub inline fn asArray(self: Matrix4x4) Array {
|
|
return @bitCast(self);
|
|
}
|
|
|
|
pub inline fn asArrayPtr(self: *Matrix4x4) *Array {
|
|
return @ptrCast(self);
|
|
}
|
|
|
|
pub inline fn asArrayConstPtr(self: *const Matrix4x4) *const Array {
|
|
return @ptrCast(self);
|
|
}
|
|
|
|
// --- TRANSFORM ---
|
|
|
|
pub inline fn transformPoint(self: Matrix4x4, p: Vector3) Vector3 {
|
|
return .{
|
|
.x = p.x * self.ix + p.y * self.jx + p.z * self.kx + self.tx,
|
|
.y = p.x * self.iy + p.y * self.jy + p.z * self.ky + self.ty,
|
|
.z = p.x * self.iz + p.y * self.jz + p.z * self.kz + self.tz,
|
|
};
|
|
}
|
|
|
|
pub inline fn transformPoint_x8(self: Matrix4x4, p: Vector3x8) Vector3x8 {
|
|
return .{
|
|
.x = p.x * ps(self.ix) + p.y * ps(self.jx) + p.z * ps(self.kx) + ps(self.tx),
|
|
.y = p.x * ps(self.iy) + p.y * ps(self.jy) + p.z * ps(self.ky) + ps(self.ty),
|
|
.z = p.x * ps(self.iz) + p.y * ps(self.jz) + p.z * ps(self.kz) + ps(self.tz),
|
|
};
|
|
}
|
|
|
|
pub inline fn transformVector(self: Matrix4x4, v: Vector3) Vector3 {
|
|
return .{
|
|
.x = v.x * self.ix + v.y * self.jx + v.z * self.kx,
|
|
.y = v.x * self.iy + v.y * self.jy + v.z * self.ky,
|
|
.z = v.x * self.iz + v.y * self.jz + v.z * self.kz,
|
|
};
|
|
}
|
|
|
|
pub inline fn transformVector_x8(self: Matrix4x4, v: Vector3x8) Vector3x8 {
|
|
return .{
|
|
.x = v.x * ps(self.ix) + v.y * ps(self.jx) + v.z * ps(self.kx),
|
|
.y = v.x * ps(self.iy) + v.y * ps(self.jy) + v.z * ps(self.ky),
|
|
.z = v.x * ps(self.iz) + v.y * ps(self.jz) + v.z * ps(self.kz),
|
|
};
|
|
}
|
|
|
|
pub inline fn transformHomogeneous(self: Matrix4x4, h: Vector4) Vector4 {
|
|
return .{
|
|
.x = h.x * self.ix + h.y * self.jx + h.z * self.kx + h.w * self.tx,
|
|
.y = h.x * self.iy + h.y * self.jy + h.z * self.ky + h.w * self.ty,
|
|
.z = h.x * self.iz + h.y * self.jz + h.z * self.kz + h.w * self.tz,
|
|
.w = h.x * self.iw + h.y * self.jw + h.z * self.kw + h.w * self.tw,
|
|
};
|
|
}
|
|
|
|
pub inline fn transformHomogeneous_x8(self: Matrix4x4, h: Vector4x8) Vector4x8 {
|
|
return .{
|
|
.x = h.x * ps(self.ix) + h.y * ps(self.jx) + h.z * ps(self.kx) + h.w * ps(self.tx),
|
|
.y = h.x * ps(self.iy) + h.y * ps(self.jy) + h.z * ps(self.ky) + h.w * ps(self.ty),
|
|
.z = h.x * ps(self.iz) + h.y * ps(self.jz) + h.z * ps(self.kz) + h.w * ps(self.tz),
|
|
.w = h.x * ps(self.iw) + h.y * ps(self.jw) + h.z * ps(self.kw) + h.w * ps(self.tw),
|
|
};
|
|
}
|
|
};
|