Dusk/WeirdUtils
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
9f2fa5213a5963265a52de863212630df7802c2e
WeirdUtils/src/silicon/silicon_sse.zig
T

507 lines
20 KiB
Zig
Raw Blame History

//! SSE math implementations for silicon module.
//!
//! Pure math functions extracted from silicon.zig for standalone compilation.
//! Used by both the DLL (via silicon.zig wrappers) and the bench harness.
//! All functions use C ABI (export fn) — callers handle CC translation.
//!
//! Compiled with SSE4.1+FMA+AVX. Uses @Vector(4, f32) and @mulAdd throughout.
const std = @import("std");
const V4 = @Vector(4, f32);
inline fn loadV4(ptr: u32) V4 {
return @as(*align(1) const V4, @ptrFromInt(ptr)).*;
}
inline fn loadV3_1(ptr: u32) V4 {
const p: [*]const f32 = @ptrFromInt(ptr);
return V4{ p[0], p[1], p[2], 1.0 };
}
inline fn dot3v(a: V4, b: V4) f32 {
return @mulAdd(f32, a[2], b[2], @mulAdd(f32, a[1], b[1], a[0] * b[0]));
}
inline fn dot4v(a: V4, b: V4) f32 {
return @mulAdd(f32, a[3], b[3], @mulAdd(f32, a[2], b[2], @mulAdd(f32, a[1], b[1], a[0] * b[0])));
}
// --- 0x4549C0: normalizeVec3 (137K/7.5s) ---
// divides vec3 by given length
export fn si_normalizeVec3(vec: u32, length_bits: u32) void {
const v: [*]f32 = @ptrFromInt(vec);
const length: f32 = @bitCast(length_bits);
const scale = 1.0 / length;
v[0] *= scale;
v[1] *= scale;
v[2] *= scale;
}
// --- 0x7BAE60: mulMat3x4 ---
// out = A * B (3x4 layout: 3x3 rotation + 3 translation)
// Layout: [r0c0 r0c1 r0c2 | r1c0 r1c1 r1c2 | r2c0 r2c1 r2c2 | tx ty tz]
// V4 per row: broadcast b[row*3+k], multiply with a's columns, accumulate.
export fn si_mulMat3x4(out: u32, a_ptr: u32, b_ptr: u32) u32 {
const dst: [*]f32 = @ptrFromInt(out);
const aa: [*]const f32 = @ptrFromInt(a_ptr);
const b: [*]const f32 = @ptrFromInt(b_ptr);
// a is row-major 3x3. a[0..2] = row 0, a[3..5] = row 1, a[6..8] = row 2.
// The formula: dst[row*3+col] = a[col]*b[row*3] + a[col+3]*b[row*3+1] + a[col+6]*b[row*3+2]
// This means: for each output row, we broadcast b's row elements and dot with a's "columns"
// a's "column k" is {a[k], a[k+3], a[k+6]} — that's picking one element from each of a's rows.
// Load a's columns (stride 3)
const ac0 = V4{ aa[0], aa[3], aa[6], aa[9] }; // col 0 of a (+ translation x)
const ac1 = V4{ aa[1], aa[4], aa[7], aa[10] }; // col 1 of a (+ translation y)
const ac2 = V4{ aa[2], aa[5], aa[8], aa[11] }; // col 2 of a (+ translation z)
// Rotation: 3 output rows
inline for (0..3) |row| {
const br0: V4 = @splat(b[row * 3]);
const br1: V4 = @splat(b[row * 3 + 1]);
const br2: V4 = @splat(b[row * 3 + 2]);
const result = @mulAdd(V4, ac2, br2, @mulAdd(V4, ac1, br1, ac0 * br0));
dst[row * 3] = result[0];
dst[row * 3 + 1] = result[1];
dst[row * 3 + 2] = result[2];
}
// Translation: dst[9+i] = a_trans dot b_col_i + b_trans[i]
// = ac0[3]*b[i] + ac1[3]*b[i+3] + ac2[3]*b[i+6] + b[9+i]
// Using the V4 approach: broadcast b elements, same ac columns, take lane 3 + add b_trans
// Translation: scalar @mulAdd (b's columns don't align for V4)
inline for (0..3) |col| {
dst[9 + col] = @mulAdd(f32, aa[11], b[col + 6], @mulAdd(f32, aa[10], b[col + 3], @mulAdd(f32, aa[9], b[col], b[9 + col])));
}
return out;
}
// --- 0x7BDDB0: rotateMatByQuat ---
// builds rotation matrix from quaternion, multiplies with existing 4x4 matrix
// Uses V4 for the matrix multiply (same pattern as bone_sse)
export fn si_rotateMatByQuat(mat: u32, quat: u32) u32 {
const q: [*]const f32 = @ptrFromInt(quat);
const x = q[0]; const y = q[1]; const z = q[2]; const w = q[3];
const x2 = x + x; const y2 = y + y; const z2 = z + z;
const xx = x * x2; const xy = x * y2; const xz = x * z2;
const yy = y * y2; const yz = y * z2; const zz = z * z2;
const wx = w * x2; const wy = w * y2; const wz = w * z2;
const q0 = V4{ 1.0 - (yy + zz), xy + wz, xz - wy, 0 };
const q1 = V4{ xy - wz, 1.0 - (xx + zz), yz + wx, 0 };
const q2 = V4{ xz + wy, yz - wx, 1.0 - (xx + yy), 0 };
const m: [*]f32 = @ptrFromInt(mat);
const m0 = V4{ m[0], m[1], m[2], m[3] };
const m1 = V4{ m[4], m[5], m[6], m[7] };
const m2 = V4{ m[8], m[9], m[10], m[11] };
const m3 = V4{ m[12], m[13], m[14], m[15] };
inline for ([_]struct { q: V4, off: u32 }{ .{ .q = q0, .off = 0 }, .{ .q = q1, .off = 4 }, .{ .q = q2, .off = 8 } }) |r| {
const row = @mulAdd(V4, @as(V4, @splat(r.q[2])), m2, @mulAdd(V4, @as(V4, @splat(r.q[1])), m1, @as(V4, @splat(r.q[0])) * m0));
m[r.off] = row[0]; m[r.off + 1] = row[1]; m[r.off + 2] = row[2]; m[r.off + 3] = row[3];
}
// Row 3 unchanged (identity row)
m[12] = m3[0]; m[13] = m3[1]; m[14] = m3[2]; m[15] = m3[3];
return mat;
}
// --- 0x7BB860: createRotMat3x4 ---
// Rodrigues rotation matrix, 3x4 layout. Uses @mulAdd for all 9 entries.
export fn si_createRotMat3x4(out: u32, axis_ptr: u32, angle_bits: u32, is_normalized: u32) u32 {
const m: [*]f32 = @ptrFromInt(out);
const ax: [*]const f32 = @ptrFromInt(axis_ptr);
var x = ax[0]; var y = ax[1]; var z = ax[2];
if (is_normalized == 0) {
const len = @sqrt(@mulAdd(f32, z, z, @mulAdd(f32, y, y, x * x)));
if (len > 1.0e-20) { const inv = 1.0 / len; x *= inv; y *= inv; z *= inv; }
}
const angle: f32 = @bitCast(angle_bits);
const c = @cos(angle); const s = @sin(angle); const t = 1.0 - c;
m[0] = @mulAdd(f32, t * x, x, c); m[1] = @mulAdd(f32, s, z, t * x * y); m[2] = @mulAdd(f32, -s, y, t * x * z);
m[3] = @mulAdd(f32, -s, z, t * x * y); m[4] = @mulAdd(f32, t * y, y, c); m[5] = @mulAdd(f32, s, x, t * y * z);
m[6] = @mulAdd(f32, s, y, t * x * z); m[7] = @mulAdd(f32, -s, x, t * y * z); m[8] = @mulAdd(f32, t * z, z, c);
m[9] = 0; m[10] = 0; m[11] = 0;
return out;
}
// --- 0x6329E0: distanceToPlane (525K/7.5s) ---
// Original: __fastcall(ECX=point, EDX=plane, stack[0]=direction), returns ST(0), RET 0x4.
// (dot(point,normal)+d) / dot(direction,normal). 70 bytes, 14cy.
// Naked FMA version: 2 dot products via vfmadd + vdivss, transfer to ST(0).
export fn si_distanceToPlane() callconv(.naked) void {
// ECX=point, EDX=plane, [ESP+4]=direction. Return ST(0), RET 0x4.
asm volatile (
// dot1 = p[0]*pl[0] + p[1]*pl[1] + p[2]*pl[2] + pl[3]
\\vmovss (%%ecx), %%xmm0
\\vmulss (%%edx), %%xmm0, %%xmm0
\\vmovss 4(%%ecx), %%xmm1
\\vfmadd231ss 4(%%edx), %%xmm1, %%xmm0
\\vmovss 8(%%ecx), %%xmm1
\\vfmadd231ss 8(%%edx), %%xmm1, %%xmm0
\\vaddss 12(%%edx), %%xmm0, %%xmm0
// dot2 = dir[0]*pl[0] + dir[1]*pl[1] + dir[2]*pl[2]
\\mov 4(%%esp), %%eax
\\vmovss (%%eax), %%xmm2
\\vmulss (%%edx), %%xmm2, %%xmm2
\\vmovss 4(%%eax), %%xmm1
\\vfmadd231ss 4(%%edx), %%xmm1, %%xmm2
\\vmovss 8(%%eax), %%xmm1
\\vfmadd231ss 8(%%edx), %%xmm1, %%xmm2
// result = dot1 / dot2 (skip epsilon check for speed — game tolerates it)
\\vdivss %%xmm2, %%xmm0, %%xmm0
// Transfer to ST(0)
\\sub $4, %%esp
\\vmovss %%xmm0, (%%esp)
\\flds (%%esp)
\\add $4, %%esp
\\ret $4
);
}
// --- 0x686C20: classifyPointFrustum (3.2M/7.5s) ---
// Tests point against 6 frustum planes, produces 6-bit bitmask.
// Scalar @mulAdd dot4 per plane — the FMA chain has best throughput for this pattern.
// Tried: V4 batch 4 planes (gather kills it), V4 hsum (shuffle overhead kills it).
export fn si_classifyPointFrustum(planes_ptr: u32, point: u32, out_mask: u32) u32 {
const mask: *u32 = @ptrFromInt(out_mask);
const pt = loadV3_1(point);
var bits: u32 = 0;
inline for (0..6) |i| {
const pl = loadV4(planes_ptr + i * 16);
const dist = dot4v(pt, pl);
// Branchless: extract sign bit via bit cast
bits |= (@as(u32, @bitCast(dist)) >> 31) << i;
}
mask.* = bits;
return planes_ptr;
}
// --- 0x6DC5A0: checkBoxLineIntersect (2.7M/7.5s) ---
// Slab-method AABB-line intersection. Uses @mulAdd for t computation.
export fn si_checkBoxLineIntersect(box_ptr: u32, line_start: u32, line_end: u32) u32 {
const bmin: [*]const f32 = @ptrFromInt(box_ptr);
const bmax: [*]const f32 = @ptrFromInt(box_ptr + 0xC);
const start: [*]const f32 = @ptrFromInt(line_start);
const end_pt: [*]const f32 = @ptrFromInt(line_end);
var tmin: f32 = 0.0;
var tmax: f32 = 1.0;
inline for (0..3) |i| {
const dir = end_pt[i] - start[i];
if (@abs(dir) < 1.0e-20) {
if (start[i] < bmin[i] or start[i] > bmax[i]) return 0;
} else {
const inv_dir = 1.0 / dir;
var t0 = (bmin[i] - start[i]) * inv_dir;
var t1 = (bmax[i] - start[i]) * inv_dir;
if (t0 > t1) { const tmp = t0; t0 = t1; t1 = tmp; }
if (t0 > tmin) tmin = t0;
if (t1 < tmax) tmax = t1;
if (tmin > tmax) return 0;
}
}
return 1;
}
// --- 0x6869C0: testOBBFrustum ---
// Tests OBB against 6 frustum planes. Uses V4 for corner transform and plane test.
export fn si_testOBBFrustum(planes_ptr: u32, aabb_ptr: u32, rot_ptr: u32, trans_ptr: u32) u32 {
const aabb: [*]const f32 = @ptrFromInt(aabb_ptr);
const rot: [*]const f32 = @ptrFromInt(rot_ptr);
const t: [*]const f32 = @ptrFromInt(trans_ptr);
// Rotation columns as V4 (xyz + 0 for w)
const rc0 = V4{ rot[0], rot[1], rot[2], 0 };
const rc1 = V4{ rot[3], rot[4], rot[5], 0 };
const rc2 = V4{ rot[6], rot[7], rot[8], 0 };
const tv = V4{ t[0], t[1], t[2], 1.0 };
// AABB extents
const mn = [3]f32{ aabb[0], aabb[1], aabb[2] };
const mx = [3]f32{ aabb[3], aabb[4], aabb[5] };
// Build 8 corners as V4 (xyz + 1.0 for plane dot w/ d term)
var corners: [8]V4 = undefined;
inline for (0..8) |i| {
const lx: f32 = if (i & 1 != 0) mx[0] else mn[0];
const ly: f32 = if (i & 2 != 0) mx[1] else mn[1];
const lz: f32 = if (i & 4 != 0) mx[2] else mn[2];
corners[i] = @mulAdd(V4, @as(V4, @splat(lz)), rc2, @mulAdd(V4, @as(V4, @splat(ly)), rc1, @mulAdd(V4, @as(V4, @splat(lx)), rc0, tv)));
}
// Test each plane: if all 8 corners are behind it, box is outside
inline for (0..6) |p| {
const pl = loadV4(planes_ptr + p * 16);
var all_outside = true;
inline for (0..8) |c| {
if (dot4v(corners[c], pl) >= 0) {
all_outside = false;
}
}
if (all_outside) return 0;
}
return 3;
}
// --- 0x686B80: testSphereFrustum (375K/7.5s) ---
// Uses V4 dot for plane distance
export fn si_testSphereFrustum(planes_ptr: u32, sphere: u32) u32 {
const s: [*]const f32 = @ptrFromInt(sphere);
const center = V4{ s[0], s[1], s[2], 1.0 };
const r = s[3];
inline for (0..6) |i| {
const pl = loadV4(planes_ptr + i * 16);
if (dot4v(center, pl) < -r) return 0;
}
return 3;
}
// --- 0x7C0570: quatSlerp ---
// V4 for final blend, @mulAdd for dot product
export fn si_quatSlerp(out: u32, a_ptr: u32, t_bits: u32, b_ptr: u32) u32 {
const dst: [*]f32 = @ptrFromInt(out);
const av = loadV4(a_ptr);
const bv = loadV4(b_ptr);
const tt: f32 = @bitCast(t_bits);
var dot_val = dot4v(av, bv);
var sign: f32 = 1.0;
if (dot_val < 0) { dot_val = -dot_val; sign = -1.0; }
var s0: f32 = undefined;
var s1: f32 = undefined;
if (dot_val > 0.9995) {
s0 = 1.0 - tt;
s1 = tt * sign;
} else {
const theta = std.math.acos(dot_val);
const sin_theta = @sin(theta);
const inv_sin = 1.0 / sin_theta;
s0 = @sin((1.0 - tt) * theta) * inv_sin;
s1 = @sin(tt * theta) * inv_sin * sign;
}
const result = @mulAdd(V4, @as(V4, @splat(s1)), bv, @as(V4, @splat(s0)) * av);
dst[0] = result[0]; dst[1] = result[1]; dst[2] = result[2]; dst[3] = result[3];
return out;
}
// --- 0x699330: isPointInsideBounds (1.7M/7.5s) ---
// Original: __fastcall(ECX=a, EDX=b), RET. 46 bytes, 6cy.
// Naked SSE: comiss replaces x87 FCOMP+FNSTSW+TEST (3 insns -> 1 insn per compare).
// Binary patch candidate: fits in 46 bytes.
export fn si_isPointInsideBounds() callconv(.naked) void {
// ECX = a, EDX = b. Return EAX = 1 if b[0..2] <= a[0..2], else 0.
asm volatile (
\\vmovss (%%edx), %%xmm0
\\vucomiss (%%ecx), %%xmm0
\\ja 1f
\\vmovss 4(%%edx), %%xmm0
\\vucomiss 4(%%ecx), %%xmm0
\\ja 1f
\\vmovss 8(%%edx), %%xmm0
\\vucomiss 8(%%ecx), %%xmm0
\\ja 1f
\\mov $1, %%eax
\\ret
\\1:
\\xor %%eax, %%eax
\\ret
);
}
// --- 0x749280: calculateSinCos ---
export fn si_calculateSinCos(angle_bits: u32, out_sin: u32, out_cos: u32) void {
const angle: f32 = @bitCast(angle_bits);
const sp: *f32 = @ptrFromInt(out_sin);
const cp: *f32 = @ptrFromInt(out_cos);
sp.* = @sin(angle);
cp.* = @cos(angle);
}
// --- 0x7BE5B0: createZRotMat3x3 ---
export fn si_createZRotMat3x3(out: u32, angle_bits: u32) u32 {
const m: [*]f32 = @ptrFromInt(out);
const angle: f32 = @bitCast(angle_bits);
const c = @cos(angle); const s = @sin(angle);
m[0] = c; m[1] = s; m[2] = 0;
m[3] = -s; m[4] = c; m[5] = 0;
m[6] = 0; m[7] = 0; m[8] = 1;
return out;
}
// --- 0x7BCEF0: transposeMat4x4 ---
// Uses V4 loads + @shuffle for efficient transpose
export fn si_transposeMat4x4(src: u32, dst: u32) u32 {
const r0 = loadV4(src);
const r1 = loadV4(src + 16);
const r2 = loadV4(src + 32);
const r3 = loadV4(src + 48);
// Interleave low/high pairs
const t0 = @shuffle(f32, r0, r1, [4]i32{ 0, -1, 2, -3 }); // r0[0] r1[0] r0[2] r1[2]
const t1 = @shuffle(f32, r0, r1, [4]i32{ 1, -2, 3, -4 }); // r0[1] r1[1] r0[3] r1[3]
const t2 = @shuffle(f32, r2, r3, [4]i32{ 0, -1, 2, -3 }); // r2[0] r3[0] r2[2] r3[2]
const t3 = @shuffle(f32, r2, r3, [4]i32{ 1, -2, 3, -4 }); // r2[1] r3[1] r2[3] r3[3]
const d: [*]f32 = @ptrFromInt(dst);
// Final columns
const c0 = @shuffle(f32, t0, t2, [4]i32{ 0, 1, -1, -2 }); // col 0: r0[0] r1[0] r2[0] r3[0]
const c1 = @shuffle(f32, t1, t3, [4]i32{ 0, 1, -1, -2 }); // col 1
const c2 = @shuffle(f32, t0, t2, [4]i32{ 2, 3, -3, -4 }); // col 2
const c3 = @shuffle(f32, t1, t3, [4]i32{ 2, 3, -3, -4 }); // col 3
inline for (0..4) |i| { d[i] = c0[i]; }
inline for (0..4) |i| { d[4 + i] = c1[i]; }
inline for (0..4) |i| { d[8 + i] = c2[i]; }
inline for (0..4) |i| { d[12 + i] = c3[i]; }
return src;
}
// --- 0x7BB420: mulMat3x4InPlace ---
// this = this * matB. V4 column approach: load a's columns (stride 3), broadcast b's row elements.
export fn si_mulMat3x4InPlace(mat_a: u32, mat_b: u32) u32 {
const a: [*]f32 = @ptrFromInt(mat_a);
const b: [*]const f32 = @ptrFromInt(mat_b);
// Load a's columns (stride 3, including translation row)
const ac0 = V4{ a[0], a[3], a[6], a[9] };
const ac1 = V4{ a[1], a[4], a[7], a[10] };
const ac2 = V4{ a[2], a[5], a[8], a[11] };
// Rotation: 3 output rows via V4 broadcast+FMA
var tmp: [12]f32 = undefined;
inline for (0..3) |row| {
const br0: V4 = @splat(b[row * 3]);
const br1: V4 = @splat(b[row * 3 + 1]);
const br2: V4 = @splat(b[row * 3 + 2]);
const result = @mulAdd(V4, ac2, br2, @mulAdd(V4, ac1, br1, ac0 * br0));
tmp[row * 3] = result[0];
tmp[row * 3 + 1] = result[1];
tmp[row * 3 + 2] = result[2];
}
// Translation: scalar @mulAdd
inline for (0..3) |col| {
tmp[9 + col] = @mulAdd(f32, a[11], b[col + 6], @mulAdd(f32, a[10], b[col + 3], @mulAdd(f32, a[9], b[col], b[9 + col])));
}
inline for (0..12) |i| { a[i] = tmp[i]; }
return mat_a;
}
// --- 0x6720F0: normalizeVec3InPlace ---
// Uses rsqrt approximation + Newton-Raphson for fast inverse sqrt
export fn si_normalizeVec3InPlace(vec: u32) void {
const v: [*]f32 = @ptrFromInt(vec);
const len = @sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
if (len > 1.0e-20) {
const inv = 1.0 / len;
v[0] *= inv;
v[1] *= inv;
v[2] *= inv;
}
}
// --- 0x71BC70: addVec3ToAccumulator (136K/7.5s) ---
export fn si_addVec3ToAccumulator(this: u32, vec: u32, scale_addr: u32) void {
const obj: [*]f32 = @ptrFromInt(this);
const v: [*]const f32 = @ptrFromInt(vec);
const scale: f32 = @as(*const f32, @ptrFromInt(scale_addr)).*;
obj[21] += v[0];
obj[22] += v[1];
obj[23] += v[2];
obj[33] = @mulAdd(f32, v[0], scale, obj[33]);
obj[42] = @mulAdd(f32, v[1], scale, obj[42]);
obj[51] = @mulAdd(f32, v[2], scale, obj[51]);
}
// --- 0x71BF60: addToColorAccumulator (10K/7.5s, 0.003ms total) ---
// 3 scalar float adds. At parity with original (9-10cy). Not worth optimizing further.
export fn si_addToColorAccumulator(this: u32, color: u32) void {
const obj: [*]f32 = @ptrFromInt(this);
const c: [*]const f32 = @ptrFromInt(color);
obj[27] += c[0];
obj[28] += c[1];
obj[29] += c[2];
}
// --- 0x7B7A80: packParticleColor (2K/7.5s) ---
// V4 multiply + clamp + convert for all 3 channels simultaneously
export fn si_packParticleColor(obj: u32, r_bits: u32, g_bits: u32, b_bits: u32) void {
const base: [*]u8 = @ptrFromInt(obj);
const out: *align(1) u32 = @ptrCast(base + 0x12C);
const alpha = base[0x12F];
const rgb = V4{ @bitCast(r_bits), @bitCast(g_bits), @bitCast(b_bits), 0 } * @as(V4, @splat(@as(f32, 255.0)));
const clamped = @min(@max(rgb, @as(V4, @splat(@as(f32, 0.0)))), @as(V4, @splat(@as(f32, 255.0))));
const rb: u8 = @intFromFloat(@round(clamped[0]));
const gb: u8 = @intFromFloat(@round(clamped[1]));
const bb: u8 = @intFromFloat(@round(clamped[2]));
out.* = @as(u32, alpha) << 24 | @as(u32, rb) << 16 | @as(u32, gb) << 8 | @as(u32, bb);
}
// --- 0x7B7B10: setParticleAlpha (2K/7.5s) ---
export fn si_setParticleAlpha(obj: u32, alpha_bits: u32) void {
const base: [*]u8 = @ptrFromInt(obj);
const alpha: f32 = @bitCast(alpha_bits);
base[0x12F] = @intFromFloat(@min(@max(alpha * 255.0, 0.0), 255.0));
}
// --- 0x40A2B0: __ftol ---
// Drop-in binary replacement. Input: ST(0). Output: EAX:EDX (i64).
// SSE3 FISTTP: truncate directly from x87 (9 bytes, replaces 39-byte original)
export fn si_ftol() callconv(.naked) void {
asm volatile (
\\sub $8, %%esp
\\.byte 0xDD, 0x0C, 0x24
\\pop %%eax
\\pop %%edx
\\ret
);
}
// --- 0x602630: vec3Dot (31K/7.5s, 0.05ms total) ---
// Original: __fastcall(ECX=a, EDX=b), returns ST(0). 21 bytes, 5cy.
// Achieved 0.8x (6cy) via naked FMA — the 1cy gap is the SSE->x87 transfer
// for the ST(0) return that callers expect. DPPS (SSE4.1) is 7-11cy, no better.
// x87 is inherently optimal here: 21 bytes, no domain crossing, pipelined.
// Not worth further optimization at 31K calls — 0.05ms total frame cost.
export fn si_vec3Dot() callconv(.naked) void {
// ECX = a ptr, EDX = b ptr (fastcall), return in ST(0)
asm volatile (
\\vmovss (%%ecx), %%xmm0
\\vmulss (%%edx), %%xmm0, %%xmm0
\\vmovss 4(%%ecx), %%xmm1
\\vfmadd231ss 4(%%edx), %%xmm1, %%xmm0
\\vmovss 8(%%ecx), %%xmm1
\\vfmadd231ss 8(%%edx), %%xmm1, %%xmm0
\\sub $4, %%esp
\\vmovss %%xmm0, (%%esp)
\\flds (%%esp)
\\add $4, %%esp
\\ret
);
}
// --- 0x686820: translateBoundingVol ---
// Uses @mulAdd for plane distance updates
export fn si_translateBoundingVol(this: u32, offset: u32) void {
const obj: [*]f32 = @ptrFromInt(this);
const off: [*]const f32 = @ptrFromInt(offset);
const dx = off[0]; const dy = off[1]; const dz = off[2];
// Translate 8 corners (stride 3, starting at index 24)
inline for (0..8) |i| {
const base = 24 + i * 3;
obj[base] += dx;
obj[base + 1] += dy;
obj[base + 2] += dz;
}
// Update 6 plane distances: d -= dot(normal, offset)
inline for (0..6) |i| {
const base = i * 4;
obj[base + 3] -= @mulAdd(f32, obj[base + 2], dz, @mulAdd(f32, obj[base + 1], dy, obj[base] * dx));
}
// Translate min/max
obj[48] += dx; obj[49] += dy; obj[50] += dz;
obj[51] += dx; obj[52] += dy; obj[53] += dz;
}
Reference in New Issue View Git Blame Copy Permalink