MathgeomGLS
5975 строк · 174.3 Кб
1{ Note about x64 calling convention2---------------------------------3Delphi uses the Microsoft x64 calling convention:5* Arguments that fit into 1, 2, 4 or 8 bytes are passed in registers RCX, RDX,6R8 and R9. This includes TVector2 records (which are 8 bytes). So those need7to be moved using MOVQ instead of MOVLPS.8NOTE: Delphi 10.3 Rio changed this behavior for 8-byte records (TVector2):9the register contains the address of the parameter instead (as is the case10in 32-bit, so we should use MOVLPS).11* The same goes for function results. Those go into RAX. Floating-point values12are returned in XMM0.13* The first 4 floating-point arguments go into XMM0, XMM1, XMM2 and XMM3.14* These registers must be preserved:15R12, R13, R14, R15, RDI, RSI, RBX, RBP, RSP, XMM6-XMM15.16* At the start of a function, RBP is always aligned to a 16-byte boundary (its17address always ends in 0).18* RSP is also always a multiple of 16, but its address always ends in 8 (since19the return address is pushed to the stack }20const22{ SSE rounding modes (bits in MXCSR register) }23SSE_ROUND_MASK = $FFFF9FFF;24SSE_ROUND_NEAREST = $00000000;25SSE_ROUND_DOWN = $00002000;26SSE_ROUND_UP = $00004000;27SSE_ROUND_TRUNC = $00006000;28{ These constants fit in a single XMM register. These values represent30sign-bits as used by 32-bit floating-point values.31XOR'ing a floating-point value with $80000000 swaps the sign.32XOR'ing a floating-point value with $00000000 leaves the value unchanged. }33SSE_MASK_SIGN: array [0..3] of UInt32 = ($80000000, $80000000, $80000000, $80000000);34SSE_MASK_NPNP: array [0..3] of UInt32 = ($80000000, $00000000, $80000000, $00000000);35SSE_MASK_PNPN: array [0..3] of UInt32 = ($00000000, $80000000, $00000000, $80000000);36SSE_MASK_0FFF: array [0..3] of UInt32 = ($FFFFFFFF, $FFFFFFFF, $FFFFFFFF, $00000000);37{ These constants mask off an element of the binary representation of a3932-bit floating-point value. }40SSE_MASK_FRACTION: array [0..3] of UInt32 = ($007FFFFF, $007FFFFF, $007FFFFF, $007FFFFF);41SSE_MASK_EXPONENT: array [0..3] of UInt32 = ($7F800000, $7F800000, $7F800000, $7F800000);42SSE_MASK_ABS_VAL : array [0..3] of UInt32 = ($7FFFFFFF, $7FFFFFFF, $7FFFFFFF, $7FFFFFFF);43{ Commonly used floating-point values }45SSE_ONE_HALF : array [0..3] of Single = (0.5, 0.5, 0.5, 0.5);46SSE_ONE : array [0..3] of Single = (1, 1, 1, 1);47SSE_TWO : array [0..3] of Single = (2, 2, 2, 2);48SSE_THREE : array [0..3] of Single = (3, 3, 3, 3);49SSE_PI_OVER_180 : array [0..3] of Single = (Pi / 180, Pi / 180, Pi / 180, Pi / 180);50SSE_180_OVER_PI : array [0..3] of Single = (180 / Pi, 180 / Pi, 180 / Pi, 180 / Pi);51SSE_NEG_INFINITY: array [0..3] of Single = (NegInfinity, NegInfinity, NegInfinity, NegInfinity);52SSE_PI_OVER_4 : array [0..3] of Single = (Pi / 4, Pi / 4, Pi / 4, Pi / 4);53{ Commonly used integer values }55SSE_INT_ONE : array [0..3] of Integer = (1, 1, 1, 1);56SSE_INT_NOT_ONE : array [0..3] of Cardinal = ($FFFFFFFE, $FFFFFFFE, $FFFFFFFE, $FFFFFFFE);57SSE_INT_TWO : array [0..3] of Integer = (2, 2, 2, 2);58SSE_INT_FOUR : array [0..3] of Integer = (4, 4, 4, 4);59{ Constants for approximating trigonometric functions }61SSE_FOPI: array [0..3] of Single = (1.27323954473516, 1.27323954473516, 1.27323954473516, 1.27323954473516);62SSE_SINCOF_P0: array [0..3] of Single = (-1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4, -1.9515295891E-4);63SSE_SINCOF_P1: array [0..3] of Single = (8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3, 8.3321608736E-3);64SSE_SINCOF_P2: array [0..3] of Single = (-1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1, -1.6666654611E-1);65SSE_COSCOF_P0: array [0..3] of Single = (2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005, 2.443315711809948E-005);66SSE_COSCOF_P1: array [0..3] of Single = (-1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003, -1.388731625493765E-003);67SSE_COSCOF_P2: array [0..3] of Single = (4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002, 4.166664568298827E-002);68SSE_EXP_A1 : array [0..3] of Single = (12102203.1615614, 12102203.1615614, 12102203.1615614, 12102203.1615614);70SSE_EXP_A2 : array [0..3] of Single = (1065353216, 1065353216, 1065353216, 1065353216);71SSE_EXP_CST: array [0..3] of Single = (2139095040, 2139095040, 2139095040, 2139095040);72SSE_EXP_F1 : array [0..3] of Single = (0.509964287281036376953125, 0.509964287281036376953125, 0.509964287281036376953125, 0.509964287281036376953125);73SSE_EXP_F2 : array [0..3] of Single = (0.3120158612728118896484375, 0.3120158612728118896484375, 0.3120158612728118896484375, 0.3120158612728118896484375);74SSE_EXP_F3 : array [0..3] of Single = (0.1666135489940643310546875, 0.1666135489940643310546875, 0.1666135489940643310546875, 0.1666135489940643310546875);75SSE_EXP_F4 : array [0..3] of Single = (-2.12528370320796966552734375e-3, -2.12528370320796966552734375e-3, -2.12528370320796966552734375e-3, -2.12528370320796966552734375e-3);76SSE_EXP_F5 : array [0..3] of Single = (1.3534179888665676116943359375e-2, 1.3534179888665676116943359375e-2, 1.3534179888665676116943359375e-2, 1.3534179888665676116943359375e-2);77SSE_EXP_I1 : array [0..3] of UInt32 = ($3F800000, $3F800000, $3F800000, $3F800000);78SSE_LN_CST: array [0..3] of Single = (-89.93423858, -89.93423858, -89.93423858, -89.93423858);80SSE_LN_F1 : array [0..3] of Single = (3.3977745, 3.3977745, 3.3977745, 3.3977745);81SSE_LN_F2 : array [0..3] of Single = (2.2744832, 2.2744832, 2.2744832, 2.2744832);82SSE_LN_F3 : array [0..3] of Single = (0.024982445, 0.024982445, 0.024982445, 0.024982445);83SSE_LN_F4 : array [0..3] of Single = (0.24371102, 0.24371102, 0.24371102, 0.24371102);84SSE_LN_F5 : array [0..3] of Single = (0.69314718055995, 0.69314718055995, 0.69314718055995, 0.69314718055995);85SSE_LOG2_I1: array [0..3] of UInt32 = ($3F000000, $3F000000, $3F000000, $3F000000);87SSE_LOG2_F1: array [0..3] of Single = (1.1920928955078125e-7, 1.1920928955078125e-7, 1.1920928955078125e-7, 1.1920928955078125e-7);88SSE_LOG2_F2: array [0..3] of Single = (124.22551499, 124.22551499, 124.22551499, 124.22551499);89SSE_LOG2_F3: array [0..3] of Single = (1.498030302, 1.498030302, 1.498030302, 1.498030302);90SSE_LOG2_F4: array [0..3] of Single = (1.72587999, 1.72587999, 1.72587999, 1.72587999);91SSE_LOG2_F5: array [0..3] of Single = (0.3520887068, 0.3520887068, 0.3520887068, 0.3520887068);92SSE_EXP2_F1: array [0..3] of Single = (121.2740575, 121.2740575, 121.2740575, 121.2740575);94SSE_EXP2_F2: array [0..3] of Single = (27.7280233, 27.7280233, 27.7280233, 27.7280233);95SSE_EXP2_F3: array [0..3] of Single = (4.84252568, 4.84252568, 4.84252568, 4.84252568);96SSE_EXP2_F4: array [0..3] of Single = (1.49012907, 1.49012907, 1.49012907, 1.49012907);97SSE_EXP2_F5: array [0..3] of Single = ($00800000, $00800000, $00800000, $00800000);98{ Angle and Trigonometry Functions }100function Radians(const ADegrees: Single): Single;102begin103Result := ADegrees * (Pi / 180);104end;105function Radians(const ADegrees: TVector2): TVector2; assembler;107asm108{$IF RTLVersion >= 33}109movlps xmm0, [ADegrees]110{$ELSE}111movq xmm0, ADegrees112{$ENDIF}113movlps xmm1, QWORD [SSE_PI_OVER_180]114mulps xmm0, xmm1115movq rax, xmm0116end;117function Radians(const ADegrees: TVector3): TVector3; assembler;119asm120movq xmm0, [ADegrees]121movss xmm1, DWORD [ADegrees+8]122movups xmm2, [SSE_PI_OVER_180]123mulps xmm0, xmm2124mulss xmm1, xmm2125movq [Result], xmm0126movss DWORD [Result+8], xmm1127end;128function Radians(const ADegrees: TVector4): TVector4; assembler;130asm131movups xmm0, [ADegrees]132movups xmm1, [SSE_PI_OVER_180]133mulps xmm0, xmm1134movups [Result], xmm0135end;136function Degrees(const ARadians: Single): Single;138begin139Result := ARadians * (180 / Pi);140end;141function Degrees(const ARadians: TVector2): TVector2; assembler;143asm144{$IF RTLVersion >= 33}145movlps xmm0, [ARadians]146{$ELSE}147movq xmm0, ARadians148{$ENDIF}149movlps xmm1, QWORD [SSE_180_OVER_PI]150mulps xmm0, xmm1151movq rax, xmm0152end;153function Degrees(const ARadians: TVector3): TVector3; assembler;155asm156movq xmm0, [ARadians]157movss xmm1, DWORD [ARadians+8]158movups xmm2, [SSE_180_OVER_PI]159mulps xmm0, xmm2160mulss xmm1, xmm2161movq [Result], xmm0162movss DWORD [Result+8], xmm1163end;164function Degrees(const ARadians: TVector4): TVector4; assembler;166asm167movups xmm0, [ARadians]168movups xmm1, [SSE_180_OVER_PI]169mulps xmm0, xmm1170movups [Result], xmm0171end;172{ Exponential Functions }174function Sqrt(const A: Single): Single; assembler;176asm177sqrtss xmm0, xmm0178end;179function Sqrt(const A: TVector2): TVector2; assembler;181asm182{$IF RTLVersion >= 33}183movlps xmm0, [A]184{$ELSE}185movq xmm0, A186{$ENDIF}187sqrtps xmm0, xmm0188movq rax, xmm0189end;190function Sqrt(const A: TVector3): TVector3; assembler;192asm193movq xmm0, [A]194movss xmm1, DWORD [A+8]195movlhps xmm0, xmm1196sqrtps xmm0, xmm0197movhlps xmm1, xmm0198movq [Result], xmm0199movss DWORD [Result+8], xmm1200end;201function Sqrt(const A: TVector4): TVector4; assembler;203asm204movups xmm0, [A]205sqrtps xmm0, xmm0206movups [Result], xmm0207end;208function InverseSqrt(const A: Single): Single; assembler;210asm211rsqrtss xmm0, xmm0212end;213function InverseSqrt(const A: TVector2): TVector2;215asm216{$IF RTLVersion >= 33}217movlps xmm0, [A]218{$ELSE}219movq xmm0, A220{$ENDIF}221rsqrtps xmm0, xmm0222movq rax, xmm0223end;224function InverseSqrt(const A: TVector3): TVector3;226asm227movq xmm0, [A]228movss xmm1, DWORD [A+8]229movlhps xmm0, xmm1230rsqrtps xmm0, xmm0231movhlps xmm1, xmm0232movq [Result], xmm0233movss DWORD [Result+8], xmm1234end;235function InverseSqrt(const A: TVector4): TVector4; assembler;237asm238movups xmm0, [A]239rsqrtps xmm0, xmm0240movups [Result], xmm0241end;242{ Fast approximate Functions }244function FastSin(const ARadians: Single): Single; assembler;246asm247movdqa [rsp-24], xmm6248movdqa [rsp-40], xmm7249movss xmm2, DWORD [SSE_MASK_ABS_VAL]251movaps xmm1, xmm0252movss xmm3, DWORD [SSE_MASK_SIGN]253andps xmm0, xmm2 // (xmm0) X := Abs(ARadians)254andps xmm1, xmm3 // (xmm1) SignBit255movaps xmm2, xmm0256movss xmm4, DWORD [SSE_FOPI]257movss xmm5, DWORD [SSE_INT_ONE]258mulss xmm2, xmm4259movss xmm6, DWORD [SSE_INT_NOT_ONE]260cvtps2dq xmm2, xmm2 // J := Trunc(X * FOPI)261movss xmm7, DWORD [SSE_INT_FOUR]262paddd xmm2, xmm5263pand xmm2, xmm6 // (xmm2) J := (J + 1) and (not 1)264movss xmm6, DWORD [SSE_INT_TWO]265cvtdq2ps xmm4, xmm2 // (xmm4) Y := J266movaps xmm5, xmm2267pand xmm2, xmm6 // J and 2268pand xmm5, xmm7 // J and 4269pxor xmm7, xmm7270pslld xmm5, 29 // (xmm5) SwapSignBit := (J and 4) shl 29271pcmpeqd xmm2, xmm7 // (xmm2) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000272movss xmm6, DWORD [SSE_PI_OVER_4]273pxor xmm1, xmm5 // (xmm1) SignBit := SignBit xor SwapSignBit274mulss xmm4, xmm6 // Y * Pi / 4275movss xmm3, DWORD [SSE_COSCOF_P0]276subss xmm0, xmm4 // (xmm0) X := X - (Y * Pi / 4)277movss xmm4, DWORD [SSE_COSCOF_P1]278movaps xmm7, xmm0279movss xmm6, DWORD [SSE_COSCOF_P2]280mulss xmm7, xmm7 // (xmm7) Z := X * X281movss xmm5, DWORD [SSE_SINCOF_P1]282mulss xmm3, xmm7 // COSCOF_P0 * Z283addss xmm3, xmm4 // Y := COSCOF_P0 * Z + COSCOF_P1284movss xmm4, DWORD [SSE_ONE_HALF]285mulss xmm3, xmm7 // Y * Z286mulss xmm4, xmm7 // Z * 0.5287addps xmm3, xmm6 // Y := (Y * Z) + COSCOF_P2288movss xmm6, DWORD [SSE_ONE]289mulss xmm3, xmm7 // Y * Z290mulss xmm3, xmm7 // Y := Y * (Z * Z)291subss xmm3, xmm4 // Y - Z * 0.5292movss xmm4, DWORD [SSE_SINCOF_P0]293addps xmm3, xmm6 // (xmm3) Y := Y - Z * 0.5 + 1294movss xmm6, DWORD [SSE_SINCOF_P2]295mulss xmm4, xmm7 // SINCOF_P0 * Z296addss xmm4, xmm5 // Y2 := SINCOF_P0 * Z + SINCOF_P1297movaps xmm5, xmm2298mulss xmm4, xmm7 // Y2 * Z299addss xmm4, xmm6 // Y2 := (Y2 * Z) + SINCOF_P2300mulss xmm4, xmm7 // Y2 * Z301mulss xmm4, xmm0 // Y2 * (Z * X)302addss xmm4, xmm0 // (xmm4) Y2 := Y2 * (Z * X) + X303andps xmm4, xmm2 // Y2 := ((J and 2) = 0)? Yes: Y2, No: 0304andnps xmm5, xmm3 // Y := ((J and 2) = 0)? Yes: 0 , No: Y305addss xmm4, xmm5306xorps xmm4, xmm1 // (Y + Y2) xor SignBit307movss xmm0, xmm4308movdqa xmm6, [rsp-24]310movdqa xmm7, [rsp-40]311end;312function FastSin(const ARadians: TVector2): TVector2; assembler;314asm315movdqa [rsp-24], xmm6316movdqa [rsp-40], xmm7317{$IF RTLVersion >= 33}319movlps xmm0, [ARadians]320{$ELSE}321movq xmm0, ARadians322{$ENDIF}323movlps xmm2, QWORD [SSE_MASK_ABS_VAL]324movaps xmm1, xmm0325movlps xmm3, QWORD [SSE_MASK_SIGN]326andps xmm0, xmm2 // (xmm0) X := Abs(ARadians)327andps xmm1, xmm3 // (xmm1) SignBit328movaps xmm2, xmm0329movlps xmm4, QWORD [SSE_FOPI]330movlps xmm5, QWORD [SSE_INT_ONE]331mulps xmm2, xmm4332movlps xmm6, QWORD [SSE_INT_NOT_ONE]333cvtps2dq xmm2, xmm2 // J := Trunc(X * FOPI)334movlps xmm7, QWORD [SSE_INT_FOUR]335paddd xmm2, xmm5336pand xmm2, xmm6 // (xmm2) J := (J + 1) and (not 1)337movlps xmm6, QWORD [SSE_INT_TWO]338cvtdq2ps xmm4, xmm2 // (xmm4) Y := J339movaps xmm5, xmm2340pand xmm2, xmm6 // J and 2341pand xmm5, xmm7 // J and 4342pxor xmm7, xmm7343pslld xmm5, 29 // (xmm5) SwapSignBit := (J and 4) shl 29344pcmpeqd xmm2, xmm7 // (xmm2) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000345movlps xmm6, QWORD [SSE_PI_OVER_4]346pxor xmm1, xmm5 // (xmm1) SignBit := SignBit xor SwapSignBit347mulps xmm4, xmm6 // Y * Pi / 4348movlps xmm3, QWORD [SSE_COSCOF_P0]349subps xmm0, xmm4 // (xmm0) X := X - (Y * Pi / 4)350movlps xmm4, QWORD [SSE_COSCOF_P1]351movaps xmm7, xmm0352movlps xmm6, QWORD [SSE_COSCOF_P2]353mulps xmm7, xmm7 // (xmm7) Z := X * X354movlps xmm5, QWORD [SSE_SINCOF_P1]355mulps xmm3, xmm7 // COSCOF_P0 * Z356addps xmm3, xmm4 // Y := COSCOF_P0 * Z + COSCOF_P1357movlps xmm4, QWORD [SSE_ONE_HALF]358mulps xmm3, xmm7 // Y * Z359mulps xmm4, xmm7 // Z * 0.5360addps xmm3, xmm6 // Y := (Y * Z) + COSCOF_P2361movlps xmm6, QWORD [SSE_ONE]362mulps xmm3, xmm7 // Y * Z363mulps xmm3, xmm7 // Y := Y * (Z * Z)364subps xmm3, xmm4 // Y - Z * 0.5365movlps xmm4, QWORD [SSE_SINCOF_P0]366addps xmm3, xmm6 // (xmm3) Y := Y - Z * 0.5 + 1367movlps xmm6, QWORD [SSE_SINCOF_P2]368mulps xmm4, xmm7 // SINCOF_P0 * Z369addps xmm4, xmm5 // Y2 := SINCOF_P0 * Z + SINCOF_P1370movaps xmm5, xmm2371mulps xmm4, xmm7 // Y2 * Z372addps xmm4, xmm6 // Y2 := (Y2 * Z) + SINCOF_P2373mulps xmm4, xmm7 // Y2 * Z374mulps xmm4, xmm0 // Y2 * (Z * X)375addps xmm4, xmm0 // (xmm4) Y2 := Y2 * (Z * X) + X376andps xmm4, xmm2 // Y2 := ((J and 2) = 0)? Yes: Y2, No: 0377andnps xmm5, xmm3 // Y := ((J and 2) = 0)? Yes: 0 , No: Y378addps xmm4, xmm5379xorps xmm4, xmm1 // (Y + Y2) xor SignBit380movq rax, xmm4381movdqa xmm6, [rsp-24]383movdqa xmm7, [rsp-40]384end;385function FastSin(const ARadians: TVector3): TVector3; assembler;387asm388movdqa [rsp-24], xmm6389movdqa [rsp-40], xmm7390movq xmm0, [ARadians]392movss xmm1, DWORD [ARadians+8]393movlhps xmm0, xmm1394movups xmm2, [SSE_MASK_ABS_VAL]395movaps xmm1, xmm0396movups xmm3, [SSE_MASK_SIGN]397andps xmm0, xmm2 // (xmm0) X := Abs(ARadians)398andps xmm1, xmm3 // (xmm1) SignBit399movaps xmm2, xmm0400movups xmm4, [SSE_FOPI]401movups xmm5, [SSE_INT_ONE]402mulps xmm2, xmm4403movups xmm6, [SSE_INT_NOT_ONE]404cvtps2dq xmm2, xmm2 // J := Trunc(X * FOPI)405movups xmm7, [SSE_INT_FOUR]406paddd xmm2, xmm5407pand xmm2, xmm6 // (xmm2) J := (J + 1) and (not 1)408movups xmm6, [SSE_INT_TWO]409cvtdq2ps xmm4, xmm2 // (xmm4) Y := J410movaps xmm5, xmm2411pand xmm2, xmm6 // J and 2412pand xmm5, xmm7 // J and 4413pxor xmm7, xmm7414pslld xmm5, 29 // (xmm5) SwapSignBit := (J and 4) shl 29415pcmpeqd xmm2, xmm7 // (xmm2) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000416movups xmm6, [SSE_PI_OVER_4]417pxor xmm1, xmm5 // (xmm1) SignBit := SignBit xor SwapSignBit418mulps xmm4, xmm6 // Y * Pi / 4419movups xmm3, [SSE_COSCOF_P0]420subps xmm0, xmm4 // (xmm0) X := X - (Y * Pi / 4)421movups xmm4, [SSE_COSCOF_P1]422movaps xmm7, xmm0423movups xmm6, [SSE_COSCOF_P2]424mulps xmm7, xmm7 // (xmm7) Z := X * X425movups xmm5, [SSE_SINCOF_P1]426mulps xmm3, xmm7 // COSCOF_P0 * Z427addps xmm3, xmm4 // Y := COSCOF_P0 * Z + COSCOF_P1428movups xmm4, [SSE_ONE_HALF]429mulps xmm3, xmm7 // Y * Z430mulps xmm4, xmm7 // Z * 0.5431addps xmm3, xmm6 // Y := (Y * Z) + COSCOF_P2432movups xmm6, [SSE_ONE]433mulps xmm3, xmm7 // Y * Z434mulps xmm3, xmm7 // Y := Y * (Z * Z)435subps xmm3, xmm4 // Y - Z * 0.5436movups xmm4, [SSE_SINCOF_P0]437addps xmm3, xmm6 // (xmm3) Y := Y - Z * 0.5 + 1438movups xmm6, [SSE_SINCOF_P2]439mulps xmm4, xmm7 // SINCOF_P0 * Z440addps xmm4, xmm5 // Y2 := SINCOF_P0 * Z + SINCOF_P1441movaps xmm5, xmm2442mulps xmm4, xmm7 // Y2 * Z443addps xmm4, xmm6 // Y2 := (Y2 * Z) + SINCOF_P2444mulps xmm4, xmm7 // Y2 * Z445mulps xmm4, xmm0 // Y2 * (Z * X)446addps xmm4, xmm0 // (xmm4) Y2 := Y2 * (Z * X) + X447andps xmm4, xmm2 // Y2 := ((J and 2) = 0)? Yes: Y2, No: 0448andnps xmm5, xmm3 // Y := ((J and 2) = 0)? Yes: 0 , No: Y449addps xmm4, xmm5450xorps xmm4, xmm1 // (Y + Y2) xor SignBit451movhlps xmm5, xmm4452movq [Result], xmm4453movss DWORD [Result+8], xmm5454movdqa xmm6, [rsp-24]456movdqa xmm7, [rsp-40]457end;458function FastSin(const ARadians: TVector4): TVector4; assembler;460asm461movdqa [rsp-24], xmm6462movdqa [rsp-40], xmm7463movups xmm0, [ARadians]465movups xmm2, [SSE_MASK_ABS_VAL]466movaps xmm1, xmm0467movups xmm3, [SSE_MASK_SIGN]468andps xmm0, xmm2 // (xmm0) X := Abs(ARadians)469andps xmm1, xmm3 // (xmm1) SignBit470movaps xmm2, xmm0471movups xmm4, [SSE_FOPI]472movups xmm5, [SSE_INT_ONE]473mulps xmm2, xmm4474movups xmm6, [SSE_INT_NOT_ONE]475cvtps2dq xmm2, xmm2 // J := Trunc(X * FOPI)476movups xmm7, [SSE_INT_FOUR]477paddd xmm2, xmm5478pand xmm2, xmm6 // (xmm2) J := (J + 1) and (not 1)479movups xmm6, [SSE_INT_TWO]480cvtdq2ps xmm4, xmm2 // (xmm4) Y := J481movaps xmm5, xmm2482pand xmm2, xmm6 // J and 2483pand xmm5, xmm7 // J and 4484pxor xmm7, xmm7485pslld xmm5, 29 // (xmm5) SwapSignBit := (J and 4) shl 29486pcmpeqd xmm2, xmm7 // (xmm2) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000487movups xmm6, [SSE_PI_OVER_4]488pxor xmm1, xmm5 // (xmm1) SignBit := SignBit xor SwapSignBit489mulps xmm4, xmm6 // Y * Pi / 4490movups xmm3, [SSE_COSCOF_P0]491subps xmm0, xmm4 // (xmm0) X := X - (Y * Pi / 4)492movups xmm4, [SSE_COSCOF_P1]493movaps xmm7, xmm0494movups xmm6, [SSE_COSCOF_P2]495mulps xmm7, xmm7 // (xmm7) Z := X * X496movups xmm5, [SSE_SINCOF_P1]497mulps xmm3, xmm7 // COSCOF_P0 * Z498addps xmm3, xmm4 // Y := COSCOF_P0 * Z + COSCOF_P1499movups xmm4, [SSE_ONE_HALF]500mulps xmm3, xmm7 // Y * Z501mulps xmm4, xmm7 // Z * 0.5502addps xmm3, xmm6 // Y := (Y * Z) + COSCOF_P2503movups xmm6, [SSE_ONE]504mulps xmm3, xmm7 // Y * Z505mulps xmm3, xmm7 // Y := Y * (Z * Z)506subps xmm3, xmm4 // Y - Z * 0.5507movups xmm4, [SSE_SINCOF_P0]508addps xmm3, xmm6 // (xmm3) Y := Y - Z * 0.5 + 1509movups xmm6, [SSE_SINCOF_P2]510mulps xmm4, xmm7 // SINCOF_P0 * Z511addps xmm4, xmm5 // Y2 := SINCOF_P0 * Z + SINCOF_P1512movaps xmm5, xmm2513mulps xmm4, xmm7 // Y2 * Z514addps xmm4, xmm6 // Y2 := (Y2 * Z) + SINCOF_P2515mulps xmm4, xmm7 // Y2 * Z516mulps xmm4, xmm0 // Y2 * (Z * X)517addps xmm4, xmm0 // (xmm4) Y2 := Y2 * (Z * X) + X518andps xmm4, xmm2 // Y2 := ((J and 2) = 0)? Yes: Y2, No: 0519andnps xmm5, xmm3 // Y := ((J and 2) = 0)? Yes: 0 , No: Y520addps xmm4, xmm5521xorps xmm4, xmm1 // (Y + Y2) xor SignBit522movups [Result], xmm4523movdqa xmm6, [rsp-24]525movdqa xmm7, [rsp-40]526end;527function FastCos(const ARadians: Single): Single; assembler;529asm530movdqa [rsp-24], xmm6531movdqa [rsp-40], xmm7532movss xmm1, DWORD [SSE_MASK_ABS_VAL]534movss xmm2, DWORD [SSE_FOPI]535andps xmm0, xmm1 // (xmm0) X := Abs(ARadians)536movss xmm3, DWORD [SSE_INT_NOT_ONE]537movaps xmm1, xmm0538movss xmm4, DWORD [SSE_INT_FOUR]539mulss xmm1, xmm2540movss xmm2, DWORD [SSE_INT_ONE]541cvtps2dq xmm1, xmm1 // J := Trunc(X * FOPI)542pxor xmm6, xmm6543paddd xmm1, xmm2544pand xmm1, xmm3 // (xmm1) J := (J + 1) and (not 1)545movss xmm3, DWORD [SSE_INT_TWO]546cvtdq2ps xmm2, xmm1 // (xmm2) Y := J547psubd xmm1, xmm3 // J - 2548movaps xmm5, xmm1549pandn xmm1, xmm4 // (not (J - 2)) and 4550pand xmm5, xmm3 // (J - 2) and 2551pslld xmm1, 29 // (xmm1) SignBit := ((not (J - 2)) and 4) shl 29552movss xmm3, DWORD [SSE_PI_OVER_4]553pcmpeqd xmm5, xmm6 // (xmm5) PolyMask := ((J-2) and 2)=0)? Yes: $FFFFFFFF, No: $00000000554mulss xmm2, xmm3 // Y * Pi / 4555movss xmm3, DWORD [SSE_COSCOF_P1]556subss xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)557movss xmm2, DWORD [SSE_COSCOF_P0]558movss xmm4, DWORD [SSE_COSCOF_P2]559movaps xmm6, xmm0560mulss xmm6, xmm6 // (xmm6) Z := X * X561mulss xmm2, xmm6 // COSCOF_P0 * Z562addps xmm2, xmm3 // Y := COSCOF_P0 * Z + COSCOF_P1563movss xmm3, DWORD [SSE_ONE_HALF]564mulss xmm2, xmm6 // Y * Z565mulss xmm3, xmm6 // Z * 0.5566addss xmm2, xmm4 // Y := (Y * Z) + COSCOF_P2567movss xmm7, DWORD [SSE_ONE]568mulss xmm2, xmm6569movss xmm4, DWORD [SSE_SINCOF_P1]570mulss xmm2, xmm6 // Y := Y * (Z * Z)571subss xmm2, xmm3 // Y - Z * 0.5572addss xmm2, xmm7 // (xmm2) Y := Y - Z * 0.5 + 1573movss xmm3, DWORD [SSE_SINCOF_P0]574movss xmm7, DWORD [SSE_SINCOF_P2]575mulss xmm3, xmm6 // SINCOF_P0 * Z576addss xmm3, xmm4 // Y2 := SINCOF_P0 * Z + SINCOF_P1577mulss xmm3, xmm6 // Y2 * Z578addss xmm3, xmm7 // Y2 := (Y2 * Z) + SINCOF_P2579mulss xmm3, xmm6 // Y2 * Z580mulss xmm3, xmm0 // Y2 * (Z * X)581addss xmm3, xmm0 // Y2 := Y2 * (Z * X) + X582andps xmm3, xmm5 // ((J-2) and 2) = 0)? Yes: Y2, No: 0583andnps xmm5, xmm2 // ((J-2) and 2) = 0)? Yes: 0 , No: Y584addss xmm3, xmm5585xorps xmm3, xmm1 // (Y + Y2) xor SignBit586movss xmm0, xmm3587movdqa xmm6, [rsp-24]589movdqa xmm7, [rsp-40]590end;591function FastCos(const ARadians: TVector2): TVector2; assembler;593asm594movdqa [rsp-24], xmm6595movdqa [rsp-40], xmm7596{$IF RTLVersion >= 33}598movlps xmm0, [ARadians]599{$ELSE}600movq xmm0, ARadians601{$ENDIF}602movlps xmm1, QWORD [SSE_MASK_ABS_VAL]603movlps xmm2, QWORD [SSE_FOPI]604andps xmm0, xmm1 // (xmm0) X := Abs(ARadians)605movlps xmm3, QWORD [SSE_INT_NOT_ONE]606movaps xmm1, xmm0607movlps xmm4, QWORD [SSE_INT_FOUR]608mulps xmm1, xmm2609movlps xmm2, QWORD [SSE_INT_ONE]610cvtps2dq xmm1, xmm1 // J := Trunc(X * FOPI)611pxor xmm6, xmm6612paddd xmm1, xmm2613pand xmm1, xmm3 // (xmm1) J := (J + 1) and (not 1)614movlps xmm3, QWORD [SSE_INT_TWO]615cvtdq2ps xmm2, xmm1 // (xmm2) Y := J616psubd xmm1, xmm3 // J - 2617movaps xmm5, xmm1618pandn xmm1, xmm4 // (not (J - 2)) and 4619pand xmm5, xmm3 // (J - 2) and 2620pslld xmm1, 29 // (xmm1) SignBit := ((not (J - 2)) and 4) shl 29621movlps xmm3, QWORD [SSE_PI_OVER_4]622pcmpeqd xmm5, xmm6 // (xmm5) PolyMask := ((J-2) and 2)=0)? Yes: $FFFFFFFF, No: $00000000623mulps xmm2, xmm3 // Y * Pi / 4624movlps xmm3, QWORD [SSE_COSCOF_P1]625subps xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)626movlps xmm2, QWORD [SSE_COSCOF_P0]627movlps xmm4, QWORD [SSE_COSCOF_P2]628movaps xmm6, xmm0629mulps xmm6, xmm6 // (xmm6) Z := X * X630mulps xmm2, xmm6 // COSCOF_P0 * Z631addps xmm2, xmm3 // Y := COSCOF_P0 * Z + COSCOF_P1632movlps xmm3, QWORD [SSE_ONE_HALF]633mulps xmm2, xmm6 // Y * Z634mulps xmm3, xmm6 // Z * 0.5635addps xmm2, xmm4 // Y := (Y * Z) + COSCOF_P2636movlps xmm7, QWORD [SSE_ONE]637mulps xmm2, xmm6638movlps xmm4, QWORD [SSE_SINCOF_P1]639mulps xmm2, xmm6 // Y := Y * (Z * Z)640subps xmm2, xmm3 // Y - Z * 0.5641addps xmm2, xmm7 // (xmm2) Y := Y - Z * 0.5 + 1642movlps xmm3, QWORD [SSE_SINCOF_P0]643movlps xmm7, QWORD [SSE_SINCOF_P2]644mulps xmm3, xmm6 // SINCOF_P0 * Z645addps xmm3, xmm4 // Y2 := SINCOF_P0 * Z + SINCOF_P1646mulps xmm3, xmm6 // Y2 * Z647addps xmm3, xmm7 // Y2 := (Y2 * Z) + SINCOF_P2648mulps xmm3, xmm6 // Y2 * Z649mulps xmm3, xmm0 // Y2 * (Z * X)650addps xmm3, xmm0 // Y2 := Y2 * (Z * X) + X651andps xmm3, xmm5 // ((J-2) and 2) = 0)? Yes: Y2, No: 0652andnps xmm5, xmm2 // ((J-2) and 2) = 0)? Yes: 0 , No: Y653addps xmm3, xmm5654xorps xmm3, xmm1 // (Y + Y2) xor SignBit655movq rax, xmm3656movdqa xmm6, [rsp-24]658movdqa xmm7, [rsp-40]659end;660function FastCos(const ARadians: TVector3): TVector3; assembler;662asm663movdqa [rsp-24], xmm6664movdqa [rsp-40], xmm7665movq xmm0, [ARadians]667movss xmm1, DWORD [ARadians+8]668movlhps xmm0, xmm1669movups xmm1, [SSE_MASK_ABS_VAL]670movups xmm2, [SSE_FOPI]671andps xmm0, xmm1 // (xmm0) X := Abs(ARadians)672movups xmm3, [SSE_INT_NOT_ONE]673movaps xmm1, xmm0674movups xmm4, [SSE_INT_FOUR]675mulps xmm1, xmm2676movups xmm2, [SSE_INT_ONE]677cvtps2dq xmm1, xmm1 // J := Trunc(X * FOPI)678pxor xmm6, xmm6679paddd xmm1, xmm2680pand xmm1, xmm3 // (xmm1) J := (J + 1) and (not 1)681movups xmm3, [SSE_INT_TWO]682cvtdq2ps xmm2, xmm1 // (xmm2) Y := J683psubd xmm1, xmm3 // J - 2684movaps xmm5, xmm1685pandn xmm1, xmm4 // (not (J - 2)) and 4686pand xmm5, xmm3 // (J - 2) and 2687pslld xmm1, 29 // (xmm1) SignBit := ((not (J - 2)) and 4) shl 29688movups xmm3, [SSE_PI_OVER_4]689pcmpeqd xmm5, xmm6 // (xmm5) PolyMask := ((J-2) and 2)=0)? Yes: $FFFFFFFF, No: $00000000690mulps xmm2, xmm3 // Y * Pi / 4691movups xmm3, [SSE_COSCOF_P1]692subps xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)693movups xmm2, [SSE_COSCOF_P0]694movups xmm4, [SSE_COSCOF_P2]695movaps xmm6, xmm0696mulps xmm6, xmm6 // (xmm6) Z := X * X697mulps xmm2, xmm6 // COSCOF_P0 * Z698addps xmm2, xmm3 // Y := COSCOF_P0 * Z + COSCOF_P1699movups xmm3, [SSE_ONE_HALF]700mulps xmm2, xmm6 // Y * Z701mulps xmm3, xmm6 // Z * 0.5702addps xmm2, xmm4 // Y := (Y * Z) + COSCOF_P2703movups xmm7, [SSE_ONE]704mulps xmm2, xmm6705movups xmm4, [SSE_SINCOF_P1]706mulps xmm2, xmm6 // Y := Y * (Z * Z)707subps xmm2, xmm3 // Y - Z * 0.5708addps xmm2, xmm7 // (xmm2) Y := Y - Z * 0.5 + 1709movups xmm3, [SSE_SINCOF_P0]710movups xmm7, [SSE_SINCOF_P2]711mulps xmm3, xmm6 // SINCOF_P0 * Z712addps xmm3, xmm4 // Y2 := SINCOF_P0 * Z + SINCOF_P1713mulps xmm3, xmm6 // Y2 * Z714addps xmm3, xmm7 // Y2 := (Y2 * Z) + SINCOF_P2715mulps xmm3, xmm6 // Y2 * Z716mulps xmm3, xmm0 // Y2 * (Z * X)717addps xmm3, xmm0 // Y2 := Y2 * (Z * X) + X718andps xmm3, xmm5 // ((J-2) and 2) = 0)? Yes: Y2, No: 0719andnps xmm5, xmm2 // ((J-2) and 2) = 0)? Yes: 0 , No: Y720addps xmm3, xmm5721xorps xmm3, xmm1 // (Y + Y2) xor SignBit722movhlps xmm4, xmm3723movq [Result], xmm3724movss DWORD [Result+8], xmm4725movdqa xmm6, [rsp-24]727movdqa xmm7, [rsp-40]728end;729function FastCos(const ARadians: TVector4): TVector4; assembler;731asm732movdqa [rsp-24], xmm6733movdqa [rsp-40], xmm7734movups xmm0, [ARadians]736movups xmm1, [SSE_MASK_ABS_VAL]737movups xmm2, [SSE_FOPI]738andps xmm0, xmm1 // (xmm0) X := Abs(ARadians)739movups xmm3, [SSE_INT_NOT_ONE]740movaps xmm1, xmm0741movups xmm4, [SSE_INT_FOUR]742mulps xmm1, xmm2743movups xmm2, [SSE_INT_ONE]744cvtps2dq xmm1, xmm1 // J := Trunc(X * FOPI)745pxor xmm6, xmm6746paddd xmm1, xmm2747pand xmm1, xmm3 // (xmm1) J := (J + 1) and (not 1)748movups xmm3, [SSE_INT_TWO]749cvtdq2ps xmm2, xmm1 // (xmm2) Y := J750psubd xmm1, xmm3 // J - 2751movaps xmm5, xmm1752pandn xmm1, xmm4 // (not (J - 2)) and 4753pand xmm5, xmm3 // (J - 2) and 2754pslld xmm1, 29 // (xmm1) SignBit := ((not (J - 2)) and 4) shl 29755movups xmm3, [SSE_PI_OVER_4]756pcmpeqd xmm5, xmm6 // (xmm5) PolyMask := ((J-2) and 2)=0)? Yes: $FFFFFFFF, No: $00000000757mulps xmm2, xmm3 // Y * Pi / 4758movups xmm3, [SSE_COSCOF_P1]759subps xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)760movups xmm2, [SSE_COSCOF_P0]761movups xmm4, [SSE_COSCOF_P2]762movaps xmm6, xmm0763mulps xmm6, xmm6 // (xmm6) Z := X * X764mulps xmm2, xmm6 // COSCOF_P0 * Z765addps xmm2, xmm3 // Y := COSCOF_P0 * Z + COSCOF_P1766movups xmm3, [SSE_ONE_HALF]767mulps xmm2, xmm6 // Y * Z768mulps xmm3, xmm6 // Z * 0.5769addps xmm2, xmm4 // Y := (Y * Z) + COSCOF_P2770movups xmm7, [SSE_ONE]771mulps xmm2, xmm6772movups xmm4, [SSE_SINCOF_P1]773mulps xmm2, xmm6 // Y := Y * (Z * Z)774subps xmm2, xmm3 // Y - Z * 0.5775addps xmm2, xmm7 // (xmm2) Y := Y - Z * 0.5 + 1776movups xmm3, [SSE_SINCOF_P0]777movups xmm7, [SSE_SINCOF_P2]778mulps xmm3, xmm6 // SINCOF_P0 * Z779addps xmm3, xmm4 // Y2 := SINCOF_P0 * Z + SINCOF_P1780mulps xmm3, xmm6 // Y2 * Z781addps xmm3, xmm7 // Y2 := (Y2 * Z) + SINCOF_P2782mulps xmm3, xmm6 // Y2 * Z783mulps xmm3, xmm0 // Y2 * (Z * X)784addps xmm3, xmm0 // Y2 := Y2 * (Z * X) + X785andps xmm3, xmm5 // ((J-2) and 2) = 0)? Yes: Y2, No: 0786andnps xmm5, xmm2 // ((J-2) and 2) = 0)? Yes: 0 , No: Y787addps xmm3, xmm5788xorps xmm3, xmm1 // (Y + Y2) xor SignBit789movups [Result], xmm3790movdqa xmm6, [rsp-24]792movdqa xmm7, [rsp-40]793end;794procedure FastSinCos(const ARadians: Single; out ASin, ACos: Single); assembler;796asm797movdqa [rsp-24], xmm6798movdqa [rsp-40], xmm7799movss xmm2, DWORD [SSE_MASK_SIGN]801movss xmm3, DWORD [SSE_MASK_ABS_VAL]802movaps xmm1, xmm0803pand xmm0, xmm3 // (xmm0) X := Abs(ARadians)804pand xmm1, xmm2 // (xmm1) SignBitSin805movaps xmm4, xmm0806movss xmm5, DWORD [SSE_FOPI]807movss xmm6, DWORD [SSE_INT_ONE]808mulss xmm4, xmm5809movss xmm7, DWORD [SSE_INT_NOT_ONE]810cvtps2dq xmm4, xmm4 // (xmm4) J := Trunc(X * FOPI)811movss xmm5, DWORD [SSE_INT_FOUR]812paddd xmm4, xmm6813pand xmm4, xmm7 // (xmm4) J := (J + 1) and (not 1)814movss xmm7, DWORD [SSE_INT_TWO]815cvtdq2ps xmm2, xmm4 // (xmm2) Y := J816movaps xmm3, xmm4817movaps xmm6, xmm4 // (xmm6) J818pand xmm3, xmm5 // J and 4819pand xmm4, xmm7 // J and 2820pxor xmm5, xmm5821pslld xmm3, 29 // (xmm3) SwapSignBitSin := (J and 4) shl 29822movss xmm7, DWORD [SSE_PI_OVER_4]823pcmpeqd xmm4, xmm5 // (xmm4) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000824mulss xmm2, xmm7 // Y * Pi / 4825movss xmm5, DWORD [SSE_INT_TWO]826subss xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)827psubd xmm6, xmm5 // J - 2828movss xmm7, DWORD [SSE_INT_FOUR]829pxor xmm1, xmm3 // (xmm1) SignBitSin := SignBitSin xor SwapSignBitSin830andnps xmm6, xmm7 // (not (J - 2)) and 4831movaps xmm3, xmm0832pslld xmm6, 29 // (xmm6) SignBitCos := ((not (J - 2)) and 4) shl 29833mulss xmm3, xmm3 // (xmm3) Z := X * X834movss xmm2, DWORD [SSE_COSCOF_P0]835movss xmm5, DWORD [SSE_COSCOF_P1]836movss xmm7, DWORD [SSE_COSCOF_P2]837mulss xmm2, xmm3 // COSCOF_P0 * Z838addss xmm2, xmm5 // Y := COSCOF_P0 * Z + COSCOF_P1839movss xmm5, DWORD [SSE_ONE_HALF]840mulss xmm2, xmm3 // Y * Z841addss xmm2, xmm7 // Y := (Y * Z) + COSCOF_P2842movss xmm7, DWORD [SSE_ONE]843mulss xmm2, xmm3 // Y * Z844mulss xmm5, xmm3 // 0.5 * Z845mulss xmm2, xmm3 // Y * (Z * Z)846subss xmm2, xmm5 // Y - 0.5 * Z847movss xmm5, DWORD [SSE_SINCOF_P0]848addss xmm2, xmm7 // (xmm2) Y := Y - 0.5 * Z + 1849movss xmm7, DWORD [SSE_SINCOF_P1]850mulss xmm5, xmm3 // SINCOF_P0 * Z851addss xmm5, xmm7 // Y2 := SINCOF_P0 * Z + SINCOF_P1852mulss xmm5, xmm3 // Y2 * Z853movss xmm7, DWORD [SSE_SINCOF_P2]854addss xmm5, xmm7 // Y2 := Y2 * Z + SINCOF_P2855mulss xmm5, xmm3 // Y2 * Z856mulss xmm5, xmm0 // Y2 * (Z * X)857addss xmm5, xmm0 // (xmm5) Y2 := Y2 * (Z * X) + X858movaps xmm0, xmm2 // Y859movaps xmm3, xmm5 // Y2860andps xmm5, xmm4 // ((J and 2) = 0)? Yes: Y2, No: 0861andnps xmm4, xmm2 // ((J and 2) = 0)? Yes: 0 , No: Y862subss xmm3, xmm5 // ((J and 2) = 0)? Yes: 0 , No: Y2863subss xmm0, xmm4 // ((J and 2) = 0)? Yes: Y , No: 0864addps xmm4, xmm5 // ((J and 2) = 0)? Yes: Y2, No: Y865addps xmm3, xmm0 // ((J and 2) = 0)? Yes: Y , No: Y2866xorps xmm4, xmm1 // Sin867xorps xmm3, xmm6 // Cos868movss [ASin], xmm4869movss [ACos], xmm3870movdqa xmm6, [rsp-24]872movdqa xmm7, [rsp-40]873end;874procedure FastSinCos(const ARadians: TVector2; out ASin, ACos: TVector2); assembler;876asm877movdqa [rsp-24], xmm6878movdqa [rsp-40], xmm7879{$IF RTLVersion >= 33}881movlps xmm0, [ARadians]882{$ELSE}883movq xmm0, ARadians884{$ENDIF}885movlps xmm2, QWORD [SSE_MASK_SIGN]886movlps xmm3, QWORD [SSE_MASK_ABS_VAL]887movaps xmm1, xmm0888pand xmm0, xmm3 // (xmm0) X := Abs(ARadians)889pand xmm1, xmm2 // (xmm1) SignBitSin890movaps xmm4, xmm0891movlps xmm5, QWORD [SSE_FOPI]892movlps xmm6, QWORD [SSE_INT_ONE]893mulps xmm4, xmm5894movlps xmm7, QWORD [SSE_INT_NOT_ONE]895cvtps2dq xmm4, xmm4 // (xmm4) J := Trunc(X * FOPI)896movlps xmm5, QWORD [SSE_INT_FOUR]897paddd xmm4, xmm6898pand xmm4, xmm7 // (xmm4) J := (J + 1) and (not 1)899movlps xmm7, QWORD [SSE_INT_TWO]900cvtdq2ps xmm2, xmm4 // (xmm2) Y := J901movaps xmm3, xmm4902movaps xmm6, xmm4 // (xmm6) J903pand xmm3, xmm5 // J and 4904pand xmm4, xmm7 // J and 2905pxor xmm5, xmm5906pslld xmm3, 29 // (xmm3) SwapSignBitSin := (J and 4) shl 29907movlps xmm7, QWORD [SSE_PI_OVER_4]908pcmpeqd xmm4, xmm5 // (xmm4) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000909mulps xmm2, xmm7 // Y * Pi / 4910movlps xmm5, QWORD [SSE_INT_TWO]911subps xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)912psubd xmm6, xmm5 // J - 2913movlps xmm7, QWORD [SSE_INT_FOUR]914pxor xmm1, xmm3 // (xmm1) SignBitSin := SignBitSin xor SwapSignBitSin915andnps xmm6, xmm7 // (not (J - 2)) and 4916movaps xmm3, xmm0917pslld xmm6, 29 // (xmm6) SignBitCos := ((not (J - 2)) and 4) shl 29918mulps xmm3, xmm3 // (xmm3) Z := X * X919movlps xmm2, QWORD [SSE_COSCOF_P0]920movlps xmm5, QWORD [SSE_COSCOF_P1]921movlps xmm7, QWORD [SSE_COSCOF_P2]922mulps xmm2, xmm3 // COSCOF_P0 * Z923addps xmm2, xmm5 // Y := COSCOF_P0 * Z + COSCOF_P1924movlps xmm5, QWORD [SSE_ONE_HALF]925mulps xmm2, xmm3 // Y * Z926addps xmm2, xmm7 // Y := (Y * Z) + COSCOF_P2927movlps xmm7, QWORD [SSE_ONE]928mulps xmm2, xmm3 // Y * Z929mulps xmm5, xmm3 // 0.5 * Z930mulps xmm2, xmm3 // Y * (Z * Z)931subps xmm2, xmm5 // Y - 0.5 * Z932movlps xmm5, QWORD [SSE_SINCOF_P0]933addps xmm2, xmm7 // (xmm2) Y := Y - 0.5 * Z + 1934movlps xmm7, QWORD [SSE_SINCOF_P1]935mulps xmm5, xmm3 // SINCOF_P0 * Z936addps xmm5, xmm7 // Y2 := SINCOF_P0 * Z + SINCOF_P1937mulps xmm5, xmm3 // Y2 * Z938movlps xmm7, QWORD [SSE_SINCOF_P2]939addps xmm5, xmm7 // Y2 := Y2 * Z + SINCOF_P2940mulps xmm5, xmm3 // Y2 * Z941mulps xmm5, xmm0 // Y2 * (Z * X)942addps xmm5, xmm0 // (xmm5) Y2 := Y2 * (Z * X) + X943movaps xmm0, xmm2 // Y944movaps xmm3, xmm5 // Y2945andps xmm5, xmm4 // ((J and 2) = 0)? Yes: Y2, No: 0946andnps xmm4, xmm2 // ((J and 2) = 0)? Yes: 0 , No: Y947subps xmm3, xmm5 // ((J and 2) = 0)? Yes: 0 , No: Y2948subps xmm0, xmm4 // ((J and 2) = 0)? Yes: Y , No: 0949addps xmm4, xmm5 // ((J and 2) = 0)? Yes: Y2, No: Y950addps xmm3, xmm0 // ((J and 2) = 0)? Yes: Y , No: Y2951xorps xmm4, xmm1 // Sin952xorps xmm3, xmm6 // Cos953movlps [ASin], xmm4954movlps [ACos], xmm3955movdqa xmm6, [rsp-24]957movdqa xmm7, [rsp-40]958end;959procedure FastSinCos(const ARadians: TVector3; out ASin, ACos: TVector3); assembler;961asm962movdqa [rsp-24], xmm6963movdqa [rsp-40], xmm7964movq xmm0, [ARadians]966movss xmm1, DWORD [ARadians+8]967movlhps xmm0, xmm1968movups xmm2, [SSE_MASK_SIGN]969movups xmm3, [SSE_MASK_ABS_VAL]970movaps xmm1, xmm0971pand xmm0, xmm3 // (xmm0) X := Abs(ARadians)972pand xmm1, xmm2 // (xmm1) SignBitSin973movaps xmm4, xmm0974movups xmm5, [SSE_FOPI]975movups xmm6, [SSE_INT_ONE]976mulps xmm4, xmm5977movups xmm7, [SSE_INT_NOT_ONE]978cvtps2dq xmm4, xmm4 // (xmm4) J := Trunc(X * FOPI)979movups xmm5, [SSE_INT_FOUR]980paddd xmm4, xmm6981pand xmm4, xmm7 // (xmm4) J := (J + 1) and (not 1)982movups xmm7, [SSE_INT_TWO]983cvtdq2ps xmm2, xmm4 // (xmm2) Y := J984movaps xmm3, xmm4985movaps xmm6, xmm4 // (xmm6) J986pand xmm3, xmm5 // J and 4987pand xmm4, xmm7 // J and 2988pxor xmm5, xmm5989pslld xmm3, 29 // (xmm3) SwapSignBitSin := (J and 4) shl 29990movups xmm7, [SSE_PI_OVER_4]991pcmpeqd xmm4, xmm5 // (xmm4) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $00000000992mulps xmm2, xmm7 // Y * Pi / 4993movups xmm5, [SSE_INT_TWO]994subps xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)995psubd xmm6, xmm5 // J - 2996movups xmm7, [SSE_INT_FOUR]997pxor xmm1, xmm3 // (xmm1) SignBitSin := SignBitSin xor SwapSignBitSin998andnps xmm6, xmm7 // (not (J - 2)) and 4999movaps xmm3, xmm01000pslld xmm6, 29 // (xmm6) SignBitCos := ((not (J - 2)) and 4) shl 291001mulps xmm3, xmm3 // (xmm3) Z := X * X1002movups xmm2, [SSE_COSCOF_P0]1003movups xmm5, [SSE_COSCOF_P1]1004movups xmm7, [SSE_COSCOF_P2]1005mulps xmm2, xmm3 // COSCOF_P0 * Z1006addps xmm2, xmm5 // Y := COSCOF_P0 * Z + COSCOF_P11007movups xmm5, [SSE_ONE_HALF]1008mulps xmm2, xmm3 // Y * Z1009addps xmm2, xmm7 // Y := (Y * Z) + COSCOF_P21010movups xmm7, [SSE_ONE]1011mulps xmm2, xmm3 // Y * Z1012mulps xmm5, xmm3 // 0.5 * Z1013mulps xmm2, xmm3 // Y * (Z * Z)1014subps xmm2, xmm5 // Y - 0.5 * Z1015movups xmm5, [SSE_SINCOF_P0]1016addps xmm2, xmm7 // (xmm2) Y := Y - 0.5 * Z + 11017movups xmm7, [SSE_SINCOF_P1]1018mulps xmm5, xmm3 // SINCOF_P0 * Z1019addps xmm5, xmm7 // Y2 := SINCOF_P0 * Z + SINCOF_P11020mulps xmm5, xmm3 // Y2 * Z1021movups xmm7, [SSE_SINCOF_P2]1022addps xmm5, xmm7 // Y2 := Y2 * Z + SINCOF_P21023mulps xmm5, xmm3 // Y2 * Z1024mulps xmm5, xmm0 // Y2 * (Z * X)1025addps xmm5, xmm0 // (xmm5) Y2 := Y2 * (Z * X) + X1026movaps xmm0, xmm2 // Y1027movaps xmm3, xmm5 // Y21028andps xmm5, xmm4 // ((J and 2) = 0)? Yes: Y2, No: 01029andnps xmm4, xmm2 // ((J and 2) = 0)? Yes: 0 , No: Y1030subps xmm3, xmm5 // ((J and 2) = 0)? Yes: 0 , No: Y21031subps xmm0, xmm4 // ((J and 2) = 0)? Yes: Y , No: 01032addps xmm4, xmm5 // ((J and 2) = 0)? Yes: Y2, No: Y1033addps xmm3, xmm0 // ((J and 2) = 0)? Yes: Y , No: Y21034xorps xmm4, xmm1 // Sin1035xorps xmm3, xmm6 // Cos1036movhlps xmm5, xmm41037movhlps xmm2, xmm31038movq [ASin], xmm41039movss DWORD [ASin+8], xmm51040movq [ACos], xmm31041movss DWORD [ACos+8], xmm21042movdqa xmm6, [rsp-24]1044movdqa xmm7, [rsp-40]1045end;1046procedure FastSinCos(const ARadians: TVector4; out ASin, ACos: TVector4); assembler;1048asm1049movdqa [rsp-24], xmm61050movdqa [rsp-40], xmm71051movups xmm0, [ARadians]1053movups xmm2, [SSE_MASK_SIGN]1054movups xmm3, [SSE_MASK_ABS_VAL]1055movaps xmm1, xmm01056pand xmm0, xmm3 // (xmm0) X := Abs(ARadians)1057pand xmm1, xmm2 // (xmm1) SignBitSin1058movaps xmm4, xmm01059movups xmm5, [SSE_FOPI]1060movups xmm6, [SSE_INT_ONE]1061mulps xmm4, xmm51062movups xmm7, [SSE_INT_NOT_ONE]1063cvtps2dq xmm4, xmm4 // (xmm4) J := Trunc(X * FOPI)1064movups xmm5, [SSE_INT_FOUR]1065paddd xmm4, xmm61066pand xmm4, xmm7 // (xmm4) J := (J + 1) and (not 1)1067movups xmm7, [SSE_INT_TWO]1068cvtdq2ps xmm2, xmm4 // (xmm2) Y := J1069movaps xmm3, xmm41070movaps xmm6, xmm4 // (xmm6) J1071pand xmm3, xmm5 // J and 41072pand xmm4, xmm7 // J and 21073pxor xmm5, xmm51074pslld xmm3, 29 // (xmm3) SwapSignBitSin := (J and 4) shl 291075movups xmm7, [SSE_PI_OVER_4]1076pcmpeqd xmm4, xmm5 // (xmm4) PolyMask := ((J and 2) = 0)? Yes: $FFFFFFFF, No: $000000001077mulps xmm2, xmm7 // Y * Pi / 41078movups xmm5, [SSE_INT_TWO]1079subps xmm0, xmm2 // (xmm0) X := X - (Y * Pi / 4)1080psubd xmm6, xmm5 // J - 21081movups xmm7, [SSE_INT_FOUR]1082pxor xmm1, xmm3 // (xmm1) SignBitSin := SignBitSin xor SwapSignBitSin1083andnps xmm6, xmm7 // (not (J - 2)) and 41084movaps xmm3, xmm01085pslld xmm6, 29 // (xmm6) SignBitCos := ((not (J - 2)) and 4) shl 291086mulps xmm3, xmm3 // (xmm3) Z := X * X1087movups xmm2, [SSE_COSCOF_P0]1088movups xmm5, [SSE_COSCOF_P1]1089movups xmm7, [SSE_COSCOF_P2]1090mulps xmm2, xmm3 // COSCOF_P0 * Z1091addps xmm2, xmm5 // Y := COSCOF_P0 * Z + COSCOF_P11092movups xmm5, [SSE_ONE_HALF]1093mulps xmm2, xmm3 // Y * Z1094addps xmm2, xmm7 // Y := (Y * Z) + COSCOF_P21095movups xmm7, [SSE_ONE]1096mulps xmm2, xmm3 // Y * Z1097mulps xmm5, xmm3 // 0.5 * Z1098mulps xmm2, xmm3 // Y * (Z * Z)1099subps xmm2, xmm5 // Y - 0.5 * Z1100movups xmm5, [SSE_SINCOF_P0]1101addps xmm2, xmm7 // (xmm2) Y := Y - 0.5 * Z + 11102movups xmm7, [SSE_SINCOF_P1]1103mulps xmm5, xmm3 // SINCOF_P0 * Z1104addps xmm5, xmm7 // Y2 := SINCOF_P0 * Z + SINCOF_P11105mulps xmm5, xmm3 // Y2 * Z1106movups xmm7, [SSE_SINCOF_P2]1107addps xmm5, xmm7 // Y2 := Y2 * Z + SINCOF_P21108mulps xmm5, xmm3 // Y2 * Z1109mulps xmm5, xmm0 // Y2 * (Z * X)1110addps xmm5, xmm0 // (xmm5) Y2 := Y2 * (Z * X) + X1111movaps xmm0, xmm2 // Y1112movaps xmm3, xmm5 // Y21113andps xmm5, xmm4 // ((J and 2) = 0)? Yes: Y2, No: 01114andnps xmm4, xmm2 // ((J and 2) = 0)? Yes: 0 , No: Y1115subps xmm3, xmm5 // ((J and 2) = 0)? Yes: 0 , No: Y21116subps xmm0, xmm4 // ((J and 2) = 0)? Yes: Y , No: 01117addps xmm4, xmm5 // ((J and 2) = 0)? Yes: Y2, No: Y1118addps xmm3, xmm0 // ((J and 2) = 0)? Yes: Y , No: Y21119xorps xmm4, xmm1 // Sin1120xorps xmm3, xmm6 // Cos1121movups [ASin], xmm41122movups [ACos], xmm31123movdqa xmm6, [rsp-24]1125movdqa xmm7, [rsp-40]1126end;1127function FastExp(const A: Single): Single; assembler;1129asm1130movdqa [rsp-24], xmm61131movdqa [rsp-40], xmm71132movss xmm1, DWORD [SSE_EXP_A1]1134movss xmm2, DWORD [SSE_EXP_A2]1135// Val := 12102203.1615614 * A + 1065353216.01137mulss xmm0, xmm11138movss xmm3, DWORD [SSE_EXP_CST]1139addss xmm0, xmm21140// if (Val >= EXP_CST) then Val := EXP_CST1142movss xmm1, xmm01143cmpltss xmm0, xmm3 // (Val < EXP_CST)? Yes: $FFFFFFFF, No: $000000001144andps xmm1, xmm0 // (Val < EXP_CST)? Yes: Val, No: 01145andnps xmm0, xmm3 // (Val < EXP_CST)? Yes: 0, No: EXP_CST1146orps xmm0, xmm1 // (Val < EXP_CST)? Yes: Val, No: EXP_CST1147// IVal := Trunc(Val)1149xorps xmm3, xmm31150cvtps2dq xmm1, xmm01151// if (IVal < 0) then I := 01153movss xmm2, DWORD [SSE_MASK_EXPONENT]1154movdqa xmm0, xmm1 // IVal1155pcmpgtd xmm1, xmm3 // (IVal > 0)? Yes: $FFFFFFFF, No: $000000001156movss xmm3, DWORD [SSE_MASK_FRACTION]1157pand xmm0, xmm1 // (IVal > 0)? Yes: IVal, No: 01158// XU.I := IVal and $7F8000001160movss xmm4, DWORD [SSE_EXP_I1]1161movss xmm1, xmm01162pand xmm0, xmm2 // XU.I / XU.S1163// XU2.I := (IVal and $007FFFFF) or $3F800000;1165pand xmm1, xmm31166movss xmm6, DWORD [SSE_EXP_F5]1167por xmm1, xmm4 // XU2.I / XU2.S1168// Result := XU.S *1170// ( 0.509964287281036376953125 + B *1171// ( 0.3120158612728118896484375 + B *1172// ( 0.1666135489940643310546875 + B *1173// (-2.12528370320796966552734375e-3 + B *1174// 1.3534179888665676116943359375e-2))));1175movss xmm5, DWORD [SSE_EXP_F4]1176movss xmm7, xmm11177mulss xmm1, xmm61179movss xmm4, DWORD [SSE_EXP_F3]1180addss xmm1, xmm51181movss xmm3, DWORD [SSE_EXP_F2]1182mulss xmm1, xmm71183movss xmm2, DWORD [SSE_EXP_F1]1184addss xmm1, xmm41185mulss xmm1, xmm71186addss xmm1, xmm31187mulss xmm1, xmm71188addss xmm1, xmm21189mulss xmm1, xmm01190movss xmm0, xmm11192movdqa xmm6, [rsp-24]1194movdqa xmm7, [rsp-40]1195end;1196function FastExp(const A: TVector2): TVector2;1198asm1199movdqa [rsp-24], xmm61200movdqa [rsp-40], xmm71201{$IF RTLVersion >= 33}1203movlps xmm0, [A]1204{$ELSE}1205movq xmm0, A1206{$ENDIF}1207movlps xmm1, QWORD [SSE_EXP_A1]1208movlps xmm2, QWORD [SSE_EXP_A2]1209// Val := 12102203.1615614 * A + 1065353216.01211mulps xmm0, xmm11212movlps xmm3, QWORD [SSE_EXP_CST]1213addps xmm0, xmm21214// if (Val >= EXP_CST) then Val := EXP_CST1216movaps xmm1, xmm01217cmpltps xmm0, xmm3 // (Val < EXP_CST)? Yes: $FFFFFFFF, No: $000000001218andps xmm1, xmm0 // (Val < EXP_CST)? Yes: Val, No: 01219andnps xmm0, xmm3 // (Val < EXP_CST)? Yes: 0, No: EXP_CST1220orps xmm0, xmm1 // (Val < EXP_CST)? Yes: Val, No: EXP_CST1221// IVal := Trunc(Val)1223xorps xmm3, xmm31224cvtps2dq xmm1, xmm01225// if (IVal < 0) then I := 01227movlps xmm2, QWORD [SSE_MASK_EXPONENT]1228movdqa xmm0, xmm1 // IVal1229pcmpgtd xmm1, xmm3 // (IVal > 0)? Yes: $FFFFFFFF, No: $000000001230movlps xmm3, QWORD [SSE_MASK_FRACTION]1231pand xmm0, xmm1 // (IVal > 0)? Yes: IVal, No: 01232// XU.I := IVal and $7F8000001234movlps xmm4, QWORD [SSE_EXP_I1]1235movdqa xmm1, xmm01236pand xmm0, xmm2 // XU.I / XU.S1237// XU2.I := (IVal and $007FFFFF) or $3F800000;1239pand xmm1, xmm31240movlps xmm6, QWORD [SSE_EXP_F5]1241por xmm1, xmm4 // XU2.I / XU2.S1242// Result := XU.S *1244// ( 0.509964287281036376953125 + B *1245// ( 0.3120158612728118896484375 + B *1246// ( 0.1666135489940643310546875 + B *1247// (-2.12528370320796966552734375e-3 + B *1248// 1.3534179888665676116943359375e-2))));1249movlps xmm5, QWORD [SSE_EXP_F4]1250movaps xmm7, xmm11251mulps xmm1, xmm61253movlps xmm4, QWORD [SSE_EXP_F3]1254addps xmm1, xmm51255movlps xmm3, QWORD [SSE_EXP_F2]1256mulps xmm1, xmm71257movlps xmm2, QWORD [SSE_EXP_F1]1258addps xmm1, xmm41259mulps xmm1, xmm71260addps xmm1, xmm31261mulps xmm1, xmm71262addps xmm1, xmm21263mulps xmm1, xmm01264movq rax, xmm11266movdqa xmm6, [rsp-24]1268movdqa xmm7, [rsp-40]1269end;1270function FastExp(const A: TVector3): TVector3;1272asm1273movdqa [rsp-24], xmm61274movdqa [rsp-40], xmm71275movq xmm0, [A]1277movss xmm1, DWORD [A+8]1278movlhps xmm0, xmm11279movups xmm1, [SSE_EXP_A1]1280movups xmm2, [SSE_EXP_A2]1281// Val := 12102203.1615614 * A + 1065353216.01283mulps xmm0, xmm11284movups xmm3, [SSE_EXP_CST]1285addps xmm0, xmm21286// if (Val >= EXP_CST) then Val := EXP_CST1288movaps xmm1, xmm01289cmpltps xmm0, xmm3 // (Val < EXP_CST)? Yes: $FFFFFFFF, No: $000000001290andps xmm1, xmm0 // (Val < EXP_CST)? Yes: Val, No: 01291andnps xmm0, xmm3 // (Val < EXP_CST)? Yes: 0, No: EXP_CST1292orps xmm0, xmm1 // (Val < EXP_CST)? Yes: Val, No: EXP_CST1293// IVal := Trunc(Val)1295xorps xmm3, xmm31296cvtps2dq xmm1, xmm01297// if (IVal < 0) then I := 01299movups xmm2, [SSE_MASK_EXPONENT]1300movdqa xmm0, xmm1 // IVal1301pcmpgtd xmm1, xmm3 // (IVal > 0)? Yes: $FFFFFFFF, No: $000000001302movups xmm3, [SSE_MASK_FRACTION]1303pand xmm0, xmm1 // (IVal > 0)? Yes: IVal, No: 01304// XU.I := IVal and $7F8000001306movups xmm4, [SSE_EXP_I1]1307movdqa xmm1, xmm01308pand xmm0, xmm2 // XU.I / XU.S1309// XU2.I := (IVal and $007FFFFF) or $3F800000;1311pand xmm1, xmm31312movups xmm6, [SSE_EXP_F5]1313por xmm1, xmm4 // XU2.I / XU2.S1314// Result := XU.S *1316// ( 0.509964287281036376953125 + B *1317// ( 0.3120158612728118896484375 + B *1318// ( 0.1666135489940643310546875 + B *1319// (-2.12528370320796966552734375e-3 + B *1320// 1.3534179888665676116943359375e-2))));1321movups xmm5, [SSE_EXP_F4]1322movaps xmm7, xmm11323mulps xmm1, xmm61325movups xmm4, [SSE_EXP_F3]1326addps xmm1, xmm51327movups xmm3, [SSE_EXP_F2]1328mulps xmm1, xmm71329movups xmm2, [SSE_EXP_F1]1330addps xmm1, xmm41331mulps xmm1, xmm71332addps xmm1, xmm31333mulps xmm1, xmm71334addps xmm1, xmm21335mulps xmm1, xmm01336movhlps xmm0, xmm11338movq [Result], xmm11339movss DWORD [Result+8], xmm01340movdqa xmm6, [rsp-24]1342movdqa xmm7, [rsp-40]1343end;1344function FastExp(const A: TVector4): TVector4;1346asm1347movdqa [rsp-24], xmm61348movdqa [rsp-40], xmm71349movups xmm0, [A]1351movups xmm1, [SSE_EXP_A1]1352movups xmm2, [SSE_EXP_A2]1353// Val := 12102203.1615614 * A + 1065353216.01355mulps xmm0, xmm11356movups xmm3, [SSE_EXP_CST]1357addps xmm0, xmm21358// if (Val >= EXP_CST) then Val := EXP_CST1360movaps xmm1, xmm01361cmpltps xmm0, xmm3 // (Val < EXP_CST)? Yes: $FFFFFFFF, No: $000000001362andps xmm1, xmm0 // (Val < EXP_CST)? Yes: Val, No: 01363andnps xmm0, xmm3 // (Val < EXP_CST)? Yes: 0, No: EXP_CST1364orps xmm0, xmm1 // (Val < EXP_CST)? Yes: Val, No: EXP_CST1365// IVal := Trunc(Val)1367xorps xmm3, xmm31368cvtps2dq xmm1, xmm01369// if (IVal < 0) then I := 01371movups xmm2, [SSE_MASK_EXPONENT]1372movdqa xmm0, xmm1 // IVal1373pcmpgtd xmm1, xmm3 // (IVal > 0)? Yes: $FFFFFFFF, No: $000000001374movups xmm3, [SSE_MASK_FRACTION]1375pand xmm0, xmm1 // (IVal > 0)? Yes: IVal, No: 01376// XU.I := IVal and $7F8000001378movups xmm4, [SSE_EXP_I1]1379movdqa xmm1, xmm01380pand xmm0, xmm2 // XU.I / XU.S1381// XU2.I := (IVal and $007FFFFF) or $3F800000;1383pand xmm1, xmm31384movups xmm6, [SSE_EXP_F5]1385por xmm1, xmm4 // XU2.I / XU2.S1386// Result := XU.S *1388// ( 0.509964287281036376953125 + B *1389// ( 0.3120158612728118896484375 + B *1390// ( 0.1666135489940643310546875 + B *1391// (-2.12528370320796966552734375e-3 + B *1392// 1.3534179888665676116943359375e-2))));1393movups xmm5, [SSE_EXP_F4]1394movaps xmm7, xmm11395mulps xmm1, xmm61397movups xmm4, [SSE_EXP_F3]1398addps xmm1, xmm51399movups xmm3, [SSE_EXP_F2]1400mulps xmm1, xmm71401movups xmm2, [SSE_EXP_F1]1402addps xmm1, xmm41403mulps xmm1, xmm71404addps xmm1, xmm31405mulps xmm1, xmm71406addps xmm1, xmm21407mulps xmm1, xmm01408movups [Result], xmm11410movdqa xmm6, [rsp-24]1412movdqa xmm7, [rsp-40]1413end;1414function FastLn(const A: Single): Single; assembler;1416asm1417movdqa [rsp-24], xmm61418movdqa [rsp-40], xmm71419xorps xmm2, xmm21421movss xmm1, xmm01422movss xmm3, DWORD [SSE_LN_CST]1423movss xmm4, DWORD [SSE_NEG_INFINITY]1424// Exp := Val.I shr 231426psrld xmm0, 231427movss xmm5, xmm11428cvtdq2ps xmm0, xmm0 // xmm0=Exp1429// if (A > 0) then AddCst := -89.93423858 else AddCst := NegInfinity1431cmpnless xmm1, xmm2 // (A > 0)? Yes: $FFFFFFFF, No: $000000001432movss xmm2, DWORD [SSE_MASK_FRACTION]1433andps xmm3, xmm1 // (A > 0)? Yes: -89.93423858, No: 01434andnps xmm1, xmm4 // (A > 0)? Yes: 0, No: NegInfinity1435movss xmm4, DWORD [SSE_EXP_I1]1436orps xmm1, xmm3 // (A > 0)? Yes: -89.93423858, No: NegInfinity1437// Val.I := (Val.I and $007FFFFF) or $3F8000001439pand xmm5, xmm21440movss xmm2, DWORD [SSE_LN_F5]1441por xmm5, xmm41442movss xmm6, DWORD [SSE_LN_F3]1443movss xmm3, xmm5 // xmm3=X1444mulss xmm5, xmm5 // xmm5=X21445movss xmm4, xmm31447movss xmm7, DWORD [SSE_LN_F4]1448mulss xmm4, xmm61449mulss xmm0, xmm2 // xmm0 = Exp * 0.693147180559951450subss xmm4, xmm71451movss xmm7, DWORD [SSE_LN_F2]1452movss xmm6, xmm31453mulss xmm4, xmm5 // xmm4 = X2 * (0.024982445 * X - 0.24371102)1454subss xmm6, xmm71455movss xmm2, DWORD [SSE_LN_F1]1456addss xmm4, xmm6 // xmm4 = (X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102)1457mulss xmm3, xmm21458mulss xmm4, xmm5 // xmm4 = X2 * ((X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102))1459addss xmm3, xmm1 // xmm3 = (3.3977745 * X + AddCst)1460addss xmm4, xmm01461addss xmm3, xmm41462movss xmm0, xmm31464movdqa xmm6, [rsp-24]1466movdqa xmm7, [rsp-40]1467end;1468function FastLn(const A: TVector2): TVector2; assembler;1470asm1471movdqa [rsp-24], xmm61472movdqa [rsp-40], xmm71473{$IF RTLVersion >= 33}1475movlps xmm0, [A]1476{$ELSE}1477movq xmm0, A1478{$ENDIF}1479xorps xmm2, xmm21480movaps xmm1, xmm01481movlps xmm3, QWORD [SSE_LN_CST]1482movlps xmm4, QWORD [SSE_NEG_INFINITY]1483// Exp := Val.I shr 231485psrld xmm0, 231486movaps xmm5, xmm11487cvtdq2ps xmm0, xmm0 // xmm0=Exp1488// if (A > 0) then AddCst := -89.93423858 else AddCst := NegInfinity1490cmpnleps xmm1, xmm2 // (A > 0)? Yes: $FFFFFFFF, No: $000000001491movlps xmm2, QWORD [SSE_MASK_FRACTION]1492andps xmm3, xmm1 // (A > 0)? Yes: -89.93423858, No: 01493andnps xmm1, xmm4 // (A > 0)? Yes: 0, No: NegInfinity1494movlps xmm4, QWORD [SSE_EXP_I1]1495orps xmm1, xmm3 // (A > 0)? Yes: -89.93423858, No: NegInfinity1496// Val.I := (Val.I and $007FFFFF) or $3F8000001498pand xmm5, xmm21499movlps xmm2, QWORD [SSE_LN_F5]1500por xmm5, xmm41501movlps xmm6, QWORD [SSE_LN_F3]1502movaps xmm3, xmm5 // xmm3=X1503mulps xmm5, xmm5 // xmm5=X21504movaps xmm4, xmm31506movlps xmm7, QWORD [SSE_LN_F4]1507mulps xmm4, xmm61508mulps xmm0, xmm2 // xmm0 = Exp * 0.693147180559951509subps xmm4, xmm71510movlps xmm7, QWORD [SSE_LN_F2]1511movaps xmm6, xmm31512mulps xmm4, xmm5 // xmm4 = X2 * (0.024982445 * X - 0.24371102)1513subps xmm6, xmm71514movlps xmm2, QWORD [SSE_LN_F1]1515addps xmm4, xmm6 // xmm4 = (X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102)1516mulps xmm3, xmm21517mulps xmm4, xmm5 // xmm4 = X2 * ((X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102))1518addps xmm3, xmm1 // xmm3 = (3.3977745 * X + AddCst)1519addps xmm4, xmm01520addps xmm3, xmm41521movq rax, xmm31523movdqa xmm6, [rsp-24]1525movdqa xmm7, [rsp-40]1526end;1527function FastLn(const A: TVector3): TVector3; assembler;1529asm1530movdqa [rsp-24], xmm61531movdqa [rsp-40], xmm71532movq xmm0, [A]1534movss xmm1, DWORD [A+8]1535movlhps xmm0, xmm11536xorps xmm2, xmm21537movaps xmm1, xmm01538movups xmm3, [SSE_LN_CST]1539movups xmm4, [SSE_NEG_INFINITY]1540// Exp := Val.I shr 231542psrld xmm0, 231543movaps xmm5, xmm11544cvtdq2ps xmm0, xmm0 // xmm0=Exp1545// if (A > 0) then AddCst := -89.93423858 else AddCst := NegInfinity1547cmpnleps xmm1, xmm2 // (A > 0)? Yes: $FFFFFFFF, No: $000000001548movups xmm2, [SSE_MASK_FRACTION]1549andps xmm3, xmm1 // (A > 0)? Yes: -89.93423858, No: 01550andnps xmm1, xmm4 // (A > 0)? Yes: 0, No: NegInfinity1551movups xmm4, [SSE_EXP_I1]1552orps xmm1, xmm3 // (A > 0)? Yes: -89.93423858, No: NegInfinity1553// Val.I := (Val.I and $007FFFFF) or $3F8000001555pand xmm5, xmm21556movups xmm2, [SSE_LN_F5]1557por xmm5, xmm41558movups xmm6, [SSE_LN_F3]1559movaps xmm3, xmm5 // xmm3=X1560mulps xmm5, xmm5 // xmm5=X21561movaps xmm4, xmm31563movups xmm7, [SSE_LN_F4]1564mulps xmm4, xmm61565mulps xmm0, xmm2 // xmm0 = Exp * 0.693147180559951566subps xmm4, xmm71567movups xmm7, [SSE_LN_F2]1568movaps xmm6, xmm31569mulps xmm4, xmm5 // xmm4 = X2 * (0.024982445 * X - 0.24371102)1570subps xmm6, xmm71571movups xmm2, [SSE_LN_F1]1572addps xmm4, xmm6 // xmm4 = (X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102)1573mulps xmm3, xmm21574mulps xmm4, xmm5 // xmm4 = X2 * ((X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102))1575addps xmm3, xmm1 // xmm3 = (3.3977745 * X + AddCst)1576addps xmm4, xmm01577addps xmm3, xmm41578movhlps xmm2, xmm31580movq [Result], xmm31581movss DWORD [Result+8], xmm21582movdqa xmm6, [rsp-24]1584movdqa xmm7, [rsp-40]1585end;1586function FastLn(const A: TVector4): TVector4; assembler;1588asm1589movdqa [rsp-24], xmm61590movdqa [rsp-40], xmm71591movups xmm0, [A]1593xorps xmm2, xmm21594movaps xmm1, xmm01595movups xmm3, [SSE_LN_CST]1596movups xmm4, [SSE_NEG_INFINITY]1597// Exp := Val.I shr 231599psrld xmm0, 231600movaps xmm5, xmm11601cvtdq2ps xmm0, xmm0 // xmm0=Exp1602// if (A > 0) then AddCst := -89.93423858 else AddCst := NegInfinity1604cmpnleps xmm1, xmm2 // (A > 0)? Yes: $FFFFFFFF, No: $000000001605movups xmm2, [SSE_MASK_FRACTION]1606andps xmm3, xmm1 // (A > 0)? Yes: -89.93423858, No: 01607andnps xmm1, xmm4 // (A > 0)? Yes: 0, No: NegInfinity1608movups xmm4, [SSE_EXP_I1]1609orps xmm1, xmm3 // (A > 0)? Yes: -89.93423858, No: NegInfinity1610// Val.I := (Val.I and $007FFFFF) or $3F8000001612pand xmm5, xmm21613movups xmm2, [SSE_LN_F5]1614por xmm5, xmm41615movups xmm6, [SSE_LN_F3]1616movaps xmm3, xmm5 // xmm3=X1617mulps xmm5, xmm5 // xmm5=X21618movaps xmm4, xmm31620movups xmm7, [SSE_LN_F4]1621mulps xmm4, xmm61622mulps xmm0, xmm2 // xmm0 = Exp * 0.693147180559951623subps xmm4, xmm71624movups xmm7, [SSE_LN_F2]1625movaps xmm6, xmm31626mulps xmm4, xmm5 // xmm4 = X2 * (0.024982445 * X - 0.24371102)1627subps xmm6, xmm71628movups xmm2, [SSE_LN_F1]1629addps xmm4, xmm6 // xmm4 = (X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102)1630mulps xmm3, xmm21631mulps xmm4, xmm5 // xmm4 = X2 * ((X - 2.2744832) + X2 * (0.024982445 * X - 0.24371102))1632addps xmm3, xmm1 // xmm3 = (3.3977745 * X + AddCst)1633addps xmm4, xmm01634addps xmm3, xmm41635movups [Result], xmm31637movdqa xmm6, [rsp-24]1639movdqa xmm7, [rsp-40]1640end;1641function FastLog2(const A: Single): Single; assembler;1643asm1644movss xmm2, DWORD [SSE_MASK_FRACTION]1645movss xmm1, xmm01646// MX.I := (VX.I and $007FFFFF) or $3F0000001648movss xmm3, DWORD [SSE_LOG2_I1]1649pand xmm0, xmm21650cvtdq2ps xmm1, xmm11651movss xmm4, DWORD [SSE_LOG2_F1]1652por xmm0, xmm31653movss xmm2, DWORD [SSE_LOG2_F2]1655mulss xmm1, xmm4 // VX.I * 1.1920928955078125e-71656movss xmm3, DWORD [SSE_LOG2_F3]1657subss xmm1, xmm2 // Result - 124.225514991658mulss xmm3, xmm01659movss xmm4, DWORD [SSE_LOG2_F5]1660subss xmm1, xmm3 // Result - 124.22551499 - 1.498030302 * MX.S1661movss xmm2, DWORD [SSE_LOG2_F4]1662addss xmm0, xmm41663divss xmm2, xmm01664subss xmm1, xmm2 // Result - 124.22551499 - 1.498030302 * MX.S - 1.72587999 / (0.3520887068 + MX.S)1665movss xmm0, xmm11667end;1668function FastLog2(const A: TVector2): TVector2; assembler;1670asm1671{$IF RTLVersion >= 33}1672movlps xmm0, [A]1673{$ELSE}1674movq xmm0, A1675{$ENDIF}1676movlps xmm2, QWORD [SSE_MASK_FRACTION]1677movaps xmm1, xmm01678// MX.I := (VX.I and $007FFFFF) or $3F0000001680movlps xmm3, QWORD [SSE_LOG2_I1]1681pand xmm0, xmm21682cvtdq2ps xmm1, xmm11683movlps xmm4, QWORD [SSE_LOG2_F1]1684por xmm0, xmm31685movlps xmm2, QWORD [SSE_LOG2_F2]1687mulps xmm1, xmm4 // VX.I * 1.1920928955078125e-71688movlps xmm3, QWORD [SSE_LOG2_F3]1689subps xmm1, xmm2 // Result - 124.225514991690mulps xmm3, xmm01691movlps xmm4, QWORD [SSE_LOG2_F5]1692subps xmm1, xmm3 // Result - 124.22551499 - 1.498030302 * MX.S1693movlps xmm2, QWORD [SSE_LOG2_F4]1694addps xmm0, xmm41695divps xmm2, xmm01696subps xmm1, xmm2 // Result - 124.22551499 - 1.498030302 * MX.S - 1.72587999 / (0.3520887068 + MX.S)1697movq rax, xmm11699end;1700function FastLog2(const A: TVector3): TVector3; assembler;1702asm1703movq xmm0, [A]1704movss xmm1, DWORD [A+8]1705movlhps xmm0, xmm11706movups xmm2, [SSE_MASK_FRACTION]1707movaps xmm1, xmm01708// MX.I := (VX.I and $007FFFFF) or $3F0000001710movups xmm3, [SSE_LOG2_I1]1711pand xmm0, xmm21712cvtdq2ps xmm1, xmm11713movups xmm4, [SSE_LOG2_F1]1714por xmm0, xmm31715movups xmm2, [SSE_LOG2_F2]1717mulps xmm1, xmm4 // VX.I * 1.1920928955078125e-71718movups xmm3, [SSE_LOG2_F3]1719subps xmm1, xmm2 // Result - 124.225514991720mulps xmm3, xmm01721movups xmm4, [SSE_LOG2_F5]1722subps xmm1, xmm3 // Result - 124.22551499 - 1.498030302 * MX.S1723movups xmm2, [SSE_LOG2_F4]1724addps xmm0, xmm41725divps xmm2, xmm01726subps xmm1, xmm2 // Result - 124.22551499 - 1.498030302 * MX.S - 1.72587999 / (0.3520887068 + MX.S)1727movhlps xmm0, xmm11729movq [Result], xmm11730movss DWORD [Result+8], xmm01731end;1732function FastLog2(const A: TVector4): TVector4; assembler;1734asm1735movups xmm0, [A]1736movups xmm2, [SSE_MASK_FRACTION]1737movaps xmm1, xmm01738// MX.I := (VX.I and $007FFFFF) or $3F0000001740movups xmm3, [SSE_LOG2_I1]1741pand xmm0, xmm21742cvtdq2ps xmm1, xmm11743movups xmm4, [SSE_LOG2_F1]1744por xmm0, xmm31745movups xmm2, [SSE_LOG2_F2]1747mulps xmm1, xmm4 // VX.I * 1.1920928955078125e-71748movups xmm3, [SSE_LOG2_F3]1749subps xmm1, xmm2 // Result - 124.225514991750mulps xmm3, xmm01751movups xmm4, [SSE_LOG2_F5]1752subps xmm1, xmm3 // Result - 124.22551499 - 1.498030302 * MX.S1753movups xmm2, [SSE_LOG2_F4]1754addps xmm0, xmm41755divps xmm2, xmm01756subps xmm1, xmm2 // Result - 124.22551499 - 1.498030302 * MX.S - 1.72587999 / (0.3520887068 + MX.S)1757movups [Result], xmm11759end;1760function FastExp2(const A: Single): Single; assembler;1762var1763OldFlags, NewFlags: UInt32;1764asm1765// Set rounding mode to Round Positive (=Round Down)1766stmxcsr [OldFlags]1767mov ecx, [OldFlags]1768xorps xmm1, xmm11769and ecx, SSE_ROUND_MASK1770movss xmm3, xmm01771or ecx, SSE_ROUND_DOWN1772movss xmm5, xmm01773mov [NewFlags], ecx1774movss xmm1, DWORD [SSE_EXP2_F1]1776ldmxcsr [NewFlags]1777// Z := A - RoundDown(A)1779cvtps2dq xmm3, xmm31780addss xmm1, xmm5 // A + 121.27405751781cvtdq2ps xmm3, xmm31782movss xmm2, DWORD [SSE_EXP2_F2]1783subss xmm0, xmm31784movss xmm3, DWORD [SSE_EXP2_F3]1786movss xmm4, DWORD [SSE_EXP2_F4]1787subss xmm3, xmm0 // (4.84252568 - Z)1788mulss xmm0, xmm4 // 1.49012907 * Z1789divss xmm2, xmm31790movss xmm5, DWORD [SSE_EXP2_F5]1791addss xmm1, xmm2 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z)1792subss xmm1, xmm0 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z1793mulss xmm1, xmm5 // (1 shl 23) * (A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z)1794cvtps2dq xmm1, xmm11795// Restore rounding mode1797ldmxcsr [OldFlags]1798movss xmm0, xmm11800end;1801function FastExp2(const A: TVector2): TVector2; assembler;1803var1804OldFlags, NewFlags: UInt32;1805asm1806// Set rounding mode to Round Positive (=Round Down)1807stmxcsr [OldFlags]1808{$IF RTLVersion >= 33}1809movlps xmm0, [A]1810{$ELSE}1811movq xmm0, A1812{$ENDIF}1813mov ecx, [OldFlags]1814xorps xmm1, xmm11815and ecx, SSE_ROUND_MASK1816movaps xmm3, xmm01817or ecx, SSE_ROUND_DOWN1818movaps xmm5, xmm01819mov [NewFlags], ecx1820movlps xmm1, QWORD [SSE_EXP2_F1]1822ldmxcsr [NewFlags]1823// Z := A - RoundDown(A)1825cvtps2dq xmm3, xmm31826addps xmm1, xmm5 // A + 121.27405751827cvtdq2ps xmm3, xmm31828movlps xmm2, QWORD [SSE_EXP2_F2]1829subps xmm0, xmm31830movlps xmm3, QWORD [SSE_EXP2_F3]1832movlps xmm4, QWORD [SSE_EXP2_F4]1833subps xmm3, xmm0 // (4.84252568 - Z)1834mulps xmm0, xmm4 // 1.49012907 * Z1835divps xmm2, xmm31836movlps xmm5, QWORD [SSE_EXP2_F5]1837addps xmm1, xmm2 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z)1838subps xmm1, xmm0 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z1839mulps xmm1, xmm5 // (1 shl 23) * (A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z)1840cvtps2dq xmm1, xmm11841// Restore rounding mode1843ldmxcsr [OldFlags]1844movq rax, xmm11846end;1847function FastExp2(const A: TVector3): TVector3; assembler;1849var1850OldFlags, NewFlags: UInt32;1851asm1852// Set rounding mode to Round Positive (=Round Down)1853stmxcsr [OldFlags]1854movq xmm0, [A]1855movss xmm1, DWORD [A+8]1856movlhps xmm0, xmm11857mov edx, [OldFlags]1858xorps xmm1, xmm11859and edx, SSE_ROUND_MASK1860movaps xmm3, xmm01861or edx, SSE_ROUND_DOWN1862movaps xmm5, xmm01863mov [NewFlags], edx1864movups xmm1, [SSE_EXP2_F1]1866ldmxcsr [NewFlags]1867// Z := A - RoundDown(A)1869cvtps2dq xmm3, xmm31870addps xmm1, xmm5 // A + 121.27405751871cvtdq2ps xmm3, xmm31872movups xmm2, [SSE_EXP2_F2]1873subps xmm0, xmm31874movups xmm3, [SSE_EXP2_F3]1876movups xmm4, [SSE_EXP2_F4]1877subps xmm3, xmm0 // (4.84252568 - Z)1878mulps xmm0, xmm4 // 1.49012907 * Z1879divps xmm2, xmm31880movups xmm5, [SSE_EXP2_F5]1881addps xmm1, xmm2 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z)1882subps xmm1, xmm0 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z1883mulps xmm1, xmm5 // (1 shl 23) * (A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z)1884cvtps2dq xmm1, xmm11885// Restore rounding mode1887ldmxcsr [OldFlags]1888movhlps xmm0, xmm11890movq [Result], xmm11891movss DWORD [Result+8], xmm01892end;1893function FastExp2(const A: TVector4): TVector4; assembler;1895var1896OldFlags, NewFlags: UInt32;1897asm1898// Set rounding mode to Round Positive (=Round Down)1899stmxcsr [OldFlags]1900movups xmm0, [A]1901mov edx, [OldFlags]1902xorps xmm1, xmm11903and edx, SSE_ROUND_MASK1904movaps xmm3, xmm01905or edx, SSE_ROUND_DOWN1906movaps xmm5, xmm01907mov [NewFlags], edx1908movups xmm1, [SSE_EXP2_F1]1910ldmxcsr [NewFlags]1911// Z := A - RoundDown(A)1913cvtps2dq xmm3, xmm31914addps xmm1, xmm5 // A + 121.27405751915cvtdq2ps xmm3, xmm31916movups xmm2, [SSE_EXP2_F2]1917subps xmm0, xmm31918movups xmm3, [SSE_EXP2_F3]1920movups xmm4, [SSE_EXP2_F4]1921subps xmm3, xmm0 // (4.84252568 - Z)1922mulps xmm0, xmm4 // 1.49012907 * Z1923divps xmm2, xmm31924movups xmm5, [SSE_EXP2_F5]1925addps xmm1, xmm2 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z)1926subps xmm1, xmm0 // A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z1927mulps xmm1, xmm5 // (1 shl 23) * (A + 121.2740575 + 27.7280233 / (4.84252568 - Z) - 1.49012907 * Z)1928cvtps2dq xmm1, xmm11929// Restore rounding mode1931ldmxcsr [OldFlags]1932movups [Result], xmm11934end;1935{ Common Functions }1937function Abs(const A: Single): Single;1939begin1940Result := System.Abs(A);1941end;1942function Abs(const A: TVector2): TVector2;1944begin1945Result.Init(System.Abs(A.X), System.Abs(A.Y));1946end;1947function Abs(const A: TVector3): TVector3; assembler;1949asm1950movq xmm0, [A]1951movss xmm1, DWORD [A+8]1952movups xmm2, [SSE_MASK_ABS_VAL]1953andps xmm0, xmm21954pand xmm1, xmm21955movq [Result], xmm01956movss DWORD [Result+8], xmm11957end;1958function Abs(const A: TVector4): TVector4; assembler;1960asm1961movups xmm0, [A]1962movups xmm1, [SSE_MASK_ABS_VAL]1963andps xmm0, xmm11964movups [Result], xmm01965end;1966function Sign(const A: Single): Single; assembler;1968asm1969movss xmm1, DWORD [SSE_ONE]1970movss xmm2, xmm01971movss xmm3, DWORD [SSE_MASK_SIGN]1972andps xmm0, xmm3 // (A < 0)? Yes: $80000000, No: $000000001974xorps xmm4, xmm41975orps xmm0, xmm1 // (A < 0)? Yes: -1, No: 11976cmpneqss xmm2, xmm4 // (A = 0)? Yes: $00000000, No: $FFFFFFFF1977andps xmm0, xmm2 // (A = 0)? Yes: 0, No: -1 or 11978end;1979function Sign(const A: TVector2): TVector2; assembler;1981asm1982{$IF RTLVersion >= 33}1983movlps xmm0, [A]1984{$ELSE}1985movq xmm0, A1986{$ENDIF}1987movlps xmm1, QWORD [SSE_ONE]1988movaps xmm2, xmm01989movlps xmm3, QWORD [SSE_MASK_SIGN]1990andps xmm0, xmm3 // (A < 0)? Yes: $80000000, No: $000000001992xorps xmm4, xmm41993orps xmm0, xmm1 // (A < 0)? Yes: -1, No: 11994cmpneqps xmm2, xmm4 // (A = 0)? Yes: $00000000, No: $FFFFFFFF1995andps xmm0, xmm2 // (A = 0)? Yes: 0, No: -1 or 11996movq rax, xmm01997end;1998function Sign(const A: TVector3): TVector3; assembler;2000asm2001movq xmm0, [A]2002movss xmm1, DWORD [A+8]2003movlhps xmm0, xmm12004movups xmm1, [SSE_ONE]2005movaps xmm2, xmm02006movups xmm3, [SSE_MASK_SIGN]2007andps xmm0, xmm3 // (A < 0)? Yes: $80000000, No: $000000002009xorps xmm4, xmm42010orps xmm0, xmm1 // (A < 0)? Yes: -1, No: 12011cmpneqps xmm2, xmm4 // (A = 0)? Yes: $00000000, No: $FFFFFFFF2012andps xmm0, xmm2 // (A = 0)? Yes: 0, No: -1 or 12013movhlps xmm1, xmm02014movq [Result], xmm02015movss DWORD [Result+8], xmm12016end;2017function Sign(const A: TVector4): TVector4; assembler;2019asm2020movups xmm0, [A]2021movups xmm1, [SSE_ONE]2022movaps xmm2, xmm02023movups xmm3, [SSE_MASK_SIGN]2024andps xmm0, xmm3 // (A < 0)? Yes: $80000000, No: $000000002026xorps xmm4, xmm42027orps xmm0, xmm1 // (A < 0)? Yes: -1, No: 12028cmpneqps xmm2, xmm4 // (A = 0)? Yes: $00000000, No: $FFFFFFFF2029andps xmm0, xmm2 // (A = 0)? Yes: 0, No: -1 or 12030movups [Result], xmm02031end;2032function Floor(const A: Single): Integer;2034begin2035Result := System.Math.Floor(A);2036end;2037{function Floor(const A: Single): Integer; assembler;2038var2039OldFlags, NewFlags: UInt32;2040asm2041// Set rounding mode to Round Down2042stmxcsr [OldFlags]2043mov ecx, [OldFlags]2044and ecx, SSE_ROUND_MASK2045or ecx, SSE_ROUND_DOWN2046mov [NewFlags], ecx2047ldmxcsr [NewFlags]2048cvtps2dq xmm0, xmm02050// Restore rounding mode2052ldmxcsr [OldFlags]2053movd eax, xmm02055end;}2056function Floor(const A: TVector2): TIVector2; assembler;2058var2059OldFlags, NewFlags: UInt32;2060asm2061// Set rounding mode to Round Down2062stmxcsr [OldFlags]2063mov eax, [OldFlags]2064and eax, SSE_ROUND_MASK2065or eax, SSE_ROUND_DOWN2066mov [NewFlags], eax2067{$IF RTLVersion >= 33}2068movlps xmm0, [A]2069{$ELSE}2070movq xmm0, A2071{$ENDIF}2072ldmxcsr [NewFlags]2073cvtps2dq xmm0, xmm02075// Restore rounding mode2077ldmxcsr [OldFlags]2078movq rax, xmm02080end;2081function Floor(const A: TVector3): TIVector3; assembler;2083var2084OldFlags, NewFlags: UInt32;2085asm2086// Set rounding mode to Round Down2087stmxcsr [OldFlags]2088mov eax, [OldFlags]2089and eax, SSE_ROUND_MASK2090or eax, SSE_ROUND_DOWN2091mov [NewFlags], eax2092movq xmm0, [A]2093movss xmm1, DWORD [A+8]2094movlhps xmm0, xmm12095ldmxcsr [NewFlags]2096cvtps2dq xmm0, xmm02098// Restore rounding mode2100ldmxcsr [OldFlags]2101movhlps xmm1, xmm02103movq [Result], xmm02104movss DWORD [Result+8], xmm12105end;2106function Floor(const A: TVector4): TIVector4; assembler;2108var2109OldFlags, NewFlags: UInt32;2110asm2111// Set rounding mode to Round Down2112stmxcsr [OldFlags]2113mov eax, [OldFlags]2114and eax, SSE_ROUND_MASK2115or eax, SSE_ROUND_DOWN2116mov [NewFlags], eax2117movups xmm0, [A]2118ldmxcsr [NewFlags]2119cvtps2dq xmm0, xmm02121// Restore rounding mode2123ldmxcsr [OldFlags]2124movups [Result], xmm02126end;2127function Trunc(const A: Single): Integer;2129begin2130Result := System.Trunc(A);2131end;2132{function Trunc(const A: Single): Integer; assembler;2134var2135OldFlags, NewFlags: UInt32;2136asm2137// Set rounding mode to Truncate2138stmxcsr [OldFlags]2139mov ecx, [OldFlags]2140and ecx, SSE_ROUND_MASK2141or ecx, SSE_ROUND_TRUNC2142mov [NewFlags], ecx2143ldmxcsr [NewFlags]2144cvtps2dq xmm0, xmm02146// Restore rounding mode2148ldmxcsr [OldFlags]2149movd eax, xmm02151end;}2152function Trunc(const A: TVector2): TIVector2; assembler;2154var2155OldFlags, NewFlags: UInt32;2156asm2157// Set rounding mode to Truncate2158stmxcsr [OldFlags]2159mov eax, [OldFlags]2160and eax, SSE_ROUND_MASK2161or eax, SSE_ROUND_TRUNC2162mov [NewFlags], eax2163{$IF RTLVersion >= 33}2164movlps xmm0, [A]2165{$ELSE}2166movq xmm0, A2167{$ENDIF}2168ldmxcsr [NewFlags]2169cvtps2dq xmm0, xmm02171// Restore rounding mode2173ldmxcsr [OldFlags]2174movq rax, xmm02176end;2177function Trunc(const A: TVector3): TIVector3; assembler;2179var2180OldFlags, NewFlags: UInt32;2181asm2182// Set rounding mode to Truncate2183stmxcsr [OldFlags]2184mov eax, [OldFlags]2185and eax, SSE_ROUND_MASK2186or eax, SSE_ROUND_TRUNC2187mov [NewFlags], eax2188movq xmm0, [A]2189movss xmm1, DWORD [A+8]2190movlhps xmm0, xmm12191ldmxcsr [NewFlags]2192cvtps2dq xmm0, xmm02194// Restore rounding mode2196ldmxcsr [OldFlags]2197movhlps xmm1, xmm02199movq [Result], xmm02200movss DWORD [Result+8], xmm12201end;2202function Trunc(const A: TVector4): TIVector4; assembler;2204var2205OldFlags, NewFlags: UInt32;2206asm2207// Set rounding mode to Truncate2208stmxcsr [OldFlags]2209mov eax, [OldFlags]2210and eax, SSE_ROUND_MASK2211or eax, SSE_ROUND_TRUNC2212mov [NewFlags], eax2213movups xmm0, [A]2214ldmxcsr [NewFlags]2215cvtps2dq xmm0, xmm02217// Restore rounding mode2219ldmxcsr [OldFlags]2220movups [Result], xmm02222end;2223function Round(const A: Single): Integer;2225begin2226Result := System.Round(A);2227end;2228function Round(const A: TVector2): TIVector2; assembler;2230asm2231// Rounding mode defaults to round-to-nearest2232{$IF RTLVersion >= 33}2233movlps xmm0, [A]2234{$ELSE}2235movq xmm0, A2236{$ENDIF}2237cvtps2dq xmm0, xmm02238movq rax, xmm02239end;2240function Round(const A: TVector3): TIVector3; assembler;2242asm2243// Rounding mode defaults to round-to-nearest2244movq xmm0, [A]2245movss xmm1, DWORD [A+8]2246movlhps xmm0, xmm12247cvtps2dq xmm0, xmm02248movhlps xmm1, xmm02249movq [Result], xmm02250movss DWORD [Result+8], xmm12251end;2252function Round(const A: TVector4): TIVector4; assembler;2254asm2255// Rounding mode defaults to round-to-nearest2256movups xmm0, [A]2257cvtps2dq xmm0, xmm02258movups [Result], xmm02259end;2260function Ceil(const A: Single): Integer;2262begin2263Result := System.Math.Ceil(A);2264end;2265{function Ceil(const A: Single): Integer; assembler;2266var2267OldFlags, NewFlags: UInt32;2268asm2269// Set rounding mode to Ceil Down2270stmxcsr [OldFlags]2271mov ecx, [OldFlags]2272and ecx, SSE_ROUND_MASK2273or ecx, SSE_ROUND_UP2274mov [NewFlags], ecx2275ldmxcsr [NewFlags]2276cvtps2dq xmm0, xmm02278// Restore rounding mode2280ldmxcsr [OldFlags]2281movd eax, xmm02283end;}2284function Ceil(const A: TVector2): TIVector2; assembler;2286var2287OldFlags, NewFlags: UInt32;2288asm2289// Set rounding mode to Ceil Down2290stmxcsr [OldFlags]2291mov eax, [OldFlags]2292and eax, SSE_ROUND_MASK2293or eax, SSE_ROUND_UP2294mov [NewFlags], eax2295{$IF RTLVersion >= 33}2296movlps xmm0, [A]2297{$ELSE}2298movq xmm0, A2299{$ENDIF}2300ldmxcsr [NewFlags]2301cvtps2dq xmm0, xmm02303// Restore rounding mode2305ldmxcsr [OldFlags]2306movq rax, xmm02308end;2309function Ceil(const A: TVector3): TIVector3; assembler;2311var2312OldFlags, NewFlags: UInt32;2313asm2314// Set rounding mode to Ceil Down2315stmxcsr [OldFlags]2316mov eax, [OldFlags]2317and eax, SSE_ROUND_MASK2318or eax, SSE_ROUND_UP2319mov [NewFlags], eax2320movq xmm0, [A]2321movss xmm1, DWORD [A+8]2322movlhps xmm0, xmm12323ldmxcsr [NewFlags]2324cvtps2dq xmm0, xmm02326// Restore rounding mode2328ldmxcsr [OldFlags]2329movhlps xmm1, xmm02331movq [Result], xmm02332movss DWORD [Result+8], xmm12333end;2334function Ceil(const A: TVector4): TIVector4; assembler;2336var2337OldFlags, NewFlags: UInt32;2338asm2339// Set rounding mode to Ceil Down2340stmxcsr [OldFlags]2341mov eax, [OldFlags]2342and eax, SSE_ROUND_MASK2343or eax, SSE_ROUND_UP2344mov [NewFlags], eax2345movups xmm0, [A]2346ldmxcsr [NewFlags]2347cvtps2dq xmm0, xmm02349// Restore rounding mode2351ldmxcsr [OldFlags]2352movups [Result], xmm02354end;2355function Frac(const A: Single): Single;2357begin2358Result := System.Frac(A);2359end;2360{function Frac(const A: Single): Single; assembler;2361var2362OldFlags, NewFlags: UInt32;2363asm2364// Set rounding mode to Truncate2365stmxcsr [OldFlags]2366mov ecx, [OldFlags]2367and ecx, SSE_ROUND_MASK2368or ecx, SSE_ROUND_TRUNC2369mov [NewFlags], ecx2370movss xmm1, xmm02371ldmxcsr [NewFlags]2372cvtps2dq xmm0, xmm02374ldmxcsr [OldFlags]2375cvtdq2ps xmm0, xmm02376subss xmm1, xmm0 // A - Trunc(A)2377movss xmm0, xmm12379end;}2380function Frac(const A: TVector2): TVector2; assembler;2382var2383OldFlags, NewFlags: UInt32;2384asm2385// Set rounding mode to Truncate2386stmxcsr [OldFlags]2387mov edx, [OldFlags]2388and edx, SSE_ROUND_MASK2389or edx, SSE_ROUND_TRUNC2390{$IF RTLVersion >= 33}2391movlps xmm0, [A]2392{$ELSE}2393movq xmm0, A2394{$ENDIF}2395mov [NewFlags], edx2396movaps xmm1, xmm02397ldmxcsr [NewFlags]2398cvtps2dq xmm0, xmm02400ldmxcsr [OldFlags]2401cvtdq2ps xmm0, xmm02402subps xmm1, xmm0 // A - Trunc(A)2403movq rax, xmm12405end;2406function Frac(const A: TVector3): TVector3; assembler;2408var2409OldFlags, NewFlags: UInt32;2410asm2411// Set rounding mode to Truncate2412stmxcsr [OldFlags]2413mov eax, [OldFlags]2414and eax, SSE_ROUND_MASK2415or eax, SSE_ROUND_TRUNC2416movq xmm0, [A]2417movss xmm1, DWORD [A+8]2418movlhps xmm0, xmm12419mov [NewFlags], eax2420movaps xmm1, xmm02421ldmxcsr [NewFlags]2422cvtps2dq xmm0, xmm02424ldmxcsr [OldFlags]2425cvtdq2ps xmm0, xmm02426subps xmm1, xmm0 // A - Trunc(A)2427movhlps xmm0, xmm12429movq [Result], xmm12430movss DWORD [Result+8], xmm02431end;2432function Frac(const A: TVector4): TVector4; assembler;2434var2435OldFlags, NewFlags: UInt32;2436asm2437// Set rounding mode to Truncate2438stmxcsr [OldFlags]2439mov eax, [OldFlags]2440and eax, SSE_ROUND_MASK2441or eax, SSE_ROUND_TRUNC2442movups xmm0, [A]2443mov [NewFlags], eax2444movaps xmm1, xmm02445ldmxcsr [NewFlags]2446cvtps2dq xmm0, xmm02448ldmxcsr [OldFlags]2449cvtdq2ps xmm0, xmm02450subps xmm1, xmm0 // A - Trunc(A)2451movups [Result], xmm12453end;2454function FMod(const A, B: Single): Single;2456begin2457Result := A - (B * Trunc(A / B));2458end;2459{function FMod(const A, B: Single): Single; assembler;2460var2461OldFlags, NewFlags: UInt32;2462asm2463// Set rounding mode to Truncate2464stmxcsr [OldFlags]2465mov edx, [OldFlags]2466movss xmm2, xmm02467and edx, SSE_ROUND_MASK2468movss xmm3, xmm12469or edx, SSE_ROUND_TRUNC2470divss xmm2, xmm3 // A / B2471mov [NewFlags], edx2472ldmxcsr [NewFlags]2473cvtps2dq xmm2, xmm22475cvtdq2ps xmm2, xmm2 // Trunc(A / B)2476mulss xmm2, xmm12477subss xmm0, xmm2 // A - (B * Trunc(A / B))2478// Restore rounding mode2480ldmxcsr [OldFlags]2481end;}2482function FMod(const A: TVector2; const B: Single): TVector2; assembler;2484var2485OldFlags, NewFlags: UInt32;2486asm2487// Set rounding mode to Truncate2488{$IF RTLVersion >= 33}2489movlps xmm0, [A]2490{$ELSE}2491movq xmm0, A2492{$ENDIF}2493stmxcsr [OldFlags]2494mov ecx, [OldFlags]2495shufps xmm1, xmm1, $00 // Replicate B2496and ecx, SSE_ROUND_MASK2497movaps xmm2, xmm02498or ecx, SSE_ROUND_TRUNC2499movaps xmm3, xmm12500mov [NewFlags], ecx2501divps xmm2, xmm3 // A / B2502ldmxcsr [NewFlags]2503cvtps2dq xmm2, xmm22505cvtdq2ps xmm2, xmm2 // Trunc(A / B)2506mulps xmm2, xmm12507subps xmm0, xmm2 // A - (B * Trunc(A / B))2508// Restore rounding mode2510ldmxcsr [OldFlags]2511movq rax, xmm02513end;2514function FMod(const A, B: TVector2): TVector2; assembler;2516var2517OldFlags, NewFlags: UInt32;2518asm2519// Set rounding mode to Truncate2520{$IF RTLVersion >= 33}2521movlps xmm0, [A]2522{$ELSE}2523movq xmm0, A2524{$ENDIF}2525stmxcsr [OldFlags]2526{$IF RTLVersion >= 33}2527movlps xmm1, [B]2528{$ELSE}2529movq xmm1, B2530{$ENDIF}2531mov edx, [OldFlags]2532movaps xmm2, xmm02533and edx, SSE_ROUND_MASK2534movaps xmm3, xmm12535or edx, SSE_ROUND_TRUNC2536divps xmm2, xmm3 // A / B2537mov [NewFlags], edx2538ldmxcsr [NewFlags]2539cvtps2dq xmm2, xmm22541cvtdq2ps xmm2, xmm2 // Trunc(A / B)2542mulps xmm2, xmm12543subps xmm0, xmm2 // A - (B * Trunc(A / B))2544// Restore rounding mode2546ldmxcsr [OldFlags]2547movq rax, xmm02549end;2550function FMod(const A: TVector3; const B: Single): TVector3; assembler;2552var2553OldFlags, NewFlags: UInt32;2554asm2555// Set rounding mode to Truncate2556movq xmm0, [A]2557movss xmm1, DWORD [A+8]2558movlhps xmm0, xmm12559movss xmm1, B2560stmxcsr [OldFlags]2561mov edx, [OldFlags]2562shufps xmm1, xmm1, $00 // Replicate B2563and edx, SSE_ROUND_MASK2564movaps xmm2, xmm02565or edx, SSE_ROUND_TRUNC2566movaps xmm3, xmm12567mov [NewFlags], edx2568divps xmm2, xmm3 // A / B2569ldmxcsr [NewFlags]2570cvtps2dq xmm2, xmm22572cvtdq2ps xmm2, xmm2 // Trunc(A / B)2573mulps xmm2, xmm12574subps xmm0, xmm2 // A - (B * Trunc(A / B))2575// Restore rounding mode2577ldmxcsr [OldFlags]2578movhlps xmm1, xmm02580movq [Result], xmm02581movss DWORD [Result+8], xmm12582end;2583function FMod(const A, B: TVector3): TVector3;2585begin2586Result.Init(Neslib.FastMath.FMod(A.X, B.X), Neslib.FastMath.FMod(A.Y, B.Y), Neslib.FastMath.FMod(A.Z, B.Z));2587end;2588{function FMod(const A, B: TVector3): TVector3; assembler;2589var2590OldFlags, NewFlags: UInt32;2591asm2592// Set rounding mode to Truncate2593movq xmm0, [A]2594movss xmm1, DWORD [A+8]2595movlhps xmm0, xmm12596stmxcsr [OldFlags]2597movq xmm1, [B]2598movss xmm2, DWORD [B+8]2599movlhps xmm1, xmm22600mov edx, [OldFlags]2601movaps xmm2, xmm02602and edx, SSE_ROUND_MASK2603movaps xmm3, xmm12604or edx, SSE_ROUND_TRUNC2605divps xmm2, xmm3 // A / B2606mov [NewFlags], edx2607ldmxcsr [NewFlags]2608cvtps2dq xmm2, xmm22610cvtdq2ps xmm2, xmm2 // Trunc(A / B)2611mulps xmm2, xmm12612subps xmm0, xmm2 // A - (B * Trunc(A / B))2613// Restore rounding mode2615ldmxcsr [OldFlags]2616movhlps xmm1, xmm02618movq [Result], xmm02619movss DWORD [Result+8], xmm12620end;}2621function FMod(const A: TVector4; const B: Single): TVector4; assembler;2623var2624OldFlags, NewFlags: UInt32;2625asm2626// Set rounding mode to Truncate2627movups xmm0, [A]2628movss xmm1, B2629stmxcsr [OldFlags]2630mov edx, [OldFlags]2631shufps xmm1, xmm1, $00 // Replicate B2632and edx, SSE_ROUND_MASK2633movaps xmm2, xmm02634or edx, SSE_ROUND_TRUNC2635movaps xmm3, xmm12636mov [NewFlags], edx2637divps xmm2, xmm3 // A / B2638ldmxcsr [NewFlags]2639cvtps2dq xmm2, xmm22641cvtdq2ps xmm2, xmm2 // Trunc(A / B)2642mulps xmm2, xmm12643subps xmm0, xmm2 // A - (B * Trunc(A / B))2644// Restore rounding mode2646ldmxcsr [OldFlags]2647movups [Result], xmm02649end;2650function FMod(const A, B: TVector4): TVector4; assembler;2652var2653OldFlags, NewFlags: UInt32;2654asm2655// Set rounding mode to Truncate2656movups xmm0, [A]2657stmxcsr [OldFlags]2658movups xmm1, [B]2659mov edx, [OldFlags]2660movaps xmm2, xmm02661and edx, SSE_ROUND_MASK2662movaps xmm3, xmm12663or edx, SSE_ROUND_TRUNC2664divps xmm2, xmm3 // A / B2665mov [NewFlags], edx2666ldmxcsr [NewFlags]2667cvtps2dq xmm2, xmm22669cvtdq2ps xmm2, xmm2 // Trunc(A / B)2670mulps xmm2, xmm12671subps xmm0, xmm2 // A - (B * Trunc(A / B))2672// Restore rounding mode2674ldmxcsr [OldFlags]2675movups [Result], xmm02677end;2678function ModF(const A: Single; out B: Integer): Single;2680begin2681B := Trunc(A);2682Result := Frac(A);2683end;2684{function ModF(const A: Single; out B: Integer): Single; assembler;2685var2686OldFlags, NewFlags: UInt32;2687asm2688// Set rounding mode to Truncate2689stmxcsr [OldFlags]2690mov ecx, [OldFlags]2691and ecx, SSE_ROUND_MASK2692or ecx, SSE_ROUND_TRUNC2693mov [NewFlags], ecx2694ldmxcsr [NewFlags]2695movss xmm1, xmm02697cvtps2dq xmm0, xmm02698movss [B], xmm0 // B = Trunc(A)2699cvtdq2ps xmm0, xmm02700subss xmm1, xmm0 // A - Trunc(A)2701// Restore rounding mode2703ldmxcsr [OldFlags]2704movss xmm0, xmm12706end;}2707function ModF(const A: TVector2; out B: TIVector2): TVector2; assembler;2709var2710OldFlags, NewFlags: UInt32;2711asm2712{$IF RTLVersion >= 33}2713movlps xmm0, [A]2714{$ELSE}2715movq xmm0, A2716{$ENDIF}2717// Set rounding mode to Truncate2719stmxcsr [OldFlags]2720mov eax, [OldFlags]2721and eax, SSE_ROUND_MASK2722or eax, SSE_ROUND_TRUNC2723mov [NewFlags], eax2724ldmxcsr [NewFlags]2725movaps xmm1, xmm02727cvtps2dq xmm0, xmm02728movlps [B], xmm0 // B = Trunc(A)2729cvtdq2ps xmm0, xmm02730subps xmm1, xmm0 // A - Trunc(A)2731// Restore rounding mode2733ldmxcsr [OldFlags]2734movq rax, xmm12736end;2737function ModF(const A: TVector3; out B: TIVector3): TVector3; assembler;2739var2740OldFlags, NewFlags: UInt32;2741asm2742movq xmm0, [A]2743movss xmm1, DWORD [A+8]2744movlhps xmm0, xmm12745// Set rounding mode to Truncate2747stmxcsr [OldFlags]2748mov eax, [OldFlags]2749and eax, SSE_ROUND_MASK2750or eax, SSE_ROUND_TRUNC2751mov [NewFlags], eax2752ldmxcsr [NewFlags]2753movaps xmm1, xmm02755cvtps2dq xmm0, xmm02756movhlps xmm2, xmm02757movq [B], xmm0 // B = Trunc(A)2758movd DWORD [B+8], xmm22759cvtdq2ps xmm0, xmm02760subps xmm1, xmm0 // A - Trunc(A)2761// Restore rounding mode2763ldmxcsr [OldFlags]2764movhlps xmm0, xmm12766movq [Result], xmm12767movss DWORD [Result+8], xmm02768end;2769function ModF(const A: TVector4; out B: TIVector4): TVector4; assembler;2771var2772OldFlags, NewFlags: UInt32;2773asm2774movups xmm0, [A]2775// Set rounding mode to Truncate2777stmxcsr [OldFlags]2778mov eax, [OldFlags]2779and eax, SSE_ROUND_MASK2780or eax, SSE_ROUND_TRUNC2781mov [NewFlags], eax2782ldmxcsr [NewFlags]2783movaps xmm1, xmm02785cvtps2dq xmm0, xmm02786movups [B], xmm0 // B = Trunc(A)2787cvtdq2ps xmm0, xmm02788subps xmm1, xmm0 // A - Trunc(A)2789// Restore rounding mode2791ldmxcsr [OldFlags]2792movups [Result], xmm12794end;2795function Min(const A: TVector2; const B: Single): TVector2; assembler;2797asm2798{$IF RTLVersion >= 33}2799movlps xmm0, [A]2800{$ELSE}2801movq xmm0, A2802{$ENDIF}2803shufps xmm1, xmm1, $00 // Replicate B2804minps xmm0, xmm12805movq rax, xmm02806end;2807function Min(const A, B: TVector2): TVector2; assembler;2809asm2810{$IF RTLVersion >= 33}2811movlps xmm0, [A]2812movlps xmm1, [B]2813{$ELSE}2814movq xmm0, A2815movq xmm1, B2816{$ENDIF}2817minps xmm0, xmm12818movq rax, xmm02819end;2820function Min(const A: TVector3; const B: Single): TVector3; assembler;2822asm2823movq xmm0, [A]2824movss xmm1, DWORD [A+8]2825movlhps xmm0, xmm12826shufps xmm2, xmm2, $00 // Replicate B2827minps xmm0, xmm22828movhlps xmm1, xmm02829movq [Result], xmm02830movss DWORD [Result+8], xmm12831end;2832function Min(const A, B: TVector3): TVector3; assembler;2834asm2835movq xmm0, [A]2836movss xmm1, DWORD [A+8]2837movlhps xmm0, xmm12838movq xmm1, [B]2839movss xmm2, DWORD [B+8]2840movlhps xmm1, xmm22841minps xmm0, xmm12842movhlps xmm1, xmm02843movq [Result], xmm02844movss DWORD [Result+8], xmm12845end;2846function Min(const A: TVector4; const B: Single): TVector4; assembler;2848asm2849movups xmm0, [A]2850shufps xmm2, xmm2, $00 // Replicate B2851minps xmm0, xmm22852movups [Result], xmm02853end;2854function Min(const A, B: TVector4): TVector4; assembler;2856asm2857movups xmm0, [A]2858movups xmm1, [B]2859minps xmm0, xmm12860movups [Result], xmm02861end;2862function Max(const A: TVector2; const B: Single): TVector2; assembler;2864asm2865{$IF RTLVersion >= 33}2866movlps xmm0, [A]2867{$ELSE}2868movq xmm0, A2869{$ENDIF}2870shufps xmm1, xmm1, $00 // Replicate B2871maxps xmm0, xmm12872movq rax, xmm02873end;2874function Max(const A, B: TVector2): TVector2; assembler;2876asm2877{$IF RTLVersion >= 33}2878movlps xmm0, [A]2879movlps xmm1, [B]2880{$ELSE}2881movq xmm0, A2882movq xmm1, B2883{$ENDIF}2884maxps xmm0, xmm12885movq rax, xmm02886end;2887function Max(const A: TVector3; const B: Single): TVector3; assembler;2889asm2890movq xmm0, [A]2891movss xmm1, DWORD [A+8]2892movlhps xmm0, xmm12893shufps xmm2, xmm2, $00 // Replicate B2894maxps xmm0, xmm22895movhlps xmm1, xmm02896movq [Result], xmm02897movss DWORD [Result+8], xmm12898end;2899function Max(const A, B: TVector3): TVector3; assembler;2901asm2902movq xmm0, [A]2903movss xmm1, DWORD [A+8]2904movlhps xmm0, xmm12905movq xmm1, [B]2906movss xmm2, DWORD [B+8]2907movlhps xmm1, xmm22908maxps xmm0, xmm12909movhlps xmm1, xmm02910movq [Result], xmm02911movss DWORD [Result+8], xmm12912end;2913function Max(const A: TVector4; const B: Single): TVector4; assembler;2915asm2916movups xmm0, [A]2917shufps xmm2, xmm2, $00 // Replicate B2918maxps xmm0, xmm22919movups [Result], xmm02920end;2921function Max(const A, B: TVector4): TVector4; assembler;2923asm2924movups xmm0, [A]2925movups xmm1, [B]2926maxps xmm0, xmm12927movups [Result], xmm02928end;2929function EnsureRange(const A, AMin, AMax: Single): Single; assembler;2931asm2932maxss xmm0, xmm12933minss xmm0, xmm22934end;2935function EnsureRange(const A: TVector2; const AMin, AMax: Single): TVector2; assembler;2937asm2938{$IF RTLVersion >= 33}2939movlps xmm0, [A]2940{$ELSE}2941movq xmm0, A2942{$ENDIF}2943shufps xmm1, xmm1, $00 // Replicate AMin2944shufps xmm2, xmm2, $00 // Replicate AMax2945maxps xmm0, xmm12946minps xmm0, xmm22947movq rax, xmm02948end;2949function EnsureRange(const A, AMin, AMax: TVector2): TVector2; assembler;2951asm2952{$IF RTLVersion >= 33}2953movlps xmm0, [A]2954movlps xmm1, [AMin]2955movlps xmm2, [AMax]2956{$ELSE}2957movq xmm0, A2958movq xmm1, AMin2959movq xmm2, AMax2960{$ENDIF}2961maxps xmm0, xmm12962minps xmm0, xmm22963movq rax, xmm02964end;2965function EnsureRange(const A: TVector3; const AMin, AMax: Single): TVector3; assembler;2967asm2968movq xmm0, [A]2969movss xmm1, DWORD [A+8]2970movlhps xmm0, xmm12971shufps xmm2, xmm2, $00 // Replicate AMin2972shufps xmm3, xmm3, $00 // Replicate AMax2973maxps xmm0, xmm22974minps xmm0, xmm32975movhlps xmm1, xmm02976movq [Result], xmm02977movss DWORD [Result+8], xmm12978end;2979function EnsureRange(const A, AMin, AMax: TVector3): TVector3; assembler;2981asm2982movq xmm0, [A]2983movss xmm1, DWORD [A+8]2984movlhps xmm0, xmm12985movq xmm1, [AMin]2986movss xmm2, DWORD [AMin+8]2987movlhps xmm1, xmm22988movq xmm2, [AMax]2989movss xmm3, DWORD [AMax+8]2990movlhps xmm2, xmm32991maxps xmm0, xmm12992minps xmm0, xmm22993movhlps xmm1, xmm02994movq [Result], xmm02995movss DWORD [Result+8], xmm12996end;2997function EnsureRange(const A: TVector4; const AMin, AMax: Single): TVector4; assembler;2999asm3000movups xmm0, [A]3001shufps xmm2, xmm2, $00 // Replicate AMin3002shufps xmm3, xmm3, $00 // Replicate AMax3003maxps xmm0, xmm23004minps xmm0, xmm33005movups [Result], xmm03006end;3007function EnsureRange(const A, AMin, AMax: TVector4): TVector4; assembler;3009asm3010movups xmm0, [A]3011movups xmm1, [AMin]3012movups xmm2, [AMax]3013maxps xmm0, xmm13014minps xmm0, xmm23015movups [Result], xmm03016end;3017function Mix(const A, B: TVector2; const T: Single): TVector2;3019begin3020Result.Init(Mix(A.X, B.X, T), Mix(A.Y, B.Y, T));3021end;3022function Mix(const A, B, T: TVector2): TVector2;3024begin3025Result.Init(Mix(A.X, B.X, T.X), Mix(A.Y, B.Y, T.Y));3026end;3027function Mix(const A, B: TVector3; const T: Single): TVector3; assembler;3029asm3030movq xmm0, [A]3031movss xmm1, DWORD [A+8]3032movlhps xmm0, xmm13033movq xmm1, [B]3034movss xmm2, DWORD [B+8]3035movlhps xmm1, xmm23036shufps xmm3, xmm3, $00 // Replicate T3037subps xmm1, xmm03038mulps xmm1, xmm33039addps xmm0, xmm1 // A + (T * (B - A))3040movhlps xmm1, xmm03041movq [Result], xmm03042movss DWORD [Result+8], xmm13043end;3044function Mix(const A, B, T: TVector3): TVector3; assembler;3046asm3047movq xmm0, [A]3048movss xmm1, DWORD [A+8]3049movlhps xmm0, xmm13050movq xmm1, [B]3051movss xmm2, DWORD [B+8]3052movlhps xmm1, xmm23053movq xmm2, [T]3054movss xmm3, DWORD [T+8]3055movlhps xmm2, xmm33056subps xmm1, xmm03057mulps xmm1, xmm23058addps xmm0, xmm1 // A + (T * (B - A))3059movhlps xmm1, xmm03060movq [Result], xmm03061movss DWORD [Result+8], xmm13062end;3063function Mix(const A, B: TVector4; const T: Single): TVector4; assembler;3065asm3066movups xmm0, [A]3067movups xmm1, [B]3068shufps xmm3, xmm3, $00 // Replicate T3069subps xmm1, xmm03070mulps xmm1, xmm33071addps xmm0, xmm1 // A + (T * (B - A))3072movups [Result], xmm03073end;3074function Mix(const A, B, T: TVector4): TVector4; assembler;3076asm3077movups xmm0, [A]3078movups xmm1, [B]3079movups xmm2, [T]3080subps xmm1, xmm03081mulps xmm1, xmm23082addps xmm0, xmm1 // A + (T * (B - A))3083movups [Result], xmm03084end;3085function Step(const AEdge: Single; const A: TVector2): TVector2; assembler;3087asm3088{$IF RTLVersion >= 33}3089movlps xmm1, [A]3090{$ELSE}3091movq xmm1, A3092{$ENDIF}3093shufps xmm0, xmm0, $00 // Replicate AEdge3094movlps xmm2, QWORD [SSE_ONE]3095cmpnltps xmm1, xmm0 // (A >= AEdge)? Yes: $FFFFFFFF, No: $000000003096andps xmm1, xmm2 // (A >= AEdge)? Yes: 1, No: 03097movq rax, xmm13098end;3099function Step(const AEdge, A: TVector2): TVector2; assembler;3101asm3102{$IF RTLVersion >= 33}3103movlps xmm0, [AEdge]3104movlps xmm1, [A]3105{$ELSE}3106movq xmm0, AEdge3107movq xmm1, A3108{$ENDIF}3109movlps xmm2, QWORD [SSE_ONE]3110cmpnltps xmm1, xmm0 // (A >= AEdge)? Yes: $FFFFFFFF, No: $000000003111andps xmm1, xmm2 // (A >= AEdge)? Yes: 1, No: 03112movq rax, xmm13113end;3114function Step(const AEdge: Single; const A: TVector3): TVector3; assembler;3116asm3117movq xmm0, [A]3118movss xmm2, DWORD [A+8]3119movlhps xmm0, xmm23120shufps xmm1, xmm1, $00 // Replicate AEdge3121movups xmm2, [SSE_ONE]3122cmpnltps xmm0, xmm1 // (A >= AEdge)? Yes: $FFFFFFFF, No: $000000003123andps xmm0, xmm2 // (A >= AEdge)? Yes: 1, No: 03124movhlps xmm1, xmm03125movq [Result], xmm03126movss DWORD [Result+8], xmm13127end;3128function Step(const AEdge, A: TVector3): TVector3; assembler;3130asm3131movq xmm0, [AEdge]3132movss xmm1, DWORD [AEdge+8]3133movlhps xmm0, xmm13134movq xmm1, [A]3135movss xmm2, DWORD [A+8]3136movlhps xmm1, xmm23137movups xmm2, [SSE_ONE]3138cmpnltps xmm1, xmm0 // (A >= AEdge)? Yes: $FFFFFFFF, No: $000000003139andps xmm1, xmm2 // (A >= AEdge)? Yes: 1, No: 03140movhlps xmm0, xmm13141movq [Result], xmm13142movss DWORD [Result+8], xmm03143end;3144function Step(const AEdge: Single; const A: TVector4): TVector4; assembler;3146asm3147movups xmm0, [A]3148shufps xmm1, xmm1, $00 // Replicate AEdge3149movups xmm2, [SSE_ONE]3150cmpnltps xmm0, xmm1 // (A >= AEdge)? Yes: $FFFFFFFF, No: $000000003151andps xmm0, xmm2 // (A >= AEdge)? Yes: 1, No: 03152movups [Result], xmm03153end;3154function Step(const AEdge, A: TVector4): TVector4;3156asm3157movups xmm0, [AEdge]3158movups xmm1, [A]3159movups xmm2, [SSE_ONE]3160cmpnltps xmm1, xmm0 // (A >= AEdge)? Yes: $FFFFFFFF, No: $000000003161andps xmm1, xmm2 // (A >= AEdge)? Yes: 1, No: 03162movups [Result], xmm13163end;3164function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector2): TVector2;3166begin3167Result.Init(SmoothStep(AEdge0, AEdge1, A.X), SmoothStep(AEdge0, AEdge1, A.Y));3168end;3169function SmoothStep(const AEdge0, AEdge1, A: TVector2): TVector2;3171begin3172Result.Init(SmoothStep(AEdge0.X, AEdge1.X, A.X), SmoothStep(AEdge0.Y, AEdge1.Y, A.Y));3173end;3174function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector3): TVector3;3176begin3177Result.Init(SmoothStep(AEdge0, AEdge1, A.X), SmoothStep(AEdge0, AEdge1, A.Y), SmoothStep(AEdge0, AEdge1, A.Z));3178end;3179{function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector3): TVector3; assembler;3180asm3181movdqa [rsp-24], xmm63182movdqa [rsp-40], xmm73183movq xmm0, [A]3185movss xmm3, DWORD [A+8]3186movlhps xmm0, xmm33187shufps xmm1, xmm1, $00 // Replicate AEdge03188shufps xmm2, xmm2, $00 // Replicate AEdge13189movaps xmm3, xmm03190movaps xmm4, xmm03191movaps xmm5, xmm03192movups xmm6, [SSE_ONE]3193cmpnltps xmm3, xmm1 // (A >= AEdge0)? Yes: $FFFFFFFF, No: $000000003195cmpleps xmm4, xmm2 // (A <= AEdge1)? Yes: $FFFFFFFF, No: $000000003196subps xmm2, xmm13197movaps xmm5, xmm43198subps xmm0, xmm13199andnps xmm5, xmm6 // (A > AEdge1)? Yes: 1.0, No: 0.03200movups xmm6, [SSE_TWO]3202divps xmm0, xmm2 // Temp := (A - AEdge0) / (AEdge1 - AEdge0)3203movups xmm7, [SSE_THREE]3204mulps xmm6, xmm0 // 2 * Temp3205subps xmm7, xmm6 // 3 - (2 * Temp)3206mulps xmm7, xmm03207mulps xmm7, xmm0 // Result := Temp * Temp * (3 - (2 * Temp))3208andps xmm7, xmm3 // (A < AEdge0)? Yes: 0, No: Result3209andps xmm7, xmm4 // (A > AEdge1)? Yes: 0, No: Result3210orps xmm7, xmm5 // (A > AEdge1)? Yes: 1, No: Result3211movhlps xmm6, xmm73213movq [Result], xmm73214movss DWORD [Result+8], xmm63215movdqa xmm6, [rsp-24]3217movdqa xmm7, [rsp-40]3218end;}3219function SmoothStep(const AEdge0, AEdge1, A: TVector3): TVector3; assembler;3221asm3222movdqa [rsp-24], xmm63223movdqa [rsp-40], xmm73224movq xmm2, [A]3226movss xmm3, DWORD [A+8]3227movlhps xmm2, xmm33228movq xmm0, [AEdge0]3229movss xmm1, DWORD [AEdge0+8]3230movlhps xmm0, xmm13231movq xmm1, [AEdge1]3232movss xmm3, DWORD [AEdge1+8]3233movlhps xmm1, xmm33234movaps xmm3, xmm23236movaps xmm4, xmm23237movaps xmm5, xmm23238movups xmm6, [SSE_ONE]3239cmpnltps xmm3, xmm0 // (A >= AEdge0)? Yes: $FFFFFFFF, No: $000000003241cmpleps xmm4, xmm1 // (A <= AEdge1)? Yes: $FFFFFFFF, No: $000000003242subps xmm1, xmm03243movaps xmm5, xmm43244subps xmm2, xmm03245andnps xmm5, xmm6 // (A > AEdge1)? Yes: 1.0, No: 0.03246movups xmm6, [SSE_TWO]3248divps xmm2, xmm1 // Temp := (A - AEdge0) / (AEdge1 - AEdge0)3249movups xmm7, [SSE_THREE]3250mulps xmm6, xmm2 // 2 * Temp3251subps xmm7, xmm6 // 3 - (2 * Temp)3252mulps xmm7, xmm23253mulps xmm7, xmm2 // Result := Temp * Temp * (3 - (2 * Temp))3254andps xmm7, xmm3 // (A < AEdge0)? Yes: 0, No: Result3255andps xmm7, xmm4 // (A > AEdge1)? Yes: 0, No: Result3256orps xmm7, xmm5 // (A > AEdge1)? Yes: 1, No: Result3257movhlps xmm6, xmm73259movq [Result], xmm73260movss DWORD [Result+8], xmm63261movdqa xmm6, [rsp-24]3263movdqa xmm7, [rsp-40]3264end;3265function SmoothStep(const AEdge0, AEdge1: Single; const A: TVector4): TVector4;3267asm3268movdqa [rsp-24], xmm63269movdqa [rsp-40], xmm73270movups xmm0, [A]3272shufps xmm1, xmm1, $00 // Replicate AEdge03273shufps xmm2, xmm2, $00 // Replicate AEdge13274movaps xmm3, xmm03275movaps xmm4, xmm03276movaps xmm5, xmm03277movups xmm6, [SSE_ONE]3278cmpnltps xmm3, xmm1 // (A >= AEdge0)? Yes: $FFFFFFFF, No: $000000003280cmpleps xmm4, xmm2 // (A <= AEdge1)? Yes: $FFFFFFFF, No: $000000003281subps xmm2, xmm13282movaps xmm5, xmm43283subps xmm0, xmm13284andnps xmm5, xmm6 // (A > AEdge1)? Yes: 1.0, No: 0.03285movups xmm6, [SSE_TWO]3287divps xmm0, xmm2 // Temp := (A - AEdge0) / (AEdge1 - AEdge0)3288movups xmm7, [SSE_THREE]3289mulps xmm6, xmm0 // 2 * Temp3290subps xmm7, xmm6 // 3 - (2 * Temp)3291mulps xmm7, xmm03292mulps xmm7, xmm0 // Result := Temp * Temp * (3 - (2 * Temp))3293andps xmm7, xmm3 // (A < AEdge0)? Yes: 0, No: Result3294andps xmm7, xmm4 // (A > AEdge1)? Yes: 0, No: Result3295orps xmm7, xmm5 // (A > AEdge1)? Yes: 1, No: Result3296movups [Result], xmm73298movdqa xmm6, [rsp-24]3300movdqa xmm7, [rsp-40]3301end;3302function SmoothStep(const AEdge0, AEdge1, A: TVector4): TVector4; assembler;3304asm3305movdqa [rsp-24], xmm63306movdqa [rsp-40], xmm73307movups xmm2, [A]3309movups xmm0, [AEdge0]3310movups xmm1, [AEdge1]3311movaps xmm3, xmm23312movaps xmm4, xmm23313movaps xmm5, xmm23314movups xmm6, [SSE_ONE]3315cmpnltps xmm3, xmm0 // (A >= AEdge0)? Yes: $FFFFFFFF, No: $000000003317cmpleps xmm4, xmm1 // (A <= AEdge1)? Yes: $FFFFFFFF, No: $000000003318subps xmm1, xmm03319movaps xmm5, xmm43320subps xmm2, xmm03321andnps xmm5, xmm6 // (A > AEdge1)? Yes: 1.0, No: 0.03322movups xmm6, [SSE_TWO]3324divps xmm2, xmm1 // Temp := (A - AEdge0) / (AEdge1 - AEdge0)3325movups xmm7, [SSE_THREE]3326mulps xmm6, xmm2 // 2 * Temp3327subps xmm7, xmm6 // 3 - (2 * Temp)3328mulps xmm7, xmm23329mulps xmm7, xmm2 // Result := Temp * Temp * (3 - (2 * Temp))3330andps xmm7, xmm3 // (A < AEdge0)? Yes: 0, No: Result3331andps xmm7, xmm4 // (A > AEdge1)? Yes: 0, No: Result3332orps xmm7, xmm5 // (A > AEdge1)? Yes: 1, No: Result3333movups [Result], xmm73335movdqa xmm6, [rsp-24]3337movdqa xmm7, [rsp-40]3338end;3339function FMA(const A, B, C: TVector2): TVector2; assembler;3341asm3342{$IF RTLVersion >= 33}3343movlps xmm0, [A]3344movlps xmm1, [B]3345movlps xmm2, [C]3346{$ELSE}3347movq xmm0, A3348movq xmm1, B3349movq xmm2, C3350{$ENDIF}3351mulps xmm0, xmm13352addps xmm0, xmm23353movq rax, xmm03354end;3355function FMA(const A, B, C: TVector3): TVector3; assembler;3357asm3358movq xmm0, [A]3359movss xmm1, DWORD [A+8]3360movlhps xmm0, xmm13361movq xmm1, [B]3362movss xmm2, DWORD [B+8]3363movlhps xmm1, xmm23364movq xmm2, [C]3365movss xmm3, DWORD [C+8]3366movlhps xmm2, xmm33367mulps xmm0, xmm13368addps xmm0, xmm23369movhlps xmm1, xmm03370movq [Result], xmm03371movss DWORD [Result+8], xmm13372end;3373function FMA(const A, B, C: TVector4): TVector4; assembler;3375asm3376movups xmm0, [A]3377movups xmm1, [B]3378movups xmm2, [C]3379mulps xmm0, xmm13380addps xmm0, xmm23381movups [Result], xmm03382end;3383{ Matrix functions }3385{$IFDEF FM_COLUMN_MAJOR}3387function OuterProduct(const C, R: TVector2): TMatrix2; assembler;3388asm3389{$IF RTLVersion >= 33}3390movlps xmm0, [R] // # # C.Y C.X3391movlps xmm1, [C] // # # R.Y R.X3392{$ELSE}3393movq xmm0, R // # # C.Y C.X3394movq xmm1, C // # # R.Y R.X3395{$ENDIF}3396shufps xmm0, xmm0, $50 // C.Y C.X C.Y C.X3398shufps xmm1, xmm1, $44 // R.Y R.Y R.X R.X3399mulps xmm1, xmm0 // (C.Y*R.Y) (C.X*R.Y) (C.Y*R.X) (C.X*R.X)3401// Store as matrix3403movups [Result], xmm13404end;3405function OuterProduct(const C, R: TVector3): TMatrix3; assembler;3407asm3408movq xmm0, [C]3409movss xmm1, DWORD [C+8]3410movlhps xmm0, xmm13411movq xmm1, [R]3412movss xmm2, DWORD [R+8]3413movlhps xmm1, xmm23414movaps xmm2, xmm13415movaps xmm3, xmm13416shufps xmm1, xmm1, $00 // C.X (4x)3418shufps xmm2, xmm2, $55 // C.Y (4x)3419shufps xmm3, xmm3, $AA // C.Z (4x)3420mulps xmm1, xmm0 // R * C.X3422mulps xmm2, xmm0 // R * C.Y3423mulps xmm3, xmm0 // R * C.Z3424// Store as matrix3426movhlps xmm0, xmm13427movhlps xmm4, xmm23428movhlps xmm5, xmm33429movq [Result+$00], xmm13430movss DWORD [Result+$08], xmm03431movq [Result+$0C], xmm23432movss DWORD [Result+$14], xmm43433movq [Result+$18], xmm33434movss DWORD [Result+$20], xmm53435end;3436function OuterProduct(const C, R: TVector4): TMatrix4; assembler;3438asm3439movups xmm0, [C]3440movups xmm1, [R]3441movaps xmm2, xmm13442movaps xmm3, xmm13443movaps xmm4, xmm13444shufps xmm1, xmm1, $00 // C.X (4x)3446shufps xmm2, xmm2, $55 // C.Y (4x)3447shufps xmm3, xmm3, $AA // C.Z (4x)3448shufps xmm4, xmm4, $FF // C.W (4x)3449mulps xmm1, xmm0 // R * C.X3451mulps xmm2, xmm0 // R * C.Y3452mulps xmm3, xmm0 // R * C.Z3453mulps xmm4, xmm0 // R * C.W3454// Store as matrix3456movups DQWORD [Result + $00], xmm13457movups DQWORD [Result + $10], xmm23458movups DQWORD [Result + $20], xmm33459movups DQWORD [Result + $30], xmm43460end;3461{$ELSE}3462function OuterProduct(const C, R: TVector2): TMatrix2; assembler;3463asm3464{$IF RTLVersion >= 33}3465movlps xmm0, [C] // # # C.Y C.X3466movlps xmm1, [R] // # # R.Y R.X3467{$ELSE}3468movq xmm0, C // # # C.Y C.X3469movq xmm1, R // # # R.Y R.X3470{$ENDIF}3471shufps xmm0, xmm0, $50 // C.Y C.X C.Y C.X3473shufps xmm1, xmm1, $44 // R.Y R.Y R.X R.X3474mulps xmm1, xmm0 // (C.Y*R.Y) (C.X*R.Y) (C.Y*R.X) (C.X*R.X)3476// Store as matrix3478movups [Result], xmm13479end;3480function OuterProduct(const C, R: TVector3): TMatrix3; assembler;3482asm3483movq xmm0, [R]3484movss xmm1, DWORD [R+8]3485movlhps xmm0, xmm13486movq xmm1, [C]3487movss xmm2, DWORD [C+8]3488movlhps xmm1, xmm23489movaps xmm2, xmm13490movaps xmm3, xmm13491shufps xmm1, xmm1, $00 // C.X (4x)3493shufps xmm2, xmm2, $55 // C.Y (4x)3494shufps xmm3, xmm3, $AA // C.Z (4x)3495mulps xmm1, xmm0 // R * C.X3497mulps xmm2, xmm0 // R * C.Y3498mulps xmm3, xmm0 // R * C.Z3499// Store as matrix3501movhlps xmm0, xmm13502movhlps xmm4, xmm23503movhlps xmm5, xmm33504movq [Result+$00], xmm13505movss DWORD [Result+$08], xmm03506movq [Result+$0C], xmm23507movss DWORD [Result+$14], xmm43508movq [Result+$18], xmm33509movss DWORD [Result+$20], xmm53510end;3511function OuterProduct(const C, R: TVector4): TMatrix4; assembler;3513asm3514movups xmm0, [R]3515movups xmm1, [C]3516movaps xmm2, xmm13517movaps xmm3, xmm13518movaps xmm4, xmm13519shufps xmm1, xmm1, $00 // C.X (4x)3521shufps xmm2, xmm2, $55 // C.Y (4x)3522shufps xmm3, xmm3, $AA // C.Z (4x)3523shufps xmm4, xmm4, $FF // C.W (4x)3524mulps xmm1, xmm0 // R * C.X3526mulps xmm2, xmm0 // R * C.Y3527mulps xmm3, xmm0 // R * C.Z3528mulps xmm4, xmm0 // R * C.W3529// Store as matrix3531movups DQWORD [Result + $00], xmm13532movups DQWORD [Result + $10], xmm23533movups DQWORD [Result + $20], xmm33534movups DQWORD [Result + $30], xmm43535end;3536{$ENDIF}3537{ TVector2 }3539class operator TVector2.Add(const A: TVector2; const B: Single): TVector2;3541begin3542Result.X := A.X + B;3543Result.Y := A.Y + B;3544end;3545class operator TVector2.Add(const A: Single; const B: TVector2): TVector2;3547begin3548Result.X := A + B.X;3549Result.Y := A + B.Y;3550end;3551class operator TVector2.Add(const A, B: TVector2): TVector2;3553begin3554Result.X := A.X + B.X;3555Result.Y := A.Y + B.Y;3556end;3557function TVector2.Distance(const AOther: TVector2): Single;3559begin3560Result := (Self - AOther).Length;3561end;3562function TVector2.DistanceSquared(const AOther: TVector2): Single;3564begin3565Result := (Self - AOther).LengthSquared;3566end;3567class operator TVector2.Divide(const A: TVector2; const B: Single): TVector2; assembler;3569asm3570{$IF RTLVersion >= 33}3571movlps xmm0, [A]3572{$ELSE}3573movq xmm0, A3574{$ENDIF}3575shufps xmm1, xmm1, 03576divps xmm0, xmm13577movq rax, xmm03578end;3579class operator TVector2.Divide(const A: Single; const B: TVector2): TVector2; assembler;3581asm3582{$IF RTLVersion >= 33}3583movlps xmm1, [B]3584{$ELSE}3585movq xmm1, B3586{$ENDIF}3587shufps xmm0, xmm0, 03588divps xmm0, xmm13589movq rax, xmm03590end;3591class operator TVector2.Divide(const A, B: TVector2): TVector2; assembler;3593asm3594{$IF RTLVersion >= 33}3595movlps xmm0, [A]3596movlps xmm1, [B]3597{$ELSE}3598movq xmm0, A3599movq xmm1, B3600{$ENDIF}3601divps xmm0, xmm13602movq rax, xmm03603end;3604function TVector2.Dot(const AOther: TVector2): Single;3606begin3607Result := (X * AOther.X) + (Y * AOther.Y);3608end;3609function TVector2.FaceForward(const I, NRef: TVector2): TVector2;3611begin3612if (NRef.Dot(I) < 0) then3613Result := Self3614else3615Result := -Self;3616end;3617function TVector2.GetLength: Single;3619begin3620Result := Sqrt((X * X) + (Y * Y));3621end;3622function TVector2.GetLengthSquared: Single;3624begin3625Result := (X * X) + (Y * Y);3626end;3627class operator TVector2.Multiply(const A: TVector2; const B: Single): TVector2;3629begin3630Result.X := A.X * B;3631Result.Y := A.Y * B;3632end;3633class operator TVector2.Multiply(const A: Single; const B: TVector2): TVector2;3635begin3636Result.X := A * B.X;3637Result.Y := A * B.Y;3638end;3639class operator TVector2.Multiply(const A, B: TVector2): TVector2;3641begin3642Result.X := A.X * B.X;3643Result.Y := A.Y * B.Y;3644end;3645function TVector2.NormalizeFast: TVector2; assembler;3647asm3648movlps xmm0, [Self] // Y X3649movaps xmm2, xmm03650mulps xmm0, xmm0 // Y*Y X*X3651pshufd xmm1, xmm0, $01 // X*X Y*Y3652addps xmm0, xmm1 // (X*X+Y*Y) (2x)3653rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y)) (4x)3654mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))3655movq rax, xmm03656end;3657function TVector2.Reflect(const N: TVector2): TVector2;3659begin3660Result := Self - ((2 * N.Dot(Self)) * N);3661end;3662function TVector2.Refract(const N: TVector2; const Eta: Single): TVector2;3664var3665D, K: Single;3666begin3667D := N.Dot(Self);3668K := 1 - Eta * Eta * (1 - D * D);3669if (K < 0) then3670Result.Init3671else3672Result := (Eta * Self) - ((Eta * D + Sqrt(K)) * N);3673end;3674procedure TVector2.SetNormalizedFast; assembler;3676asm3677movlps xmm0, [Self] // Y X3678movaps xmm2, xmm03679mulps xmm0, xmm0 // Y*Y X*X3680pshufd xmm1, xmm0, $01 // X*X Y*Y3681addps xmm0, xmm1 // (X*X+Y*Y) (2x)3682rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y)) (4x)3683mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))3684movlps [Self], xmm03685end;3686class operator TVector2.Subtract(const A: TVector2; const B: Single): TVector2;3688begin3689Result.X := A.X - B;3690Result.Y := A.Y - B;3691end;3692class operator TVector2.Subtract(const A: Single; const B: TVector2): TVector2;3694begin3695Result.X := A - B.X;3696Result.Y := A - B.Y;3697end;3698class operator TVector2.Subtract(const A, B: TVector2): TVector2;3700begin3701Result.X := A.X - B.X;3702Result.Y := A.Y - B.Y;3703end;3704{ TVector3 }3706class operator TVector3.Add(const A: TVector3; const B: Single): TVector3; assembler;3708asm3709movq xmm0, [A] // Load 3 floating-point values3710movss xmm1, DWORD [A+8]3711shufps xmm2, xmm2, 0 // Replicate B3712addps xmm0, xmm2 // A + B3713addss xmm1, xmm23714movq [Result], xmm0 // Store result3715movss DWORD [Result+8], xmm13716end;3717class operator TVector3.Add(const A: Single; const B: TVector3): TVector3; assembler;3719asm3720movq xmm0, [B]3721movss xmm2, DWORD [B+8]3722shufps xmm1, xmm1, 03723addps xmm0, xmm13724addss xmm2, xmm13725movq [Result], xmm03726movss DWORD [Result+8], xmm23727end;3728class operator TVector3.Add(const A, B: TVector3): TVector3; assembler;3730asm3731movq xmm0, [A]3732movss xmm1, DWORD [A+8]3733movq xmm2, [B]3734movss xmm3, DWORD [B+8]3735addps xmm0, xmm23736addss xmm1, xmm33737movq [Result], xmm03738movss DWORD [Result+8], xmm13739end;3740function TVector3.Distance(const AOther: TVector3): Single; assembler;3742asm3743movq xmm0, [Self]3744movss xmm1, DWORD [Self+8]3745movq xmm2, [AOther]3746movss xmm3, DWORD [AOther+8]3747movlhps xmm0, xmm13748movlhps xmm2, xmm33749subps xmm0, xmm2 // A - B3750// (A - B).Length3752mulps xmm0, xmm03753pshufd xmm1, xmm0, $0E3754addps xmm0, xmm13755pshufd xmm1, xmm0, $013756addss xmm0, xmm13757sqrtss xmm0, xmm03758end;3759function TVector3.DistanceSquared(const AOther: TVector3): Single; assembler;3761asm3762movq xmm0, [Self]3763movss xmm1, DWORD [Self+8]3764movq xmm2, [AOther]3765movss xmm3, DWORD [AOther+8]3766movlhps xmm0, xmm13767movlhps xmm2, xmm33768subps xmm0, xmm2 // A - B3769// (A - B).Length3771mulps xmm0, xmm03772pshufd xmm1, xmm0, $0E3773addps xmm0, xmm13774pshufd xmm1, xmm0, $013775addss xmm0, xmm13776end;3777class operator TVector3.Divide(const A: TVector3; const B: Single): TVector3;3779var3780InvB: Single;3781begin3782InvB := 1 / B;3783Result.X := A.X * InvB;3784Result.Y := A.Y * InvB;3785Result.Z := A.Z * InvB;3786end;3787{class operator TVector3.Divide(const A: TVector3; const B: Single): TVector3; assembler;3788asm3789movq xmm0, [A]3790movss xmm1, DWORD [A+8]3791shufps xmm2, xmm2, 03792divps xmm0, xmm23793divss xmm1, xmm23794movq [Result], xmm03795movss DWORD [Result+8], xmm13796end;}3797class operator TVector3.Divide(const A: Single; const B: TVector3): TVector3; assembler;3799asm3800movq xmm0, [B]3801movss xmm2, DWORD [B+8]3802movss xmm3, xmm13803shufps xmm1, xmm1, 03804divps xmm1, xmm03805divss xmm3, xmm23806movq [Result], xmm13807movss DWORD [Result+8], xmm33808end;3809class operator TVector3.Divide(const A, B: TVector3): TVector3; assembler;3811asm3812movq xmm0, [A]3813movss xmm1, DWORD [A+8]3814movq xmm2, [B]3815movss xmm3, DWORD [B+8]3816divps xmm0, xmm23817divss xmm1, xmm33818movq [Result], xmm03819movss DWORD [Result+8], xmm13820end;3821function TVector3.Cross(const AOther: TVector3): TVector3;3823begin3824Result.X := (Y * AOther.Z) - (AOther.Y * Z);3825Result.Y := (Z * AOther.X) - (AOther.Z * X);3826Result.Z := (X * AOther.Y) - (AOther.X * Y);3827end;3828function TVector3.Dot(const AOther: TVector3): Single;3830begin3831Result := (X * AOther.X) + (Y * AOther.Y) + (Z * AOther.Z);3832end;3833function TVector3.FaceForward(const I, NRef: TVector3): TVector3; assembler;3835begin3836if (NRef.Dot(I) < 0) then3837Result := Self3838else3839Result := -Self;3840end;3841function TVector3.GetLength: Single; assembler;3843asm3844movq xmm0, [Self] // 0 0 Y X3845movss xmm1, DWORD [Self+8] // 0 0 0 Z3846movlhps xmm0, xmm1 // 0 Z Y Z3847mulps xmm0, xmm0 // 0 Z*Z Y*Y X*X3848pshufd xmm1, xmm0, $0E // Y*Y X*X 0 Z*Z3849addps xmm0, xmm1 // # # (Y*Y) (X*X+Z*Z)3850pshufd xmm1, xmm0, $01 // (X*X+Z*Z) (X*X+Z*Z) (X*X+Z*Z) (Y*Y)3851addss xmm0, xmm1 // (X*X + Y*Y + Z*Z)3852sqrtss xmm0, xmm0 // Sqrt(X*X + Y*Y + Z*Z)3853end;3854function TVector3.GetLengthSquared: Single;3856begin3857Result := (X * X) + (Y * Y) + (Z * Z);3858end;3859{function TVector3.GetLengthSquared: Single; assembler;3860asm3861movq xmm0, [Self] // 0 0 Y X3862movss xmm1, DWORD [Self+8] // 0 0 0 Z3863movlhps xmm0, xmm1 // 0 Z Y Z3864mulps xmm0, xmm0 // 0 Z*Z Y*Y X*X3865pshufd xmm1, xmm0, $0E // Y*Y X*X 0 Z*Z3866addps xmm0, xmm1 // # # (Y*Y) (X*X+Z*Z)3867pshufd xmm1, xmm0, $01 // (X*X+Z*Z) (X*X+Z*Z) (X*X+Z*Z) (Y*Y)3868addss xmm0, xmm1 // (X*X + Y*Y + Z*Z)3869end;}3870class operator TVector3.Multiply(const A: TVector3; const B: Single): TVector3; assembler;3872asm3873movq xmm0, [A]3874movss xmm1, DWORD [A+8]3875shufps xmm2, xmm2, 03876mulps xmm0, xmm23877mulss xmm1, xmm23878movq [Result], xmm03879movss DWORD [Result+8], xmm13880end;3881class operator TVector3.Multiply(const A: Single; const B: TVector3): TVector3; assembler;3883asm3884movq xmm0, [B]3885movss xmm2, DWORD [B+8]3886shufps xmm1, xmm1, 03887mulps xmm0, xmm13888mulss xmm2, xmm13889movq [Result], xmm03890movss DWORD [Result+8], xmm23891end;3892class operator TVector3.Multiply(const A, B: TVector3): TVector3; assembler;3894asm3895movq xmm0, [A]3896movss xmm1, DWORD [A+8]3897movq xmm2, [B]3898movss xmm3, DWORD [B+8]3899mulps xmm0, xmm23900mulss xmm1, xmm33901movq [Result], xmm03902movss DWORD [Result+8], xmm13903end;3904class operator TVector3.Negative(const A: TVector3): TVector3;3906begin3907Result.X := -A.X;3908Result.Y := -A.Y;3909Result.Z := -A.Z;3910end;3911{class operator TVector3.Negative(const A: TVector3): TVector3; assembler;3912asm3913movups xmm0, [SSE_MASK_SIGN] // Load mask with 4 sign (upper) bits3914movq xmm1, [A]3915movss xmm2, DWORD [A+8]3916xorps xmm1, xmm0 // Flip sign bit3917xorps xmm2, xmm03918movq [Result], xmm13919movss DWORD [Result+8], xmm23920end;}3921function TVector3.NormalizeFast: TVector3; assembler;3923asm3924movq xmm0, [Self] // 0 0 Y X3925movss xmm1, DWORD [Self+8] // 0 0 0 Z3926movlhps xmm0, xmm1 // 0 Z Y Z3927movaps xmm2, xmm03928// Dot(A, A)3930mulps xmm0, xmm0 // 0 Z*Z Y*Y X*X3931pshufd xmm1, xmm0, $4E // Y*Y X*X 0 Z*Z3932addps xmm0, xmm1 // (Y*Y) (X*X+Z*Z) (Y*Y) (X*X+Z*Z)3933pshufd xmm1, xmm0, $11 // (X*X+Z*Z) (Y*Y) (X*X+Z*Z) (Y*Y)3934addps xmm0, xmm1 // (X*X + Y*Y + Z*Z) (4x)3935rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y + Z*Z)) (4x)3937mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))3938movhlps xmm1, xmm03939movq [Result], xmm03940movss DWORD [Result+8], xmm13941end;3942function TVector3.Reflect(const N: TVector3): TVector3; assembler;3944asm3945movq xmm0, [Self]3946movss xmm2, DWORD [Self+8]3947movq xmm1, [N]3948movss xmm3, DWORD [N+8]3949movlhps xmm0, xmm23950movlhps xmm1, xmm33951movaps xmm2, xmm03952movups xmm3, [SSE_TWO]3953// Dot(N, I)3955mulps xmm0, xmm13956mulps xmm3, xmm1 // N * 23957pshufd xmm1, xmm0, $4E3958addps xmm0, xmm13959pshufd xmm1, xmm0, $113960addps xmm0, xmm13961// (2 * Dot(N, I)) * N3963mulps xmm0, xmm33964// I - ((2 * Dot(N, I)) * N)3966subps xmm2, xmm03967movhlps xmm3, xmm23968movq [Result], xmm23969movss DWORD [Result+8], xmm33970end;3971function TVector3.Refract(const N: TVector3; const Eta: Single): TVector3; assembler;3973asm3974movdqa [rsp-24], xmm63975movdqa [rsp-40], xmm73976movq xmm0, [Self]3978movss xmm2, DWORD [Self+8]3979movq xmm1, [N]3980movss xmm4, DWORD [N+8]3981movlhps xmm0, xmm23982movlhps xmm1, xmm43983movups xmm7, xmm03984movss xmm2, DWORD [SSE_ONE]3985// D := Dot(N, I)3987mulps xmm0, xmm13988movss xmm4, xmm2 // 13989pshufd xmm1, xmm0, $4E3990movss xmm5, xmm3 // Eta3991addps xmm0, xmm13992mulss xmm5, xmm5 // Eta * Eta3993pshufd xmm1, xmm0, $113994addss xmm0, xmm13995// K := 1 - Eta * Eta * (1 - D * D)3997movss xmm6, xmm0 // D3998mulss xmm0, xmm0 // D * D3999subss xmm4, xmm0 // 1 - D * D4000mulss xmm4, xmm5 // Eta * Eta * (1 - D * D)4001xorps xmm5, xmm5 // 04002subss xmm2, xmm4 // K := 1 - Eta * Eta * (1 - D * D)4003// if (K < 0) then4005comiss xmm2, xmm54006jb @KLessThanZero4008// K >= 04010mulss xmm6, xmm3 // Eta * D4011shufps xmm3, xmm3, 0 // Replicate Eta (4x)4012mulps xmm7, xmm3 // Eta * I4013sqrtss xmm2, xmm2 // Sqrt(K)4014addss xmm6, xmm2 // Eta * D + Sqrt(K)4015shufps xmm6, xmm6, 0 // Replicate Eta * D + Sqrt(K) (4x)4016movups xmm1, [N]4017mulps xmm6, xmm1 // ((Eta * D + Sqrt(K)) * N)4018subps xmm7, xmm6 // (Eta * I) - ((Eta * D + Sqrt(K)) * N)4019movhlps xmm0, xmm74020movq [Result], xmm74021movss DWORD [Result+8], xmm04022jmp @Finish4023@KLessThanZero:4025// K < 0: Result := Vector4(0, 0, 0, 0)4026movlhps xmm6, xmm54027movq [Result], xmm54028movss DWORD [Result+8], xmm64029@Finish:4031movdqa xmm6, [rsp-24]4032movdqa xmm7, [rsp-40]4033end;4034procedure TVector3.SetNormalizedFast; assembler;4036asm4037movq xmm0, [Self] // 0 0 Y X4038movss xmm1, DWORD [Self+8] // 0 0 0 Z4039movlhps xmm0, xmm1 // 0 Z Y Z4040movaps xmm2, xmm04041// Dot(A, A)4043mulps xmm0, xmm0 // 0 Z*Z Y*Y X*X4044pshufd xmm1, xmm0, $4E // Y*Y X*X 0 Z*Z4045addps xmm0, xmm1 // (Y*Y) (X*X+Z*Z) (Y*Y) (X*X+Z*Z)4046pshufd xmm1, xmm0, $11 // (X*X+Z*Z) (Y*Y) (X*X+Z*Z) (Y*Y)4047addps xmm0, xmm1 // (X*X + Y*Y + Z*Z) (4x)4048rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y + Z*Z)) (4x)4050mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))4051movhlps xmm1, xmm04052movq [Self], xmm04053movss DWORD [Self+8], xmm14054end;4055class operator TVector3.Subtract(const A: TVector3; const B: Single): TVector3; assembler;4057asm4058movq xmm0, [A]4059movss xmm1, DWORD [A+8]4060shufps xmm2, xmm2, 04061subps xmm0, xmm24062subss xmm1, xmm24063movq [Result], xmm04064movss DWORD [Result+8], xmm14065end;4066class operator TVector3.Subtract(const A: Single; const B: TVector3): TVector3; assembler;4068asm4069movq xmm4, [B]4070movss xmm2, DWORD [B+8]4071movss xmm3, xmm14072shufps xmm1, xmm1, 04073subps xmm1, xmm44074subss xmm3, xmm24075movq [Result], xmm14076movss DWORD [Result+8], xmm34077end;4078class operator TVector3.Subtract(const A, B: TVector3): TVector3; assembler;4080asm4081movq xmm0, [A]4082movss xmm1, DWORD [A+8]4083movq xmm2, [B]4084movss xmm3, DWORD [B+8]4085subps xmm0, xmm24086subss xmm1, xmm34087movq [Result], xmm04088movss DWORD [Result+8], xmm14089end;4090{ TVector4 }4092class operator TVector4.Add(const A: TVector4; const B: Single): TVector4; assembler;4094asm4095movups xmm0, [A] // Load 4 floating-point values4096shufps xmm2, xmm2, 0 // Replicate B4097addps xmm0, xmm2 // A + B4098movups [Result], xmm0 // Store result4099end;4100class operator TVector4.Add(const A: Single; const B: TVector4): TVector4; assembler;4102asm4103movups xmm0, [B]4104shufps xmm1, xmm1, 04105addps xmm0, xmm14106movups [Result], xmm04107end;4108class operator TVector4.Add(const A, B: TVector4): TVector4; assembler;4110asm4111movups xmm0, [A]4112movups xmm1, [B]4113addps xmm0, xmm14114movups [Result], xmm04115end;4116function TVector4.Distance(const AOther: TVector4): Single; assembler;4118asm4119movups xmm0, [Self]4120movups xmm1, [AOther]4121subps xmm0, xmm1 // A - B4122// (A - B).Length4124mulps xmm0, xmm04125pshufd xmm1, xmm0, $0E4126addps xmm0, xmm14127pshufd xmm1, xmm0, $014128addss xmm0, xmm14129sqrtss xmm0, xmm04130end;4131function TVector4.DistanceSquared(const AOther: TVector4): Single; assembler;4133asm4134movups xmm0, [Self]4135movups xmm1, [AOther]4136subps xmm0, xmm1 // A - B4137// (A - B).LengthSquared4139mulps xmm0, xmm04140pshufd xmm1, xmm0, $0E4141addps xmm0, xmm14142pshufd xmm1, xmm0, $014143addss xmm0, xmm14144end;4145class operator TVector4.Divide(const A: TVector4; const B: Single): TVector4; assembler;4147asm4148movups xmm0, [A]4149shufps xmm2, xmm2, 04150divps xmm0, xmm24151movups [Result], xmm04152end;4153class operator TVector4.Divide(const A: Single; const B: TVector4): TVector4; assembler;4155asm4156movups xmm0, [B]4157shufps xmm1, xmm1, 04158divps xmm1, xmm04159movups [Result], xmm14160end;4161class operator TVector4.Divide(const A, B: TVector4): TVector4; assembler;4163asm4164movups xmm0, [A]4165movups xmm1, [B]4166divps xmm0, xmm14167movups [Result], xmm04168end;4169function TVector4.Dot(const AOther: TVector4): Single;4171begin4172Result := (X * AOther.X) + (Y * AOther.Y) + (Z * AOther.Z) + (W * AOther.W);4173end;4174function TVector4.FaceForward(const I, NRef: TVector4): TVector4; assembler;4176asm4177movups xmm0, [Self]4178movups xmm1, [I]4179movups xmm2, [NRef]4180xorps xmm3, xmm3 // 04181movups xmm4, [SSE_MASK_SIGN]4182// Dot(NRef, I)4184mulps xmm2, xmm14185pshufd xmm1, xmm2, $4E4186addps xmm2, xmm14187pshufd xmm1, xmm2, $114188addps xmm2, xmm14189// Dot(NRef, I) >= 0? Yes: $FFFFFFFF, No: $000000004191cmpnltps xmm2, xmm34192andps xmm2, xmm4 // Yes: $80000000, No: $000000004193// Flip sign of N if (Dot(NRef, I) >= 0)4195xorps xmm0, xmm24196movups [Result], xmm04197end;4198function TVector4.GetLength: Single; assembler;4200asm4201movups xmm0, [Self] // W Z Y X4202mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4203pshufd xmm1, xmm0, $0E // Y*Y X*X W*W Z*Z4204addps xmm0, xmm1 // # # (Y*Y+W*W) (X*X+Z*Z)4205pshufd xmm1, xmm0, $01 // (X*X+Z*Z) (X*X+Z*Z) (X*X+Z*Z) (Y*Y+W*W)4206addss xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W)4207sqrtss xmm0, xmm0 // Sqrt(X*X + Y*Y + Z*Z + W*W)4208end;4209function TVector4.GetLengthSquared: Single;4211begin4212Result := (X * X) + (Y * Y) + (Z * Z) + (W * W);4213end;4214{function TVector4.GetLengthSquared: Single; assembler;4215asm4216movups xmm0, [Self] // W Z Y X4217mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4218pshufd xmm1, xmm0, $0E // Y*Y X*X W*W Z*Z4219addps xmm0, xmm1 // # # (Y*Y+W*W) (X*X+Z*Z)4220pshufd xmm1, xmm0, $01 // (X*X+Z*Z) (X*X+Z*Z) (X*X+Z*Z) (Y*Y+W*W)4221addss xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W)4222end;}4223class operator TVector4.Multiply(const A: TVector4; const B: Single): TVector4; assembler;4225asm4226movups xmm0, [A]4227shufps xmm2, xmm2, 04228mulps xmm0, xmm24229movups [Result], xmm04230end;4231class operator TVector4.Multiply(const A: Single; const B: TVector4): TVector4; assembler;4233asm4234movups xmm0, [B]4235shufps xmm1, xmm1, 04236mulps xmm1, xmm04237movups [Result], xmm14238end;4239class operator TVector4.Multiply(const A, B: TVector4): TVector4; assembler;4241asm4242movups xmm0, [A]4243movups xmm1, [B]4244mulps xmm0, xmm14245movups [Result], xmm04246end;4247class operator TVector4.Negative(const A: TVector4): TVector4; assembler;4249asm4250movups xmm0, [SSE_MASK_SIGN] // Load mask with 4 sign (upper) bits4251movups xmm1, [A]4252xorps xmm0, xmm1 // Flip sign bit4253movups [Result], xmm04254end;4255function TVector4.NormalizeFast: TVector4;4257asm4258movups xmm0, [Self] // W Z Y X4259movaps xmm2, xmm04260// Dot(A, A)4262mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4263pshufd xmm1, xmm0, $4E // Y*Y X*X W*W Z*Z4264addps xmm0, xmm1 // (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z)4265pshufd xmm1, xmm0, $11 // (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W)4266addps xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W) (4x)4267rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y + Z*Z + W*W)) (4x)4269mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))4270movups [Result], xmm04271end;4272function TVector4.Reflect(const N: TVector4): TVector4; assembler;4274asm4275movups xmm0, [Self]4276movups xmm1, [N]4277movaps xmm2, xmm04278movups xmm3, [SSE_TWO]4279// Dot(N, I)4281mulps xmm0, xmm14282mulps xmm3, xmm1 // N * 24283pshufd xmm1, xmm0, $4E4284addps xmm0, xmm14285pshufd xmm1, xmm0, $114286addps xmm0, xmm14287// (2 * Dot(N, I)) * N4289mulps xmm0, xmm34290// I - ((2 * Dot(N, I)) * N)4292subps xmm2, xmm04293movups [Result], xmm24294end;4295function TVector4.Refract(const N: TVector4; const Eta: Single): TVector4; assembler;4297asm4298movdqa [rsp-24], xmm64299movdqa [rsp-40], xmm74300movups xmm0, [Self]4302movups xmm1, [N]4303movups xmm7, xmm04304movss xmm2, DWORD [SSE_ONE]4305// D := Dot(N, I)4307mulps xmm0, xmm14308movss xmm4, xmm2 // 14309pshufd xmm1, xmm0, $4E4310movss xmm5, xmm3 // Eta4311addps xmm0, xmm14312mulss xmm5, xmm5 // Eta * Eta4313pshufd xmm1, xmm0, $114314addss xmm0, xmm14315// K := 1 - Eta * Eta * (1 - D * D)4317movss xmm6, xmm0 // D4318mulss xmm0, xmm0 // D * D4319subss xmm4, xmm0 // 1 - D * D4320mulss xmm4, xmm5 // Eta * Eta * (1 - D * D)4321xorps xmm5, xmm5 // 04322subss xmm2, xmm4 // K := 1 - Eta * Eta * (1 - D * D)4323// if (K < 0) then4325comiss xmm2, xmm54326jb @KLessThanZero4328// K >= 04330mulss xmm6, xmm3 // Eta * D4331shufps xmm3, xmm3, 0 // Replicate Eta (4x)4332mulps xmm7, xmm3 // Eta * I4333sqrtss xmm2, xmm2 // Sqrt(K)4334addss xmm6, xmm2 // Eta * D + Sqrt(K)4335shufps xmm6, xmm6, 0 // Replicate Eta * D + Sqrt(K) (4x)4336movups xmm1, [N]4337mulps xmm6, xmm1 // ((Eta * D + Sqrt(K)) * N)4338subps xmm7, xmm6 // (Eta * I) - ((Eta * D + Sqrt(K)) * N)4339movups [Result], xmm74340jmp @Finish4341@KLessThanZero:4343// K < 0: Result := Vector4(0, 0, 0, 0)4344movups [Result], xmm54345@Finish:4347movdqa xmm6, [rsp-24]4348movdqa xmm7, [rsp-40]4349end;4350procedure TVector4.SetNormalizedFast; assembler;4352asm4353movups xmm0, [Self] // W Z Y X4354movaps xmm2, xmm04355// Dot(A, A)4357mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4358pshufd xmm1, xmm0, $4E // Y*Y X*X W*W Z*Z4359addps xmm0, xmm1 // (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z)4360pshufd xmm1, xmm0, $11 // (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W)4361addps xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W) (4x)4362rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y + Z*Z + W*W)) (4x)4364mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))4365movups [Self], xmm04366end;4367class operator TVector4.Subtract(const A: TVector4; const B: Single): TVector4; assembler;4369asm4370movups xmm0, [A]4371shufps xmm2, xmm2, 04372subps xmm0, xmm24373movups [Result], xmm04374end;4375class operator TVector4.Subtract(const A: Single; const B: TVector4): TVector4; assembler;4377asm4378movups xmm0, [B]4379shufps xmm1, xmm1, 04380subps xmm1, xmm04381movups [Result], xmm14382end;4383class operator TVector4.Subtract(const A, B: TVector4): TVector4; assembler;4385asm4386movups xmm0, [A]4387movups xmm1, [B]4388subps xmm0, xmm14389movups [Result], xmm04390end;4391{ TQuaternion }4393class operator TQuaternion.Add(const A, B: TQuaternion): TQuaternion;4395asm4396movups xmm0, [A]4397movups xmm1, [B]4398addps xmm0, xmm14399movups [Result], xmm04400end;4401function TQuaternion.GetLength: Single;4403asm4404movups xmm0, [Self] // W Z Y X4405mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4406pshufd xmm1, xmm0, $0E // Y*Y X*X W*W Z*Z4407addps xmm0, xmm1 // # # (Y*Y+W*W) (X*X+Z*Z)4408pshufd xmm1, xmm0, $01 // (X*X+Z*Z) (X*X+Z*Z) (X*X+Z*Z) (Y*Y+W*W)4409addss xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W)4410sqrtss xmm0, xmm0 // Sqrt(X*X + Y*Y + Z*Z + W*W)4411end;4412function TQuaternion.GetLengthSquared: Single;4414asm4415movups xmm0, [Self] // W Z Y X4416mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4417pshufd xmm1, xmm0, $0E // Y*Y X*X W*W Z*Z4418addps xmm0, xmm1 // # # (Y*Y+W*W) (X*X+Z*Z)4419pshufd xmm1, xmm0, $01 // (X*X+Z*Z) (X*X+Z*Z) (X*X+Z*Z) (Y*Y+W*W)4420addss xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W)4421end;4422class operator TQuaternion.Multiply(const A: TQuaternion; const B: Single): TQuaternion;4424asm4425movups xmm0, [A]4426shufps xmm2, xmm2, 04427mulps xmm0, xmm24428movups [Result], xmm04429end;4430class operator TQuaternion.Multiply(const A: Single; const B: TQuaternion): TQuaternion;4432asm4433movups xmm0, [B]4434shufps xmm1, xmm1, 04435mulps xmm1, xmm04436movups [Result], xmm14437end;4438class operator TQuaternion.Multiply(const A, B: TQuaternion): TQuaternion;4440begin4441Result.X := (A.W * B.X) + (A.X * B.W) + (A.Y * B.Z) - (A.Z * B.Y);4442Result.Y := (A.W * B.Y) + (A.Y * B.W) + (A.Z * B.X) - (A.X * B.Z);4443Result.Z := (A.W * B.Z) + (A.Z * B.W) + (A.X * B.Y) - (A.Y * B.X);4444Result.W := (A.W * B.W) - (A.X * B.X) - (A.Y * B.Y) - (A.Z * B.Z);4445end;4446function TQuaternion.NormalizeFast: TQuaternion;4448asm4449movups xmm0, [Self] // W Z Y X4450movaps xmm2, xmm04451// Dot(A, A)4453mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4454pshufd xmm1, xmm0, $4E // Y*Y X*X W*W Z*Z4455addps xmm0, xmm1 // (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z)4456pshufd xmm1, xmm0, $11 // (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W)4457addps xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W) (4x)4458rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y + Z*Z + W*W)) (4x)4460mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))4461movups [Result], xmm04462end;4463procedure TQuaternion.SetNormalizedFast;4465asm4466movups xmm0, [Self] // W Z Y X4467movaps xmm2, xmm04468// Dot(A, A)4470mulps xmm0, xmm0 // W*W Z*Z Y*Y X*X4471pshufd xmm1, xmm0, $4E // Y*Y X*X W*W Z*Z4472addps xmm0, xmm1 // (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z)4473pshufd xmm1, xmm0, $11 // (X*X+Z*Z) (Y*Y+W*W) (X*X+Z*Z) (Y*Y+W*W)4474addps xmm0, xmm1 // (X*X + Y*Y + Z*Z + W*W) (4x)4475rsqrtps xmm0, xmm0 // (1 / Sqrt(X*X + Y*Y + Z*Z + W*W)) (4x)4477mulps xmm0, xmm2 // A * (1 / Sqrt(Dot(A, A)))4478movups [Self], xmm04479end;4480{ TMatrix 2 }4482class operator TMatrix2.Add(const A: TMatrix2; const B: Single): TMatrix2; assembler;4484asm4485movups xmm1, [A] // Load matrix4486shufps xmm2, xmm2, 0 // Replicate B4487addps xmm1, xmm2 // Add B4488movups [Result], xmm14489end;4490class operator TMatrix2.Add(const A: Single; const B: TMatrix2): TMatrix2; assembler;4492asm4493movups xmm0, [B] // Load matrix4494shufps xmm1, xmm1, 0 // Replicate A4495addps xmm0, xmm1 // Add A4496movups [Result], xmm04497end;4498class operator TMatrix2.Add(const A, B: TMatrix2): TMatrix2; assembler;4500asm4501movups xmm0, [A] // Load A4502movups xmm1, [B] // Load B4503addps xmm0, xmm1 // Add4504movups [Result], xmm04505end;4506function TMatrix2.CompMult(const AOther: TMatrix2): TMatrix2; assembler;4508asm4509movups xmm0, [Self]4510movups xmm1, [AOther]4511// Component-wise multiplication4513mulps xmm0, xmm14514// Store result4516movups [Result], xmm04517end;4518class operator TMatrix2.Divide(const A: TMatrix2; const B: Single): TMatrix2; assembler;4520asm4521movups xmm1, [A] // Load matrix4522shufps xmm2, xmm2, 0 // Replicate B4523divps xmm1, xmm2 // Divide B4524movups [Result], xmm14525end;4526class operator TMatrix2.Divide(const A: Single; const B: TMatrix2): TMatrix2; assembler;4528asm4529movups xmm0, [B] // Load matrix4530shufps xmm1, xmm1, 0 // Replicate A4531divps xmm1, xmm0 // Divide B4532movups [Result], xmm14533end;4534class operator TMatrix2.Multiply(const A: TMatrix2; const B: Single): TMatrix2; assembler;4536asm4537movups xmm1, [A] // Load matrix4538shufps xmm2, xmm2, 0 // Replicate B4539mulps xmm1, xmm2 // Multiply4540movups [Result], xmm14541end;4542class operator TMatrix2.Multiply(const A: Single; const B: TMatrix2): TMatrix2; assembler;4544asm4545movups xmm0, [B] // Load matrix4546shufps xmm1, xmm1, 0 // Replicate A4547mulps xmm0, xmm1 // Multiply4548movups [Result], xmm04549end;4550class operator TMatrix2.Multiply(const A: TVector2; const B: TMatrix2): TVector2;4552begin4553Result.X := (A.X * B.M[0,0]) + (A.Y * B.M[0,1]);4554Result.Y := (A.X * B.M[1,0]) + (A.Y * B.M[1,1]);4555end;4556class operator TMatrix2.Multiply(const A: TMatrix2; const B: TVector2): TVector2;4558begin4559Result.X := (A.M[0,0] * B.X) + (A.M[1,0] * B.Y);4560Result.Y := (A.M[0,1] * B.X) + (A.M[1,1] * B.Y);4561end;4562class operator TMatrix2.Multiply(const A, B: TMatrix2): TMatrix2;4564begin4565Result.M[0,0] := (A.M[0,0] * B.M[0,0]) + (A.M[1,0] * B.M[0,1]);4566Result.M[0,1] := (A.M[0,1] * B.M[0,0]) + (A.M[1,1] * B.M[0,1]);4567Result.M[1,0] := (A.M[0,0] * B.M[1,0]) + (A.M[1,0] * B.M[1,1]);4568Result.M[1,1] := (A.M[0,1] * B.M[1,0]) + (A.M[1,1] * B.M[1,1]);4569end;4570class operator TMatrix2.Negative(const A: TMatrix2): TMatrix2; assembler;4572asm4573movups xmm0, [SSE_MASK_SIGN] // Load mask with 4 sign (upper) bits4574movups xmm1, [A] // Load matrix4575xorps xmm1, xmm0 // Flip sign bits4576movups [Result], xmm14577end;4578procedure TMatrix2.SetTransposed;4580begin4581Self := Transpose;4582end;4583class operator TMatrix2.Subtract(const A: TMatrix2; const B: Single): TMatrix2; assembler;4585asm4586movups xmm1, [A] // Load matrix4587shufps xmm2, xmm2, 0 // Replicate B4588subps xmm1, xmm2 // Subtract B4589movups [Result], xmm14590end;4591class operator TMatrix2.Subtract(const A: Single; const B: TMatrix2): TMatrix2; assembler;4593asm4594movups xmm0, [B] // Load matrix4595shufps xmm1, xmm1, 0 // Replicate A4596subps xmm1, xmm0 // Subtract B4597movups [Result], xmm14598end;4599class operator TMatrix2.Subtract(const A, B: TMatrix2): TMatrix2; assembler;4601asm4602movups xmm0, [A] // Load A4603movups xmm1, [B] // Load B4604subps xmm0, xmm1 // Subtract4605movups [Result], xmm04606end;4607function TMatrix2.Transpose: TMatrix2;4609begin4610Result.M[0,0] := M[0,0];4611Result.M[0,1] := M[1,0];4612Result.M[1,0] := M[0,1];4614Result.M[1,1] := M[1,1];4615end;4616{ TMatrix3 }4618class operator TMatrix3.Add(const A: TMatrix3; const B: Single): TMatrix3; assembler;4620asm4621movups xmm1, DQWORD [A + $00] // Load 3 rows4622shufps xmm2, xmm2, 0 // Replicate B4623movups xmm3, DQWORD [A + $10]4624movss xmm4, DWORD [A + $20]4625addps xmm1, xmm2 // Add B to each row4626addps xmm3, xmm24627addss xmm4, xmm24628movups DQWORD [Result + $00], xmm14629movups DQWORD [Result + $10], xmm34630movss DWORD [Result + $20], xmm44631end;4632class operator TMatrix3.Add(const A: Single; const B: TMatrix3): TMatrix3; assembler;4634asm4635movups xmm0, DQWORD [B + $00] // Load 3 rows4636shufps xmm1, xmm1, 0 // Replicate A4637movups xmm2, DQWORD [B + $10]4638movss xmm3, DWORD [B + $20]4639addps xmm0, xmm1 // Add A to each row4640addps xmm2, xmm14641addss xmm3, xmm14642movups DQWORD [Result + $00], xmm04643movups DQWORD [Result + $10], xmm24644movss DWORD [Result + $20], xmm34645end;4646class operator TMatrix3.Add(const A, B: TMatrix3): TMatrix3; assembler;4648asm4649movups xmm0, DQWORD [A + $00] // Load 3 rows of A4650movups xmm1, DQWORD [A + $10]4651movss xmm2, DWORD [A + $20]4652movups xmm4, DQWORD [B + $00] // Load 3 rows of B4653movups xmm5, DQWORD [B + $10]4654movss xmm3, DWORD [B + $20]4655addps xmm0, xmm4 // Add rows4656addps xmm1, xmm54657addss xmm2, xmm34658movups DQWORD [Result + $00], xmm04659movups DQWORD [Result + $10], xmm14660movss DWORD [Result + $20], xmm24661end;4662function TMatrix3.CompMult(const AOther: TMatrix3): TMatrix3; assembler;4664asm4665movups xmm0, DQWORD[Self + $00] // Self[0]4666movups xmm1, DQWORD[Self + $10] // Self[1]4667movss xmm2, DWORD[Self + $20] // Self[2]4668movups xmm4, DQWORD[AOther + $00] // AOther[0]4669movups xmm5, DQWORD[AOther + $10] // AOther[1]4670movss xmm3, DWORD[AOther + $20] // AOther[2]4671// Component-wise multiplication4673mulps xmm0, xmm44674mulps xmm1, xmm54675mulss xmm2, xmm34676// Store result4678movups DQWORD [Result + $00], xmm04679movups DQWORD [Result + $10], xmm14680movss DWORD [Result + $20], xmm24681end;4682class operator TMatrix3.Divide(const A: Single; const B: TMatrix3): TMatrix3; assembler;4684asm4685movups xmm4, DQWORD [B + $00] // Load 3 rows4686shufps xmm1, xmm1, 0 // Replicate A4687movups xmm5, DQWORD [B + $10]4688movaps xmm0, xmm14689movaps xmm2, xmm14690movss xmm3, DWORD [B + $20]4691divps xmm1, xmm4 // Divide A by each row4692divps xmm0, xmm54693divss xmm2, xmm34694movups DQWORD [Result + $00], xmm14695movups DQWORD [Result + $10], xmm04696movss DWORD [Result + $20], xmm24697end;4698class operator TMatrix3.Divide(const A: TMatrix3; const B: Single): TMatrix3; assembler;4700asm4701movups xmm1, DQWORD [A + $00] // Load 3 rows4702shufps xmm2, xmm2, 0 // Replicate B4703movups xmm0, DQWORD [A + $10]4704movss xmm3, DWORD [A + $20]4705divps xmm1, xmm2 // Divide each row by B4706divps xmm0, xmm24707divss xmm3, xmm24708movups DQWORD [Result + $00], xmm14709movups DQWORD [Result + $10], xmm04710movss DWORD [Result + $20], xmm34711end;4712class operator TMatrix3.Multiply(const A: Single; const B: TMatrix3): TMatrix3; assembler;4714asm4715movups xmm0, DQWORD [B + $00] // Load 3 rows4716shufps xmm1, xmm1, 0 // Replicate A4717movups xmm2, DQWORD [B + $10]4718movss xmm3, DWORD [B + $20]4719mulps xmm0, xmm1 // Multiply each row by A4720mulps xmm2, xmm14721mulss xmm3, xmm14722movups DQWORD [Result + $00], xmm04723movups DQWORD [Result + $10], xmm24724movss DWORD [Result + $20], xmm34725end;4726class operator TMatrix3.Multiply(const A: TMatrix3; const B: Single): TMatrix3; assembler;4728asm4729movups xmm1, DQWORD [A + $00] // Load 3 rows4730shufps xmm2, xmm2, 0 // Replicate B4731movups xmm0, DQWORD [A + $10]4732movss xmm3, DWORD [A + $20]4733mulps xmm1, xmm2 // Multiply each row by B4734mulps xmm0, xmm24735mulss xmm3, xmm24736movups DQWORD [Result + $00], xmm14737movups DQWORD [Result + $10], xmm04738movss DWORD [Result + $20], xmm34739end;4740{$IFDEF FM_COLUMN_MAJOR}4742class operator TMatrix3.Multiply(const A: TMatrix3; const B: TVector3): TVector3; assembler;4743asm4744movdqa [rsp-24], xmm64745movq xmm0, [B]4747movss xmm1, DWORD [B+8]4748movlhps xmm0, xmm14749movq xmm4, QWORD [A + $00]4751movss xmm1, DWORD [A + $08]4752movlhps xmm4, xmm14753movaps xmm1, xmm04755movaps xmm2, xmm04756shufps xmm0, xmm0, $004757shufps xmm1, xmm1, $554758shufps xmm2, xmm2, $AA4759movq xmm5, QWORD [A + $0C]4761movss xmm3, DWORD [A + $14]4762movlhps xmm5, xmm34763movq xmm6, QWORD [A + $18]4765movss xmm3, DWORD [A + $20]4766movlhps xmm6, xmm34767mulps xmm0, xmm44769mulps xmm1, xmm54770mulps xmm2, xmm64771addps xmm0, xmm14772addps xmm0, xmm24773movhlps xmm1, xmm04774movq [Result], xmm04775movss DWORD [Result+8], xmm14776movdqa xmm6, [rsp-24]4778end;4779class operator TMatrix3.Multiply(const A: TVector3; const B: TMatrix3): TVector3; assembler;4781asm4782movdqa [rsp-24], xmm64783movq xmm0, [A]4785movss xmm1, DWORD [A+8]4786movlhps xmm0, xmm14787movq xmm4, QWORD [B + $00]4789movss xmm1, DWORD [B + $08]4790movlhps xmm4, xmm14791movaps xmm1, xmm04793movaps xmm2, xmm04794movq xmm5, QWORD [B + $0C]4796movss xmm6, DWORD [B + $14]4797movlhps xmm5, xmm64798movq xmm6, QWORD [B + $18]4800movss xmm3, DWORD [B + $20]4801movlhps xmm6, xmm34802mulps xmm0, xmm44804mulps xmm1, xmm54805mulps xmm2, xmm64806xorps xmm3, xmm34807{ Transpose xmm0-xmm2 }4809movaps xmm4, xmm24810unpcklps xmm2, xmm34811unpckhps xmm4, xmm34812movaps xmm3, xmm04814unpcklps xmm0, xmm14815unpckhps xmm3, xmm14816movaps xmm1, xmm04818unpcklpd xmm0, xmm24819unpckhpd xmm1, xmm24820unpcklpd xmm3, xmm44822addps xmm0, xmm14824addps xmm0, xmm34825movhlps xmm1, xmm04826movq [Result], xmm04827movss DWORD [Result+8], xmm14828movdqa xmm6, [rsp-24]4830end;4831class operator TMatrix3.Multiply(const A, B: TMatrix3): TMatrix3; assembler;4833{ Code below consists of 3 Vector*Matrix calculations }4834asm4835movdqa [rsp-24], xmm64836movq xmm0, QWORD [B + $00]4838movss xmm1, DWORD [B + $08]4839movlhps xmm0, xmm14840movq xmm4, QWORD [A + $00]4842movss xmm1, DWORD [A + $08]4843movlhps xmm4, xmm14844movaps xmm1, xmm04846movaps xmm2, xmm04847shufps xmm0, xmm0, $004848shufps xmm1, xmm1, $554849shufps xmm2, xmm2, $AA4850movq xmm5, QWORD [A + $0C]4852movss xmm3, DWORD [A + $14]4853movlhps xmm5, xmm34854movq xmm6, QWORD [A + $18]4856movss xmm3, DWORD [A + $20]4857movlhps xmm6, xmm34858mulps xmm0, xmm44860mulps xmm1, xmm54861mulps xmm2, xmm64862addps xmm0, xmm14863addps xmm0, xmm24864movhlps xmm1, xmm04865movq QWORD [Result + $00], xmm04866movss DWORD [Result + $08], xmm14867movq xmm0, QWORD [B + $0C]4869movss xmm1, DWORD [B + $14]4870movlhps xmm0, xmm14871movaps xmm1, xmm04873movaps xmm2, xmm04874shufps xmm0, xmm0, $004875shufps xmm1, xmm1, $554876shufps xmm2, xmm2, $AA4877mulps xmm0, xmm44878mulps xmm1, xmm54879mulps xmm2, xmm64880addps xmm0, xmm14881addps xmm0, xmm24882movhlps xmm1, xmm04883movq QWORD [Result + $0C], xmm04884movss DWORD [Result + $14], xmm14885movq xmm0, QWORD [B + $18]4887movss xmm1, DWORD [B + $20]4888movlhps xmm0, xmm14889movaps xmm1, xmm04891movaps xmm2, xmm04892shufps xmm0, xmm0, $004893shufps xmm1, xmm1, $554894shufps xmm2, xmm2, $AA4895mulps xmm0, xmm44896mulps xmm1, xmm54897mulps xmm2, xmm64898addps xmm0, xmm14899addps xmm0, xmm24900movhlps xmm1, xmm04901movq QWORD [Result + $18], xmm04902movss DWORD [Result + $20], xmm14903movdqa xmm6, [rsp-24]4905end;4906{$ELSE}4907class operator TMatrix3.Multiply(const A: TMatrix3; const B: TVector3): TVector3; assembler;4908asm4909movdqa [rsp-24], xmm64910movq xmm0, [B] // Load vector4912movss xmm1, DWORD [B+8]4913movlhps xmm0, xmm14914movq xmm4, QWORD [A + $00] // Load 3 rows4916movss xmm1, DWORD [A + $08]4917movlhps xmm4, xmm14918movaps xmm1, xmm04920movaps xmm2, xmm04921movq xmm5, QWORD [A + $0C]4923movss xmm6, DWORD [A + $14]4924movlhps xmm5, xmm64925movq xmm6, QWORD [A + $18]4927movss xmm3, DWORD [A + $20]4928movlhps xmm6, xmm34929mulps xmm0, xmm4 // ###, (Az * B02), (Ay * B01), (Ax * B00)4931mulps xmm1, xmm5 // ###, (Az * B12), (Ay * B11), (Ax * B10)4932mulps xmm2, xmm6 // ###, (Az * B22), (Ay * B21), (Ax * B20)4933xorps xmm3, xmm3 // 0004934{ Transpose xmm0-xmm2 }4936movaps xmm4, xmm24937unpcklps xmm2, xmm3 // 000 B21 000 B204938unpckhps xmm4, xmm3 // 000 ### 000 B224939movaps xmm3, xmm04941unpcklps xmm0, xmm1 // B11 B01 B10 B004942unpckhps xmm3, xmm1 // ### ### B12 B024943movaps xmm1, xmm04945unpcklpd xmm0, xmm2 // 000 B20 B10 B004946unpckhpd xmm1, xmm2 // 000 B21 B11 B014947unpcklpd xmm3, xmm4 // 000 B22 B12 B024949addps xmm0, xmm1 // Add rows4951addps xmm0, xmm34952movhlps xmm1, xmm04953movq [Result], xmm04954movss DWORD [Result+8], xmm14955movdqa xmm6, [rsp-24]4957end;4958class operator TMatrix3.Multiply(const A: TVector3; const B: TMatrix3): TVector3; assembler;4960asm4961movdqa [rsp-24], xmm64962movq xmm0, [A] // Load vector4964movss xmm1, DWORD [A+8]4965movlhps xmm0, xmm14966movq xmm4, QWORD [B + $00] // Load 3 rows4968movss xmm1, DWORD [B + $08]4969movlhps xmm4, xmm14970movaps xmm1, xmm04972movaps xmm2, xmm04973shufps xmm0, xmm0, $00 // Bx Bx Bx Bx4974shufps xmm1, xmm1, $55 // By By By By4975shufps xmm2, xmm2, $AA // Bz Bz Bz Bz4976movq xmm5, QWORD [B + $0C]4978movss xmm3, DWORD [B + $14]4979movlhps xmm5, xmm34980movq xmm6, QWORD [B + $18]4982movss xmm3, DWORD [B + $20]4983movlhps xmm6, xmm34984mulps xmm0, xmm4 // (A00 * Bx), (A01 * Bx), (A02 * Bx), #4986mulps xmm1, xmm5 // (A10 * By), (A11 * By), (A12 * By), #4987mulps xmm2, xmm6 // (A20 * Bz), (A21 * Bz), (A22 * Bz), #4988addps xmm0, xmm1 // Add rows4989addps xmm0, xmm24990movhlps xmm1, xmm04991movq [Result], xmm04992movss DWORD [Result+8], xmm14993movdqa xmm6, [rsp-24]4995end;4996class operator TMatrix3.Multiply(const A, B: TMatrix3): TMatrix3; assembler;4998{ Code below consists of 3 Vector*Matrix calculations }4999asm5000movdqa [rsp-24], xmm65001{ A.R[0] * B }5003movq xmm0, QWORD [A + $00]5004movss xmm1, DWORD [A + $08]5005movlhps xmm0, xmm15006movq xmm4, QWORD [B + $00]5008movss xmm1, DWORD [B + $08]5009movlhps xmm4, xmm15010movaps xmm1, xmm05012movaps xmm2, xmm05013shufps xmm0, xmm0, $005014shufps xmm1, xmm1, $555015shufps xmm2, xmm2, $AA5016movq xmm5, QWORD [B + $0C]5018movss xmm3, DWORD [B + $14]5019movlhps xmm5, xmm35020movq xmm6, QWORD [B + $18]5022movss xmm3, DWORD [B + $20]5023movlhps xmm6, xmm35024mulps xmm0, xmm45026mulps xmm1, xmm55027mulps xmm2, xmm65028addps xmm0, xmm15029addps xmm0, xmm25030movhlps xmm1, xmm05031movq QWORD [Result + $00], xmm05032movss DWORD [Result + $08], xmm15033{ A.R[1] * B }5035movq xmm0, QWORD [A + $0C]5036movss xmm1, DWORD [A + $14]5037movlhps xmm0, xmm15038movaps xmm1, xmm05040movaps xmm2, xmm05041shufps xmm0, xmm0, $005042shufps xmm1, xmm1, $555043shufps xmm2, xmm2, $AA5044mulps xmm0, xmm45045mulps xmm1, xmm55046mulps xmm2, xmm65047addps xmm0, xmm15048addps xmm0, xmm25049movhlps xmm1, xmm05050movq QWORD [Result + $0C], xmm05051movss DWORD [Result + $14], xmm15052{ A.R[2] * B }5054movq xmm0, QWORD [A + $18]5055movss xmm1, DWORD [A + $20]5056movlhps xmm0, xmm15057movaps xmm1, xmm05059movaps xmm2, xmm05060shufps xmm0, xmm0, $005061shufps xmm1, xmm1, $555062shufps xmm2, xmm2, $AA5063mulps xmm0, xmm45064mulps xmm1, xmm55065mulps xmm2, xmm65066addps xmm0, xmm15067addps xmm0, xmm25068movhlps xmm1, xmm05069movq QWORD [Result + $18], xmm05070movss DWORD [Result + $20], xmm15071movdqa xmm6, [rsp-24]5073end;5074{$ENDIF}5075class operator TMatrix3.Negative(const A: TMatrix3): TMatrix3; assembler;5077asm5078movups xmm0, [SSE_MASK_SIGN] // Load mask with 4 sign (upper) bits5079movups xmm1, DQWORD [A + $00] // Load 3 rows5080movups xmm2, DQWORD [A + $10]5081movss xmm3, DWORD [A + $20]5082xorps xmm1, xmm0 // Flip sign bits of each element in each row5083xorps xmm2, xmm05084pxor xmm3, xmm05085movups DQWORD [Result + $00], xmm15086movups DQWORD [Result + $10], xmm25087movss DWORD [Result + $20], xmm35088end;5089procedure TMatrix3.SetTransposed; assembler;5091asm5092movss xmm0, DWORD [Self + $04]5093movss xmm1, DWORD [Self + $08]5094movss xmm2, DWORD [Self + $0C]5096movss xmm3, DWORD [Self + $14]5097movss xmm4, DWORD [Self + $18]5099movss xmm5, DWORD [Self + $1C]5100movss DWORD [Self + $0C], xmm05102movss DWORD [Self + $18], xmm15103movss DWORD [Self + $04], xmm25105movss DWORD [Self + $1C], xmm35106movss DWORD [Self + $08], xmm45108movss DWORD [Self + $14], xmm55109end;5110class operator TMatrix3.Subtract(const A: TMatrix3; const B: Single): TMatrix3; assembler;5112asm5113movups xmm1, DQWORD [A + $00] // Load 3 rows5114shufps xmm2, xmm2, 0 // Replicate B5115movups xmm0, DQWORD [A + $10]5116movss xmm3, DWORD [A + $20]5117subps xmm1, xmm2 // Subtract B from each row5118subps xmm0, xmm25119subss xmm3, xmm25120movups DQWORD [Result + $00], xmm15121movups DQWORD [Result + $10], xmm05122movss DWORD [Result + $20], xmm35123end;5124class operator TMatrix3.Subtract(const A: Single; const B: TMatrix3): TMatrix3; assembler;5126asm5127movups xmm4, DQWORD [B + $00] // Load 3 rows5128shufps xmm1, xmm1, 0 // Replicate A5129movups xmm5, DQWORD [B + $10]5130movaps xmm0, xmm15131movaps xmm2, xmm15132movss xmm6, DWORD [B + $20]5133subps xmm1, xmm4 // Subtract each row from A5134subps xmm0, xmm55135subss xmm2, xmm65136movups DQWORD [Result + $00], xmm15137movups DQWORD [Result + $10], xmm05138movss DWORD [Result + $20], xmm25139end;5140class operator TMatrix3.Subtract(const A, B: TMatrix3): TMatrix3; assembler;5142asm5143movups xmm0, DQWORD [A + $00] // Load 3 rows of A5144movups xmm1, DQWORD [A + $10]5145movss xmm2, DWORD [A + $20]5146movups xmm4, DQWORD [B + $00] // Load 3 rows of B5147movups xmm5, DQWORD [B + $10]5148movss xmm6, DWORD [B + $20]5149subps xmm0, xmm4 // Subtract rows5150subps xmm1, xmm55151subss xmm2, xmm65152movups DQWORD [Result + $00], xmm05153movups DQWORD [Result + $10], xmm15154movss DWORD [Result + $20], xmm25155end;5156function TMatrix3.Transpose: TMatrix3; assembler;5158asm5159movss xmm0, DWORD [Self + $00]5160movss xmm1, DWORD [Self + $04]5161movss xmm2, DWORD [Self + $08]5162movss DWORD [Result + $00], xmm05164movss DWORD [Result + $0C], xmm15165movss DWORD [Result + $18], xmm25166movss xmm0, DWORD [Self + $0C]5168movss xmm1, DWORD [Self + $10]5169movss xmm2, DWORD [Self + $14]5170movss DWORD [Result + $04], xmm05172movss DWORD [Result + $10], xmm15173movss DWORD [Result + $1C], xmm25174movss xmm0, DWORD [Self + $18]5176movss xmm1, DWORD [Self + $1C]5177movss xmm2, DWORD [Self + $20]5178movss DWORD [Result + $08], xmm05180movss DWORD [Result + $14], xmm15181movss DWORD [Result + $20], xmm25182end;5183{ TMatrix 4 }5185class operator TMatrix4.Add(const A: TMatrix4; const B: Single): TMatrix4; assembler;5187asm5188movups xmm1, DQWORD [A + $00] // Load 4 rows5189shufps xmm2, xmm2, 0 // Replicate B5190movups xmm0, DQWORD [A + $10]5191movups xmm3, DQWORD [A + $20]5192movups xmm4, DQWORD [A + $30]5193addps xmm1, xmm2 // Add B to each row5194addps xmm0, xmm25195addps xmm3, xmm25196addps xmm4, xmm25197movups DQWORD [Result + $00], xmm15198movups DQWORD [Result + $10], xmm05199movups DQWORD [Result + $20], xmm35200movups DQWORD [Result + $30], xmm45201end;5202class operator TMatrix4.Add(const A: Single; const B: TMatrix4): TMatrix4; assembler;5204asm5205movups xmm0, DQWORD [B + $00] // Load 4 rows5206shufps xmm1, xmm1, 0 // Replicate A5207movups xmm2, DQWORD [B + $10]5208movups xmm3, DQWORD [B + $20]5209movups xmm4, DQWORD [B + $30]5210addps xmm0, xmm1 // Add A to each row5211addps xmm2, xmm15212addps xmm3, xmm15213addps xmm4, xmm15214movups DQWORD [Result + $00], xmm05215movups DQWORD [Result + $10], xmm25216movups DQWORD [Result + $20], xmm35217movups DQWORD [Result + $30], xmm45218end;5219class operator TMatrix4.Add(const A, B: TMatrix4): TMatrix4; assembler;5221asm5222movups xmm0, DQWORD [A + $00] // Load 4 rows of A5223movups xmm1, DQWORD [A + $10]5224movups xmm2, DQWORD [A + $20]5225movups xmm3, DQWORD [A + $30]5226movups xmm4, DQWORD [B + $00] // Load 2 rows of B5227movups xmm5, DQWORD [B + $10]5228addps xmm0, xmm4 // Add rows5229addps xmm1, xmm55230movups xmm4, DQWORD [B + $20] // Load 2 rows of B5231movups xmm5, DQWORD [B + $30]5232addps xmm2, xmm4 // Add rows5233addps xmm3, xmm55234movups DQWORD [Result + $00], xmm05235movups DQWORD [Result + $10], xmm15236movups DQWORD [Result + $20], xmm25237movups DQWORD [Result + $30], xmm35238end;5239function TMatrix4.CompMult(const AOther: TMatrix4): TMatrix4; assembler;5241asm5242movups xmm0, DQWORD[Self + $00] // Self[0]5243movups xmm1, DQWORD[Self + $10] // Self[1]5244movups xmm2, DQWORD[Self + $20] // Self[2]5245movups xmm3, DQWORD[Self + $30] // Self[3]5246movups xmm4, DQWORD[AOther + $00] // AOther[0]5247movups xmm5, DQWORD[AOther + $10] // AOther[1]5248// Component-wise multiplication5250mulps xmm0, xmm45251mulps xmm1, xmm55252movups xmm4, DQWORD[AOther + $20] // AOther[2]5253movups xmm5, DQWORD[AOther + $30] // AOther[3]5254mulps xmm2, xmm45255mulps xmm3, xmm55256// Store result5258movups DQWORD [Result + $00], xmm05259movups DQWORD [Result + $10], xmm15260movups DQWORD [Result + $20], xmm25261movups DQWORD [Result + $30], xmm35262end;5263class operator TMatrix4.Divide(const A: Single; const B: TMatrix4): TMatrix4; assembler;5265asm5266movups xmm4, DQWORD [B + $00] // Load 4 rows5267shufps xmm1, xmm1, 0 // Replicate A5268movups xmm5, DQWORD [B + $10]5269movaps xmm0, xmm15270movaps xmm2, xmm15271movaps xmm3, xmm15272divps xmm1, xmm4 // Divide A by each row5273divps xmm0, xmm55274movups xmm4, DQWORD [B + $20]5275movups xmm5, DQWORD [B + $30]5276divps xmm2, xmm45277divps xmm3, xmm55278movups DQWORD [Result + $00], xmm15279movups DQWORD [Result + $10], xmm05280movups DQWORD [Result + $20], xmm25281movups DQWORD [Result + $30], xmm35282end;5283class operator TMatrix4.Divide(const A: TMatrix4; const B: Single): TMatrix4; assembler;5285asm5286movups xmm1, DQWORD [A + $00] // Load 4 rows5287shufps xmm2, xmm2, 0 // Replicate B5288movups xmm0, DQWORD [A + $10]5289movups xmm3, DQWORD [A + $20]5290movups xmm4, DQWORD [A + $30]5291divps xmm1, xmm2 // Divide each row by B5292divps xmm0, xmm2 // NOTE: We could speed it up by multiplying by5293divps xmm3, xmm2 // 1/B instead, using the "rcpps" instruction,5294divps xmm4, xmm2 // but that instruction is an approximation,5295// so we lose accuracy.5296movups DQWORD [Result + $00], xmm15297movups DQWORD [Result + $10], xmm05298movups DQWORD [Result + $20], xmm35299movups DQWORD [Result + $30], xmm45300end;5301function TMatrix4.Inverse: TMatrix4; assembler;5303type5304TStack = record5305case Byte of53060: (WorkSpace: array [0..7] of TVector4);53071: (F0, F1, F2, F3, F4, F5, X6, X7: TVector4);5308end;5309var5310Stack: TStack;5311asm5312movdqa [Stack.X6], xmm65313movdqa [Stack.X7], xmm65314movups xmm1, DQWORD[Self + $10] // M[1]5316movups xmm2, DQWORD[Self + $20] // M[2]5317movups xmm3, DQWORD[Self + $30] // M[3]5318// C00 := (A.M[2,2] * A.M[3,3]) - (A.M[3,2] * A.M[2,3]);5320// C02 := (A.M[1,2] * A.M[3,3]) - (A.M[3,2] * A.M[1,3]);5321// C03 := (A.M[1,2] * A.M[2,3]) - (A.M[2,2] * A.M[1,3]);5322// F0 := Vector4(C00, C00, C02, C03);5323movaps xmm5, xmm2 // M[2]5324movaps xmm7, xmm2 // M[2]5325movaps xmm0, xmm3 // M[3]5326movaps xmm6, xmm3 // M[3]5327shufps xmm6, xmm2, $AA // M22 M22 M32 M325328shufps xmm0, xmm2, $FF // M23 M23 M33 M335329shufps xmm7, xmm1, $FF // M13 M13 M23 M235330pshufd xmm4, xmm0, $80 // M23 M33 M33 M335331shufps xmm5, xmm1, $AA // M12 M12 M22 M225332pshufd xmm0, xmm6, $80 // M22 M32 M32 M325333mulps xmm5, xmm4 // (M12 * M23) (M12 * M33) (M22 * M33) (M22 * M33)5334mulps xmm7, xmm0 // (M22 * M13) (M32 * M13) (M32 * M23) (M32 * M23)5335subps xmm5, xmm7 // C03=(M12*M23)-(M22*M13), C02=(M12*M33)-(M32*M13), C00=(M22*M33)-(M32*M23), C00=(M22*M33)-(M32*M23)5336movups [Stack.F0], xmm55337// C04 := (A.M[2,1] * A.M[3,3]) - (A.M[3,1] * A.M[2,3]);5339// C06 := (A.M[1,1] * A.M[3,3]) - (A.M[3,1] * A.M[1,3]);5340// C07 := (A.M[1,1] * A.M[2,3]) - (A.M[2,1] * A.M[1,3]);5341// F1 := Vector4(C04, C04, C06, C07);5342movaps xmm5, xmm2 // M[2]5343movaps xmm7, xmm2 // M[2]5344movaps xmm0, xmm3 // M[3]5345movaps xmm6, xmm3 // M[3]5346shufps xmm6, xmm2, $55 // M21 M21 M31 M315347shufps xmm0, xmm2, $FF // M23 M23 M33 M335348shufps xmm7, xmm1, $FF // M13 M13 M23 M235349pshufd xmm4, xmm0, $80 // M23 M33 M33 M335350shufps xmm5, xmm1, $55 // M11 M11 M21 M215351pshufd xmm0, xmm6, $80 // M21 M31 M31 M315352mulps xmm5, xmm4 // (M11 * M23) (M11 * M33) (M21 * M33) (M21 * M33)5353mulps xmm7, xmm0 // (M21 * M13) (M31 * M13) (M31 * M23) (M31 * M23)5354subps xmm5, xmm7 // C07=(M11*M23)-(M21*M13), C06=(M11*M33)-(M31*M13), C04=(M21*M33)-(M31*M23), C04=(M21*M33)-(M31*M23)5355movups [Stack.F1], xmm55356// C08 := (A.M[2,1] * A.M[3,2]) - (A.M[3,1] * A.M[2,2]);5358// C10 := (A.M[1,1] * A.M[3,2]) - (A.M[3,1] * A.M[1,2]);5359// C11 := (A.M[1,1] * A.M[2,2]) - (A.M[2,1] * A.M[1,2]);5360// F2 := Vector4(C08, C08, C10, C11);5361movaps xmm5, xmm2 // M[2]5362movaps xmm7, xmm2 // M[2]5363movaps xmm0, xmm3 // M[3]5364movaps xmm6, xmm3 // M[3]5365shufps xmm6, xmm2, $55 // M21 M21 M31 M315366shufps xmm0, xmm2, $AA // M22 M22 M32 M325367shufps xmm7, xmm1, $AA // M12 M12 M22 M225368pshufd xmm4, xmm0, $80 // M22 M32 M32 M325369shufps xmm5, xmm1, $55 // M11 M11 M21 M215370pshufd xmm0, xmm6, $80 // M21 M31 M31 M315371mulps xmm5, xmm4 // (M11 * M22) (M11 * M32) (M21 * M32) (M21 * M32)5372mulps xmm7, xmm0 // (M21 * M12) (M31 * M12) (M31 * M22) (M32 * M22)5373subps xmm5, xmm7 // C11=(M11*M22)-(M21*M12), C10=(M11*M32)-(M31*M12), C08=(M21*M32)-(M31*M22), C08=(M21*M32)-(M31*M22)5374movups [Stack.F2], xmm55375// C12 := (A.M[2,0] * A.M[3,3]) - (A.M[3,0] * A.M[2,3]);5377// C14 := (A.M[1,0] * A.M[3,3]) - (A.M[3,0] * A.M[1,3]);5378// C15 := (A.M[1,0] * A.M[2,3]) - (A.M[2,0] * A.M[1,3]);5379// F3 := Vector4(C12, C12, C14, C15);5380movaps xmm5, xmm2 // M[2]5381movaps xmm7, xmm2 // M[2]5382movaps xmm0, xmm3 // M[3]5383movaps xmm6, xmm3 // M[3]5384shufps xmm6, xmm2, $00 // M20 M20 M30 M305385shufps xmm0, xmm2, $FF // M23 M23 M33 M335386shufps xmm7, xmm1, $FF // M13 M13 M23 M235387pshufd xmm4, xmm0, $80 // M23 M33 M33 M335388shufps xmm5, xmm1, $00 // M10 M10 M20 M205389pshufd xmm0, xmm6, $80 // M20 M30 M30 M305390mulps xmm5, xmm4 // (M10 * M23) (M10 * M33) (M20 * M33) (M20 * M33)5391mulps xmm7, xmm0 // (M20 * M13) (M30 * M13) (M30 * M23) (M30 * M23)5392subps xmm5, xmm7 // C15=(M10*M23)-(M20*M13), C14=(M10*M33)-(M30*M13), C12=(M20*M33)-(M30*M23), C12=(M20*M33)-(M30*M23)5393movups [Stack.F3], xmm55394// C16 := (A.M[2,0] * A.M[3,2]) - (A.M[3,0] * A.M[2,2]);5396// C18 := (A.M[1,0] * A.M[3,2]) - (A.M[3,0] * A.M[1,2]);5397// C19 := (A.M[1,0] * A.M[2,2]) - (A.M[2,0] * A.M[1,2]);5398// F4 := Vector4(C16, C16, C18, C19);5399movaps xmm5, xmm2 // M[2]5400movaps xmm7, xmm2 // M[2]5401movaps xmm0, xmm3 // M[3]5402movaps xmm6, xmm3 // M[3]5403shufps xmm6, xmm2, $00 // M20 M20 M30 M305404shufps xmm0, xmm2, $AA // M22 M22 M32 M325405shufps xmm7, xmm1, $AA // M12 M12 M22 M225406pshufd xmm4, xmm0, $80 // M22 M32 M32 M325407shufps xmm5, xmm1, $00 // M10 M10 M20 M205408pshufd xmm0, xmm6, $80 // M20 M30 M30 M305409mulps xmm5, xmm4 // (M10 * M22) (M10 * M32) (M20 * M32) (M20 * M32)5410mulps xmm7, xmm0 // (M20 * M12) (M30 * M12) (M30 * M22) (M30 * M22)5411subps xmm5, xmm7 // C19=(M10*M22)-(M20*M12), C18=(M10*M32)-(M30*M12), C16=(M20*M32)-(M30*M22), C16=(M20*M32)-(M30*M22)5412movups [Stack.F4], xmm55413// C20 := (A.M[2,0] * A.M[3,1]) - (A.M[3,0] * A.M[2,1]);5415// C22 := (A.M[1,0] * A.M[3,1]) - (A.M[3,0] * A.M[1,1]);5416// C23 := (A.M[1,0] * A.M[2,1]) - (A.M[2,0] * A.M[1,1]);5417// F5 := Vector4(C20, C20, C22, C23);5418movaps xmm5, xmm2 // M[2]5419movaps xmm7, xmm2 // M[2]5420movaps xmm0, xmm3 // M[3]5421movaps xmm6, xmm3 // M[3]5422shufps xmm6, xmm2, $00 // M20 M20 M30 M305423shufps xmm0, xmm2, $55 // M21 M21 M31 M315424shufps xmm7, xmm1, $55 // M11 M11 M21 M215425pshufd xmm4, xmm0, $80 // M21 M31 M31 M315426shufps xmm5, xmm1, $00 // M10 M10 M20 M205427pshufd xmm0, xmm6, $80 // M20 M30 M30 M305428mulps xmm5, xmm4 // (M10 * M21) (M10 * M31) (M20 * M31) (M20 * M31)5429mulps xmm7, xmm0 // (M20 * M11) (M30 * M11) (M30 * M21) (M30 * M21)5430subps xmm5, xmm7 // C23=(M10*M21)-(M20*M11), C22=(M10*M31)-(M30*M11), C20=(M20*M31)-(M30*M21), C20=(M20*M31)-(M30*M21)5431movups [Stack.F5], xmm55432// V0 := Vector4(A.M[1,0], A.M[0,0], A.M[0,0], A.M[0,0]);5434// V1 := Vector4(A.M[1,1], A.M[0,1], A.M[0,1], A.M[0,1]);5435// V2 := Vector4(A.M[1,2], A.M[0,2], A.M[0,2], A.M[0,2]);5436// V3 := Vector4(A.M[1,3], A.M[0,3], A.M[0,3], A.M[0,3]);5437movups xmm0, DQWORD[Self + $00] // M[0]5438movaps xmm4, xmm1 // M[1]5439movaps xmm5, xmm1 // M[1]5440movaps xmm6, xmm1 // M[1]5441movaps xmm7, xmm1 // M[1]5442shufps xmm4, xmm0, $00 // M00 M00 M10 M105444shufps xmm5, xmm0, $55 // M01 M01 M11 M115445shufps xmm6, xmm0, $AA // M02 M02 M12 M125446shufps xmm7, xmm0, $FF // M03 M03 M13 M135447pshufd xmm4, xmm4, $A8 // V0=M00 M00 M00 M105449pshufd xmm5, xmm5, $A8 // V1=M01 M01 M01 M115450pshufd xmm6, xmm6, $A8 // V2=M02 M02 M02 M125451pshufd xmm7, xmm7, $A8 // V3=M03 M03 M03 M135452// I0 := (V1 * F0) - (V2 * F1) + (V3 * F2);5454// I1 := (V0 * F0) - (V2 * F3) + (V3 * F4);5455// I2 := (V0 * F1) - (V1 * F3) + (V3 * F5);5456// I3 := (V0 * F2) - (V1 * F4) + (V2 * F5);5457movaps xmm0, xmm5 // V15458movaps xmm1, xmm6 // V25459movaps xmm2, xmm7 // V35460mulps xmm0, [Stack.F0] // V1 * F05461mulps xmm1, [Stack.F1] // V2 * F15462mulps xmm2, [Stack.F2] // V3 * F25463subps xmm0, xmm1 // (V1 * F0) - (V2 * F1)5464movaps xmm1, xmm4 // V05465addps xmm0, xmm2 // I0=(V1 * F0) - (V2 * F1) + (V3 * F2)5466movaps xmm2, xmm6 // V25468movaps xmm3, xmm7 // V35469mulps xmm1, [Stack.F0] // V0 * F05470mulps xmm2, [Stack.F3] // V2 * F35471mulps xmm3, [Stack.F4] // V3 * F45472subps xmm1, xmm2 // (V0 * F0) - (V2 * F3)5473movaps xmm2, xmm4 // V05474addps xmm1, xmm3 // I1=(V0 * F0) - (V2 * F3) + (V3 * F4)5475movaps xmm3, xmm5 // V15477mulps xmm2, [Stack.F1] // V0 * F15478mulps xmm3, [Stack.F3] // V1 * F35479mulps xmm7, [Stack.F5] // V3 * F55480subps xmm2, xmm3 // (V0 * F1) - (V1 * F3)5481mulps xmm4, [Stack.F2] // V0 * F25482addps xmm2, xmm7 // I2=(V0 * F1) - (V1 * F3) + (V3 * F5)5483mulps xmm5, [Stack.F4] // V1 * F45485mulps xmm6, [Stack.F5] // V2 * F55486subps xmm4, xmm5 // (V0 * F2) - (V1 * F4)5487addps xmm4, xmm6 // I3=(V0 * F2) - (V1 * F4) + (V2 * F5)5488// SA := Vector4(+1, -1, +1, -1);5490// SB := Vector4(-1, +1, -1, +1);5491// Inv := Matrix4(I0 * SA, I1 * SB, I2 * SA, I3 * SB);5492movups xmm6, [SSE_MASK_PNPN] // SA5494movups xmm7, [SSE_MASK_NPNP] // SB5495xorps xmm0, xmm6 // Inv[0] = I0 * SA5496xorps xmm1, xmm7 // Inv[1] = I1 * SB5497xorps xmm2, xmm6 // Inv[2] = I2 * SA5498xorps xmm4, xmm7 // Inv[3] = I3 * SB5499// Row := Vector4(Inv[0,0], Inv[1,0], Inv[2,0], Inv[3,0]);5501movaps xmm3, xmm05502movaps xmm5, xmm25503movaps xmm6, xmm15504unpcklps xmm3, xmm1 // Inv[1,1] Inv[0,1] Inv[1,0] Inv[0,0]5506unpcklps xmm5, xmm4 // Inv[3,1] Inv[2,1] Inv[3,0] Inv[2,0]5507movups xmm6, DQWORD[Self + $00] // A.C[0]5508movlhps xmm3, xmm5 // Inv[3,0] Inv[2,0] Inv[1,0] Inv[0,0]5509// Dot := A.C[0] * Row;5511mulps xmm3, xmm6 // Dot.W Dot.Z Dot.Y Dot.X5512// OneOverDeterminant := 1 / ((Dot.X + Dot.Y) + (Dot.Z + Dot.W));5514pshufd xmm6, xmm3, $4E // Dot.Y Dot.X Dot.W Dot.Z5515addps xmm3, xmm6 // W+Y Z+X Y+W X+Z5516pshufd xmm6, xmm3, $11 // X+Z Y+X X+Z Y+W5517movups xmm5, [SSE_ONE] // 1.0 (4x)5518addps xmm3, xmm6 // X+Y+Z+W (4x)5519divps xmm5, xmm3 // OneOverDeterminant (4x)5520// Result := Inv * OneOverDeterminant;5522mulps xmm0, xmm55523mulps xmm1, xmm55524mulps xmm2, xmm55525mulps xmm4, xmm55526movups DQWORD[Result + $00], xmm05528movups DQWORD[Result + $10], xmm15529movups DQWORD[Result + $20], xmm25530movups DQWORD[Result + $30], xmm45531movdqa xmm6, [Stack.X6]5533movdqa xmm7, [Stack.X7]5534end;5535class operator TMatrix4.Multiply(const A: Single; const B: TMatrix4): TMatrix4; assembler;5537asm5538movups xmm0, DQWORD [B + $00] // Load 4 rows5539shufps xmm1, xmm1, 0 // Replicate A5540movups xmm2, DQWORD [B + $10]5541movups xmm3, DQWORD [B + $20]5542movups xmm4, DQWORD [B + $30]5543mulps xmm0, xmm1 // Multiply each row by A5544mulps xmm2, xmm15545mulps xmm3, xmm15546mulps xmm4, xmm15547movups DQWORD [Result + $00], xmm05548movups DQWORD [Result + $10], xmm25549movups DQWORD [Result + $20], xmm35550movups DQWORD [Result + $30], xmm45551end;5552class operator TMatrix4.Multiply(const A: TMatrix4; const B: Single): TMatrix4; assembler;5554asm5555movups xmm1, DQWORD [A + $00] // Load 4 rows5556shufps xmm2, xmm2, 0 // Replicate B5557movups xmm0, DQWORD [A + $10]5558movups xmm3, DQWORD [A + $20]5559movups xmm4, DQWORD [A + $30]5560mulps xmm1, xmm2 // Multiply each row by B5561mulps xmm0, xmm25562mulps xmm3, xmm25563mulps xmm4, xmm25564movups DQWORD [Result + $00], xmm15565movups DQWORD [Result + $10], xmm05566movups DQWORD [Result + $20], xmm35567movups DQWORD [Result + $30], xmm45568end;5569{$IFDEF FM_COLUMN_MAJOR}5571class operator TMatrix4.Multiply(const A: TMatrix4; const B: TVector4): TVector4; assembler;5572asm5573movups xmm0, [B]5574movups xmm4, DQWORD [A + $00]5575movaps xmm1, xmm05576movaps xmm2, xmm05577movaps xmm3, xmm05578shufps xmm0, xmm0, $005579shufps xmm1, xmm1, $555580shufps xmm2, xmm2, $AA5581shufps xmm3, xmm3, $FF5582movups xmm5, DQWORD [A + $10]5583mulps xmm0, xmm45584mulps xmm1, xmm55585movups xmm4, DQWORD [A + $20]5586movups xmm5, DQWORD [A + $30]5587mulps xmm2, xmm45588mulps xmm3, xmm55589addps xmm0, xmm15590addps xmm2, xmm35591addps xmm0, xmm25592movups [Result], xmm05593end;5594class operator TMatrix4.Multiply(const A: TVector4; const B: TMatrix4): TVector4; assembler;5596asm5597movups xmm0, [A]5598movups xmm4, DQWORD [B + $00]5599movaps xmm1, xmm05600movaps xmm2, xmm05601movaps xmm3, xmm05602movups xmm5, DQWORD [B + $10]5603mulps xmm0, xmm45604mulps xmm1, xmm55605movups xmm4, DQWORD [B + $20]5606movups xmm5, DQWORD [B + $30]5607mulps xmm2, xmm45608mulps xmm3, xmm55609{ Transpose xmm0-xmm3 }5611movaps xmm4, xmm25612unpcklps xmm2, xmm35613unpckhps xmm4, xmm35614movaps xmm3, xmm05616unpcklps xmm0, xmm15617unpckhps xmm3, xmm15618movaps xmm1, xmm05620unpcklpd xmm0, xmm25621unpckhpd xmm1, xmm25622movaps xmm2, xmm35624unpcklpd xmm2, xmm45625unpckhpd xmm3, xmm45626addps xmm0, xmm15628addps xmm2, xmm35629addps xmm0, xmm25630movups [Result], xmm05631end;5632class operator TMatrix4.Multiply(const A, B: TMatrix4): TMatrix4; assembler;5634{ Code below consists of 4 Vector*Matrix calculations }5635asm5636movdqa [rsp-24], xmm65637movdqa [rsp-40], xmm75638movups xmm0, DQWORD [B + $00]5640movups xmm4, DQWORD [A + $00]5641movaps xmm1, xmm05642movaps xmm2, xmm05643movaps xmm3, xmm05644shufps xmm0, xmm0, $005645shufps xmm1, xmm1, $555646shufps xmm2, xmm2, $AA5647shufps xmm3, xmm3, $FF5648movups xmm5, DQWORD [A + $10]5649movups xmm6, DQWORD [A + $20]5650movups xmm7, DQWORD [A + $30]5651mulps xmm0, xmm45652mulps xmm1, xmm55653mulps xmm2, xmm65654mulps xmm3, xmm75655addps xmm0, xmm15656addps xmm2, xmm35657addps xmm0, xmm25658movups DQWORD [Result + $00], xmm05659movups xmm0, DQWORD [B + $10]5661movaps xmm1, xmm05662movaps xmm2, xmm05663movaps xmm3, xmm05664shufps xmm0, xmm0, $005665shufps xmm1, xmm1, $555666shufps xmm2, xmm2, $AA5667shufps xmm3, xmm3, $FF5668mulps xmm0, xmm45669mulps xmm1, xmm55670mulps xmm2, xmm65671mulps xmm3, xmm75672addps xmm0, xmm15673addps xmm2, xmm35674addps xmm0, xmm25675movups DQWORD [Result + $10], xmm05676movups xmm0, DQWORD [B + $20]5678movaps xmm1, xmm05679movaps xmm2, xmm05680movaps xmm3, xmm05681shufps xmm0, xmm0, $005682shufps xmm1, xmm1, $555683shufps xmm2, xmm2, $AA5684shufps xmm3, xmm3, $FF5685mulps xmm0, xmm45686mulps xmm1, xmm55687mulps xmm2, xmm65688mulps xmm3, xmm75689addps xmm0, xmm15690addps xmm2, xmm35691addps xmm0, xmm25692movups DQWORD [Result + $20], xmm05693movups xmm0, DQWORD [B + $30]5695movaps xmm1, xmm05696movaps xmm2, xmm05697movaps xmm3, xmm05698shufps xmm0, xmm0, $005699shufps xmm1, xmm1, $555700shufps xmm2, xmm2, $AA5701shufps xmm3, xmm3, $FF5702mulps xmm0, xmm45703mulps xmm1, xmm55704mulps xmm2, xmm65705mulps xmm3, xmm75706addps xmm0, xmm15707addps xmm2, xmm35708addps xmm0, xmm25709movups DQWORD [Result + $30], xmm05710movdqa xmm6, [rsp-24]5712movdqa xmm7, [rsp-40]5713end;5714{$ELSE}5715class operator TMatrix4.Multiply(const A: TMatrix4; const B: TVector4): TVector4; assembler;5716asm5717movups xmm0, [B] // Load vector5718movups xmm4, DQWORD [A + $00] // Load 4 rows5719movaps xmm1, xmm05720movaps xmm2, xmm05721movaps xmm3, xmm05722movups xmm5, DQWORD [A + $10]5723mulps xmm0, xmm4 // (Ax * B00), (Ay * B01), (Az * B02), (Aw * B03)5724mulps xmm1, xmm5 // (Ax * B10), (Ay * B11), (Az * B12), (Aw * B13)5725movups xmm4, DQWORD [A + $20]5726movups xmm5, DQWORD [A + $30]5727mulps xmm2, xmm4 // (Ax * B20), (Ay * B21), (Az * B22), (Aw * B23)5728mulps xmm3, xmm5 // (Ax * B30), (Ay * B31), (Az * B32), (Aw * B33)5729{ Transpose xmm0-xmm3 }5731movaps xmm4, xmm25732unpcklps xmm2, xmm3 // B32 B22 B33 B235733unpckhps xmm4, xmm3 // B30 B20 B31 B215734movaps xmm3, xmm05736unpcklps xmm0, xmm1 // B12 B02 B13 B035737unpckhps xmm3, xmm1 // B10 B00 B11 B015738movaps xmm1, xmm05740unpcklpd xmm0, xmm2 // B33 B23 B13 B035741unpckhpd xmm1, xmm2 // B32 B22 B12 B025742movaps xmm2, xmm35744unpcklpd xmm2, xmm4 // B31 B21 B11 B015745unpckhpd xmm3, xmm4 // B30 B20 B10 B005746addps xmm0, xmm1 // Add rows5748addps xmm2, xmm35749addps xmm0, xmm25750movups [Result], xmm05751end;5752class operator TMatrix4.Multiply(const A: TVector4; const B: TMatrix4): TVector4; assembler;5754asm5755movups xmm0, [A] // Load vector5756movups xmm4, DQWORD [B + $00] // Load 4 rows5757movaps xmm1, xmm05758movaps xmm2, xmm05759movaps xmm3, xmm05760shufps xmm0, xmm0, $00 // Bx Bx Bx Bx5761shufps xmm1, xmm1, $55 // By By By By5762shufps xmm2, xmm2, $AA // Bz Bz Bz Bz5763shufps xmm3, xmm3, $FF // Bw Bw Bw Bw5764movups xmm5, DQWORD [B + $10]5765mulps xmm0, xmm4 // (A00 * Bx), (A01 * Bx), (A02 * Bx), (A03 * Bx)5766mulps xmm1, xmm5 // (A10 * By), (A11 * By), (A12 * By), (A13 * By)5767movups xmm4, DQWORD [B + $20]5768movups xmm5, DQWORD [B + $30]5769mulps xmm2, xmm4 // (A20 * Bz), (A21 * Bz), (A22 * Bz), (A23 * Bz)5770mulps xmm3, xmm5 // (A30 * Bw), (A31 * Bw), (A32 * Bw), (A33 * Bw)5771addps xmm0, xmm1 // Add rows5772addps xmm2, xmm35773addps xmm0, xmm25774movups [Result], xmm05775end;5776class operator TMatrix4.Multiply(const A, B: TMatrix4): TMatrix4; assembler;5778{ Code below consists of 4 Vector*Matrix calculations }5779asm5780movdqa [rsp-24], xmm65781movdqa [rsp-40], xmm75782{ A.R[0] * B }5784movups xmm0, DQWORD [A + $00]5785movups xmm4, DQWORD [B + $00]5786movaps xmm1, xmm05787movaps xmm2, xmm05788movaps xmm3, xmm05789shufps xmm0, xmm0, $005790shufps xmm1, xmm1, $555791shufps xmm2, xmm2, $AA5792shufps xmm3, xmm3, $FF5793movups xmm5, DQWORD [B + $10]5794movups xmm6, DQWORD [B + $20]5795movups xmm7, DQWORD [B + $30]5796mulps xmm0, xmm45797mulps xmm1, xmm55798mulps xmm2, xmm65799mulps xmm3, xmm75800addps xmm0, xmm15801addps xmm2, xmm35802addps xmm0, xmm25803movups DQWORD [Result + $00], xmm05804{ A.R[1] * B }5806movups xmm0, DQWORD [A + $10]5807movaps xmm1, xmm05808movaps xmm2, xmm05809movaps xmm3, xmm05810shufps xmm0, xmm0, $005811shufps xmm1, xmm1, $555812shufps xmm2, xmm2, $AA5813shufps xmm3, xmm3, $FF5814mulps xmm0, xmm45815mulps xmm1, xmm55816mulps xmm2, xmm65817mulps xmm3, xmm75818addps xmm0, xmm15819addps xmm2, xmm35820addps xmm0, xmm25821movups DQWORD [Result + $10], xmm05822{ A.R[2] * B }5824movups xmm0, DQWORD [A + $20]5825movaps xmm1, xmm05826movaps xmm2, xmm05827movaps xmm3, xmm05828shufps xmm0, xmm0, $005829shufps xmm1, xmm1, $555830shufps xmm2, xmm2, $AA5831shufps xmm3, xmm3, $FF5832mulps xmm0, xmm45833mulps xmm1, xmm55834mulps xmm2, xmm65835mulps xmm3, xmm75836addps xmm0, xmm15837addps xmm2, xmm35838addps xmm0, xmm25839movups DQWORD [Result + $20], xmm05840{ A.R[3] * B }5842movups xmm0, DQWORD [A + $30]5843movaps xmm1, xmm05844movaps xmm2, xmm05845movaps xmm3, xmm05846shufps xmm0, xmm0, $005847shufps xmm1, xmm1, $555848shufps xmm2, xmm2, $AA5849shufps xmm3, xmm3, $FF5850mulps xmm0, xmm45851mulps xmm1, xmm55852mulps xmm2, xmm65853mulps xmm3, xmm75854addps xmm0, xmm15855addps xmm2, xmm35856addps xmm0, xmm25857movups DQWORD [Result + $30], xmm05858movdqa xmm6, [rsp-24]5860movdqa xmm7, [rsp-40]5861end;5862{$ENDIF}5863class operator TMatrix4.Negative(const A: TMatrix4): TMatrix4; assembler;5865asm5866movups xmm0, [SSE_MASK_SIGN] // Load mask with 4 sign (upper) bits5867movups xmm1, DQWORD [A + $00] // Load 4 rows5868movups xmm2, DQWORD [A + $10]5869movups xmm3, DQWORD [A + $20]5870movups xmm4, DQWORD [A + $30]5871xorps xmm1, xmm0 // Flip sign bits of each element in each row5872xorps xmm2, xmm05873xorps xmm3, xmm05874xorps xmm4, xmm05875movups DQWORD [Result + $00], xmm15876movups DQWORD [Result + $10], xmm25877movups DQWORD [Result + $20], xmm35878movups DQWORD [Result + $30], xmm45879end;5880procedure TMatrix4.SetInversed;5882begin5883Self := Inverse;5884end;5885procedure TMatrix4.SetTransposed;5887begin5888Self := Transpose;5889end;5890class operator TMatrix4.Subtract(const A: TMatrix4; const B: Single): TMatrix4; assembler;5892asm5893movups xmm1, DQWORD [A + $00] // Load 4 rows5894shufps xmm2, xmm2, 0 // Replicate B5895movups xmm0, DQWORD [A + $10]5896movups xmm3, DQWORD [A + $20]5897movups xmm4, DQWORD [A + $30]5898subps xmm1, xmm2 // Subtract B from each row5899subps xmm0, xmm25900subps xmm3, xmm25901subps xmm4, xmm25902movups DQWORD [Result + $00], xmm15903movups DQWORD [Result + $10], xmm05904movups DQWORD [Result + $20], xmm35905movups DQWORD [Result + $30], xmm45906end;5907class operator TMatrix4.Subtract(const A: Single; const B: TMatrix4): TMatrix4; assembler;5909asm5910movups xmm4, DQWORD [B + $00] // Load 4 rows5911shufps xmm1, xmm1, 0 // Replicate A5912movups xmm5, DQWORD [B + $10]5913movaps xmm0, xmm15914movaps xmm2, xmm15915movaps xmm3, xmm15916subps xmm1, xmm4 // Subtract each row from A5917subps xmm0, xmm55918movups xmm4, DQWORD [B + $20]5919movups xmm5, DQWORD [B + $30]5920subps xmm2, xmm45921subps xmm3, xmm55922movups DQWORD [Result + $00], xmm15923movups DQWORD [Result + $10], xmm05924movups DQWORD [Result + $20], xmm25925movups DQWORD [Result + $30], xmm35926end;5927class operator TMatrix4.Subtract(const A, B: TMatrix4): TMatrix4; assembler;5929asm5930movups xmm0, DQWORD [A + $00] // Load 4 rows of A5931movups xmm1, DQWORD [A + $10]5932movups xmm2, DQWORD [A + $20]5933movups xmm3, DQWORD [A + $30]5934movups xmm4, DQWORD [B + $00] // Load 4 rows of B5935movups xmm5, DQWORD [B + $10]5936subps xmm0, xmm4 // Subtract rows5937subps xmm1, xmm55938movups xmm4, DQWORD [B + $20]5939movups xmm5, DQWORD [B + $30]5940subps xmm2, xmm45941subps xmm3, xmm55942movups DQWORD [Result + $00], xmm05943movups DQWORD [Result + $10], xmm15944movups DQWORD [Result + $20], xmm25945movups DQWORD [Result + $30], xmm35946end;5947function TMatrix4.Transpose: TMatrix4; assembler;5949asm5950movups xmm0, DQWORD[Self + $00] // A03 A02 A01 A005951movups xmm1, DQWORD[Self + $10] // A13 A12 A11 A105952movups xmm2, DQWORD[Self + $20] // A23 A22 A21 A205953movups xmm3, DQWORD[Self + $30] // A33 A32 A31 A305954movaps xmm4, xmm25956unpcklps xmm2, xmm3 // A31 A21 A30 A205957unpckhps xmm4, xmm3 // A33 A23 A32 A225958movaps xmm3, xmm05960unpcklps xmm0, xmm1 // A11 A01 A10 A005961unpckhps xmm3, xmm1 // A13 A03 A12 A025962movaps xmm1, xmm05964unpcklpd xmm0, xmm2 // A30 A20 A10 A005965unpckhpd xmm1, xmm2 // A31 A21 A11 A015966movaps xmm2, xmm35968unpcklpd xmm2, xmm4 // A32 A22 A12 A025969unpckhpd xmm3, xmm4 // A33 A23 A13 A035970movups DQWORD[Result + $00], xmm05972movups DQWORD[Result + $10], xmm15973movups DQWORD[Result + $20], xmm25974movups DQWORD[Result + $30], xmm35975end;5976