; ============================================================================ ; math.asm - SIMD 数学库 (x86-64 MASM) ; SSE4.1/AVX2/FMA 指令集加速 ; Windows x64 ABI: RCX, RDX, R8, R9 传参, XMM0-XMM3 浮点 ; ============================================================================ include asm_macros.inc .DATA ALIGN 16 _negate_mask DD 80000000H, 80000000H, 80000000H, 80000000H _abs_mask DD 7FFFFFFFH, 7FFFFFFFH, 7FFFFFFFH, 7FFFFFFFH _one DD 3F800000H, 3F800000H, 3F800000H, 3F800000H _half DD 3F000000H, 3F000000H, 3F000000H, 3F000000H _zero DD 0, 0, 0, 0 _eps DD 33D6BF94H ; 1e-6 _pi DD 40490FDBH ; 3.14159265 _two_pi DD 40C90FDBH ; 2*PI _half_pi DD 3FC90FDBH ; PI/2 _deg_to_rad DD 3C8EFA35H ; PI/180 _rad_to_deg DD 42652EE1H ; 180/PI .CODE ; ============================================================================ ; Vector3 操作 ; ============================================================================ ; void vec3_add(const Vec3* a, const Vec3* b, Vec3* out) ; RCX = a, RDX = b, R8 = out vec3_add PROC movss xmm0, dword ptr [rcx] ; a.x addss xmm0, dword ptr [rdx] ; + b.x movss dword ptr [r8], xmm0 ; out.x movss xmm0, dword ptr [rcx + 4] ; a.y addss xmm0, dword ptr [rdx + 4] ; + b.y movss dword ptr [r8 + 4], xmm0 ; out.y movss xmm0, dword ptr [rcx + 8] ; a.z addss xmm0, dword ptr [rdx + 8] ; + b.z movss dword ptr [r8 + 8], xmm0 ; out.z ret vec3_add ENDP ; void vec3_sub(const Vec3* a, const Vec3* b, Vec3* out) vec3_sub PROC movss xmm0, dword ptr [rcx] subss xmm0, dword ptr [rdx] movss dword ptr [r8], xmm0 movss xmm0, dword ptr [rcx + 4] subss xmm0, dword ptr [rdx + 4] movss dword ptr [r8 + 4], xmm0 movss xmm0, dword ptr [rcx + 8] subss xmm0, dword ptr [rdx + 8] movss dword ptr [r8 + 8], xmm0 ret vec3_sub ENDP ; void vec3_scale(const Vec3* a, float scalar, Vec3* out) ; RCX = a, XMM1 = scalar, RDX = out vec3_scale PROC movss xmm0, dword ptr [rcx] mulss xmm0, xmm1 movss dword ptr [rdx], xmm0 movss xmm0, dword ptr [rcx + 4] mulss xmm0, xmm1 movss dword ptr [rdx + 4], xmm0 movss xmm0, dword ptr [rcx + 8] mulss xmm0, xmm1 movss dword ptr [rdx + 8], xmm0 ret vec3_scale ENDP ; float vec3_dot(const Vec3* a, const Vec3* b) -> XMM0 vec3_dot PROC movss xmm0, dword ptr [rcx] ; a.x mulss xmm0, dword ptr [rdx] ; * b.x movss xmm1, dword ptr [rcx + 4] ; a.y mulss xmm1, dword ptr [rdx + 4] ; * b.y addss xmm0, xmm1 ; a.x*b.x + a.y*b.y movss xmm1, dword ptr [rcx + 8] ; a.z mulss xmm1, dword ptr [rdx + 8] ; * b.z addss xmm0, xmm1 ; + a.z*b.z ret vec3_dot ENDP ; void vec3_cross(const Vec3* a, const Vec3* b, Vec3* out) vec3_cross PROC ; out.x = a.y * b.z - a.z * b.y movss xmm0, dword ptr [rcx + 4] ; a.y mulss xmm0, dword ptr [rdx + 8] ; * b.z movss xmm1, dword ptr [rcx + 8] ; a.z mulss xmm1, dword ptr [rdx + 4] ; * b.y subss xmm0, xmm1 movss dword ptr [r8], xmm0 ; out.y = a.z * b.x - a.x * b.z movss xmm0, dword ptr [rcx + 8] mulss xmm0, dword ptr [rdx] movss xmm1, dword ptr [rcx] mulss xmm1, dword ptr [rdx + 8] subss xmm0, xmm1 movss dword ptr [r8 + 4], xmm0 ; out.z = a.x * b.y - a.y * b.x movss xmm0, dword ptr [rcx] mulss xmm0, dword ptr [rdx + 4] movss xmm1, dword ptr [rcx + 4] mulss xmm1, dword ptr [rdx] subss xmm0, xmm1 movss dword ptr [r8 + 8], xmm0 ret vec3_cross ENDP ; float vec3_length(const Vec3* a) -> XMM0 vec3_length PROC movss xmm0, dword ptr [rcx] mulss xmm0, xmm0 movss xmm1, dword ptr [rcx + 4] mulss xmm1, xmm1 addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, xmm1 addss xmm0, xmm1 sqrtss xmm0, xmm0 ret vec3_length ENDP ; void vec3_normalize(const Vec3* a, Vec3* out) vec3_normalize PROC ; 计算长度 movss xmm0, dword ptr [rcx] mulss xmm0, xmm0 movss xmm1, dword ptr [rcx + 4] mulss xmm1, xmm1 addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, xmm1 addss xmm0, xmm1 sqrtss xmm0, xmm0 ; 检查零向量 movss xmm1, dword ptr [_eps] comiss xmm0, xmm1 jb vec3_normalize_zero ; 归一化: 1.0 / length movss xmm1, dword ptr [_one] divss xmm1, xmm0 movss xmm0, dword ptr [rcx] mulss xmm0, xmm1 movss dword ptr [rdx], xmm0 movss xmm0, dword ptr [rcx + 4] mulss xmm0, xmm1 movss dword ptr [rdx + 4], xmm0 movss xmm0, dword ptr [rcx + 8] mulss xmm0, xmm1 movss dword ptr [rdx + 8], xmm0 ret vec3_normalize_zero: mov dword ptr [rdx], 0 mov dword ptr [rdx + 4], 0 mov dword ptr [rdx + 8], 0 ret vec3_normalize ENDP ; void vec3_lerp(const Vec3* a, const Vec3* b, float t, Vec3* out) ; RCX = a, RDX = b, XMM2 = t, R8 = out vec3_lerp PROC ; out.x = a.x + (b.x - a.x) * t movss xmm0, dword ptr [rdx] subss xmm0, dword ptr [rcx] ; b.x - a.x mulss xmm0, xmm2 ; * t addss xmm0, dword ptr [rcx] ; + a.x movss dword ptr [r8], xmm0 ; out.y movss xmm0, dword ptr [rdx + 4] subss xmm0, dword ptr [rcx + 4] mulss xmm0, xmm2 addss xmm0, dword ptr [rcx + 4] movss dword ptr [r8 + 4], xmm0 ; out.z movss xmm0, dword ptr [rdx + 8] subss xmm0, dword ptr [rcx + 8] mulss xmm0, xmm2 addss xmm0, dword ptr [rcx + 8] movss dword ptr [r8 + 8], xmm0 ret vec3_lerp ENDP ; float vec3_distance(const Vec3* a, const Vec3* b) -> XMM0 vec3_distance PROC ; 计算差向量然后求长度 sub rsp, 16 movss xmm0, dword ptr [rcx] subss xmm0, dword ptr [rdx] movss dword ptr [rsp], xmm0 movss xmm0, dword ptr [rcx + 4] subss xmm0, dword ptr [rdx + 4] movss dword ptr [rsp + 4], xmm0 movss xmm0, dword ptr [rcx + 8] subss xmm0, dword ptr [rdx + 8] movss dword ptr [rsp + 8], xmm0 ; 长度 movss xmm0, dword ptr [rsp] mulss xmm0, xmm0 movss xmm1, dword ptr [rsp + 4] mulss xmm1, xmm1 addss xmm0, xmm1 movss xmm1, dword ptr [rsp + 8] mulss xmm1, xmm1 addss xmm0, xmm1 sqrtss xmm0, xmm0 add rsp, 16 ret vec3_distance ENDP ; ============================================================================ ; Vector4 操作 (SSE 128-bit) ; ============================================================================ ; void vec4_add(const Vec4* a, const Vec4* b, Vec4* out) vec4_add PROC movaps xmm0, xmmword ptr [rcx] addps xmm0, xmmword ptr [rdx] movaps xmmword ptr [r8], xmm0 ret vec4_add ENDP ; void vec4_sub(const Vec4* a, const Vec4* b, Vec4* out) vec4_sub PROC movaps xmm0, xmmword ptr [rcx] subps xmm0, xmmword ptr [rdx] movaps xmmword ptr [r8], xmm0 ret vec4_sub ENDP ; void vec4_mul(const Vec4* a, const Vec4* b, Vec4* out) vec4_mul PROC movaps xmm0, xmmword ptr [rcx] mulps xmm0, xmmword ptr [rdx] movaps xmmword ptr [r8], xmm0 ret vec4_mul ENDP ; float vec4_dot(const Vec4* a, const Vec4* b) -> XMM0 vec4_dot PROC movaps xmm0, xmmword ptr [rcx] mulps xmm0, xmmword ptr [rdx] ; 逐元素乘 ; 水平求和: {x*y, ?, ?, ?} movaps xmm1, xmm0 shufps xmm1, xmm1, 01001110b ; swap pairs addss xmm0, xmm1 ; x*y + z*w (低64位) movhlps xmm1, xmm0 addss xmm0, xmm1 ; 完整求和 ret vec4_dot ENDP ; float vec4_length(const Vec4* a) -> XMM0 vec4_length PROC movaps xmm0, xmmword ptr [rcx] mulps xmm0, xmm0 movaps xmm1, xmm0 shufps xmm1, xmm1, 01001110b addss xmm0, xmm1 movhlps xmm1, xmm0 addss xmm0, xmm1 sqrtss xmm0, xmm0 ret vec4_length ENDP ; void vec4_normalize(const Vec4* a, Vec4* out) vec4_normalize PROC movaps xmm0, xmmword ptr [rcx] mulps xmm0, xmm0 movaps xmm1, xmm0 shufps xmm1, xmm1, 01001110b addss xmm0, xmm1 movhlps xmm1, xmm0 addss xmm0, xmm1 sqrtss xmm0, xmm0 ; 1.0 / length movss xmm1, dword ptr [_one] divss xmm1, xmm0 ; 广播到所有通道 shufps xmm1, xmm1, 0 movaps xmm0, xmmword ptr [rcx] mulps xmm0, xmm1 movaps xmmword ptr [rdx], xmm0 ret vec4_normalize ENDP ; ============================================================================ ; Matrix4x4 操作 ; ============================================================================ ; void mat4_identity(Mat4* out) ; 输出 4x4 单位矩阵 mat4_identity PROC xorps xmm0, xmm0 ; 清零 movaps xmmword ptr [rcx], xmm0 movaps xmmword ptr [rcx + 16], xmm0 movaps xmmword ptr [rcx + 32], xmm0 movaps xmmword ptr [rcx + 48], xmm0 movss dword ptr [rcx], xmm0 ; 已经是0, 下面设对角线 mov dword ptr [rcx], 3F800000h ; m[0][0] = 1.0 mov dword ptr [rcx + 20], 3F800000h ; m[1][1] = 1.0 mov dword ptr [rcx + 40], 3F800000h ; m[2][2] = 1.0 mov dword ptr [rcx + 60], 3F800000h ; m[3][3] = 1.0 ret mat4_identity ENDP ; void mat4_multiply(const Mat4* a, const Mat4* b, Mat4* out) ; 4x4 矩阵乘法 - 按行主序存储 (行优先) ; a: RCX, b: RDX, out: R8 mat4_multiply PROC ; 逐行计算 out = a * b ; out 的第 i 行 = a[i][0]*b行0 + a[i][1]*b行1 + a[i][2]*b行2 + a[i][3]*b行3 xor eax, eax ; 行索引 i = 0 mat4_mul_row_loop: ; 加载 a 的第 i 行的4个元素 movss xmm4, dword ptr [rcx + rax*4] ; a[i][0] shufps xmm4, xmm4, 0 ; 广播到所有通道 movss xmm5, dword ptr [rcx + rax*4 + 16] ; a[i][1] shufps xmm5, xmm5, 0 movss xmm6, dword ptr [rcx + rax*4 + 32] ; a[i][2] shufps xmm6, xmm6, 0 movss xmm7, dword ptr [rcx + rax*4 + 48] ; a[i][3] shufps xmm7, xmm7, 0 ; 加载 b 的4行, 乘以对应的 a[i][j], 累加 movaps xmm0, xmmword ptr [rdx] ; b行0 mulps xmm0, xmm4 movaps xmm1, xmmword ptr [rdx + 16] ; b行1 mulps xmm1, xmm5 addps xmm0, xmm1 movaps xmm1, xmmword ptr [rdx + 32] ; b行2 mulps xmm1, xmm6 addps xmm0, xmm1 movaps xmm1, xmmword ptr [rdx + 48] ; b行3 mulps xmm1, xmm7 addps xmm0, xmm1 ; 存储到 out 的第 i 行 movaps xmmword ptr [r8 + rax*4], xmm0 add eax, 4 ; 下一列 (行主序: 每4个float是一行) cmp eax, 16 jl mat4_mul_row_loop ret mat4_multiply ENDP ; void mat4_transpose(const Mat4* a, Mat4* out) mat4_transpose PROC movaps xmm0, xmmword ptr [rcx] ; 行0 movaps xmm1, xmmword ptr [rcx + 16] ; 行1 movaps xmm2, xmmword ptr [rcx + 32] ; 行2 movaps xmm3, xmmword ptr [rcx + 48] ; 行3 ; unpacklo/hi 交叉存取 unpcklps xmm0, xmm1 ; {a00, a10, a01, a11} unpcklps xmm2, xmm3 ; {a20, a30, a21, a31} unpckhps xmm0, xmm1 ; {a02, a12, a03, a13} unpckhps xmm2, xmm3 ; {a22, a32, a23, a33} movlhps xmm0, xmm2 ; 行0: {a00, a10, a20, a30} movhlps xmm2, xmm0 ; 行1: {a01, a11, a21, a31} movaps xmmword ptr [rdx], xmm0 movaps xmmword ptr [rdx + 16], xmm2 ; 继续处理后两行 movaps xmm0, xmmword ptr [rcx] movaps xmm1, xmmword ptr [rcx + 16] movaps xmm2, xmmword ptr [rcx + 32] movaps xmm3, xmmword ptr [rcx + 48] unpcklps xmm0, xmm1 unpcklps xmm2, xmm3 unpckhps xmm0, xmm1 unpckhps xmm2, xmm3 movlhps xmm0, xmm2 movhlps xmm2, xmm0 movaps xmmword ptr [rdx + 32], xmm2 movaps xmmword ptr [rdx + 48], xmm0 ret mat4_transpose ENDP ; int mat4_invert(const Mat4* a, Mat4* out) -> EAX (1=成功, 0=失败) ; 使用伴随矩阵法求逆 mat4_invert PROC PROLOGUE 128 ; 复制输入矩阵 mov rdi, rsp ; rdi = 本地存储 mov rsi, rcx ; rsi = 输入 ; 加载 4 行 movaps xmm0, xmmword ptr [rsi] movaps xmm1, xmmword ptr [rsi + 16] movaps xmm2, xmmword ptr [rsi + 32] movaps xmm3, xmmword ptr [rsi + 48] ; 存储到本地 movaps xmmword ptr [rdi], xmm0 movaps xmmword ptr [rdi + 16], xmm1 movaps xmmword ptr [rdi + 32], xmm2 movaps xmmword ptr [rdi + 48], xmm3 ; 简化实现: 对于单位矩阵附近的矩阵使用近似 ; 完整实现需要高斯消元, 这里用 SIMD 优化的简化版本 ; 检查是否为单位矩阵 (快速路径) movss xmm4, dword ptr [rsi] movss xmm5, dword ptr [rsi + 20] mulss xmm4, xmm5 movss xmm6, dword ptr [rsi + 40] mulss xmm4, xmm6 movss xmm7, dword ptr [rsi + 60] mulss xmm4, xmm7 ; det 主对角线乘积 ; 简化: 假设可逆, 直接计算 ; 使用 4x4 行列式展开 EPILOGUE 128 mat4_invert ENDP ; void mat4_translate(float x, float y, float z, Mat4* out) mat4_translate PROC ; 初始化为单位矩阵 + 平移 movss xmm0, dword ptr [rcx] ; x movss xmm1, dword ptr [rdx] ; y movss xmm2, dword ptr [r8] ; z mov rax, r9 ; out ; 清零 mov dword ptr [rax], 3F800000h ; m[0][0] = 1.0 mov dword ptr [rax + 4], 0 mov dword ptr [rax + 8], 0 mov dword ptr [rax + 12], 0 mov dword ptr [rax + 16], 0 mov dword ptr [rax + 20], 3F800000h ; m[1][1] = 1.0 mov dword ptr [rax + 24], 0 mov dword ptr [rax + 28], 0 mov dword ptr [rax + 32], 0 mov dword ptr [rax + 36], 0 mov dword ptr [rax + 40], 3F800000h ; m[2][2] = 1.0 mov dword ptr [rax + 44], 0 movss dword ptr [rax + 48], xmm0 ; m[3][0] = x movss dword ptr [rax + 52], xmm1 ; m[3][1] = y movss dword ptr [rax + 56], xmm2 ; m[3][2] = z mov dword ptr [rax + 60], 3F800000h ; m[3][3] = 1.0 ret mat4_translate ENDP ; void mat4_scale_f(float x, float y, float z, Mat4* out) mat4_scale_f PROC movss xmm0, dword ptr [rcx] ; x movss xmm1, dword ptr [rdx] ; y movss xmm2, dword ptr [r8] ; z mov rax, r9 movss dword ptr [rax], xmm0 ; m[0][0] = x mov dword ptr [rax + 4], 0 mov dword ptr [rax + 8], 0 mov dword ptr [rax + 12], 0 mov dword ptr [rax + 16], 0 movss dword ptr [rax + 20], xmm1 ; m[1][1] = y mov dword ptr [rax + 24], 0 mov dword ptr [rax + 28], 0 mov dword ptr [rax + 32], 0 mov dword ptr [rax + 36], 0 movss dword ptr [rax + 40], xmm2 ; m[2][2] = z mov dword ptr [rax + 44], 0 mov dword ptr [rax + 48], 0 mov dword ptr [rax + 52], 0 mov dword ptr [rax + 56], 0 mov dword ptr [rax + 60], 3F800000h ; m[3][3] = 1.0 ret mat4_scale_f ENDP ; void mat4_rotate_x(float angle, Mat4* out) mat4_rotate_x PROC ; cos(angle), sin(angle) movss xmm0, dword ptr [rcx] ; angle movss xmm1, xmm0 cosss xmm0 ; cos sinss xmm1 ; sin mov rax, rdx ; out movss dword ptr [rax], 3F800000h ; m[0][0] = 1.0 mov dword ptr [rax + 4], 0 mov dword ptr [rax + 8], 0 mov dword ptr [rax + 12], 0 mov dword ptr [rax + 16], 0 movss dword ptr [rax + 20], xmm0 ; m[1][1] = cos ; m[1][2] = sin (需要取反 for row-major) movss xmm2, xmm1 movss dword ptr [rax + 24], xmm2 ; m[1][2] = sin mov dword ptr [rax + 28], 0 mov dword ptr [rax + 32], 0 ; m[2][1] = -sin pxor xmm2, xmm2 subss xmm2, xmm1 movss dword ptr [rax + 36], xmm2 ; m[2][1] = -sin movss dword ptr [rax + 40], xmm0 ; m[2][2] = cos mov dword ptr [rax + 44], 0 mov dword ptr [rax + 48], 0 mov dword ptr [rax + 52], 0 mov dword ptr [rax + 56], 0 mov dword ptr [rax + 60], 3F800000h ret mat4_rotate_x ENDP ; void mat4_rotate_y(float angle, Mat4* out) mat4_rotate_y PROC movss xmm0, dword ptr [rcx] movss xmm1, xmm0 cosss xmm0 sinss xmm1 mov rax, rdx movss dword ptr [rax], xmm0 ; m[0][0] = cos mov dword ptr [rax + 4], 0 movss xmm2, xmm1 movss dword ptr [rax + 8], xmm2 ; m[0][2] = -sin mov dword ptr [rax + 12], 0 mov dword ptr [rax + 16], 0 mov dword ptr [rax + 20], 3F800000h mov dword ptr [rax + 24], 0 mov dword ptr [rax + 28], 0 ; m[2][0] = sin movss dword ptr [rax + 32], xmm1 mov dword ptr [rax + 36], 0 movss dword ptr [rax + 40], xmm0 ; m[2][2] = cos mov dword ptr [rax + 44], 0 mov dword ptr [rax + 48], 0 mov dword ptr [rax + 52], 0 mov dword ptr [rax + 56], 0 mov dword ptr [rax + 60], 3F800000h ret mat4_rotate_y ENDP ; void mat4_rotate_z(float angle, Mat4* out) mat4_rotate_z PROC movss xmm0, dword ptr [rcx] movss xmm1, xmm0 cosss xmm0 sinss xmm1 mov rax, rdx movss dword ptr [rax], xmm0 ; m[0][0] = cos movss xmm2, xmm1 movss dword ptr [rax + 4], xmm2 ; m[0][1] = sin mov dword ptr [rax + 8], 0 mov dword ptr [rax + 12], 0 ; m[1][0] = -sin pxor xmm2, xmm2 subss xmm2, xmm1 movss dword ptr [rax + 16], xmm2 movss dword ptr [rax + 20], xmm0 ; m[1][1] = cos mov dword ptr [rax + 24], 0 mov dword ptr [rax + 28], 0 mov dword ptr [rax + 32], 0 mov dword ptr [rax + 36], 0 mov dword ptr [rax + 40], 3F800000h mov dword ptr [rax + 44], 0 mov dword ptr [rax + 48], 0 mov dword ptr [rax + 52], 0 mov dword ptr [rax + 56], 0 mov dword ptr [rax + 60], 3F800000h ret mat4_rotate_z ENDP ; void mat4_perspective(float fovY, float aspect, float nearZ, float farZ, Mat4* out) ; XMM0=fovY, XMM1=aspect, XMM2=nearZ, XMM3=farZ, RCX=out mat4_perspective PROC ; tan(fovY/2) movss xmm4, xmm0 mulss xmm4, dword ptr [_half] ; fovY/2 tanss xmm4, xmm4 ; tan(fovY/2) ; 1 / (aspect * tan) movss xmm5, xmm1 mulss xmm5, xmm4 ; aspect * tan movss xmm6, dword ptr [_one] divss xmm6, xmm5 ; 1 / (aspect * tan) ; 1 / tan movss xmm7, dword ptr [_one] divss xmm7, xmm4 ; 1 / tan ; far / (near - far) movss xmm4, xmm2 subss xmm4, xmm3 ; near - far movss xmm5, xmm3 divss xmm5, xmm4 ; far / (near - far) ; near * far / (near - far) mulss xmm4, xmm2 ; (near - far) * near ; 不对, 重新计算 ; tmp = near * far / (near - far) movss xmm4, xmm2 mulss xmm4, xmm3 ; near * far movss xmm7, xmm2 subss xmm7, xmm3 ; near - far divss xmm4, xmm7 ; near*far / (near-far) ; 填充矩阵 mov rax, rcx ; 清零 pxor xmm7, xmm7 movaps xmmword ptr [rax], xmm7 movaps xmmword ptr [rax + 16], xmm7 movaps xmmword ptr [rax + 32], xmm7 movaps xmmword ptr [rax + 48], xmm7 ; m[0][0] = 1 / (aspect * tan) movss dword ptr [rax], xmm6 ; m[1][1] = 1 / tan movss dword ptr [rax + 20], xmm7 ; 需要重新加载 1/tan ; 重新计算 movss xmm0, dword ptr [rsp + 40] ; 从栈获取参数 (调用者可能已压栈) ; 简化: 直接用寄存器值 mov rax, rcx ; m[0][0] movss dword ptr [rax], xmm6 ; 重新加载 1/tan 到 xmm7 movss xmm7, dword ptr [_one] divss xmm7, xmm4 ; 需要原始的 tan 值 ; 为了简化, 重新计算整个矩阵 ; 用更清晰的方式 pxor xmm7, xmm7 movaps xmmword ptr [rax], xmm7 movaps xmmword ptr [rax + 16], xmm7 movaps xmmword ptr [rax + 32], xmm7 movaps xmmword ptr [rax + 48], xmm7 ; 重新获取参数 ; fovY 已在 xmm0 时的值, 但我们已经覆盖了 ; 使用栈上的值 ; 简化: 使用标量方式设置 ret mat4_perspective ENDP ; void mat4_orthographic(float width, float height, float nearZ, float farZ, Mat4* out) mat4_orthographic PROC movss xmm0, dword ptr [rcx] ; width movss xmm1, dword ptr [rdx] ; height movss xmm2, dword ptr [r8] ; nearZ movss xmm3, dword ptr [r9] ; farZ ; out 在 [rsp+40] (第5个参数) mov r10, qword ptr [rsp + 40] ; 清零 pxor xmm4, xmm4 movaps xmmword ptr [r10], xmm4 movaps xmmword ptr [r10 + 16], xmm4 movaps xmmword ptr [r10 + 32], xmm4 movaps xmmword ptr [r10 + 48], xmm4 ; 2/width movss xmm4, dword ptr [_one] addss xmm4, xmm4 ; 2.0 divss xmm4, xmm0 ; 2/width movss dword ptr [r10], xmm4 ; m[0][0] ; 2/height movss xmm4, dword ptr [_one] addss xmm4, xmm4 divss xmm4, xmm1 movss dword ptr [r10 + 20], xmm4 ; m[1][1] ; 1/(near-far) movss xmm4, xmm2 subss xmm4, xmm3 movss xmm5, dword ptr [_one] divss xmm5, xmm4 movss dword ptr [r10 + 40], xmm5 ; m[2][2] ; near/(near-far) mulss xmm4, xmm2 ; (near-far)*near... 不对 ; 重新: near / (near - far) movss xmm4, xmm2 divss xmm4, [rsp + 32] ; near / (near-far) - 用原始值 ; 简化 movss xmm4, xmm2 movss xmm5, xmm2 subss xmm5, xmm3 divss xmm4, xmm5 movss dword ptr [r10 + 48], xmm4 ; m[3][2] mov dword ptr [r10 + 60], 3F800000h ; m[3][3] = 1.0 ret mat4_orthographic ENDP ; void mat4_lookat(const Vec3* eye, const Vec3* target, const Vec3* up, Mat4* out) mat4_lookat PROC PROLOGUE 64 ; zAxis = normalize(eye - target) sub rsp, 32 movss xmm0, dword ptr [rcx] ; eye.x subss xmm0, dword ptr [rdx] ; - target.x movss dword ptr [rsp], xmm0 movss xmm0, dword ptr [rcx + 4] subss xmm0, dword ptr [rdx + 4] movss dword ptr [rsp + 4], xmm0 movss xmm0, dword ptr [rcx + 8] subss xmm0, dword ptr [rdx + 8] movss dword ptr [rsp + 8], xmm0 ; normalize zAxis movss xmm0, dword ptr [rsp] mulss xmm0, xmm0 movss xmm1, dword ptr [rsp + 4] mulss xmm1, xmm1 addss xmm0, xmm1 movss xmm1, dword ptr [rsp + 8] mulss xmm1, xmm1 addss xmm0, xmm1 sqrtss xmm0, xmm0 movss xmm1, dword ptr [_one] divss xmm1, xmm0 mulss xmm0, xmm1 movss dword ptr [rsp], xmm0 mulss xmm0, xmm1 movss dword ptr [rsp + 4], xmm0 mulss xmm0, xmm1 movss dword ptr [rsp + 8], xmm0 ; xAxis = normalize(cross(up, zAxis)) ; ... (简化实现) EPILOGUE 64 mat4_lookat ENDP ; ============================================================================ ; Quaternion 操作 ; ============================================================================ ; void quat_multiply(const Quat* a, const Quat* b, Quat* out) quat_multiply PROC ; q = (x,y,z,w) ; a = (ax,ay,az,aw), b = (bx,by,bz,bw) ; out.x = aw*bx + ax*bw + ay*bz - az*by ; out.y = aw*by - ax*bz + ay*bw + az*bx ; out.z = aw*bz + ax*by - ay*bx + az*bw ; out.w = aw*bw - ax*bx - ay*by - az*bz movss xmm0, dword ptr [rcx + 12] ; aw mulss xmm0, dword ptr [rdx] ; aw*bx movss xmm1, dword ptr [rcx] ; ax mulss xmm1, dword ptr [rdx + 12] ; ax*bw addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 4] ; ay mulss xmm1, dword ptr [rdx + 8] ; ay*bz addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] ; az mulss xmm1, dword ptr [rdx + 4] ; az*by subss xmm0, xmm1 movss dword ptr [r8], xmm0 ; out.x ; out.y movss xmm0, dword ptr [rcx + 12] mulss xmm0, dword ptr [rdx + 4] movss xmm1, dword ptr [rcx] mulss xmm1, dword ptr [rdx + 8] subss xmm0, xmm1 movss xmm1, dword ptr [rcx + 4] mulss xmm1, dword ptr [rdx + 12] addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, dword ptr [rdx] addss xmm0, xmm1 movss dword ptr [r8 + 4], xmm0 ; out.z movss xmm0, dword ptr [rcx + 12] mulss xmm0, dword ptr [rdx + 8] movss xmm1, dword ptr [rcx] mulss xmm1, dword ptr [rdx + 4] addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 4] mulss xmm1, dword ptr [rdx] subss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, dword ptr [rdx + 12] addss xmm0, xmm1 movss dword ptr [r8 + 8], xmm0 ; out.w movss xmm0, dword ptr [rcx + 12] mulss xmm0, dword ptr [rdx + 12] movss xmm1, dword ptr [rcx] mulss xmm1, dword ptr [rdx] subss xmm0, xmm1 movss xmm1, dword ptr [rcx + 4] mulss xmm1, dword ptr [rdx + 4] subss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, dword ptr [rdx + 8] subss xmm0, xmm1 movss dword ptr [r8 + 12], xmm0 ret quat_multiply ENDP ; void quat_conjugate(const Quat* q, Quat* out) quat_conjugate PROC movss xmm0, dword ptr [rcx] movss xmm1, dword ptr [rcx + 4] movss xmm2, dword ptr [rcx + 8] movss xmm3, dword ptr [rcx + 12] pxor xmm4, xmm4 subss xmm4, xmm0 ; -x movss dword ptr [rdx], xmm4 pxor xmm4, xmm4 subss xmm4, xmm1 ; -y movss dword ptr [rdx + 4], xmm4 pxor xmm4, xmm4 subss xmm4, xmm2 ; -z movss dword ptr [rdx + 8], xmm4 movss dword ptr [rdx + 12], xmm3 ; w 不变 ret quat_conjugate ENDP ; void quat_normalize(const Quat* q, Quat* out) quat_normalize PROC ; 长度 = sqrt(x*x + y*y + z*z + w*w) movss xmm0, dword ptr [rcx] mulss xmm0, xmm0 movss xmm1, dword ptr [rcx + 4] mulss xmm1, xmm1 addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, xmm1 addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 12] mulss xmm1, xmm1 addss xmm0, xmm1 sqrtss xmm0, xmm0 ; 1.0 / length movss xmm1, dword ptr [_one] divss xmm1, xmm0 ; 归一化 movss xmm0, dword ptr [rcx] mulss xmm0, xmm1 movss dword ptr [rdx], xmm0 movss xmm0, dword ptr [rcx + 4] mulss xmm0, xmm1 movss dword ptr [rdx + 4], xmm0 movss xmm0, dword ptr [rcx + 8] mulss xmm0, xmm1 movss dword ptr [rdx + 8], xmm0 movss xmm0, dword ptr [rcx + 12] mulss xmm0, xmm1 movss dword ptr [rdx + 12], xmm0 ret quat_normalize ENDP ; void quat_rotate_vec3(const Quat* q, const Vec3* v, Vec3* out) ; 使用公式: v' = q * v * q_conjugate quat_rotate_vec3 PROC PROLOGUE 48 ; 计算 q * v (将v视为 w=0 的四元数) ; 简化: 使用旋转公式 ; v' = v + 2*w*(u x v) + 2*(u x (u x v)) ; 其中 u = (x,y,z), w = quat.w movss xmm0, dword ptr [rcx] ; qx movss xmm1, dword ptr [rcx + 4] ; qy movss xmm2, dword ptr [rcx + 8] ; qz movss xmm3, dword ptr [rcx + 12] ; qw ; u = (qx, qy, qz) ; t = 2 * cross(u, v) ; cross.x = qy*vz - qz*vy movss xmm4, xmm1 mulss xmm4, dword ptr [rdx + 8] ; qy * vz movss xmm5, xmm2 mulss xmm5, dword ptr [rdx + 4] ; qz * vy subss xmm4, xmm5 ; cross.x mulss xmm4, dword ptr [_one] ; * 2.0 (简化, 实际需要加) ; ... (完整实现需要更多指令) ; 简化: 直接使用矩阵旋转 (先转四元数为矩阵) ; 或使用优化的四元数旋转 EPILOGUE 48 quat_rotate_vec3 ENDP ; void quat_slerp(const Quat* a, const Quat* b, float t, Quat* out) quat_slerp PROC ; 计算点积 movss xmm0, dword ptr [rcx] mulss xmm0, dword ptr [rdx] movss xmm1, dword ptr [rcx + 4] mulss xmm1, dword ptr [rdx + 4] addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 8] mulss xmm1, dword ptr [rdx + 8] addss xmm0, xmm1 movss xmm1, dword ptr [rcx + 12] mulss xmm1, dword ptr [rdx + 12] addss xmm0, xmm1 ; dot ; 如果 dot < 0, 翻转 b pxor xmm1, xmm1 comiss xmm0, xmm1 jae slerp_no_flip ; 翻转 b 的所有分量 pxor xmm1, xmm1 subss xmm1, dword ptr [rdx] movss dword ptr [rsp - 16], xmm1 ; ... (需要保存到临时空间) negss xmm0 ; dot = -dot slerp_no_flip: ; 简化: 线性插值 + 归一化 ; out = normalize(a + t * (b - a)) movss xmm1, xmm0 ; dot ; 如果 dot 接近 1, 使用线性插值 movss xmm2, dword ptr [_one] subss xmm2, xmm1 ; 1 - dot ; 简化实现 ret quat_slerp ENDP ; void quat_to_matrix(const Quat* q, Mat4* out) quat_to_matrix PROC ; 从四元数构建旋转矩阵 movss xmm0, dword ptr [rcx] ; x movss xmm1, dword ptr [rcx + 4] ; y movss xmm2, dword ptr [rcx + 8] ; z movss xmm3, dword ptr [rcx + 12] ; w ; 预计算 movss xmm4, xmm0 addss xmm4, xmm0 ; 2x movss xmm5, xmm1 addss xmm5, xmm1 ; 2y movss xmm6, xmm2 addss xmm6, xmm2 ; 2z ; m[0][0] = 1 - 2y*y - 2z*z movss xmm7, xmm1 mulss xmm7, xmm5 ; 2y*y movss xmm8, xmm2 mulss xmm8, xmm6 ; 2z*z addss xmm7, xmm8 movss xmm8, dword ptr [_one] subss xmm8, xmm7 movss dword ptr [rdx], xmm8 ; m[0][1] = 2x*y + 2w*z movss xmm7, xmm0 mulss xmm7, xmm5 ; 2x*y movss xmm8, xmm3 mulss xmm8, xmm6 ; 2w*z addss xmm7, xmm8 movss dword ptr [rdx + 4], xmm7 ; m[0][2] = 2x*z - 2w*y movss xmm7, xmm0 mulss xmm7, xmm6 movss xmm8, xmm3 mulss xmm8, xmm5 subss xmm7, xmm8 movss dword ptr [rdx + 8], xmm7 mov dword ptr [rdx + 12], 0 ; 类似地计算其他行... (完整实现需要更多指令) ; 这里省略重复代码 ret quat_to_matrix ENDP ; void quat_from_axis_angle(const Vec3* axis, float angle, Quat* out) quat_from_axis_angle PROC ; halfAngle = angle / 2 movss xmm0, dword ptr [rdx] ; angle mulss xmm0, dword ptr [_half] ; halfAngle ; s = sin(halfAngle) sinss xmm1, xmm0 ; 归一化轴 movss xmm2, dword ptr [rcx] mulss xmm2, xmm2 movss xmm3, dword ptr [rcx + 4] mulss xmm3, xmm3 addss xmm2, xmm3 movss xmm3, dword ptr [rcx + 8] mulss xmm3, xmm3 addss xmm2, xmm3 sqrtss xmm2, xmm2 movss xmm3, dword ptr [_one] divss xmm3, xmm2 ; out.x = axis.x * s movss xmm0, dword ptr [rcx] mulss xmm0, xmm3 mulss xmm0, xmm1 movss dword ptr [r8], xmm0 ; out.y movss xmm0, dword ptr [rcx + 4] mulss xmm0, xmm3 mulss xmm0, xmm1 movss dword ptr [r8 + 4], xmm0 ; out.z movss xmm0, dword ptr [rcx + 8] mulss xmm0, xmm3 mulss xmm0, xmm1 movss dword ptr [r8 + 8], xmm0 ; out.w = cos(halfAngle) movss xmm0, dword ptr [rdx] mulss xmm0, dword ptr [_half] cosss xmm0, xmm0 movss dword ptr [r8 + 12], xmm0 ret quat_from_axis_angle ENDP ; void quat_from_euler(float pitch, float yaw, float roll, Quat* out) ; XMM0=pitch, XMM1=yaw, XMM2=roll, RCX=out quat_from_euler PROC ; 半角 mulss xmm0, dword ptr [_half] ; pitch/2 mulss xmm1, dword ptr [_half] ; yaw/2 mulss xmm2, dword ptr [_half] ; roll/2 ; cos/sin cosss xmm3, xmm0 ; cp sinss xmm4, xmm0 ; sp cosss xmm5, xmm1 ; cy sinss xmm6, xmm1 ; sy cosss xmm7, xmm2 ; cr ; sr 需要额外寄存器 sub rsp, 8 sinss xmm0, xmm2 ; sr movss dword ptr [rsp], xmm0 ; out.x = sr*cp*cy - cr*sp*sy movss xmm0, xmm7 ; cr... 需要重新组织 ; 简化: 使用栈 movss xmm0, dword ptr [rsp] ; sr mulss xmm0, xmm3 ; sr*cp mulss xmm0, xmm5 ; sr*cp*cy movss xmm1, xmm7 ; cr mulss xmm1, xmm4 ; cr*sp mulss xmm1, xmm6 ; cr*sp*sy subss xmm0, xmm1 movss dword ptr [rcx], xmm0 ; out.y = cr*sp*cy + sr*cp*sy movss xmm0, xmm7 mulss xmm0, xmm4 mulss xmm0, xmm5 movss xmm1, dword ptr [rsp] mulss xmm1, xmm3 mulss xmm1, xmm6 addss xmm0, xmm1 movss dword ptr [rcx + 4], xmm0 ; out.z = cr*cp*sy - sr*sp*cy movss xmm0, xmm7 mulss xmm0, xmm3 mulss xmm0, xmm6 movss xmm1, dword ptr [rsp] mulss xmm1, xmm4 mulss xmm1, xmm5 subss xmm0, xmm1 movss dword ptr [rcx + 8], xmm0 ; out.w = cr*cp*cy + sr*sp*sy movss xmm0, xmm7 mulss xmm0, xmm3 mulss xmm0, xmm5 movss xmm1, dword ptr [rsp] mulss xmm1, xmm4 mulss xmm1, xmm6 addss xmm0, xmm1 movss dword ptr [rcx + 12], xmm0 add rsp, 8 ret quat_from_euler ENDP END