Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/avx/3dmath/3dmath_nz.h

raw
1 /*
2 * Copyright (C) 2026 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2026 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-dsp-lib
6 * Created on: 7 авг. 2026 г.
7 *
8 * lsp-dsp-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-dsp-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-dsp-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #ifndef PRIVATE_DSP_ARCH_X86_AVX_3DMATH_3DMATH_H_
23 #define PRIVATE_DSP_ARCH_X86_AVX_3DMATH_3DMATH_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_AVX_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_AVX_IMPL */
28
29 #include <private/dsp/arch/x86/avx/3dmath/common.h>
30
31 namespace lsp
32 {
33 namespace avx
34 {
35 using namespace dsp;
36
37 void init_point_xyz(point3d_t *p, float x, float y, float z)
38 {
39 ARCH_X86_ASM
40 (
41 __ASM_EMIT("vmovlhps %[x1], %[x0], %[x0]") // x0 = x ? y ?
42 __ASM_EMIT("vmovhps %[id], %[x2], %[x2]") // x2 = z ? 1 0
43 __ASM_EMIT("vshufps $0x88, %[x2], %[x0], %[x0]") // x0 = x y z 1
44 __ASM_EMIT("vmovups %[x0], (%[p])")
45
46 : [x0] "+x" (x), [x1] "+x" (y), [x2] "+x"(z)
47 : [p] "r" (p),
48 [id] "m" (IDENTITY)
49 : "memory"
50 );
51 }
52
53 void init_point(point3d_t *p, const point3d_t *s)
54 {
55 float x0;
56
57 ARCH_X86_ASM
58 (
59 __ASM_EMIT("vmovups (%[s]), %[x0]")
60 __ASM_EMIT("vmovups %[x0], (%[p])")
61 : [x0] "=&x" (x0)
62 : [s] "r" (s), [p] "r" (p)
63 : "memory"
64 );
65 }
66
67 void normalize_point(point3d_t *p)
68 {
69 float x0, x1, x2;
70
71 ARCH_X86_ASM
72 (
73 __ASM_EMIT("vmovups (%[p]), %[x0]") // x0 = x y z w
74 __ASM_EMIT("vandps %[mask], %[x0], %[x0]") // x0 = x y z 0
75 NORMALIZE("[x0]", "[x1]", "[x2]")
76 __ASM_EMIT("vinsertps $0x30, %[id], %[x0], %[x0]") // x0 = x y z 1
77 __ASM_EMIT("vmovups %[x0], (%[p])")
78
79 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
80 : [p] "r" (p),
81 [id] "m" (IDENTITY),
82 [mask] "m" (X_MASK0111)
83 : "cc", "memory"
84 );
85 }
86
87 void init_vector_dxyz(vector3d_t *p, float dx, float dy, float dz)
88 {
89 ARCH_X86_ASM
90 (
91 __ASM_EMIT("vmovlhps %[x1], %[x0], %[x0]") // x0 = dx ? dy ?
92 __ASM_EMIT("vmovhps %[id], %[x2], %[x2]") // x2 = dz ? 1 0
93 __ASM_EMIT("vshufps $0xc8, %[x2], %[x0], %[x0]") // x0 = dx dy dz 0
94 __ASM_EMIT("vmovups %[x0], (%[p])")
95
96 : [x0] "+x" (dx), [x1] "+x" (dy), [x2] "+x"(dz)
97 : [p] "r" (p),
98 [id] "m" (IDENTITY)
99 : "memory"
100 );
101 }
102
103 void init_vector(vector3d_t *p, const vector3d_t *s)
104 {
105 float x0;
106
107 ARCH_X86_ASM
108 (
109 __ASM_EMIT("vmovups (%[s]), %[x0]")
110 __ASM_EMIT("vmovups %[x0], (%[p])")
111 : [x0] "=&x" (x0)
112 : [s] "r" (s), [p] "r" (p)
113 : "memory"
114 );
115 }
116
117 void normalize_vector(vector3d_t *v)
118 {
119 float x0, x1, x2;
120
121 ARCH_X86_ASM
122 (
123 __ASM_EMIT("vmovups (%[v]), %[x0]") // x0 = dx dy dz dw
124 __ASM_EMIT("vandps %[mask], %[x0], %[x0]") // x0 = dx dy dz 0
125 NORMALIZE("[x0]", "[x1]", "[x2]")
126 __ASM_EMIT("vmovups %[x0], (%[v])")
127
128 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
129 : [v] "r" (v),
130 [id] "m" (IDENTITY),
131 [mask] "m" (X_MASK0111)
132 : "cc", "memory"
133 );
134 }
135
136 void normalize_vector2(vector3d_t *v, const vector3d_t *sv)
137 {
138 float x0, x1, x2;
139
140 ARCH_X86_ASM
141 (
142 __ASM_EMIT("vmovups (%[sv]), %[x0]") // x0 = dx dy dz dw
143 __ASM_EMIT("vandps %[mask], %[x0], %[x0]") // x0 = dx dy dz 0
144 NORMALIZE("[x0]", "[x1]", "[x2]")
145 __ASM_EMIT("vmovups %[x0], (%[v])")
146
147 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
148 : [v] "r" (v),
149 [sv] "r" (sv),
150 [id] "m" (IDENTITY),
151 [mask] "m" (X_MASK0111)
152 : "cc", "memory"
153 );
154 }
155
156 void init_matrix3d_zero(matrix3d_t *m)
157 {
158 ARCH_X86_ASM
159 (
160 __ASM_EMIT("vxorps %%ymm0, %%ymm0, %%ymm0")
161 __ASM_EMIT("vmovups %%ymm0, 0x00(%[m])")
162 __ASM_EMIT("vmovups %%ymm0, 0x20(%[m])")
163 :
164 : [m] "r" (m)
165 : "memory",
166 "%xmm0"
167 );
168 }
169
170 void init_matrix3d_translate(matrix3d_t *m, float dx, float dy, float dz)
171 {
172 float x3, x4, x5;
173
174 ARCH_X86_ASM
175 (
176 __ASM_EMIT("vmovaps 0x00 + %[id], %[x3]") // x3 = 1 0 0 0
177 __ASM_EMIT("vmovaps 0x10 + %[id], %[x4]") // x4 = 0 1 0 0
178 __ASM_EMIT("vmovlhps %[x1], %[x0], %[x0]") // x0 = x ? y ?
179 __ASM_EMIT("vmovaps 0x20 + %[id], %[x5]") // x5 = 0 0 1 0
180 __ASM_EMIT("vmovhps 0x00 + %[id], %[x2], %[x2]") // x2 = z ? 1 0
181 __ASM_EMIT("vshufps $0x88, %[x2], %[x0], %[x0]") // x0 = x y z 1
182 MATRIX_STORE("m", "[x3]", "[x4]", "[x5]", "[x0]")
183
184 : [x0] "+x" (dx), [x1] "+x" (dy), [x2] "+x"(dz),
185 [x3] "=&x" (x3), [x4] "=&x" (x4), [x5] "=&x" (x5)
186 : [m] "r" (m),
187 [id] "o" (IDENTITY)
188 : "memory"
189 );
190 }
191
192 void init_matrix3d_scale(matrix3d_t *m, float sx, float sy, float sz)
193 {
194 float x3;
195
196 ARCH_X86_ASM
197 (
198 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0 0 0 0
199 __ASM_EMIT("vinsertps $0x00, %[x0], %[x3], %[x0]") // x0 = sx 0 0 0
200 __ASM_EMIT("vinsertps $0x10, %[x1], %[x3], %[x1]") // x0 = 0 sy 0 0
201 __ASM_EMIT("vinsertps $0x20, %[x2], %[x3], %[x2]") // x0 = 0 0 sz 0
202 __ASM_EMIT("vmovaps 0x30 + %[id], %[x3]") // x3 = 0 0 0 1
203
204 MATRIX_STORE("m", "[x0]", "[x1]", "[x2]", "[x3]")
205
206 : [x0] "+x" (sx), [x1] "+x" (sy), [x2] "+x"(sz),
207 [x3] "=&x" (x3)
208 : [m] "r" (m),
209 [id] "o" (IDENTITY)
210 : "memory"
211 );
212 }
213
214 void init_matrix3d_rotate_x(matrix3d_t *m, float angle)
215 {
216 float s = sinf(angle);
217 float c = cosf(angle);
218 float x2, x3;
219
220 ARCH_X86_ASM
221 (
222 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0 0 0 0
223 __ASM_EMIT("vmovaps 0x00 + %[id], %[x2]") // x2 = 1 0 0 0
224 __ASM_EMIT("vinsertps $0x10, %[x0], %[x3], %[x3]") // x3 = 0 s 0 0
225 __ASM_EMIT("vinsertps $0x20, %[x1], %[x3], %[x3]") // x3 = 0 s c 0
226 __ASM_EMIT("vmovaps 0x30 + %[id], %[x0]") // x0 = 0 0 0 1
227 __ASM_EMIT("vxorps %[mask], %[x3], %[x1]") // x1 = 0 -s c 0
228 __ASM_EMIT("vshufps $0xd8, %[x3], %[x3], %[x3]") // x3 = 0 c s 0
229
230 MATRIX_STORE("m", "[x2]", "[x3]", "[x1]", "[x0]")
231
232 : [x0] "+x" (s), [x1] "+x" (c), [x2] "=&x" (x2), [x3] "=&x" (x3)
233 : [m] "r" (m),
234 [id] "o" (IDENTITY),
235 [mask] "m" (X_SMASK0010)
236 : "memory"
237 );
238 }
239
240 void init_matrix3d_rotate_y(matrix3d_t *m, float angle)
241 {
242 float s = sinf(angle);
243 float c = cosf(angle);
244 float x2, x3;
245
246 ARCH_X86_ASM
247 (
248 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0 0 0 0
249 __ASM_EMIT("vmovaps 0x10 + %[id], %[x2]") // x2 = 0 1 0 0
250 __ASM_EMIT("vinsertps $0x20, %[x0], %[x3], %[x3]") // x3 = 0 0 s 0
251 __ASM_EMIT("vinsertps $0x00, %[x1], %[x3], %[x3]") // x3 = c 0 s 0
252 __ASM_EMIT("vmovaps 0x30 + %[id], %[x0]") // x0 = 0 0 0 1
253 __ASM_EMIT("vxorps %[mask], %[x3], %[x1]") // x1 = c 0 -s 0
254 __ASM_EMIT("vshufps $0xc6, %[x3], %[x3], %[x3]") // x3 = s 0 c 0
255
256 MATRIX_STORE("m", "[x1]", "[x2]", "[x3]", "[x0]")
257
258 : [x0] "+x" (s), [x1] "+x" (c), [x2] "=&x" (x2), [x3] "=&x" (x3)
259 : [m] "r" (m),
260 [id] "o" (IDENTITY),
261 [mask] "m" (X_SMASK0100)
262 : "memory"
263 );
264 }
265
266 void init_matrix3d_rotate_z(matrix3d_t *m, float angle)
267 {
268 float s = sinf(angle);
269 float c = cosf(angle);
270 float x2, x3;
271
272 ARCH_X86_ASM
273 (
274 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0 0 0 0
275 __ASM_EMIT("vmovaps 0x20 + %[id], %[x2]") // x2 = 0 0 1 0
276 __ASM_EMIT("vinsertps $0x00, %[x0], %[x3], %[x3]") // x3 = s 0 0 0
277 __ASM_EMIT("vinsertps $0x10, %[x1], %[x3], %[x3]") // x3 = s c 0 0
278 __ASM_EMIT("vmovaps 0x30 + %[id], %[x0]") // x0 = 0 0 0 1
279 __ASM_EMIT("vxorps %[mask], %[x3], %[x1]") // x1 = -s c 0 0
280 __ASM_EMIT("vshufps $0xe1, %[x3], %[x3], %[x3]") // x3 = c s 0 0
281
282 MATRIX_STORE("m", "[x3]", "[x1]", "[x2]", "[x0]")
283
284 : [x0] "+x" (s), [x1] "+x" (c), [x2] "=&x" (x2), [x3] "=&x" (x3)
285 : [m] "r" (m),
286 [id] "o" (IDENTITY),
287 [mask] "m" (X_SMASK0001)
288 : "memory"
289 );
290 }
291
292 void transpose_matrix3d1(matrix3d_t *r)
293 {
294 ARCH_X86_ASM
295 (
296 MATRIX_LOAD("m", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
297 MAT4_TRANSPOSE("%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4")
298 MATRIX_STORE("m", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
299 :
300 : [m] "r" (r)
301 : "memory",
302 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
303 "%xmm4"
304 );
305 }
306
307 void transpose_matrix3d2(matrix3d_t *r, const matrix3d_t *m)
308 {
309 ARCH_X86_ASM
310 (
311 MATRIX_LOAD("m", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
312 MAT4_TRANSPOSE("%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4")
313 MATRIX_STORE("r", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
314 :
315 : [r] "r" (r), [m] "r" (m)
316 : "memory",
317 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
318 "%xmm4"
319 );
320 }
321
322 void apply_matrix3d_mm2(matrix3d_t *r, const matrix3d_t *s, const matrix3d_t *m)
323 {
324 ARCH_X86_ASM
325 (
326 MATRIX_LOAD("A", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
327
328 // Multiply matrix and store
329 __ASM_EMIT("vmovups 0x00(%[B]), %%xmm4") // xmm4 = b0 b1 b2 b3
330 MATMUL_CORE(
331 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
332 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
333 "%xmm4")
334 __ASM_EMIT("vmovups %%xmm4, 0x00(%[R])")
335
336 __ASM_EMIT("vmovups 0x10(%[B]), %%xmm5") // xmm5 = b4 b5 b6 b7
337 MATMUL_CORE(
338 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
339 "%xmm5", "%xmm6", "%xmm7", "%xmm4",
340 "%xmm5")
341 __ASM_EMIT("vmovups %%xmm5, 0x10(%[R])")
342
343 __ASM_EMIT("vmovups 0x20(%[B]), %%xmm6") // xmm6 = b4 b5 b6 b7
344 MATMUL_CORE(
345 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
346 "%xmm6", "%xmm7", "%xmm4", "%xmm5",
347 "%xmm6")
348 __ASM_EMIT("vmovups %%xmm6, 0x20(%[R])")
349
350 __ASM_EMIT("vmovups 0x30(%[B]), %%xmm7") // xmm7 = b4 b5 b6 b7
351 MATMUL_CORE(
352 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
353 "%xmm7", "%xmm4", "%xmm5", "%xmm6",
354 "%xmm7")
355 __ASM_EMIT("vmovups %%xmm7, 0x30(%[R])")
356
357 :
358 : [A] "r" (s), [B] "r" (m), [R] "r" (r)
359 : "memory",
360 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
361 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
362 );
363 }
364
365 void apply_matrix3d_mm1(matrix3d_t *r, const matrix3d_t *m)
366 {
367 IF_ARCH_I386(
368 matrix3d_t __lsp_aligned32 t;
369 );
370
371 ARCH_X86_ASM
372 (
373 MATRIX_LOAD("A", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
374
375 // Multiply matrix and store
376 __ASM_EMIT("vmovups 0x00(%[B]), %%xmm4") // xmm4 = b0 b1 b2 b3
377 MATMUL_CORE(
378 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
379 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
380 __IF_32("%xmm4") __IF_64("%xmm8"))
381 __ASM_EMIT32("vmovaps %%xmm4, 0x00(%[T])")
382
383 __ASM_EMIT("vmovups 0x10(%[B]), %%xmm5") // xmm5 = b4 b5 b6 b7
384 MATMUL_CORE(
385 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
386 "%xmm5", "%xmm6", "%xmm7", "%xmm4",
387 __IF_32("%xmm5") __IF_64("%xmm9"))
388 __ASM_EMIT32("vmovaps %%xmm5, 0x10(%[T])")
389
390 __ASM_EMIT("vmovups 0x20(%[B]), %%xmm6") // xmm6 = b4 b5 b6 b7
391 MATMUL_CORE(
392 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
393 "%xmm6", "%xmm7", "%xmm4", "%xmm5",
394 __IF_32("%xmm6") __IF_64("%xmm10"))
395 __ASM_EMIT32("vmovaps %%xmm6, 0x20(%[T])")
396
397 __ASM_EMIT("vmovups 0x30(%[B]), %%xmm7") // xmm7 = b4 b5 b6 b7
398 MATMUL_CORE(
399 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
400 "%xmm7", "%xmm4", "%xmm5", "%xmm6",
401 __IF_32("%xmm7") __IF_64("%xmm11"))
402
403 // Save matrix (32-bit)
404 __ASM_EMIT32("vmovaps 0x00(%[T]), %%xmm0")
405 __ASM_EMIT32("vmovaps 0x10(%[T]), %%xmm1")
406 __ASM_EMIT32("vmovaps 0x20(%[T]), %%xmm6")
407 __ASM_EMIT32("vmovups %%xmm0, 0x00(%[A])")
408 __ASM_EMIT32("vmovups %%xmm1, 0x10(%[A])")
409 __ASM_EMIT32("vmovups %%xmm6, 0x20(%[A])")
410 __ASM_EMIT32("vmovups %%xmm7, 0x30(%[A])")
411
412 // Save matrix (64-bit)
413 __ASM_EMIT64("vmovups %%xmm8, 0x00(%[A])")
414 __ASM_EMIT64("vmovups %%xmm9, 0x10(%[A])")
415 __ASM_EMIT64("vmovups %%xmm10, 0x20(%[A])")
416 __ASM_EMIT64("vmovups %%xmm11, 0x30(%[A])")
417
418 :
419 : [A] "r" (r), [B] "r" (m)
420 __IF_32(, [T] "r" (&t))
421 : "memory",
422 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
423 , "%xmm4", "%xmm5", "%xmm6", "%xmm7"
424 __IF_64(, "%xmm8", "%xmm9", "%xmm10", "%xmm11")
425 );
426 }
427
428 void apply_matrix3d_mm2_fma3(matrix3d_t *r, const matrix3d_t *s, const matrix3d_t *m)
429 {
430 ARCH_X86_ASM
431 (
432 MATRIX_LOAD("A", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
433
434 // Multiply matrix and store
435 __ASM_EMIT("vmovups 0x00(%[B]), %%xmm4") // xmm4 = b0 b1 b2 b3
436 MATMUL_CORE_FMA3(
437 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
438 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
439 "%xmm4")
440 __ASM_EMIT("vmovups %%xmm4, 0x00(%[R])")
441
442 __ASM_EMIT("vmovups 0x10(%[B]), %%xmm5") // xmm5 = b4 b5 b6 b7
443 MATMUL_CORE_FMA3(
444 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
445 "%xmm5", "%xmm6", "%xmm7", "%xmm4",
446 "%xmm5")
447 __ASM_EMIT("vmovups %%xmm5, 0x10(%[R])")
448
449 __ASM_EMIT("vmovups 0x20(%[B]), %%xmm6") // xmm6 = b4 b5 b6 b7
450 MATMUL_CORE_FMA3(
451 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
452 "%xmm6", "%xmm7", "%xmm4", "%xmm5",
453 "%xmm6")
454 __ASM_EMIT("vmovups %%xmm6, 0x20(%[R])")
455
456 __ASM_EMIT("vmovups 0x30(%[B]), %%xmm7") // xmm7 = b4 b5 b6 b7
457 MATMUL_CORE_FMA3(
458 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
459 "%xmm7", "%xmm4", "%xmm5", "%xmm6",
460 "%xmm7")
461 __ASM_EMIT("vmovups %%xmm7, 0x30(%[R])")
462
463 :
464 : [A] "r" (s), [B] "r" (m), [R] "r" (r)
465 : "memory",
466 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
467 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
468 );
469 }
470
471 void apply_matrix3d_mm1_fma3(matrix3d_t *r, const matrix3d_t *m)
472 {
473 IF_ARCH_I386(
474 matrix3d_t __lsp_aligned32 t;
475 );
476
477 ARCH_X86_ASM
478 (
479 MATRIX_LOAD("A", "%xmm0", "%xmm1", "%xmm2", "%xmm3")
480
481 // Multiply matrix and store
482 __ASM_EMIT("vmovups 0x00(%[B]), %%xmm4") // xmm4 = b0 b1 b2 b3
483 MATMUL_CORE_FMA3(
484 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
485 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
486 __IF_32("%xmm4") __IF_64("%xmm8"))
487 __ASM_EMIT32("vmovaps %%xmm4, 0x00(%[T])")
488
489 __ASM_EMIT("vmovups 0x10(%[B]), %%xmm5") // xmm5 = b4 b5 b6 b7
490 MATMUL_CORE_FMA3(
491 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
492 "%xmm5", "%xmm6", "%xmm7", "%xmm4",
493 __IF_32("%xmm5") __IF_64("%xmm9"))
494 __ASM_EMIT32("vmovaps %%xmm5, 0x10(%[T])")
495
496 __ASM_EMIT("vmovups 0x20(%[B]), %%xmm6") // xmm6 = b4 b5 b6 b7
497 MATMUL_CORE_FMA3(
498 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
499 "%xmm6", "%xmm7", "%xmm4", "%xmm5",
500 __IF_32("%xmm6") __IF_64("%xmm10"))
501 __ASM_EMIT32("vmovaps %%xmm6, 0x20(%[T])")
502
503 __ASM_EMIT("vmovups 0x30(%[B]), %%xmm7") // xmm7 = b4 b5 b6 b7
504 MATMUL_CORE_FMA3(
505 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
506 "%xmm7", "%xmm4", "%xmm5", "%xmm6",
507 __IF_32("%xmm7") __IF_64("%xmm11"))
508
509 // Save matrix (32-bit)
510 __ASM_EMIT32("vmovaps 0x00(%[T]), %%xmm0")
511 __ASM_EMIT32("vmovaps 0x10(%[T]), %%xmm1")
512 __ASM_EMIT32("vmovaps 0x20(%[T]), %%xmm6")
513 __ASM_EMIT32("vmovups %%xmm0, 0x00(%[A])")
514 __ASM_EMIT32("vmovups %%xmm1, 0x10(%[A])")
515 __ASM_EMIT32("vmovups %%xmm6, 0x20(%[A])")
516 __ASM_EMIT32("vmovups %%xmm7, 0x30(%[A])")
517
518 // Save matrix (64-bit)
519 __ASM_EMIT64("vmovups %%xmm8, 0x00(%[A])")
520 __ASM_EMIT64("vmovups %%xmm9, 0x10(%[A])")
521 __ASM_EMIT64("vmovups %%xmm10, 0x20(%[A])")
522 __ASM_EMIT64("vmovups %%xmm11, 0x30(%[A])")
523
524 :
525 : [A] "r" (r), [B] "r" (m)
526 __IF_32(, [T] "r" (&t))
527 : "memory",
528 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
529 , "%xmm4", "%xmm5", "%xmm6", "%xmm7"
530 __IF_64(, "%xmm8", "%xmm9", "%xmm10", "%xmm11")
531 );
532 }
533
534 void apply_matrix3d_mv2(vector3d_t *r, const vector3d_t *v, const matrix3d_t *m)
535 {
536 ARCH_X86_ASM
537 (
538 __ASM_EMIT("vbroadcastss 0x00(%[v]), %%xmm0") // xmm0 = vx vx vx vx
539 __ASM_EMIT("vbroadcastss 0x04(%[v]), %%xmm1") // xmm1 = vy vy vy vy
540 __ASM_EMIT("vbroadcastss 0x08(%[v]), %%xmm2") // xmm2 = vz vz vz vz
541 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
542 __ASM_EMIT("vmulps 0x10(%[m]), %%xmm1, %%xmm1") // xmm1 = vy * (m4 m5 m6 m7)
543 __ASM_EMIT("vmulps 0x20(%[m]), %%xmm2, %%xmm2") // xmm2 = vz * (m8 m9 m10 m11)
544 __ASM_EMIT("vaddps %%xmm1, %%xmm0, %%xmm0")
545 __ASM_EMIT("vxorps %%xmm3, %%xmm3, %%xmm3") // xmm3 = 0 0 0 0
546 __ASM_EMIT("vaddps %%xmm2, %%xmm0, %%xmm0") // xmm0 = rx ry rz rw
547 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm1") // xmm1 = rw rw rw rw
548 __ASM_EMIT("vucomiss %%xmm1, %%xmm3") // xmm1 =?= xmm1
549 __ASM_EMIT("je 1f")
550 __ASM_EMIT("vdivps %%xmm1, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
551 __ASM_EMIT("1:")
552 __ASM_EMIT("vmovups %%xmm0, (%[r])")
553 :
554 : [r] "r" (r), [v] "r" (v), [m] "r" (m)
555 : "cc", "memory",
556 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
557 );
558 }
559
560 void apply_matrix3d_mv1(vector3d_t *r, const matrix3d_t *m)
561 {
562 ARCH_X86_ASM
563 (
564 __ASM_EMIT("vbroadcastss 0x00(%[r]), %%xmm0") // xmm0 = vx vx vx vx
565 __ASM_EMIT("vbroadcastss 0x04(%[r]), %%xmm1") // xmm1 = vy vy vy vy
566 __ASM_EMIT("vbroadcastss 0x08(%[r]), %%xmm2") // xmm2 = vz vz vz vz
567 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
568 __ASM_EMIT("vmulps 0x10(%[m]), %%xmm1, %%xmm1") // xmm1 = vy * (m4 m5 m6 m7)
569 __ASM_EMIT("vmulps 0x20(%[m]), %%xmm2, %%xmm2") // xmm2 = vz * (m8 m9 m10 m11)
570 __ASM_EMIT("vaddps %%xmm1, %%xmm0, %%xmm0")
571 __ASM_EMIT("vxorps %%xmm3, %%xmm3, %%xmm3") // xmm3 = 0 0 0 0
572 __ASM_EMIT("vaddps %%xmm2, %%xmm0, %%xmm0") // xmm0 = rx ry rz rw
573 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm1") // xmm1 = rw rw rw rw
574 __ASM_EMIT("vucomiss %%xmm1, %%xmm3") // xmm1 =?= 0
575 __ASM_EMIT("je 1f")
576 __ASM_EMIT("vdivps %%xmm1, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
577 __ASM_EMIT("1:")
578 __ASM_EMIT("vmovups %%xmm0, (%[r])")
579 :
580 : [r] "r" (r), [m] "r" (m)
581 : "cc", "memory",
582 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
583 );
584 }
585
586 void apply_matrix3d_mv2_fma3(vector3d_t *r, const vector3d_t *v, const matrix3d_t *m)
587 {
588 ARCH_X86_ASM
589 (
590 __ASM_EMIT("vbroadcastss 0x00(%[v]), %%xmm0") // xmm0 = vx vx vx vx
591 __ASM_EMIT("vbroadcastss 0x04(%[v]), %%xmm1") // xmm1 = vy vy vy vy
592 __ASM_EMIT("vbroadcastss 0x08(%[v]), %%xmm2") // xmm2 = vz vz vz vz
593 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
594 __ASM_EMIT("vxorps %%xmm3, %%xmm3, %%xmm3") // xmm3 = 0 0 0 0
595 __ASM_EMIT("vfmadd231ps 0x10(%[m]), %%xmm1, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
596 __ASM_EMIT("vfmadd231ps 0x20(%[m]), %%xmm2, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
597 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm1") // xmm1 = rw rw rw rw
598 __ASM_EMIT("vucomiss %%xmm1, %%xmm3") // xmm1 =?= xmm1
599 __ASM_EMIT("je 1f")
600 __ASM_EMIT("vdivps %%xmm1, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
601 __ASM_EMIT("1:")
602 __ASM_EMIT("vmovups %%xmm0, (%[r])")
603 :
604 : [r] "r" (r), [v] "r" (v), [m] "r" (m)
605 : "cc", "memory",
606 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
607 );
608 }
609
610 void apply_matrix3d_mv1_fma3(vector3d_t *r, const matrix3d_t *m)
611 {
612 ARCH_X86_ASM
613 (
614 __ASM_EMIT("vbroadcastss 0x00(%[r]), %%xmm0") // xmm0 = vx vx vx vx
615 __ASM_EMIT("vbroadcastss 0x04(%[r]), %%xmm1") // xmm1 = vy vy vy vy
616 __ASM_EMIT("vbroadcastss 0x08(%[r]), %%xmm2") // xmm2 = vz vz vz vz
617 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
618 __ASM_EMIT("vxorps %%xmm3, %%xmm3, %%xmm3") // xmm3 = 0 0 0 0
619 __ASM_EMIT("vfmadd231ps 0x10(%[m]), %%xmm1, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
620 __ASM_EMIT("vfmadd231ps 0x20(%[m]), %%xmm2, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
621 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm1") // xmm1 = rw rw rw rw
622 __ASM_EMIT("vucomiss %%xmm1, %%xmm3") // xmm1 =?= xmm1
623 __ASM_EMIT("je 1f")
624 __ASM_EMIT("vdivps %%xmm1, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
625 __ASM_EMIT("1:")
626 __ASM_EMIT("vmovups %%xmm0, (%[r])")
627 :
628 : [r] "r" (r), [m] "r" (m)
629 : "cc", "memory",
630 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
631 );
632 }
633
634 void apply_matrix3d_mp2(point3d_t *p, const point3d_t *s, const matrix3d_t *m)
635 {
636 ARCH_X86_ASM
637 (
638 __ASM_EMIT("vbroadcastss 0x00(%[s]), %%xmm0") // xmm0 = vx vx vx vx
639 __ASM_EMIT("vbroadcastss 0x04(%[s]), %%xmm1") // xmm1 = vy vy vy vy
640 __ASM_EMIT("vbroadcastss 0x08(%[s]), %%xmm2") // xmm2 = vz vz vz vz
641 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
642 __ASM_EMIT("vmulps 0x10(%[m]), %%xmm1, %%xmm1") // xmm1 = vy * (m4 m5 m6 m7)
643 __ASM_EMIT("vmulps 0x20(%[m]), %%xmm2, %%xmm2") // xmm2 = vz * (m8 m9 m10 m11)
644 __ASM_EMIT("vaddps %%xmm1, %%xmm0, %%xmm0")
645 __ASM_EMIT("vaddps 0x30(%[m]), %%xmm2, %%xmm2")
646 __ASM_EMIT("vxorps %%xmm3, %%xmm3, %%xmm3") // xmm3 = 0 0 0 0
647 __ASM_EMIT("vaddps %%xmm2, %%xmm0, %%xmm0") // xmm0 = rx ry rz rw
648 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm1") // xmm1 = rw rw rw rw
649 __ASM_EMIT("vucomiss %%xmm1, %%xmm3") // xmm1 =?= xmm1
650 __ASM_EMIT("je 1f")
651 __ASM_EMIT("vdivps %%xmm1, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
652 __ASM_EMIT("1:")
653 __ASM_EMIT("vmovups %%xmm0, (%[p])")
654 :
655 : [p] "r" (p), [s] "r" (s), [m] "r" (m)
656 : "cc", "memory",
657 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
658 );
659 }
660
661 void apply_matrix3d_mp1(point3d_t *p, const matrix3d_t *m)
662 {
663 ARCH_X86_ASM
664 (
665 __ASM_EMIT("vbroadcastss 0x00(%[p]), %%xmm0") // xmm0 = vx vx vx vx
666 __ASM_EMIT("vbroadcastss 0x04(%[p]), %%xmm1") // xmm1 = vy vy vy vy
667 __ASM_EMIT("vbroadcastss 0x08(%[p]), %%xmm2") // xmm2 = vz vz vz vz
668 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
669 __ASM_EMIT("vmulps 0x10(%[m]), %%xmm1, %%xmm1") // xmm1 = vy * (m4 m5 m6 m7)
670 __ASM_EMIT("vmulps 0x20(%[m]), %%xmm2, %%xmm2") // xmm2 = vz * (m8 m9 m10 m11)
671 __ASM_EMIT("vaddps %%xmm1, %%xmm0, %%xmm0")
672 __ASM_EMIT("vaddps 0x30(%[m]), %%xmm2, %%xmm2")
673 __ASM_EMIT("vxorps %%xmm3, %%xmm3, %%xmm3") // xmm3 = 0 0 0 0
674 __ASM_EMIT("vaddps %%xmm2, %%xmm0, %%xmm0") // xmm0 = rx ry rz rw
675 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm1") // xmm1 = rw rw rw rw
676 __ASM_EMIT("vucomiss %%xmm1, %%xmm3") // xmm1 =?= xmm1
677 __ASM_EMIT("je 1f")
678 __ASM_EMIT("vdivps %%xmm1, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
679 __ASM_EMIT("1:")
680 __ASM_EMIT("vmovups %%xmm0, (%[p])")
681 :
682 : [p] "r" (p), [m] "r" (m)
683 : "cc", "memory",
684 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
685 );
686 }
687
688 void apply_matrix3d_mp2_fma3(point3d_t *p, const point3d_t *s, const matrix3d_t *m)
689 {
690 ARCH_X86_ASM
691 (
692 __ASM_EMIT("vbroadcastss 0x00(%[s]), %%xmm0") // xmm0 = vx vx vx vx
693 __ASM_EMIT("vbroadcastss 0x04(%[s]), %%xmm1") // xmm1 = vy vy vy vy
694 __ASM_EMIT("vbroadcastss 0x08(%[s]), %%xmm2") // xmm2 = vz vz vz vz
695 __ASM_EMIT("vmulps 0x00(%[m]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
696 __ASM_EMIT("vmovups 0x30(%[m]), %%xmm3") // xmm3 = (m12 m13 m14 m15)
697 __ASM_EMIT("vfmadd231ps 0x10(%[m]), %%xmm1, %%xmm0")
698 __ASM_EMIT("vfmadd231ps 0x20(%[m]), %%xmm2, %%xmm3")
699 __ASM_EMIT("vxorps %%xmm1, %%xmm1, %%xmm1") // xmm1 = 0 0 0 0
700 __ASM_EMIT("vaddps %%xmm3, %%xmm0, %%xmm0") // xmm0 = rx ry rz rw
701 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm2") // xmm1 = rw rw rw rw
702 __ASM_EMIT("vucomiss %%xmm2, %%xmm1") // xmm2 =?= xmm2
703 __ASM_EMIT("je 1f")
704 __ASM_EMIT("vdivps %%xmm2, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
705 __ASM_EMIT("1:")
706 __ASM_EMIT("vmovups %%xmm0, (%[p])")
707 :
708 : [p] "r" (p), [s] "r" (s), [m] "r" (m)
709 : "cc", "memory",
710 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
711 );
712 }
713
714 void apply_matrix3d_mp1_fma3(point3d_t *p, const matrix3d_t *m)
715 {
716 ARCH_X86_ASM
717 (
718 __ASM_EMIT("vbroadcastss 0x00(%[p]), %%xmm0") // xmm0 = vx vx vx vx
719 __ASM_EMIT("vbroadcastss 0x04(%[p]), %%xmm1") // xmm1 = vy vy vy vy
720 __ASM_EMIT("vbroadcastss 0x08(%[p]), %%xmm2") // xmm2 = vz vz vz vz
721 __ASM_EMIT("vmulps 0x00(%[p]), %%xmm0, %%xmm0") // xmm0 = vx * (m0 m1 m2 m3)
722 __ASM_EMIT("vmovups 0x30(%[m]), %%xmm3") // xmm3 = (m12 m13 m14 m15)
723 __ASM_EMIT("vfmadd231ps 0x10(%[m]), %%xmm1, %%xmm0")
724 __ASM_EMIT("vfmadd231ps 0x20(%[m]), %%xmm2, %%xmm3")
725 __ASM_EMIT("vxorps %%xmm1, %%xmm1, %%xmm1") // xmm1 = 0 0 0 0
726 __ASM_EMIT("vaddps %%xmm3, %%xmm0, %%xmm0") // xmm0 = rx ry rz rw
727 __ASM_EMIT("vshufps $0xff, %%xmm0, %%xmm0, %%xmm2") // xmm1 = rw rw rw rw
728 __ASM_EMIT("vucomiss %%xmm2, %%xmm1") // xmm2 =?= xmm2
729 __ASM_EMIT("je 1f")
730 __ASM_EMIT("vdivps %%xmm2, %%xmm0, %%xmm0") // xmm0 = rx/r2 ry/r2 rz/rw rw/rw
731 __ASM_EMIT("1:")
732 __ASM_EMIT("vmovups %%xmm0, (%[p])")
733 :
734 : [p] "r" (p), [m] "r" (m)
735 : "cc", "memory",
736 "%xmm0", "%xmm1", "%xmm2", "%xmm3"
737 );
738 }
739
740 float calc_area_p3(const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
741 {
742 float x0, x1, x2, x3;
743
744 ARCH_X86_ASM
745 (
746 __ASM_EMIT("vmovups (%[p0]), %[x2]") /* x2 = p0 = x0 y0 z0 w0 */
747 __ASM_EMIT("vmovups (%[p1]), %[x0]") /* x1 = p1 = x1 y1 z1 w1 */
748 __ASM_EMIT("vmovups (%[p2]), %[x1]") /* x2 = p2 = x2 y2 z2 w2 */
749 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") /* x0 = p1 - p0 = dx1 dy1 dz1 0 */
750 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") /* x1 = p2 - p0 = dx2 dy2 dz2 0 */
751 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") /* x0 = NZ NX NY 0 */
752 VECTOR_DOT3("[x0]", "[x0]", "[x1]", "[x2]") /* x0 = NX*NX + NY*NY + NZ*NZ */
753 __ASM_EMIT("vsqrtss %[x0], %[x0], %[x0]") /* x0 = sqrtf(NX*NX + NY*NY + NZ*NZ) */
754 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
755 : [p0] "r" (p0), [p1] "r" (p1), [p2] "r" (p2)
756 : "memory"
757 );
758
759 return x0;
760 }
761
762 float calc_area_pv(const point3d_t *pv)
763 {
764 float x0, x1, x2, x3;
765
766 ARCH_X86_ASM
767 (
768 __ASM_EMIT("vmovups 0x00(%[pv]), %[x2]") /* x0 = p0 = x0 y0 z0 w0 */
769 __ASM_EMIT("vmovups 0x10(%[pv]), %[x0]") /* x1 = p1 = x1 y1 z1 w1 */
770 __ASM_EMIT("vmovups 0x20(%[pv]), %[x1]") /* x2 = p2 = x2 y2 z2 w2 */
771 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") /* x0 = p1 - p0 = dx1 dy1 dz1 0 */
772 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") /* x1 = p2 - p0 = dx2 dy2 dz2 0 */
773 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") /* x0 = NZ NX NY 0 */
774 VECTOR_DOT3("[x0]", "[x0]", "[x1]", "[x2]") /* x0 = NX*NX + NY*NY + NZ*NZ */
775 __ASM_EMIT("vsqrtss %[x0], %[x0], %[x0]") /* x0 = sqrtf(NX*NX + NY*NY + NZ*NZ) */
776
777 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
778 : [pv] "r" (pv)
779 : "memory"
780 );
781
782 return x0;
783 }
784
785 float calc_area_p3_fma3(const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
786 {
787 float x0, x1, x2, x3;
788
789 ARCH_X86_ASM
790 (
791 __ASM_EMIT("vmovups (%[p0]), %[x2]") /* x2 = x0 y0 z0 w0 */
792 __ASM_EMIT("vmovups (%[p1]), %[x0]") /* x1 = x1 y1 z1 w1 */
793 __ASM_EMIT("vmovups (%[p2]), %[x1]") /* x2 = x2 y2 z2 w2 */
794 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") /* x0 = p1 - p0 = dx1 dy1 dz1 0 */
795 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") /* x1 = p2 - p0 = dx2 dy2 dz2 0 */
796 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") /* x0 = NZ NX NY 0 */
797 VECTOR_DOT3("[x0]", "[x0]", "[x1]", "[x2]") /* x0 = NX*NX + NY*NY + NZ*NZ */
798 __ASM_EMIT("vsqrtss %[x0], %[x0], %[x0]") /* x0 = sqrtf(NX*NX + NY*NY + NZ*NZ) */
799 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
800 : [p0] "r" (p0), [p1] "r" (p1), [p2] "r" (p2)
801 : "memory"
802 );
803
804 return x0;
805 }
806
807 float calc_area_pv_fma3(const point3d_t *pv)
808 {
809 float x0, x1, x2, x3;
810
811 ARCH_X86_ASM
812 (
813 __ASM_EMIT("vmovups 0x00(%[pv]), %[x2]") /* x0 = x0 y0 z0 w0 */
814 __ASM_EMIT("vmovups 0x10(%[pv]), %[x0]") /* x1 = x1 y1 z1 w1 */
815 __ASM_EMIT("vmovups 0x20(%[pv]), %[x1]") /* x2 = x2 y2 z2 w2 */
816 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") /* x0 = p1 - p0 = dx1 dy1 dz1 0 */
817 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") /* x1 = p2 - p0 = dx2 dy2 dz2 0 */
818 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") /* x0 = NZ NX NY 0 */
819 VECTOR_DOT3("[x0]", "[x0]", "[x1]", "[x2]") /* x0 = NX*NX + NY*NY + NZ*NZ */
820 __ASM_EMIT("vsqrtss %[x0], %[x0], %[x0]") /* x0 = sqrtf(NX*NX + NY*NY + NZ*NZ) */
821
822 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
823 : [pv] "r" (pv)
824 : "memory"
825 );
826
827 return x0;
828 }
829
830 size_t colocation_x2_v1p2(const vector3d_t *pl, const point3d_t *p0, const point3d_t *p1)
831 {
832 float x0, x1, x2;
833
834 ARCH_X86_ASM
835 (
836 __ASM_EMIT("vmovups (%[pl]), %[x2]") /* x2 = pl */
837 __ASM_EMIT("vmulps (%[p0]), %[x2], %[x0]") /* x0 = x0*px y0*py z0*pz w0*pw */
838 __ASM_EMIT("vmulps (%[p1]), %[x2], %[x1]") /* x1 = x1*px y1*py z1*pz w1*pw */
839 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]") /* x0 = x0*px+y0*py z0*pz+w0*pw x1*px+y1*py z1*pz+w1*pw */
840 __ASM_EMIT("vhaddps %[x0], %[x0], %[x0]") /* x0 = x1*px+y1*py+z1*pz+w1*pw x1*px+y1*py+z1*pz+w1*pw ? ? = k0 k1 ? ? */
841
842 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL ? ? */
843 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL ? ? */
844 __ASM_EMIT("vpand %[IONE], %[x1], %[x1]") /* x1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
845 __ASM_EMIT("vpand %[IONE], %[x2], %[x2]") /* x2 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
846 __ASM_EMIT("vpaddd %[x1], %[x2], %[x0]")
847 __ASM_EMIT("vextractps $0x00, %[x0], %[p0]")
848 __ASM_EMIT("vextractps $0x01, %[x0], %[p1]")
849 __ASM_EMIT("lea (%[p0], %[p1], 4), %[p0]")
850 : [p0] "+r" (p0), [p1] "+r" (p1),
851 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
852 : [pl] "r" (pl),
853 [PTOL] "m" (X_3D_TOLERANCE),
854 [MTOL] "m" (X_3D_MTOLERANCE),
855 [IONE] "m" (IONE)
856 : "cc", "memory"
857 );
858
859 return size_t(p0);
860 }
861
862 size_t colocation_x2_v1pv(const vector3d_t *pl, const point3d_t *pv)
863 {
864 float x0, x1, x2;
865
866 ARCH_X86_ASM
867 (
868 __ASM_EMIT("vmovups (%[pl]), %[x2]") /* x2 = pl */
869 __ASM_EMIT("vmulps 0x00(%[pv]), %[x2], %[x0]") /* x0 = x0*px y0*py z0*pz w0*pw */
870 __ASM_EMIT("vmulps 0x10(%[pv]), %[x2], %[x1]") /* x1 = x1*px y1*py z1*pz w1*pw */
871 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]") /* x0 = x0*px+y0*py z0*pz+w0*pw x1*px+y1*py z1*pz+w1*pw */
872 __ASM_EMIT("vhaddps %[x0], %[x0], %[x0]") /* x0 = x1*px+y1*py+z1*pz+w1*pw x1*px+y1*py+z1*pz+w1*pw ? ? = k0 k1 ? ? */
873
874 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL ? ? */
875 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL ? ? */
876 __ASM_EMIT("vpand %[IONE], %[x1], %[x1]") /* x1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
877 __ASM_EMIT("vpand %[IONE], %[x2], %[x2]") /* x2 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
878 __ASM_EMIT("vpaddd %[x1], %[x2], %[x0]")
879 __ASM_EMIT("vextractps $0x00, %[x0], %[pl]")
880 __ASM_EMIT("vextractps $0x01, %[x0], %[pv]")
881 __ASM_EMIT("lea (%[pl], %[pv], 4), %[pl]")
882 : [pl] "+r" (pl), [pv] "+r" (pv),
883 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
884 : [PTOL] "m" (X_3D_TOLERANCE),
885 [MTOL] "m" (X_3D_MTOLERANCE),
886 [IONE] "m" (IONE)
887 : "cc", "memory"
888 );
889
890 return size_t(pl);
891 }
892
893 size_t colocation_x3_v1p3(const vector3d_t *pl, const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
894 {
895 float x0, x1, x2, x3;
896
897 ARCH_X86_ASM
898 (
899 __ASM_EMIT("vmovups (%[pl]), %[x3]") /* x3 = pl */
900 __ASM_EMIT("vmulps (%[p0]), %[x3], %[x0]") /* x0 = p0 * pl */
901 __ASM_EMIT("vmulps (%[p1]), %[x3], %[x1]") /* x1 = p1 * pl */
902 __ASM_EMIT("vmulps (%[p2]), %[x3], %[x2]") /* x2 = p2 * pl */
903 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]")
904 __ASM_EMIT("vhaddps %[x3], %[x2], %[x2]")
905 __ASM_EMIT("vhaddps %[x2], %[x0], %[x0]") /* x0 = k0 k1 k2 ? */
906 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL ? ? */
907 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL ? ? */
908 __ASM_EMIT("vpand %[IONE], %[x1], %[x1]") /* x1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
909 __ASM_EMIT("vpand %[IONE], %[x2], %[x2]") /* x2 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
910 __ASM_EMIT("vpaddd %[x1], %[x2], %[x0]")
911 __ASM_EMIT("vextractps $0x00, %[x0], %[p0]")
912 __ASM_EMIT("vextractps $0x01, %[x0], %[p1]")
913 __ASM_EMIT("vextractps $0x02, %[x0], %[p2]")
914 __ASM_EMIT("lea (%[p1], %[p2], 4), %[p1]")
915 __ASM_EMIT("lea (%[p0], %[p1], 4), %[p0]")
916 : [p0] "+r" (p0), [p1] "+r" (p1), [p2] "+r" (p2),
917 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
918 : [pl] "r" (pl),
919 [PTOL] "m" (X_3D_TOLERANCE),
920 [MTOL] "m" (X_3D_MTOLERANCE),
921 [IONE] "m" (IONE)
922 : "cc", "memory"
923 );
924
925 return size_t(p0);
926 }
927
928 size_t colocation_x3_v1pv(const vector3d_t *pl, const point3d_t *pv)
929 {
930 float x0, x1, x2, x3;
931 size_t pt;
932
933 ARCH_X86_ASM
934 (
935 __ASM_EMIT("vmovups (%[pl]), %[x3]") /* x3 = pl */
936 __ASM_EMIT("vmulps 0x00(%[pv]), %[x3], %[x0]") /* x0 = p0 * pl */
937 __ASM_EMIT("vmulps 0x10(%[pv]), %[x3], %[x1]") /* x1 = p1 * pl */
938 __ASM_EMIT("vmulps 0x20(%[pv]), %[x3], %[x2]") /* x2 = p2 * pl */
939 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]")
940 __ASM_EMIT("vhaddps %[x3], %[x2], %[x2]")
941 __ASM_EMIT("vhaddps %[x2], %[x0], %[x0]") /* x0 = k0 k1 k2 ? */
942 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL ? ? */
943 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL ? ? */
944 __ASM_EMIT("vpand %[IONE], %[x1], %[x1]") /* x1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
945 __ASM_EMIT("vpand %[IONE], %[x2], %[x2]") /* x2 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
946 __ASM_EMIT("vpaddd %[x1], %[x2], %[x0]")
947 __ASM_EMIT("vextractps $0x00, %[x0], %[pt]")
948 __ASM_EMIT("vextractps $0x01, %[x0], %[pl]")
949 __ASM_EMIT("vextractps $0x02, %[x0], %[pv]")
950 __ASM_EMIT("lea (%[pl], %[pv], 4), %[pl]")
951 __ASM_EMIT("lea (%[pt], %[pl], 4), %[pt]")
952 : [pl] "+r" (pl), [pv] "+r" (pv), [pt] "=&r" (pt),
953 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
954 : [PTOL] "m" (X_3D_TOLERANCE),
955 [MTOL] "m" (X_3D_MTOLERANCE),
956 [IONE] "m" (IONE)
957 : "cc", "memory"
958 );
959
960 return pt;
961 }
962
963 size_t colocation_x3_v3p1(const vector3d_t *v0, const vector3d_t *v1, const vector3d_t *v2, const point3d_t *p)
964 {
965 float x0, x1, x2, x3;
966
967 ARCH_X86_ASM
968 (
969 __ASM_EMIT("vmovups (%[p]), %[x3]") /* x3 = p */
970 __ASM_EMIT("vmulps (%[v0]), %[x3], %[x0]") /* x0 = v0 * p */
971 __ASM_EMIT("vmulps (%[v1]), %[x3], %[x1]") /* x1 = v1 * p */
972 __ASM_EMIT("vmulps (%[v2]), %[x3], %[x2]") /* x2 = v2 * p */
973 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]")
974 __ASM_EMIT("vhaddps %[x3], %[x2], %[x2]")
975 __ASM_EMIT("vhaddps %[x2], %[x0], %[x0]") /* x0 = k0 k1 k2 ? */
976 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL ? ? */
977 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL ? ? */
978 __ASM_EMIT("vpand %[IONE], %[x1], %[x1]") /* x1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
979 __ASM_EMIT("vpand %[IONE], %[x2], %[x2]") /* x2 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
980 __ASM_EMIT("vpaddd %[x1], %[x2], %[x0]")
981 __ASM_EMIT("vextractps $0x00, %[x0], %[v0]")
982 __ASM_EMIT("vextractps $0x01, %[x0], %[v1]")
983 __ASM_EMIT("vextractps $0x02, %[x0], %[v2]")
984 __ASM_EMIT("lea (%[v1], %[v2], 4), %[v1]")
985 __ASM_EMIT("lea (%[v0], %[v1], 4), %[v0]")
986
987 : [v0] "+r" (v0), [v1] "+r" (v1), [v2] "+r" (v2),
988 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
989 : [p] "r" (p),
990 [PTOL] "m" (X_3D_TOLERANCE),
991 [MTOL] "m" (X_3D_MTOLERANCE),
992 [IONE] "m" (IONE)
993 : "cc", "memory"
994 );
995
996 return size_t(v0);
997 }
998
999 size_t colocation_x3_vvp1(const vector3d_t *vv, const point3d_t *p)
1000 {
1001 float x0, x1, x2, x3;
1002 size_t pt;
1003
1004 ARCH_X86_ASM
1005 (
1006 __ASM_EMIT("vmovups (%[p]), %[x3]") /* x3 = p */
1007 __ASM_EMIT("vmulps 0x00(%[vv]), %[x3], %[x0]") /* x0 = v0 * p */
1008 __ASM_EMIT("vmulps 0x10(%[vv]), %[x3], %[x1]") /* x1 = v1 * p */
1009 __ASM_EMIT("vmulps 0x20(%[vv]), %[x3], %[x2]") /* x2 = v2 * p */
1010 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]")
1011 __ASM_EMIT("vhaddps %[x3], %[x2], %[x2]")
1012 __ASM_EMIT("vhaddps %[x2], %[x0], %[x0]") /* x0 = k0 k1 k2 ? */
1013 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL ? ? */
1014 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL ? ? */
1015 __ASM_EMIT("vpand %[IONE], %[x1], %[x1]") /* x1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
1016 __ASM_EMIT("vpand %[IONE], %[x2], %[x2]") /* x2 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
1017 __ASM_EMIT("vpaddd %[x1], %[x2], %[x0]")
1018 __ASM_EMIT("vextractps $0x00, %[x0], %[pt]")
1019 __ASM_EMIT("vextractps $0x01, %[x0], %[vv]")
1020 __ASM_EMIT("vextractps $0x02, %[x0], %[p]")
1021 __ASM_EMIT("lea (%[vv], %[p], 4), %[vv]")
1022 __ASM_EMIT("lea (%[pt], %[vv], 4), %[pt]")
1023
1024 : [p] "+r" (p), [vv] "+r" (vv), [pt] "=&r" (pt),
1025 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1026 : [PTOL] "m" (X_3D_TOLERANCE),
1027 [MTOL] "m" (X_3D_MTOLERANCE),
1028 [IONE] "m" (IONE)
1029 : "cc", "memory"
1030 );
1031
1032 return pt;
1033 }
1034
1035 void split_triangle_raw(
1036 raw_triangle_t *out,
1037 size_t *n_out,
1038 raw_triangle_t *in,
1039 size_t *n_in,
1040 const vector3d_t *pl,
1041 const raw_triangle_t *pv)
1042 {
1043 float x0, x1, x2, x3, x4, x5, x6, x7;
1044 float k[4] __lsp_aligned16;
1045 size_t t0;
1046
1047 in += *n_in;
1048 out += *n_out;
1049
1050 // Estimate co-location of triangle and plane
1051 ARCH_X86_ASM
1052 (
1053 __ASM_EMIT("vmovups (%[pl]), %[x3]") /* x3 = pl */
1054 __ASM_EMIT("vmulps 0x00(%[pv]), %[x3], %[x0]") /* x0 = p0 * pl = sx0 sy0 sz0 sw0 */
1055 __ASM_EMIT("vmulps 0x10(%[pv]), %[x3], %[x1]") /* x1 = p1 * pl = sx1 sy1 sz1 sw1 */
1056 __ASM_EMIT("vmulps 0x20(%[pv]), %[x3], %[x2]") /* x2 = p2 * pl = sx2 sy2 sz2 sw2 */
1057 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]") /* x0 = sx0+sy0 sz0+sw0 sx1+sy1 sz1+sw1 */
1058 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") /* x2 = sx2+sy2 sz2+sw2 sx2+sy2 sz2+sw2 */
1059 __ASM_EMIT("vhaddps %[x2], %[x0], %[x0]") /* x0 = sx0+sy0+sz0+sw0 sx1+sy1+sz1+sw1 sx2+sy2+sz2+sw2 sx2+sy2+sz2+sw2 = k0 k1 k2 k2 */
1060 __ASM_EMIT("vmovaps %[x0], (%[k])") /* *k = x0 */
1061 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL k2 < -TOL k2 < -TOL */
1062 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL k2 <= +TOL k2 <= +TOL */
1063 __ASM_EMIT("vpand %[ICULL3], %[x1], %[x1]") /* x1 = 0x01*[k0 < -TOL] 0x04*[k1 < -TOL] 0x10*[k2 < -TOL] 0 */
1064 __ASM_EMIT("vpand %[ICULL3], %[x2], %[x2]") /* x2 = 0x01*[k0 <= +TOL] 0x04*[k1 <= +TOL] 0x10*[k2 <= +TOL] 0 */
1065 __ASM_EMIT("vpaddd %[x2], %[x1], %[x0]") /* x0 = x0 x1 x2 0 */
1066 __ASM_EMIT("vphaddd %[x0], %[x0], %[x0]") /* x0 = x0+x1 x2+0 x0+x1 x2+0 */
1067 __ASM_EMIT("vphaddd %[x0], %[x0], %[x0]") /* x0 = x0+x1+x2+0 x0+x1+x2+0 x0+x1+x2+0 */
1068 __ASM_EMIT32("vmovd %[x0], %[t0]")
1069 __ASM_EMIT64("vmovd %[x0], %k[t0]")
1070
1071 : [t0] "=&r" (t0),
1072 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
1073 [x4] "=&x" (x4)
1074 : [pl] "r" (pl), [pv] "r" (pv),
1075 [k] "r" (k),
1076 [PTOL] "m" (X_3D_TOLERANCE),
1077 [MTOL] "m" (X_3D_MTOLERANCE),
1078 [ICULL3] "m" (ICULL3)
1079 : "cc", "memory"
1080 );
1081
1082 #define STR_COPY_TO(tgt) \
1083 ARCH_X86_ASM( \
1084 __ASM_EMIT("vmovups 0x00(%[src]), %%xmm0") \
1085 __ASM_EMIT("vmovups 0x10(%[src]), %%xmm1") \
1086 __ASM_EMIT("vmovups 0x20(%[src]), %%xmm2") \
1087 __ASM_EMIT("vmovups %%xmm0, 0x00(%[dst])") \
1088 __ASM_EMIT("vmovups %%xmm1, 0x10(%[dst])") \
1089 __ASM_EMIT("vmovups %%xmm2, 0x20(%[dst])") \
1090 : \
1091 : [dst] "r" (tgt), \
1092 [src] "r" (pv) \
1093 : "cc", "memory", \
1094 "%xmm0", "%xmm1" \
1095 );
1096
1097 #define STR_SPLIT_1P(off0, off1, koff, store) \
1098 ARCH_X86_ASM( \
1099 __ASM_EMIT("vmovups 0x" off0 "(%[st]), %[x0]") /* x0 = p0 = lx0 ly0 lz0 1 */ \
1100 __ASM_EMIT("vmovups 0x" off1 "(%[st]), %[x1]") /* x1 = p1 = lx1 ly1 lz1 1 */ \
1101 __ASM_EMIT("vmovups (%[pl]), %[x2]") /* x2 = pl = nx ny nz nw */ \
1102 \
1103 __ASM_EMIT("vsubps %[x0], %[x1], %[x1]") /* x1 = d = p1 - p0 = dx dy dz 0 */ \
1104 __ASM_EMIT("vbroadcastss 0x" koff "(%[k]), %[x3]") /* x3 = k k k k */ \
1105 __ASM_EMIT("vmulps %[x1], %[x2], %[x2]") /* x2 = dx*nx dy*ny dz*nz 0 */ \
1106 __ASM_EMIT("vmulps %[x3], %[x1], %[x1]") /* x1 = k*dx k*dy k*dz 0 */ \
1107 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") /* x2 = dx*nx+dy*ny dz*nz dx*nx+dy*ny dz*nz */ \
1108 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") /* x2 = dx*nx+dy*ny+dz*nz = b b b b */ \
1109 __ASM_EMIT("vdivps %[x2], %[x1], %[x1]") /* x1 = k*dx/b k*dy/b k*dz/b 0 */ \
1110 __ASM_EMIT("vsubps %[x1], %[x0], %[x0]") /* x0 = lx0-k*dx/b ly0-k*dy/b lz0-k*dz/b 1 */ \
1111 \
1112 store \
1113 \
1114 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4) \
1115 : [st] "r" (pv), [pl] "r" (pl), [out] "r" (out), [in] "r" (in), \
1116 [k] "r" (k) \
1117 : "cc", "memory" \
1118 );
1119
1120 #define STR_SPLIT_2P(off0, off1, off2, koff, store) \
1121 ARCH_X86_ASM( \
1122 __ASM_EMIT("vmovups 0x" off0 "(%[st]), %[x0]") /* x0 = p0 = lx0 ly0 lz0 1 */ \
1123 __ASM_EMIT("vmovups 0x" off1 "(%[st]), %[x2]") /* x2 = p1 = lx1 ly1 lz1 1 */ \
1124 __ASM_EMIT("vmovups 0x" off2 "(%[st]), %[x3]") /* x3 = p2 = lx2 ly2 lz2 1 */ \
1125 __ASM_EMIT("vmovups (%[pl]), %[x4]") /* x4 = pl = nx ny nz nw */ \
1126 \
1127 __ASM_EMIT("vsubps %[x0], %[x3], %[x3]") /* x3 = d2 = p2 - p0 = dx2 dy2 dz2 0 */ \
1128 __ASM_EMIT("vsubps %[x0], %[x2], %[x2]") /* x2 = d1 = p1 - p0 = dx1 dy1 dz1 0 */ \
1129 __ASM_EMIT("vmulps %[x3], %[x4], %[x5]") /* x5 = dx2*nx dy2*ny dz2*nz 0 */ \
1130 __ASM_EMIT("vmulps %[x2], %[x4], %[x4]") /* x4 = dx1*nx dy1*ny dz1*nz 0 */ \
1131 __ASM_EMIT("vbroadcastss 0x" koff "(%[k]), %[x6]") /* x6 = k k k k */ \
1132 __ASM_EMIT("vhaddps %[x5], %[x5], %[x5]") /* x5 = dx2*nx+dy2*ny dz2*nz dx2*nx+dy2*ny dz2*nz */ \
1133 __ASM_EMIT("vhaddps %[x4], %[x4], %[x4]") /* x4 = dx1*nx+dy1*ny dz1*nz dx1*nx+dy1*ny dz1*nz */ \
1134 __ASM_EMIT("vhaddps %[x5], %[x5], %[x5]") /* x5 = dx2*nx+dy2*ny+dz2*nz = b2 b2 b2 b2 */ \
1135 __ASM_EMIT("vhaddps %[x4], %[x4], %[x4]") /* x4 = dx1*nx+dy1*ny+dz1*nz = b1 b1 b1 b1 */ \
1136 __ASM_EMIT("vdivps %[x5], %[x3], %[x3]") /* x3 = dx2/b2 dy2/b2 dz2/b2 0 */ \
1137 __ASM_EMIT("vdivps %[x4], %[x2], %[x2]") /* x2 = dx1/b1 dy1/b1 dz1/b1 0 */ \
1138 __ASM_EMIT("vmulps %[x6], %[x3], %[x3]") /* x3 = k*dx2/b2 k*dy2/b2 k*dz2/b2 0 */ \
1139 __ASM_EMIT("vmulps %[x6], %[x2], %[x2]") /* x2 = k*dx1/b1 k*dy1/b1 k*dz1/b1 0 */ \
1140 __ASM_EMIT("vsubps %[x3], %[x0], %[x1]") /* x1 = lx0-k*dx2/b2 ly0-k*dy2/b2 lz0-k*dz2/b2 1 */ \
1141 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") /* x0 = lx0-k*dx1/b1 ly0-k*dy1/b1 lz0-k*dz1/b1 1 */ \
1142 \
1143 store \
1144 \
1145 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), \
1146 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7) \
1147 : [st] "r" (pv), [pl] "r" (pl), [out] "r" (out), [in] "r" (in), \
1148 [k] "r" (k) \
1149 : "cc", "memory" \
1150 );
1151
1152 switch (t0)
1153 {
1154 // 0 intersections, triangle is above
1155 case 0x00: // 0 0 0
1156 case 0x01: // 0 0 1
1157 case 0x04: // 0 1 0
1158 case 0x05: // 0 1 1
1159 case 0x10: // 1 0 0
1160 case 0x11: // 1 0 1
1161 case 0x14: // 1 1 0
1162 case 0x15: // 1 1 1
1163 STR_COPY_TO(out);
1164 ++(*n_out);
1165 break;
1166
1167 // 0 intersections, triangle is below
1168 case 0x16: // 1 1 2
1169 case 0x19: // 1 2 1
1170 case 0x1a: // 1 2 2
1171 case 0x25: // 2 1 1
1172 case 0x26: // 2 1 2
1173 case 0x29: // 2 2 1
1174 case 0x2a: // 2 2 2
1175 STR_COPY_TO(in);
1176 ++(*n_in);
1177 break;
1178
1179 // 1 intersection, 1 triangle above, 1 triangle below, counter-clockwise
1180 case 0x06: // 0 1 2
1181 STR_SPLIT_1P("00", "20", "00",
1182 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1183 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1184 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1185 __ASM_EMIT("vmovups %[x1], 0x00(%[in])")
1186 __ASM_EMIT("vmovups %[x2], 0x10(%[in])")
1187 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1188 __ASM_EMIT("vmovups %[x2], 0x00(%[out])")
1189 __ASM_EMIT("vmovups %[x3], 0x10(%[out])")
1190 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1191 );
1192 ++(*n_out); ++(*n_in);
1193 break;
1194 case 0x21: // 2 0 1
1195 STR_SPLIT_1P("00", "10", "00",
1196 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1197 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1198 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1199 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1200 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1201 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1202 __ASM_EMIT("vmovups %[x2], 0x00(%[out])")
1203 __ASM_EMIT("vmovups %[x0], 0x10(%[out])")
1204 __ASM_EMIT("vmovups %[x1], 0x20(%[out])")
1205 );
1206 ++(*n_out); ++(*n_in);
1207 break;
1208 case 0x18: // 1 2 0
1209 STR_SPLIT_1P("10", "20", "04",
1210 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1211 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1212 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1213 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1214 __ASM_EMIT("vmovups %[x3], 0x10(%[in])")
1215 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1216 __ASM_EMIT("vmovups %[x1], 0x00(%[out])")
1217 __ASM_EMIT("vmovups %[x0], 0x10(%[out])")
1218 __ASM_EMIT("vmovups %[x3], 0x20(%[out])")
1219 );
1220 ++(*n_out); ++(*n_in);
1221 break;
1222
1223 // 1 intersection, 1 triangle above, 1 triangle below, clockwise
1224 case 0x24: // 2 1 0
1225 STR_SPLIT_1P("00", "20", "00",
1226 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1227 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1228 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1229 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1230 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1231 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1232 __ASM_EMIT("vmovups %[x1], 0x00(%[out])")
1233 __ASM_EMIT("vmovups %[x2], 0x10(%[out])")
1234 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1235 );
1236 ++(*n_out); ++(*n_in);
1237 break;
1238 case 0x12: // 1 0 2
1239 STR_SPLIT_1P("00", "10", "00",
1240 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1241 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1242 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1243 __ASM_EMIT("vmovups %[x1], 0x00(%[in])")
1244 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1245 __ASM_EMIT("vmovups %[x3], 0x20(%[in])")
1246 __ASM_EMIT("vmovups %[x2], 0x00(%[out])")
1247 __ASM_EMIT("vmovups %[x3], 0x10(%[out])")
1248 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1249 );
1250 ++(*n_out); ++(*n_in);
1251 break;
1252 case 0x09: // 0 2 1
1253 STR_SPLIT_1P("10", "20", "04",
1254 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1255 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1256 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1257 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1258 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1259 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1260 __ASM_EMIT("vmovups %[x3], 0x00(%[out])")
1261 __ASM_EMIT("vmovups %[x1], 0x10(%[out])")
1262 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1263 );
1264 ++(*n_out); ++(*n_in);
1265 break;
1266
1267 // 2 intersections, 1 triangle below, 2 triangles above
1268 case 0x02: // 0 0 2
1269 STR_SPLIT_2P("00", "10", "20", "00",
1270 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1271 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1272 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1273 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1274 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1275 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1276 __ASM_EMIT("vmovups %[x3], 0x00(%[out])")
1277 __ASM_EMIT("vmovups %[x1], 0x10(%[out])")
1278 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1279 __ASM_EMIT("vmovups %[x4], 0x30(%[out])")
1280 __ASM_EMIT("vmovups %[x1], 0x40(%[out])")
1281 __ASM_EMIT("vmovups %[x3], 0x50(%[out])")
1282 );
1283 (*n_out) += 2; ++(*n_in);
1284 break;
1285 case 0x08: // 0 2 0
1286 STR_SPLIT_2P("10", "00", "20", "04",
1287 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1288 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1289 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1290 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1291 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1292 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1293 __ASM_EMIT("vmovups %[x4], 0x00(%[out])")
1294 __ASM_EMIT("vmovups %[x0], 0x10(%[out])")
1295 __ASM_EMIT("vmovups %[x1], 0x20(%[out])")
1296 __ASM_EMIT("vmovups %[x2], 0x30(%[out])")
1297 __ASM_EMIT("vmovups %[x0], 0x40(%[out])")
1298 __ASM_EMIT("vmovups %[x4], 0x50(%[out])")
1299 );
1300 (*n_out) += 2; ++(*n_in);
1301 break;
1302 case 0x20: // 2 0 0
1303 STR_SPLIT_2P("20", "00", "10", "08",
1304 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1305 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1306 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1307 __ASM_EMIT("vmovups %[x4], 0x00(%[in])")
1308 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1309 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1310 __ASM_EMIT("vmovups %[x2], 0x00(%[out])")
1311 __ASM_EMIT("vmovups %[x1], 0x10(%[out])")
1312 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1313 __ASM_EMIT("vmovups %[x3], 0x30(%[out])")
1314 __ASM_EMIT("vmovups %[x1], 0x40(%[out])")
1315 __ASM_EMIT("vmovups %[x2], 0x50(%[out])")
1316 );
1317 (*n_out) += 2; ++(*n_in);
1318 break;
1319
1320 // 2 intersections, 1 triangle above, 2 triangles below
1321 case 0x28: // 2 2 0
1322 STR_SPLIT_2P("00", "10", "20", "00",
1323 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1324 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1325 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1326 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1327 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1328 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1329 __ASM_EMIT("vmovups %[x4], 0x30(%[in])")
1330 __ASM_EMIT("vmovups %[x1], 0x40(%[in])")
1331 __ASM_EMIT("vmovups %[x3], 0x50(%[in])")
1332 __ASM_EMIT("vmovups %[x2], 0x00(%[out])")
1333 __ASM_EMIT("vmovups %[x0], 0x10(%[out])")
1334 __ASM_EMIT("vmovups %[x1], 0x20(%[out])")
1335 );
1336 ++(*n_out); (*n_in) += 2;
1337 break;
1338
1339 case 0x22: // 2 0 2
1340 STR_SPLIT_2P("10", "00", "20", "04",
1341 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1342 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1343 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1344 __ASM_EMIT("vmovups %[x4], 0x00(%[in])")
1345 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1346 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1347 __ASM_EMIT("vmovups %[x2], 0x30(%[in])")
1348 __ASM_EMIT("vmovups %[x0], 0x40(%[in])")
1349 __ASM_EMIT("vmovups %[x4], 0x50(%[in])")
1350 __ASM_EMIT("vmovups %[x3], 0x00(%[out])")
1351 __ASM_EMIT("vmovups %[x1], 0x10(%[out])")
1352 __ASM_EMIT("vmovups %[x0], 0x20(%[out])")
1353 );
1354 ++(*n_out); (*n_in) += 2;
1355 break;
1356
1357 case 0x0a: // 0 2 2
1358 STR_SPLIT_2P("20", "00", "10", "08",
1359 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1360 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1361 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1362 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1363 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1364 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1365 __ASM_EMIT("vmovups %[x3], 0x30(%[in])")
1366 __ASM_EMIT("vmovups %[x1], 0x40(%[in])")
1367 __ASM_EMIT("vmovups %[x2], 0x50(%[in])")
1368 __ASM_EMIT("vmovups %[x4], 0x00(%[out])")
1369 __ASM_EMIT("vmovups %[x0], 0x10(%[out])")
1370 __ASM_EMIT("vmovups %[x1], 0x20(%[out])")
1371 );
1372 ++(*n_out); (*n_in) += 2;
1373 break;
1374
1375 default:
1376 break;
1377 }
1378
1379 #undef STR_COPY_TO
1380 #undef STR_SPLIT_1P
1381 #undef STR_SPLIT_2P
1382 }
1383
1384 void cull_triangle_raw(
1385 raw_triangle_t *in,
1386 size_t *n_in,
1387 const vector3d_t *pl,
1388 const raw_triangle_t *pv)
1389 {
1390 float x0, x1, x2, x3, x4, x5, x6, x7;
1391 float k[4] __lsp_aligned16;
1392 size_t t0;
1393
1394 in += *n_in;
1395
1396 // Estimate co-location of triangle and plane
1397 ARCH_X86_ASM
1398 (
1399 __ASM_EMIT("vmovups (%[pl]), %[x3]") /* x3 = pl */
1400 __ASM_EMIT("vmulps 0x00(%[pv]), %[x3], %[x0]") /* x0 = p0 * pl = sx0 sy0 sz0 sw0 */
1401 __ASM_EMIT("vmulps 0x10(%[pv]), %[x3], %[x1]") /* x1 = p1 * pl = sx1 sy1 sz1 sw1 */
1402 __ASM_EMIT("vmulps 0x20(%[pv]), %[x3], %[x2]") /* x2 = p2 * pl = sx2 sy2 sz2 sw2 */
1403 __ASM_EMIT("vhaddps %[x1], %[x0], %[x0]") /* x0 = sx0+sy0 sz0+sw0 sx1+sy1 sz1+sw1 */
1404 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") /* x2 = sx2+sy2 sz2+sw2 sx2+sy2 sz2+sw2 */
1405 __ASM_EMIT("vhaddps %[x2], %[x0], %[x0]") /* x0 = sx0+sy0+sz0+sw0 sx1+sy1+sz1+sw1 sx2+sy2+sz2+sw2 sx2+sy2+sz2+sw2 = k0 k1 k2 k2 */
1406 __ASM_EMIT("vmovaps %[x0], (%[k])") /* *k = x0 */
1407 __ASM_EMIT("vcmpps $1, %[MTOL], %[x0], %[x1]") /* x1 = k0 < -TOL k1 < -TOL k2 < -TOL k2 < -TOL */
1408 __ASM_EMIT("vcmpps $2, %[PTOL], %[x0], %[x2]") /* x2 = k0 <= +TOL k1 <= +TOL k2 <= +TOL k2 <= +TOL */
1409 __ASM_EMIT("vpand %[ICULL3], %[x1], %[x1]") /* x1 = 0x01*[k0 < -TOL] 0x04*[k1 < -TOL] 0x10*[k2 < -TOL] 0 */
1410 __ASM_EMIT("vpand %[ICULL3], %[x2], %[x2]") /* x2 = 0x01*[k0 <= +TOL] 0x04*[k1 <= +TOL] 0x10*[k2 <= +TOL] 0 */
1411 __ASM_EMIT("vpaddd %[x2], %[x1], %[x0]") /* x0 = x0 x1 x2 0 */
1412 __ASM_EMIT("vphaddd %[x0], %[x0], %[x0]") /* x0 = x0+x1 x2+0 x0+x1 x2+0 */
1413 __ASM_EMIT("vphaddd %[x0], %[x0], %[x0]") /* x0 = x0+x1+x2+0 x0+x1+x2+0 x0+x1+x2+0 */
1414 __ASM_EMIT32("vmovd %[x0], %[t0]")
1415 __ASM_EMIT64("vmovd %[x0], %k[t0]")
1416
1417 : [t0] "=&r" (t0),
1418 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
1419 [x4] "=&x" (x4)
1420 : [pl] "r" (pl), [pv] "r" (pv),
1421 [k] "r" (k),
1422 [PTOL] "m" (X_3D_TOLERANCE),
1423 [MTOL] "m" (X_3D_MTOLERANCE),
1424 [ICULL3] "m" (ICULL3)
1425 : "cc", "memory"
1426 );
1427
1428 #define STR_COPY_TO(tgt) \
1429 ARCH_X86_ASM( \
1430 __ASM_EMIT("vmovups 0x00(%[src]), %%xmm0") \
1431 __ASM_EMIT("vmovups 0x10(%[src]), %%xmm1") \
1432 __ASM_EMIT("vmovups 0x20(%[src]), %%xmm2") \
1433 __ASM_EMIT("vmovups %%xmm0, 0x00(%[dst])") \
1434 __ASM_EMIT("vmovups %%xmm1, 0x10(%[dst])") \
1435 __ASM_EMIT("vmovups %%xmm2, 0x20(%[dst])") \
1436 : \
1437 : [dst] "r" (tgt), \
1438 [src] "r" (pv) \
1439 : "cc", "memory", \
1440 "%xmm0", "%xmm1" \
1441 );
1442
1443 #define STR_SPLIT_1P(off0, off1, koff, store) \
1444 ARCH_X86_ASM( \
1445 __ASM_EMIT("vmovups 0x" off0 "(%[st]), %[x0]") /* x0 = p0 = lx0 ly0 lz0 1 */ \
1446 __ASM_EMIT("vmovups 0x" off1 "(%[st]), %[x1]") /* x1 = p1 = lx1 ly1 lz1 1 */ \
1447 __ASM_EMIT("vmovups (%[pl]), %[x2]") /* x2 = pl = nx ny nz nw */ \
1448 \
1449 __ASM_EMIT("vsubps %[x0], %[x1], %[x1]") /* x1 = d = p1 - p0 = dx dy dz 0 */ \
1450 __ASM_EMIT("vbroadcastss 0x" koff "(%[k]), %[x3]") /* x3 = k k k k */ \
1451 __ASM_EMIT("vmulps %[x1], %[x2], %[x2]") /* x2 = dx*nx dy*ny dz*nz 0 */ \
1452 __ASM_EMIT("vmulps %[x3], %[x1], %[x1]") /* x1 = k*dx k*dy k*dz 0 */ \
1453 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") /* x2 = dx*nx+dy*ny dz*nz dx*nx+dy*ny dz*nz */ \
1454 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") /* x2 = dx*nx+dy*ny+dz*nz = b b b b */ \
1455 __ASM_EMIT("vdivps %[x2], %[x1], %[x1]") /* x1 = k*dx/b k*dy/b k*dz/b 0 */ \
1456 __ASM_EMIT("vsubps %[x1], %[x0], %[x0]") /* x0 = lx0-k*dx/b ly0-k*dy/b lz0-k*dz/b 1 */ \
1457 \
1458 store \
1459 \
1460 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4) \
1461 : [st] "r" (pv), [pl] "r" (pl), [in] "r" (in), \
1462 [k] "r" (k) \
1463 : "cc", "memory" \
1464 );
1465
1466 #define STR_SPLIT_2P(off0, off1, off2, koff, store) \
1467 ARCH_X86_ASM( \
1468 __ASM_EMIT("vmovups 0x" off0 "(%[st]), %[x0]") /* x0 = p0 = lx0 ly0 lz0 1 */ \
1469 __ASM_EMIT("vmovups 0x" off1 "(%[st]), %[x2]") /* x2 = p1 = lx1 ly1 lz1 1 */ \
1470 __ASM_EMIT("vmovups 0x" off2 "(%[st]), %[x3]") /* x3 = p2 = lx2 ly2 lz2 1 */ \
1471 __ASM_EMIT("vmovups (%[pl]), %[x4]") /* x4 = pl = nx ny nz nw */ \
1472 \
1473 __ASM_EMIT("vsubps %[x0], %[x3], %[x3]") /* x3 = d2 = p2 - p0 = dx2 dy2 dz2 0 */ \
1474 __ASM_EMIT("vsubps %[x0], %[x2], %[x2]") /* x2 = d1 = p1 - p0 = dx1 dy1 dz1 0 */ \
1475 __ASM_EMIT("vmulps %[x3], %[x4], %[x5]") /* x5 = dx2*nx dy2*ny dz2*nz 0 */ \
1476 __ASM_EMIT("vmulps %[x2], %[x4], %[x4]") /* x4 = dx1*nx dy1*ny dz1*nz 0 */ \
1477 __ASM_EMIT("vbroadcastss 0x" koff "(%[k]), %[x6]") /* x6 = k k k k */ \
1478 __ASM_EMIT("vhaddps %[x5], %[x5], %[x5]") /* x5 = dx2*nx+dy2*ny dz2*nz dx2*nx+dy2*ny dz2*nz */ \
1479 __ASM_EMIT("vhaddps %[x4], %[x4], %[x4]") /* x4 = dx1*nx+dy1*ny dz1*nz dx1*nx+dy1*ny dz1*nz */ \
1480 __ASM_EMIT("vhaddps %[x5], %[x5], %[x5]") /* x5 = dx2*nx+dy2*ny+dz2*nz = b2 b2 b2 b2 */ \
1481 __ASM_EMIT("vhaddps %[x4], %[x4], %[x4]") /* x4 = dx1*nx+dy1*ny+dz1*nz = b1 b1 b1 b1 */ \
1482 __ASM_EMIT("vdivps %[x5], %[x3], %[x3]") /* x3 = dx2/b2 dy2/b2 dz2/b2 0 */ \
1483 __ASM_EMIT("vdivps %[x4], %[x2], %[x2]") /* x2 = dx1/b1 dy1/b1 dz1/b1 0 */ \
1484 __ASM_EMIT("vmulps %[x6], %[x3], %[x3]") /* x3 = k*dx2/b2 k*dy2/b2 k*dz2/b2 0 */ \
1485 __ASM_EMIT("vmulps %[x6], %[x2], %[x2]") /* x2 = k*dx1/b1 k*dy1/b1 k*dz1/b1 0 */ \
1486 __ASM_EMIT("vsubps %[x3], %[x0], %[x1]") /* x1 = lx0-k*dx2/b2 ly0-k*dy2/b2 lz0-k*dz2/b2 1 */ \
1487 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") /* x0 = lx0-k*dx1/b1 ly0-k*dy1/b1 lz0-k*dz1/b1 1 */ \
1488 \
1489 store \
1490 \
1491 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), \
1492 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7) \
1493 : [st] "r" (pv), [pl] "r" (pl), [in] "r" (in), \
1494 [k] "r" (k) \
1495 : "cc", "memory" \
1496 );
1497
1498 switch (t0)
1499 {
1500 // 0 intersections, triangle is above
1501 case 0x00: // 0 0 0
1502 case 0x01: // 0 0 1
1503 case 0x04: // 0 1 0
1504 case 0x05: // 0 1 1
1505 case 0x10: // 1 0 0
1506 case 0x11: // 1 0 1
1507 case 0x14: // 1 1 0
1508 case 0x15: // 1 1 1
1509 break;
1510
1511 // 0 intersections, triangle is below
1512 case 0x16: // 1 1 2
1513 case 0x19: // 1 2 1
1514 case 0x1a: // 1 2 2
1515 case 0x25: // 2 1 1
1516 case 0x26: // 2 1 2
1517 case 0x29: // 2 2 1
1518 case 0x2a: // 2 2 2
1519 STR_COPY_TO(in);
1520 ++(*n_in);
1521 break;
1522
1523 // 1 intersection, 1 triangle above, 1 triangle below, counter-clockwise
1524 case 0x06: // 0 1 2
1525 STR_SPLIT_1P("00", "20", "00",
1526 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1527 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1528 __ASM_EMIT("vmovups %[x1], 0x00(%[in])")
1529 __ASM_EMIT("vmovups %[x2], 0x10(%[in])")
1530 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1531 );
1532 ++(*n_in);
1533 break;
1534 case 0x21: // 2 0 1
1535 STR_SPLIT_1P("00", "10", "00",
1536 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1537 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1538 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1539 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1540 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1541 );
1542 ++(*n_in);
1543 break;
1544 case 0x18: // 1 2 0
1545 STR_SPLIT_1P("10", "20", "04",
1546 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1547 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1548 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1549 __ASM_EMIT("vmovups %[x3], 0x10(%[in])")
1550 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1551 );
1552 ++(*n_in);
1553 break;
1554
1555 // 1 intersection, 1 triangle above, 1 triangle below, clockwise
1556 case 0x24: // 2 1 0
1557 STR_SPLIT_1P("00", "20", "00",
1558 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1559 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1560 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1561 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1562 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1563 );
1564 ++(*n_in);
1565 break;
1566 case 0x12: // 1 0 2
1567 STR_SPLIT_1P("00", "10", "00",
1568 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1569 __ASM_EMIT("vmovups 0x20(%[st]), %[x3]")
1570 __ASM_EMIT("vmovups %[x1], 0x00(%[in])")
1571 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1572 __ASM_EMIT("vmovups %[x3], 0x20(%[in])")
1573 );
1574 ++(*n_in);
1575 break;
1576 case 0x09: // 0 2 1
1577 STR_SPLIT_1P("10", "20", "04",
1578 __ASM_EMIT("vmovups 0x00(%[st]), %[x1]")
1579 __ASM_EMIT("vmovups 0x10(%[st]), %[x2]")
1580 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1581 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1582 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1583 );
1584 ++(*n_in);
1585 break;
1586
1587 // 2 intersections, 1 triangle below, 2 triangles above
1588 case 0x02: // 0 0 2
1589 STR_SPLIT_2P("00", "10", "20", "00",
1590 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1591 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1592 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1593 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1594 );
1595 ++(*n_in);
1596 break;
1597 case 0x08: // 0 2 0
1598 STR_SPLIT_2P("10", "00", "20", "04",
1599 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1600 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1601 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1602 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1603 );
1604 ++(*n_in);
1605 break;
1606 case 0x20: // 2 0 0
1607 STR_SPLIT_2P("20", "00", "10", "08",
1608 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1609 __ASM_EMIT("vmovups %[x4], 0x00(%[in])")
1610 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1611 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1612 );
1613 ++(*n_in);
1614 break;
1615
1616 // 2 intersections, 1 triangle above, 2 triangles below
1617 case 0x28: // 2 2 0
1618 STR_SPLIT_2P("00", "10", "20", "00",
1619 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1620 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1621 __ASM_EMIT("vmovups %[x3], 0x00(%[in])")
1622 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1623 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1624 __ASM_EMIT("vmovups %[x4], 0x30(%[in])")
1625 __ASM_EMIT("vmovups %[x1], 0x40(%[in])")
1626 __ASM_EMIT("vmovups %[x3], 0x50(%[in])")
1627 );
1628 (*n_in) += 2;
1629 break;
1630
1631 case 0x22: // 2 0 2
1632 STR_SPLIT_2P("10", "00", "20", "04",
1633 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1634 __ASM_EMIT("vmovups 0x20(%[st]), %[x4]")
1635 __ASM_EMIT("vmovups %[x4], 0x00(%[in])")
1636 __ASM_EMIT("vmovups %[x0], 0x10(%[in])")
1637 __ASM_EMIT("vmovups %[x1], 0x20(%[in])")
1638 __ASM_EMIT("vmovups %[x2], 0x30(%[in])")
1639 __ASM_EMIT("vmovups %[x0], 0x40(%[in])")
1640 __ASM_EMIT("vmovups %[x4], 0x50(%[in])")
1641 );
1642 (*n_in) += 2;
1643 break;
1644
1645 case 0x0a: // 0 2 2
1646 STR_SPLIT_2P("20", "00", "10", "08",
1647 __ASM_EMIT("vmovups 0x00(%[st]), %[x2]")
1648 __ASM_EMIT("vmovups 0x10(%[st]), %[x3]")
1649 __ASM_EMIT("vmovups %[x2], 0x00(%[in])")
1650 __ASM_EMIT("vmovups %[x1], 0x10(%[in])")
1651 __ASM_EMIT("vmovups %[x0], 0x20(%[in])")
1652 __ASM_EMIT("vmovups %[x3], 0x30(%[in])")
1653 __ASM_EMIT("vmovups %[x1], 0x40(%[in])")
1654 __ASM_EMIT("vmovups %[x2], 0x50(%[in])")
1655 );
1656 (*n_in) += 2;
1657 break;
1658
1659 default:
1660 break;
1661 }
1662
1663 #undef STR_COPY_TO
1664 #undef STR_SPLIT_1P
1665 #undef STR_SPLIT_2P
1666 }
1667
1668 size_t longest_edge3d_p3(const point3d_t *p1, const point3d_t *p2, const point3d_t *p3)
1669 {
1670 size_t res;
1671 float x0, x1, x2, x3;
1672
1673 ARCH_X86_ASM
1674 (
1675 // Calc vectors
1676 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x0 y0 z0 w0
1677 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x1 = x1 y1 z1 w1
1678 __ASM_EMIT("vmovups (%[p3]), %[x2]") // x2 = x2 y2 z2 w2
1679 __ASM_EMIT("vsubps %[x0], %[x1], %[x3]") // x3 = x1-x0 y1-y0 z1-z0 w1-w0 = dx0 dy0 dz0 0
1680 __ASM_EMIT("vsubps %[x1], %[x2], %[x1]") // x1 = x2-x1 y2-y1 z2-z1 w2-w1 = dx1 dy1 dz1 0
1681 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") // x0 = x0-x2 y0-y2 z0-z2 w0-w2 = dx2 dy2 dz2 0
1682
1683 __ASM_EMIT("vmulps %[x3], %[x3], %[x2]") // x2 = ax2 ay2 az2 0
1684 __ASM_EMIT("vmulps %[x1], %[x1], %[x1]") // x1 = bx2 by2 bz2 0
1685 __ASM_EMIT("vmulps %[x0], %[x0], %[x0]") // x0 = cx2 cy2 cz2 0
1686 MAT3_TRANSPOSE("x2", "x1", "x0", "x3")
1687 __ASM_EMIT("vaddps %[x2], %[x0], %[x3]") // x3 = ax2+az2 + bx2+bz2 cx2+cz2 ?
1688 __ASM_EMIT("vaddps %[x1], %[x0], %[x3]") // x3 = A2 B2 C2
1689 __ASM_EMIT("xor %[res], %[res]") // res = 0
1690 __ASM_EMIT("vunpcklps %[x3], %[x3], %[x2]") // x2 = A2 A2 B2 B2
1691 __ASM_EMIT("vmovhlps %[x3], %[x0], %[x0]") // x0 = C2 ? ? ?
1692 __ASM_EMIT("vmovhlps %[x2], %[x1], %[x1]") // x1 = B2 B2 ? ?
1693
1694 // Solve result
1695 __ASM_EMIT("vucomiss %[x1], %[x2]") // A2 <?> B2
1696 __ASM_EMIT("jae 1f")
1697 // A2 < B2
1698 __ASM_EMIT("vucomiss %[x1], %[x0]") // C2 <?> B2
1699 __ASM_EMIT("seta %%al") // res = (B2 >= C2) ? 0 : 1
1700 __ASM_EMIT("add $1, %[res]") // res = (B2 >= C2) ? 1 : 2
1701 __ASM_EMIT("jmp 2f")
1702 __ASM_EMIT("1:")
1703 // A2 >= B2
1704 __ASM_EMIT("vucomiss %[x0], %[x2]") // A2 <?> C2
1705 __ASM_EMIT("jae 2f") //
1706 __ASM_EMIT("mov $2, %[res]") // res = (A2 >= C2) ? 0 : 2
1707 __ASM_EMIT("2:")
1708 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
1709 [res] "=a" (res)
1710 : [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3)
1711 );
1712
1713 return res;
1714 }
1715
1716 size_t longest_edge3d_pv(const point3d_t *p)
1717 {
1718 size_t res;
1719 float x0, x1, x2, x3;
1720
1721 ARCH_X86_ASM
1722 (
1723 // Calc vectors
1724 __ASM_EMIT("vmovups 0x00(%[pv]), %[x0]") // x0 = x0 y0 z0 w0
1725 __ASM_EMIT("vmovups 0x10(%[pv]), %[x1]") // x1 = x1 y1 z1 w1
1726 __ASM_EMIT("vmovups 0x20(%[pv]), %[x2]") // x2 = x2 y2 z2 w2
1727 __ASM_EMIT("vsubps %[x0], %[x1], %[x3]") // x3 = x1-x0 y1-y0 z1-z0 w1-w0 = dx0 dy0 dz0 0
1728 __ASM_EMIT("vsubps %[x1], %[x2], %[x1]") // x1 = x2-x1 y2-y1 z2-z1 w2-w1 = dx1 dy1 dz1 0
1729 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") // x0 = x0-x2 y0-y2 z0-z2 w0-w2 = dx2 dy2 dz2 0
1730
1731 __ASM_EMIT("vmulps %[x3], %[x3], %[x2]") // x2 = ax2 ay2 az2 0
1732 __ASM_EMIT("vmulps %[x1], %[x1], %[x1]") // x1 = bx2 by2 bz2 0
1733 __ASM_EMIT("vmulps %[x0], %[x0], %[x0]") // x0 = cx2 cy2 cz2 0
1734 MAT3_TRANSPOSE("x2", "x1", "x0", "x3")
1735 __ASM_EMIT("vaddps %[x2], %[x0], %[x3]") // x3 = ax2+az2 + bx2+bz2 cx2+cz2 ?
1736 __ASM_EMIT("vaddps %[x1], %[x0], %[x3]") // x3 = A2 B2 C2
1737 __ASM_EMIT("xor %[res], %[res]") // res = 0
1738 __ASM_EMIT("vunpcklps %[x3], %[x3], %[x2]") // x2 = A2 A2 B2 B2
1739 __ASM_EMIT("vmovhlps %[x3], %[x0], %[x0]") // x0 = C2 ? ? ?
1740 __ASM_EMIT("vmovhlps %[x2], %[x1], %[x1]") // x1 = B2 B2 ? ?
1741
1742 // Solve result
1743 __ASM_EMIT("vucomiss %[x1], %[x2]") // A2 <?> B2
1744 __ASM_EMIT("jae 1f")
1745 // A2 < B2
1746 __ASM_EMIT("vucomiss %[x1], %[x0]") // C2 <?> B2
1747 __ASM_EMIT("seta %%al") // res = (B2 >= C2) ? 0 : 1
1748 __ASM_EMIT("add $1, %[res]") // res = (B2 >= C2) ? 1 : 2
1749 __ASM_EMIT("jmp 2f")
1750 __ASM_EMIT("1:")
1751 // A2 >= B2
1752 __ASM_EMIT("vucomiss %[x0], %[x2]") // A2 <?> C2
1753 __ASM_EMIT("jae 2f") //
1754 __ASM_EMIT("mov $2, %[res]") // res = (A2 >= C2) ? 0 : 2
1755 __ASM_EMIT("2:")
1756 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
1757 [res] "=a" (res)
1758 : [pv] "r" (p)
1759 );
1760
1761 return res;
1762 }
1763
1764 void calc_normal3d_v2(vector3d_t *n, const vector3d_t *v1, const vector3d_t *v2)
1765 {
1766 float x0, x1, x2, x3;
1767
1768 ARCH_X86_ASM
1769 (
1770 __ASM_EMIT("vmovups (%[v1]), %[x0]") // x0 = dx1 dy1 dz1 dw1
1771 __ASM_EMIT("vmovups (%[v2]), %[x1]") // x1 = dx2 dy2 dz2 dw2
1772 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1773 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1774 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1775 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1776 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1777 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1778 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1779 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1780 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1781 __ASM_EMIT("vmovups %[x0], (%[n])")
1782
1783 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1784 : [n] "r" (n), [v1] "r" (v1), [v2] "r" (v2),
1785 [X_3DMASK] "m" (X_MASK0111)
1786 : "memory"
1787 );
1788 }
1789
1790 void calc_normal3d_vv(vector3d_t *n, const vector3d_t *vv)
1791 {
1792 float x0, x1, x2, x3;
1793
1794 ARCH_X86_ASM
1795 (
1796 __ASM_EMIT("vmovups 0x00(%[vv]), %[x0]") // x0 = dx1 dy1 dz1 0
1797 __ASM_EMIT("vmovups 0x10(%[vv]), %[x1]") // x1 = dx2 dy2 dz2 0
1798 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1799 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1800 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1801 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1802 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1803 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1804 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1805 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1806 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1807 __ASM_EMIT("vmovups %[x0], (%[n])")
1808
1809 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1810 : [n] "r" (n), [vv] "r" (vv)
1811 : "memory"
1812 );
1813 }
1814
1815 void calc_normal3d_p3(vector3d_t *n, const point3d_t *p1, const point3d_t *p2, const point3d_t *p3)
1816 {
1817 float x0, x1, x2, x3;
1818
1819 ARCH_X86_ASM
1820 (
1821 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x0 = dx1 dy1 dz1 dw1
1822 __ASM_EMIT("vmovups (%[p3]), %[x2]") // x1 = dx2 dy2 dz2 dw2
1823 __ASM_EMIT("vsubps (%[p1]), %[x1], %[x0]") // x0 = dx1 dy1 dz1 dw1
1824 __ASM_EMIT("vsubps %[x1], %[x2], %[x1]") // x1 = dx2 dy2 dz2 dw2
1825 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1826 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1827 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1828 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1829 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1830 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1831 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1832 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1833 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1834 __ASM_EMIT("vmovups %[x0], (%[n])")
1835
1836 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1837 : [n] "r" (n), [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3),
1838 [X_3DMASK] "m" (X_MASK0111)
1839 : "memory"
1840 );
1841 }
1842
1843 void calc_normal3d_pv(vector3d_t *n, const point3d_t *pv)
1844 {
1845 float x0, x1, x2, x3;
1846
1847 ARCH_X86_ASM
1848 (
1849 __ASM_EMIT("vmovups 0x10(%[pv]), %[x1]") // x0 = dx1 dy1 dz1 dw1
1850 __ASM_EMIT("vmovups 0x20(%[pv]), %[x2]") // x1 = dx2 dy2 dz2 dw2
1851 __ASM_EMIT("vsubps 0x00(%[pv]), %[x1], %[x0]") // x0 = dx1 dy1 dz1 dw1
1852 __ASM_EMIT("vsubps %[x1], %[x2], %[x1]") // x1 = dx2 dy2 dz2 dw2
1853 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1854 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1855 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1856 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1857 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1858 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1859 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1860 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1861 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1862 __ASM_EMIT("vmovups %[x0], (%[n])")
1863
1864 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1865 : [n] "r" (n), [pv] "r" (pv),
1866 [X_3DMASK] "m" (X_MASK0111)
1867 : "memory"
1868 );
1869 }
1870
1871 void calc_normal3d_v2_fma3(vector3d_t *n, const vector3d_t *v1, const vector3d_t *v2)
1872 {
1873 float x0, x1, x2, x3;
1874
1875 ARCH_X86_ASM
1876 (
1877 __ASM_EMIT("vmovups (%[v1]), %[x0]") // x0 = dx1 dy1 dz1 dw1
1878 __ASM_EMIT("vmovups (%[v2]), %[x1]") // x1 = dx2 dy2 dz2 dw2
1879 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1880 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1881 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1882 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1883 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1884 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1885 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1886 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1887 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1888 __ASM_EMIT("vmovups %[x0], (%[n])")
1889
1890 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1891 : [n] "r" (n), [v1] "r" (v1), [v2] "r" (v2),
1892 [X_3DMASK] "m" (X_MASK0111)
1893 : "memory"
1894 );
1895 }
1896
1897 void calc_normal3d_vv_fma3(vector3d_t *n, const vector3d_t *vv)
1898 {
1899 float x0, x1, x2, x3;
1900
1901 ARCH_X86_ASM
1902 (
1903 __ASM_EMIT("vmovups 0x00(%[vv]), %[x0]") // x0 = dx1 dy1 dz1 dw1
1904 __ASM_EMIT("vmovups 0x10(%[vv]), %[x1]") // x1 = dx2 dy2 dz2 dw2
1905 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1906 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1907 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1908 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1909 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1910 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1911 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1912 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1913 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1914 __ASM_EMIT("vmovups %[x0], (%[n])")
1915
1916 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1917 : [n] "r" (n), [vv] "r" (vv),
1918 [X_3DMASK] "m" (X_MASK0111)
1919 : "memory"
1920 );
1921 }
1922
1923 void calc_normal3d_p3_fma3(vector3d_t *n, const point3d_t *p1, const point3d_t *p2, const point3d_t *p3)
1924 {
1925 float x0, x1, x2, x3;
1926
1927 ARCH_X86_ASM
1928 (
1929 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x0 = dx1 dy1 dz1 dw1
1930 __ASM_EMIT("vmovups (%[p3]), %[x2]") // x1 = dx2 dy2 dz2 dw2
1931 __ASM_EMIT("vsubps (%[p1]), %[x1], %[x0]") // x0 = dx1 dy1 dz1 dw1
1932 __ASM_EMIT("vsubps %[x1], %[x2], %[x1]") // x1 = dx2 dy2 dz2 dw2
1933 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1934 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1935 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1936 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1937 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1938 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1939 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1940 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1941 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1942 __ASM_EMIT("vmovups %[x0], (%[n])")
1943
1944 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1945 : [n] "r" (n), [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3),
1946 [X_3DMASK] "m" (X_MASK0111)
1947 : "memory"
1948 );
1949 }
1950
1951 void calc_normal3d_pv_fma3(vector3d_t *n, const point3d_t *pv)
1952 {
1953 float x0, x1, x2, x3;
1954
1955 ARCH_X86_ASM
1956 (
1957 __ASM_EMIT("vmovups 0x10(%[pv]), %[x1]") // x0 = dx1 dy1 dz1 dw1
1958 __ASM_EMIT("vmovups 0x20(%[pv]), %[x2]") // x1 = dx2 dy2 dz2 dw2
1959 __ASM_EMIT("vsubps 0x00(%[pv]), %[x1], %[x0]") // x0 = dx1 dy1 dz1 dw1
1960 __ASM_EMIT("vsubps %[x1], %[x2], %[x1]") // x1 = dx2 dy2 dz2 dw2
1961 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1962 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1963 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1964 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1965 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1966 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = W = sqrtf(W2)
1967 __ASM_EMIT("vcmpps $4, %[x3], %[x0], %[x3]") // x3 = W != 0
1968 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W NZ/W
1969 __ASM_EMIT("vandps %[x3], %[x1], %[x0]") // x0 = (W != 0) ? NX/W NY/W NZ/W NZ/W : 0
1970 __ASM_EMIT("vmovups %[x0], (%[n])")
1971
1972 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
1973 : [n] "r" (n), [pv] "r" (pv),
1974 [X_3DMASK] "m" (X_MASK0111)
1975 : "memory"
1976 );
1977 }
1978
1979 float calc_plane_p3(vector3d_t *v, const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
1980 {
1981 float x0, x1, x2, x3, x4;
1982
1983 ARCH_X86_ASM
1984 (
1985 __ASM_EMIT("vmovups (%[p0]), %[x2]") // x2 = x0 y0 z0 w0
1986 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x1 y1 z1 w1
1987 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x1 = x2 y2 z2 w2
1988 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") // x0 = p1 - p0 = dx1 dy1 dz1 0
1989 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") // x1 = p2 - p0 = dx2 dy2 dz2 0
1990 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
1991 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
1992 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
1993 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
1994 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
1995 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = sqrtf(W2) sqrtf(W2) sqrtf(W2) sqrtf(W2) = W W W W
1996 __ASM_EMIT("vcmpps $4, %[x0], %[x3], %[x3]") // x3 = W != 0
1997 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W 0/W
1998 __ASM_EMIT("vandps %[x3], %[x1], %[x1]") // x1 = nx ny nz 0 = (NX/W) & [W!=0] (NY/W) & [W!=0] (NZ/W) & [W!=0] (NZ/W) & [W!=0] = nx ny nz nz
1999 __ASM_EMIT("vxorps %[x2], %[x2], %[x2]") // x2 = 0 0 0 0
2000 __ASM_EMIT("vmovups (%[p0]), %[x3]") // x3 = x0 y0 z0 w0
2001 __ASM_EMIT("vsubps %[x1], %[x2], %[x2]") // x2 = -nx -ny -nz 0
2002 VECTOR_DOT3("[x2]", "[x3]", "[x3]", "[x4]") // x2 = -(nx*x0 + ny*y0 + nz*z0) = dw
2003 __ASM_EMIT("vinsertps $0x30, %[x2], %[x1], %[x1]")// x1 = nx ny nz dw
2004 __ASM_EMIT("vmovups %[x1], (%[v])")
2005
2006 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2007 : [v] "r" (v), [p0] "r" (p0), [p1] "r" (p1), [p2] "r" (p2)
2008 : "memory"
2009 );
2010
2011 return x0;
2012 }
2013
2014 float calc_plane_pv(vector3d_t *v, const point3d_t *pv)
2015 {
2016 float x0, x1, x2, x3, x4;
2017
2018 ARCH_X86_ASM
2019 (
2020 __ASM_EMIT("vmovups 0x00(%[pv]), %[x2]") // x2 = x0 y0 z0 w0
2021 __ASM_EMIT("vmovups 0x10(%[pv]), %[x0]") // x0 = x1 y1 z1 w1
2022 __ASM_EMIT("vmovups 0x20(%[pv]), %[x1]") // x1 = x2 y2 z2 w2
2023 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") // x0 = p1 - p0 = dx1 dy1 dz1 0
2024 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") // x1 = p2 - p0 = dx2 dy2 dz2 0
2025 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
2026 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
2027 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
2028 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
2029 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
2030 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = sqrtf(W2) sqrtf(W2) sqrtf(W2) sqrtf(W2) = W W W W
2031 __ASM_EMIT("vcmpps $4, %[x0], %[x3], %[x3]") // x3 = W != 0
2032 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W 0/W
2033 __ASM_EMIT("vandps %[x3], %[x1], %[x1]") // x1 = nx ny nz 0 = (NX/W) & [W!=0] (NY/W) & [W!=0] (NZ/W) & [W!=0] (NZ/W) & [W!=0] = nx ny nz nz
2034 __ASM_EMIT("vxorps %[x2], %[x2], %[x2]") // x2 = 0 0 0 0
2035 __ASM_EMIT("vmovups 0x00(%[pv]), %[x3]") // x3 = x0 y0 z0 w0
2036 __ASM_EMIT("vsubps %[x1], %[x2], %[x2]") // x2 = -nx -ny -nz 0
2037 VECTOR_DOT3("[x2]", "[x3]", "[x3]", "[x4]") // x2 = -(nx*x0 + ny*y0 + nz*z0) = dw
2038 __ASM_EMIT("vinsertps $0x30, %[x2], %[x1], %[x1]")// x1 = nx ny nz dw
2039 __ASM_EMIT("vmovups %[x1], (%[v])")
2040
2041 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2042 : [v] "r" (v), [pv] "r" (pv)
2043 : "memory"
2044 );
2045
2046 return x0;
2047 }
2048
2049 float calc_plane_v1p2(vector3d_t *v, const vector3d_t *v0, const point3d_t *p0, const point3d_t *p1)
2050 {
2051 float x0, x1, x2, x3, x4;
2052
2053 ARCH_X86_ASM
2054 (
2055 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x1 y1 z1 w1
2056 __ASM_EMIT("vmovups (%[v0]), %[x1]") // x1 = v = dx2 dy2 dz2 0
2057 __ASM_EMIT("vsubps (%[p0]), %[x0], %[x0]") // x0 = p1 - p0 = dx1 dy1 dz1 0
2058 VECTOR_CROSS3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
2059 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
2060 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
2061 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
2062 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
2063 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = sqrtf(W2) sqrtf(W2) sqrtf(W2) sqrtf(W2) = W W W W
2064 __ASM_EMIT("vcmpps $4, %[x0], %[x3], %[x3]") // x3 = W != 0
2065 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W 0/W
2066 __ASM_EMIT("vandps %[x3], %[x1], %[x1]") // x1 = nx ny nz 0 = (NX/W) & [W!=0] (NY/W) & [W!=0] (NZ/W) & [W!=0] (NZ/W) & [W!=0] = nx ny nz nz
2067 __ASM_EMIT("vxorps %[x2], %[x2], %[x2]") // x2 = 0 0 0 0
2068 __ASM_EMIT("vmovups (%[p0]), %[x3]") // x3 = x0 y0 z0 w0
2069 __ASM_EMIT("vsubps %[x1], %[x2], %[x2]") // x2 = -nx -ny -nz 0
2070 VECTOR_DOT3("[x2]", "[x3]", "[x3]", "[x4]") // x2 = -(nx*x0 + ny*y0 + nz*z0) = dw
2071 __ASM_EMIT("vinsertps $0x30, %[x2], %[x1], %[x1]")// x1 = nx ny nz dw
2072 __ASM_EMIT("vmovups %[x1], (%[v])")
2073
2074 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2075 : [v] "r" (v), [v0] "r" (v0), [p0] "r" (p0), [p1] "r" (p1)
2076 : "memory"
2077 );
2078
2079 return x0;
2080 }
2081
2082 float calc_plane_p3_fma3(vector3d_t *v, const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
2083 {
2084 float x0, x1, x2, x3, x4;
2085
2086 ARCH_X86_ASM
2087 (
2088 __ASM_EMIT("vmovups (%[p0]), %[x2]") // x2 = x0 y0 z0 w0
2089 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x1 y1 z1 w1
2090 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x1 = x2 y2 z2 w2
2091 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") // x0 = p1 - p0 = dx1 dy1 dz1 0
2092 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") // x1 = p2 - p0 = dx2 dy2 dz2 0
2093 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
2094 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
2095 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
2096 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
2097 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
2098 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = sqrtf(W2) sqrtf(W2) sqrtf(W2) sqrtf(W2) = W W W W
2099 __ASM_EMIT("vcmpps $4, %[x0], %[x3], %[x3]") // x3 = W != 0
2100 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W 0/W
2101 __ASM_EMIT("vandps %[x3], %[x1], %[x1]") // x1 = nx ny nz 0 = (NX/W) & [W!=0] (NY/W) & [W!=0] (NZ/W) & [W!=0] (NZ/W) & [W!=0] = nx ny nz nz
2102 __ASM_EMIT("vxorps %[x2], %[x2], %[x2]") // x2 = 0 0 0 0
2103 __ASM_EMIT("vmovups (%[p0]), %[x3]") // x3 = x0 y0 z0 w0
2104 __ASM_EMIT("vsubps %[x1], %[x2], %[x2]") // x2 = -nx -ny -nz 0
2105 VECTOR_DOT3("[x2]", "[x3]", "[x3]", "[x4]") // x2 = -(nx*x0 + ny*y0 + nz*z0) = dw
2106 __ASM_EMIT("vinsertps $0x30, %[x2], %[x1], %[x1]")// x1 = nx ny nz dw
2107 __ASM_EMIT("vmovups %[x1], (%[v])")
2108
2109 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2110 : [v] "r" (v), [p0] "r" (p0), [p1] "r" (p1), [p2] "r" (p2)
2111 : "memory"
2112 );
2113
2114 return x0;
2115 }
2116
2117 float calc_plane_pv_fma3(vector3d_t *v, const point3d_t *pv)
2118 {
2119 float x0, x1, x2, x3, x4;
2120
2121 ARCH_X86_ASM
2122 (
2123 __ASM_EMIT("vmovups 0x00(%[pv]), %[x2]") // x2 = x0 y0 z0 w0
2124 __ASM_EMIT("vmovups 0x10(%[pv]), %[x0]") // x0 = x1 y1 z1 w1
2125 __ASM_EMIT("vmovups 0x20(%[pv]), %[x1]") // x1 = x2 y2 z2 w2
2126 __ASM_EMIT("vsubps %[x2], %[x0], %[x0]") // x0 = p1 - p0 = dx1 dy1 dz1 0
2127 __ASM_EMIT("vsubps %[x2], %[x1], %[x1]") // x1 = p2 - p0 = dx2 dy2 dz2 0
2128 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
2129 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
2130 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
2131 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
2132 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
2133 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = sqrtf(W2) sqrtf(W2) sqrtf(W2) sqrtf(W2) = W W W W
2134 __ASM_EMIT("vcmpps $4, %[x0], %[x3], %[x3]") // x3 = W != 0
2135 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W 0/W
2136 __ASM_EMIT("vandps %[x3], %[x1], %[x1]") // x1 = nx ny nz 0 = (NX/W) & [W!=0] (NY/W) & [W!=0] (NZ/W) & [W!=0] (NZ/W) & [W!=0] = nx ny nz nz
2137 __ASM_EMIT("vxorps %[x2], %[x2], %[x2]") // x2 = 0 0 0 0
2138 __ASM_EMIT("vmovups 0x00(%[pv]), %[x3]") // x3 = x0 y0 z0 w0
2139 __ASM_EMIT("vsubps %[x1], %[x2], %[x2]") // x2 = -nx -ny -nz 0
2140 VECTOR_DOT3("[x2]", "[x3]", "[x3]", "[x4]") // x2 = -(nx*x0 + ny*y0 + nz*z0) = dw
2141 __ASM_EMIT("vinsertps $0x30, %[x2], %[x1], %[x1]")// x1 = nx ny nz dw
2142 __ASM_EMIT("vmovups %[x1], (%[v])")
2143
2144 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2145 : [v] "r" (v), [pv] "r" (pv)
2146 : "memory"
2147 );
2148
2149 return x0;
2150 }
2151
2152 float calc_plane_v1p2_fma3(vector3d_t *v, const vector3d_t *v0, const point3d_t *p0, const point3d_t *p1)
2153 {
2154 float x0, x1, x2, x3, x4;
2155
2156 ARCH_X86_ASM
2157 (
2158 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x1 y1 z1 w1
2159 __ASM_EMIT("vmovups (%[v0]), %[x1]") // x1 = v = dx2 dy2 dz2 0
2160 __ASM_EMIT("vsubps (%[p0]), %[x0], %[x0]") // x0 = p1 - p0 = dx1 dy1 dz1 0
2161 VECTOR_CROSS3_FMA3("[x0]", "[x1]", "[x2]", "[x3]") // x0 = NZ NX NY 0
2162 __ASM_EMIT("vshufps $0xc9, %[x0], %[x0], %[x1]")// x1 = NX NY NZ 0
2163 VECTOR_DOT3("[x0]", "[x0]", "[x2]", "[x3]") // x0 = NX*NX + NY*NY + NZ*NZ = W2
2164 __ASM_EMIT("vshufps $0x00, %[x0], %[x0], %[x0]")// x0 = W2 W2 W2 W2
2165 __ASM_EMIT("vxorps %[x3], %[x3], %[x3]") // x3 = 0
2166 __ASM_EMIT("vsqrtps %[x0], %[x0]") // x0 = sqrtf(W2) sqrtf(W2) sqrtf(W2) sqrtf(W2) = W W W W
2167 __ASM_EMIT("vcmpps $4, %[x0], %[x3], %[x3]") // x3 = W != 0
2168 __ASM_EMIT("vdivps %[x0], %[x1], %[x1]") // x1 = NX/W NY/W NZ/W 0/W
2169 __ASM_EMIT("vandps %[x3], %[x1], %[x1]") // x1 = nx ny nz 0 = (NX/W) & [W!=0] (NY/W) & [W!=0] (NZ/W) & [W!=0] (NZ/W) & [W!=0] = nx ny nz nz
2170 __ASM_EMIT("vxorps %[x2], %[x2], %[x2]") // x2 = 0 0 0 0
2171 __ASM_EMIT("vmovups (%[p0]), %[x3]") // x3 = x0 y0 z0 w0
2172 __ASM_EMIT("vsubps %[x1], %[x2], %[x2]") // x2 = -nx -ny -nz 0
2173 VECTOR_DOT3("[x2]", "[x3]", "[x3]", "[x4]") // x2 = -(nx*x0 + ny*y0 + nz*z0) = dw
2174 __ASM_EMIT("vinsertps $0x30, %[x2], %[x1], %[x1]")// x1 = nx ny nz dw
2175 __ASM_EMIT("vmovups %[x1], (%[v])")
2176
2177 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2178 : [v] "r" (v), [v0] "r" (v0), [p0] "r" (p0), [p1] "r" (p1)
2179 : "memory"
2180 );
2181
2182 return x0;
2183 }
2184
2185 void calc_split_point_p2v1(point3d_t *sp, const point3d_t *l0, const point3d_t *l1, const vector3d_t *pl)
2186 {
2187 float x0, x1, x2, x3;
2188
2189 ARCH_X86_ASM
2190 (
2191 __ASM_EMIT("vmovups (%[l0]), %[x1]") // x1 = l0 = lx0 ly0 lz0 1
2192 __ASM_EMIT("vmovups (%[l1]), %[x0]") // x0 = l1 = lx1 ly1 lz1 1
2193 __ASM_EMIT("vmovups (%[pl]), %[x2]") // x2 = pl = nx ny nz nw
2194 __ASM_EMIT("vsubps %[x1], %[x0], %[x0]") // x0 = d = l1 - l0 = dx dy dz 0
2195 __ASM_EMIT("vmulps %[x2], %[x1], %[x3]") // x3 = nx*lx0 ny*ly0 nz*lz0 nw */
2196 __ASM_EMIT("vmulps %[x0], %[x2], %[x2]") // x2 = nx*dx ny*dy nz*dz 0 */
2197 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0 nz*lz0+nw nx*lx0+ny*ly0 nz*lz0+nw
2198 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz nx*dx+ny*dy nz*dz
2199 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0+nz*lz0+nw = T T T T
2200 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz B B B B
2201 __ASM_EMIT("vdivps %[x2], %[x3], %[x3]") // x3 = T/B T/B T/B T/B = W
2202 __ASM_EMIT("vmulps %[x3], %[x0], %[x0]") // x0 = dx*W dy*W dz*W 0
2203 __ASM_EMIT("vsubps %[x0], %[x1], %[x1]") // x1 = lx0-dx*W ly0-dy*W lz0-dz*W 1
2204 __ASM_EMIT("vmovups %[x1], (%[sp])")
2205 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
2206 : [sp] "r" (sp), [l0] "r" (l0), [l1] "r" (l1), [pl] "r" (pl)
2207 : "memory"
2208 );
2209 }
2210
2211 void calc_split_point_pvv1(point3d_t *sp, const point3d_t *lv, const vector3d_t *pl)
2212 {
2213 float x0, x1, x2, x3;
2214
2215 ARCH_X86_ASM
2216 (
2217 __ASM_EMIT("vmovups 0x00(%[lv]), %[x1]") // x1 = l0 = lx0 ly0 lz0 1
2218 __ASM_EMIT("vmovups 0x10(%[lv]), %[x0]") // x0 = l1 = lx1 ly1 lz1 1
2219 __ASM_EMIT("vmovups (%[pl]), %[x2]") // x2 = pl = nx ny nz nw
2220 __ASM_EMIT("vsubps %[x1], %[x0], %[x0]") // x0 = d = l1 - l0 = dx dy dz 0
2221 __ASM_EMIT("vmulps %[x2], %[x1], %[x3]") // x3 = nx*lx0 ny*ly0 nz*lz0 nw */
2222 __ASM_EMIT("vmulps %[x0], %[x2], %[x2]") // x2 = nx*dx ny*dy nz*dz 0 */
2223 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0 nz*lz0+nw nx*lx0+ny*ly0 nz*lz0+nw
2224 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz nx*dx+ny*dy nz*dz
2225 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0+nz*lz0+nw = T T T T
2226 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz B B B B
2227 __ASM_EMIT("vdivps %[x2], %[x3], %[x3]") // x3 = T/B T/B T/B T/B = W
2228 __ASM_EMIT("vmulps %[x3], %[x0], %[x0]") // x0 = dx*W dy*W dz*W 0
2229 __ASM_EMIT("vsubps %[x0], %[x1], %[x1]") // x1 = lx0-dx*W ly0-dy*W lz0-dz*W 1
2230 __ASM_EMIT("vmovups %[x1], (%[sp])")
2231
2232 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
2233 : [sp] "r" (sp), [lv] "r" (lv), [pl] "r" (pl)
2234 : "cc", "memory"
2235 );
2236 }
2237
2238 void calc_split_point_p2v1_fma3(point3d_t *sp, const point3d_t *l0, const point3d_t *l1, const vector3d_t *pl)
2239 {
2240 float x0, x1, x2, x3;
2241
2242 ARCH_X86_ASM
2243 (
2244 __ASM_EMIT("vmovups (%[l0]), %[x1]") // x1 = l0 = lx0 ly0 lz0 1
2245 __ASM_EMIT("vmovups (%[l1]), %[x0]") // x0 = l1 = lx1 ly1 lz1 1
2246 __ASM_EMIT("vmovups (%[pl]), %[x2]") // x2 = pl = nx ny nz nw
2247 __ASM_EMIT("vsubps %[x1], %[x0], %[x0]") // x0 = d = l1 - l0 = dx dy dz 0
2248 __ASM_EMIT("vmulps %[x2], %[x1], %[x3]") // x3 = nx*lx0 ny*ly0 nz*lz0 nw */
2249 __ASM_EMIT("vmulps %[x0], %[x2], %[x2]") // x2 = nx*dx ny*dy nz*dz 0 */
2250 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0 nz*lz0+nw nx*lx0+ny*ly0 nz*lz0+nw
2251 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz nx*dx+ny*dy nz*dz
2252 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0+nz*lz0+nw = T T T T
2253 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz B B B B
2254 __ASM_EMIT("vdivps %[x2], %[x3], %[x3]") // x3 = T/B T/B T/B T/B = W
2255 __ASM_EMIT("vfnmadd231ps %[x3], %[x0], %[x1]") // x1 = lx0-dx*W ly0-dy*W lz0-dz*W 1
2256 __ASM_EMIT("vmovups %[x1], (%[sp])")
2257 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
2258 : [sp] "r" (sp), [l0] "r" (l0), [l1] "r" (l1), [pl] "r" (pl)
2259 : "memory"
2260 );
2261 }
2262
2263 void calc_split_point_pvv1_fma3(point3d_t *sp, const point3d_t *lv, const vector3d_t *pl)
2264 {
2265 float x0, x1, x2, x3;
2266
2267 ARCH_X86_ASM
2268 (
2269 __ASM_EMIT("vmovups 0x00(%[lv]), %[x1]") // x1 = l0 = lx0 ly0 lz0 1
2270 __ASM_EMIT("vmovups 0x10(%[lv]), %[x0]") // x0 = l1 = lx1 ly1 lz1 1
2271 __ASM_EMIT("vmovups (%[pl]), %[x2]") // x2 = pl = nx ny nz nw
2272 __ASM_EMIT("vsubps %[x1], %[x0], %[x0]") // x0 = d = l1 - l0 = dx dy dz 0
2273 __ASM_EMIT("vmulps %[x2], %[x1], %[x3]") // x3 = nx*lx0 ny*ly0 nz*lz0 nw */
2274 __ASM_EMIT("vmulps %[x0], %[x2], %[x2]") // x2 = nx*dx ny*dy nz*dz 0 */
2275 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0 nz*lz0+nw nx*lx0+ny*ly0 nz*lz0+nw
2276 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz nx*dx+ny*dy nz*dz
2277 __ASM_EMIT("vhaddps %[x3], %[x3], %[x3]") // x3 = nx*lx0+ny*ly0+nz*lz0+nw = T T T T
2278 __ASM_EMIT("vhaddps %[x2], %[x2], %[x2]") // x2 = nx*dx+ny*dy nz*dz B B B B
2279 __ASM_EMIT("vdivps %[x2], %[x3], %[x3]") // x3 = T/B T/B T/B T/B = W
2280 __ASM_EMIT("vfnmadd231ps %[x3], %[x0], %[x1]") // x1 = lx0-dx*W ly0-dy*W lz0-dz*W 1
2281 __ASM_EMIT("vmovups %[x1], (%[sp])")
2282
2283 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
2284 : [sp] "r" (sp), [lv] "r" (lv), [pl] "r" (pl)
2285 : "cc", "memory"
2286 );
2287 }
2288
2289 float check_triplet3d_p3n(const point3d_t *p1, const point3d_t *p2, const point3d_t *p3, const vector3d_t *n)
2290 {
2291 float x0, x1, x2, x3, x4;
2292
2293 ARCH_X86_ASM
2294 (
2295 __ASM_EMIT("vmovups (%[p2]), %[x2]") // x2 = p2 = px2 py2 pz2 1
2296 __ASM_EMIT("vmovups (%[p3]), %[x3]") // x3 = p3 = px3 py3 pz3 1
2297 __ASM_EMIT("vsubps (%[p1]), %[x2], %[x1]") // x1 = p2 - p1
2298 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz 0
2299 __ASM_EMIT("vsubps %[x2], %[x3], %[x2]") // x2 = p3 - p2
2300
2301 MIXED_PRODUCT3("x0", "x1", "x2", "x3", "x4")
2302
2303 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2304 : [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3), [n] "r" (n)
2305 );
2306
2307 return x0;
2308 }
2309
2310 float check_triplet3d_pvn(const point3d_t *pv, const vector3d_t *n)
2311 {
2312 float x0, x1, x2, x3, x4;
2313
2314 ARCH_X86_ASM
2315 (
2316 __ASM_EMIT("vmovups 0x10(%[pv]), %[x2]") // x2 = p2 = px2 py2 pz2 1
2317 __ASM_EMIT("vmovups 0x20(%[pv]), %[x3]") // x3 = p3 = px3 py3 pz3 1
2318 __ASM_EMIT("vsubps 0x00(%[pv]), %[x2], %[x1]") // x1 = p2 - p1
2319 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz nw
2320 __ASM_EMIT("vsubps %[x2], %[x3], %[x2]") // x2 = p3 - p2
2321
2322 MIXED_PRODUCT3("x0", "x1", "x2", "x3", "x4")
2323
2324 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2325 : [pv] "r" (pv), [n] "r" (n)
2326 );
2327
2328 return x0;
2329 }
2330
2331 float check_triplet3d_v2n(const vector3d_t *v1, const vector3d_t *v2, const vector3d_t *n)
2332 {
2333 float x0, x1, x2, x3, x4;
2334
2335 ARCH_X86_ASM
2336 (
2337 __ASM_EMIT("vmovups (%[v1]), %[x1]") // x1 = x1 y1 z1 w1
2338 __ASM_EMIT("vmovups (%[v2]), %[x2]") // x2 = x2 y2 z2 w2
2339 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz nw
2340
2341 MIXED_PRODUCT3("x0", "x1", "x2", "x3", "x4")
2342
2343 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2344 : [v1] "r" (v1), [v2] "r" (v2), [n] "r" (n)
2345 );
2346
2347 return x0;
2348 }
2349
2350 float check_triplet3d_vvn(const vector3d_t *v, const vector3d_t *n)
2351 {
2352 float x0, x1, x2, x3, x4;
2353
2354 ARCH_X86_ASM
2355 (
2356 __ASM_EMIT("vmovups 0x00(%[v]), %[x1]") // x1 = x1 y1 z1 w1
2357 __ASM_EMIT("vmovups 0x10(%[v]), %[x2]") // x2 = x2 y2 z2 w2
2358 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz nw
2359
2360 MIXED_PRODUCT3("x0", "x1", "x2", "x3", "x4")
2361
2362 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2363 : [v] "r" (v), [n] "r" (n)
2364 );
2365
2366 return x0;
2367 }
2368
2369 float check_triplet3d_vv(const vector3d_t *v)
2370 {
2371 float x0, x1, x2, x3, x4;
2372
2373 ARCH_X86_ASM
2374 (
2375 __ASM_EMIT("vmovups 0x00(%[v]), %[x1]") // x1 = x1 y1 z1 w1
2376 __ASM_EMIT("vmovups 0x10(%[v]), %[x2]") // x2 = x2 y2 z2 w2
2377 __ASM_EMIT("vmovups 0x20(%[v]), %[x0]") // x0 = nx ny nz nw
2378
2379 MIXED_PRODUCT3("x0", "x1", "x2", "x3", "x4")
2380
2381 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2382 : [v] "r" (v)
2383 );
2384
2385 return x0;
2386 }
2387
2388 float check_triplet3d_p3n_fma3(const point3d_t *p1, const point3d_t *p2, const point3d_t *p3, const vector3d_t *n)
2389 {
2390 float x0, x1, x2, x3, x4;
2391
2392 ARCH_X86_ASM
2393 (
2394 __ASM_EMIT("vmovups (%[p2]), %[x2]") // x2 = p2 = px2 py2 pz2 1
2395 __ASM_EMIT("vmovups (%[p3]), %[x3]") // x3 = p3 = px3 py3 pz3 1
2396 __ASM_EMIT("vsubps (%[p1]), %[x2], %[x1]") // x1 = p2 - p1
2397 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz 0
2398 __ASM_EMIT("vsubps %[x2], %[x3], %[x2]") // x2 = p3 - p2
2399
2400 MIXED_PRODUCT3_FMA3("x0", "x1", "x2", "x3", "x4")
2401
2402 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2403 : [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3), [n] "r" (n)
2404 );
2405
2406 return x0;
2407 }
2408
2409 float check_triplet3d_pvn_fma3(const point3d_t *pv, const vector3d_t *n)
2410 {
2411 float x0, x1, x2, x3, x4;
2412
2413 ARCH_X86_ASM
2414 (
2415 __ASM_EMIT("vmovups 0x10(%[pv]), %[x2]") // x2 = p2 = px2 py2 pz2 1
2416 __ASM_EMIT("vmovups 0x20(%[pv]), %[x3]") // x3 = p3 = px3 py3 pz3 1
2417 __ASM_EMIT("vsubps 0x00(%[pv]), %[x2], %[x1]") // x1 = p2 - p1
2418 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz nw
2419 __ASM_EMIT("vsubps %[x2], %[x3], %[x2]") // x2 = p3 - p2
2420
2421 MIXED_PRODUCT3_FMA3("x0", "x1", "x2", "x3", "x4")
2422
2423 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2424 : [pv] "r" (pv), [n] "r" (n)
2425 );
2426
2427 return x0;
2428 }
2429
2430 float check_triplet3d_v2n_fma3(const vector3d_t *v1, const vector3d_t *v2, const vector3d_t *n)
2431 {
2432 float x0, x1, x2, x3, x4;
2433
2434 ARCH_X86_ASM
2435 (
2436 __ASM_EMIT("vmovups (%[v1]), %[x1]") // x1 = x1 y1 z1 w1
2437 __ASM_EMIT("vmovups (%[v2]), %[x2]") // x2 = x2 y2 z2 w2
2438 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz nw
2439
2440 MIXED_PRODUCT3_FMA3("x0", "x1", "x2", "x3", "x4")
2441
2442 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2443 : [v1] "r" (v1), [v2] "r" (v2), [n] "r" (n)
2444 );
2445
2446 return x0;
2447 }
2448
2449 float check_triplet3d_vvn_fma3(const vector3d_t *v, const vector3d_t *n)
2450 {
2451 float x0, x1, x2, x3, x4;
2452
2453 ARCH_X86_ASM
2454 (
2455 __ASM_EMIT("vmovups 0x00(%[v]), %[x1]") // x1 = x1 y1 z1 w1
2456 __ASM_EMIT("vmovups 0x10(%[v]), %[x2]") // x2 = x2 y2 z2 w2
2457 __ASM_EMIT("vmovups (%[n]), %[x0]") // x0 = nx ny nz nw
2458
2459 MIXED_PRODUCT3_FMA3("x0", "x1", "x2", "x3", "x4")
2460
2461 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2462 : [v] "r" (v), [n] "r" (n)
2463 );
2464
2465 return x0;
2466 }
2467
2468 float check_triplet3d_vv_fma3(const vector3d_t *v)
2469 {
2470 float x0, x1, x2, x3, x4;
2471
2472 ARCH_X86_ASM
2473 (
2474 __ASM_EMIT("vmovups 0x00(%[v]), %[x1]") // x1 = x1 y1 z1 w1
2475 __ASM_EMIT("vmovups 0x10(%[v]), %[x2]") // x2 = x2 y2 z2 w2
2476 __ASM_EMIT("vmovups 0x20(%[v]), %[x0]") // x0 = nx ny nz nw
2477
2478 MIXED_PRODUCT3_FMA3("x0", "x1", "x2", "x3", "x4")
2479
2480 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4)
2481 : [v] "r" (v)
2482 );
2483
2484 return x0;
2485 }
2486
2487 float check_point3d_on_triangle_pvp(const point3d_t *pv, const point3d_t *p)
2488 {
2489 float x0, x1, x2, x3, x4, x5, x6, x7;
2490 uint32_t mask;
2491
2492 ARCH_X86_ASM
2493 (
2494 /* Load vectors */
2495 __ASM_EMIT("vmovups (%[p]), %[x3]") // x3 = px py pz 1
2496 __ASM_EMIT("vmovups 0x00(%[pv]), %[x0]") // x0 = x0 y0 z0 1
2497 __ASM_EMIT("vmovups 0x10(%[pv]), %[x1]") // x1 = x1 y1 z1 1
2498 __ASM_EMIT("vmovups 0x20(%[pv]), %[x2]") // x2 = x2 y2 z2 1
2499 __ASM_EMIT("vsubps %[x3], %[x0], %[x0]") // x0 = v0 = dx0 dy0 dz0 0
2500 __ASM_EMIT("vsubps %[x3], %[x1], %[x1]") // x1 = v1 = dx1 dy1 dz1 0
2501 __ASM_EMIT("vsubps %[x3], %[x2], %[x2]") // x2 = v2 = dx2 dy2 dz2 0
2502 /* 3x vector multiplications */
2503 VECTOR_CROSS3_X3("[x0]", "[x1]", "[x2]", "[x3]", "[x4]", "[x5]", "[x6]", "[x7]")
2504 /* 3x scalar multiplications */
2505 /* x0 = m0 = v0 cross v1 */
2506 /* x1 = m1 = v1 cross v2 */
2507 /* x2 = m2 = v2 cross v0 */
2508 VECTOR_DOT3_X3("[x0]", "[x1]", "[x2]", "[x3]")
2509 /* Compare with zeros */
2510 /* x0 = r0 = m0 dot m1 */
2511 /* x1 = r1 = m1 dot m2 */
2512 /* x2 = r2 = m2 dot m0 */
2513 __ASM_EMIT("vunpcklps %[x1], %[x0], %[x0]") // x0 = r0 r1 ? ?
2514 __ASM_EMIT("vmovlhps %[x2], %[x0], %[x0]") // x0 = r0 r1 r2 ?
2515 __ASM_EMIT("vxorps %[x4], %[x4], %[x4]") // x4 = 0
2516 __ASM_EMIT("vcmpps $1, %[x4], %[x0], %[x3]") // x3 = [ r0 < 0, r1 < 0, r2 < 0 ]
2517 __ASM_EMIT("vmovmskps %[x3], %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2518 __ASM_EMIT("testl $0x07, %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2519 __ASM_EMIT("jnz 100f")
2520 __ASM_EMIT("vmulss %[x0], %[x1], %[x0]") // x0 = r0 * r1
2521 __ASM_EMIT("vmulss %[x0], %[x2], %[x0]") // x0 = r0 * r1 * r2
2522 __ASM_EMIT("jmp 110f")
2523 __ASM_EMIT("100:")
2524 __ASM_EMIT("vmovss %[NEG], %[x0]") // x0 = negative value
2525 /* End */
2526 __ASM_EMIT("110:")
2527 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
2528 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7),
2529 [mask] "=&r"(mask)
2530 : [pv] "r" (pv), [p] "r" (p),
2531 [NEG] "m" (X_3D_MTOLERANCE)
2532 : "cc"
2533 );
2534
2535 return x0;
2536 }
2537
2538 float check_point3d_on_triangle_p3p(const point3d_t *p1, const point3d_t *p2, const point3d_t *p3, const point3d_t *p)
2539 {
2540 float x0, x1, x2, x3, x4, x5, x6, x7;
2541 uint32_t mask;
2542
2543 ARCH_X86_ASM
2544 (
2545 /* Load vectors */
2546 __ASM_EMIT("vmovups (%[p]), %[x3]") // x3 = px py pz 1
2547 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x0 y0 z0 1
2548 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x1 = x1 y1 z1 1
2549 __ASM_EMIT("vmovups (%[p3]), %[x2]") // x2 = x2 y2 z2 1
2550 __ASM_EMIT("vsubps %[x3], %[x0], %[x0]") // x0 = v0 = dx0 dy0 dz0 0
2551 __ASM_EMIT("vsubps %[x3], %[x1], %[x1]") // x1 = v1 = dx1 dy1 dz1 0
2552 __ASM_EMIT("vsubps %[x3], %[x2], %[x2]") // x2 = v2 = dx2 dy2 dz2 0
2553 /* 3x vector multiplications */
2554 VECTOR_CROSS3_X3("[x0]", "[x1]", "[x2]", "[x3]", "[x4]", "[x5]", "[x6]", "[x7]")
2555 /* 3x scalar multiplications */
2556 /* x0 = m0 = v0 cross v1 */
2557 /* x1 = m1 = v1 cross v2 */
2558 /* x2 = m2 = v2 cross v0 */
2559 VECTOR_DOT3_X3("[x0]", "[x1]", "[x2]", "[x3]")
2560 /* Compare with zeros */
2561 /* x0 = r0 = m0 dot m1 */
2562 /* x1 = r1 = m1 dot m2 */
2563 /* x2 = r2 = m2 dot m0 */
2564 __ASM_EMIT("vunpcklps %[x1], %[x0], %[x0]") // x0 = r0 r1 ? ?
2565 __ASM_EMIT("vmovlhps %[x2], %[x0], %[x0]") // x0 = r0 r1 r2 ?
2566 __ASM_EMIT("vxorps %[x4], %[x4], %[x4]") // x4 = 0
2567 __ASM_EMIT("vcmpps $1, %[x4], %[x0], %[x3]") // x3 = [ r0 < 0, r1 < 0, r2 < 0 ]
2568 __ASM_EMIT("vmovmskps %[x3], %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2569 __ASM_EMIT("testl $0x07, %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2570 __ASM_EMIT("jnz 100f")
2571 __ASM_EMIT("vmulss %[x0], %[x1], %[x0]") // x0 = r0 * r1
2572 __ASM_EMIT("vmulss %[x0], %[x2], %[x0]") // x0 = r0 * r1 * r2
2573 __ASM_EMIT("jmp 110f")
2574 __ASM_EMIT("100:")
2575 __ASM_EMIT("vmovss %[NEG], %[x0]") // x0 = r1
2576 /* End */
2577 __ASM_EMIT("110:")
2578 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
2579 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7),
2580 [mask] "=&r"(mask)
2581 : [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3), [p] "r" (p),
2582 [NEG] "m" (X_3D_MTOLERANCE)
2583 : "cc"
2584 );
2585
2586 return x0;
2587 }
2588
2589 float check_point3d_on_triangle_pvp_fma3(const point3d_t *pv, const point3d_t *p)
2590 {
2591 float x0, x1, x2, x3, x4, x5, x6, x7;
2592 uint32_t mask;
2593
2594 ARCH_X86_ASM
2595 (
2596 /* Load vectors */
2597 __ASM_EMIT("vmovups (%[p]), %[x3]") // x3 = px py pz 1
2598 __ASM_EMIT("vmovups 0x00(%[pv]), %[x0]") // x0 = x0 y0 z0 1
2599 __ASM_EMIT("vmovups 0x10(%[pv]), %[x1]") // x1 = x1 y1 z1 1
2600 __ASM_EMIT("vmovups 0x20(%[pv]), %[x2]") // x2 = x2 y2 z2 1
2601 __ASM_EMIT("vsubps %[x3], %[x0], %[x0]") // x0 = v0 = dx0 dy0 dz0 0
2602 __ASM_EMIT("vsubps %[x3], %[x1], %[x1]") // x1 = v1 = dx1 dy1 dz1 0
2603 __ASM_EMIT("vsubps %[x3], %[x2], %[x2]") // x2 = v2 = dx2 dy2 dz2 0
2604 /* 3x vector multiplications */
2605 VECTOR_CROSS3_X3_FMA3("[x0]", "[x1]", "[x2]", "[x3]", "[x4]", "[x5]", "[x6]", "[x7]")
2606 /* 3x scalar multiplications */
2607 /* x0 = m0 = v0 cross v1 */
2608 /* x1 = m1 = v1 cross v2 */
2609 /* x2 = m2 = v2 cross v0 */
2610 VECTOR_DOT3_X3("[x0]", "[x1]", "[x2]", "[x3]")
2611 /* Compare with zeros */
2612 /* x0 = r0 = m0 dot m1 */
2613 /* x1 = r1 = m1 dot m2 */
2614 /* x2 = r2 = m2 dot m0 */
2615 __ASM_EMIT("vunpcklps %[x1], %[x0], %[x0]") // x0 = r0 r1 ? ?
2616 __ASM_EMIT("vmovlhps %[x2], %[x0], %[x0]") // x0 = r0 r1 r2 ?
2617 __ASM_EMIT("vxorps %[x4], %[x4], %[x4]") // x4 = 0
2618 __ASM_EMIT("vcmpps $1, %[x4], %[x0], %[x3]") // x3 = [ r0 < 0, r1 < 0, r2 < 0 ]
2619 __ASM_EMIT("vmovmskps %[x3], %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2620 __ASM_EMIT("testl $0x07, %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2621 __ASM_EMIT("jnz 100f")
2622 __ASM_EMIT("vmulss %[x0], %[x1], %[x0]") // x0 = r0 * r1
2623 __ASM_EMIT("vmulss %[x0], %[x2], %[x0]") // x0 = r0 * r1 * r2
2624 __ASM_EMIT("jmp 110f")
2625 __ASM_EMIT("100:")
2626 __ASM_EMIT("vmovss %[NEG], %[x0]") // x0 = r1
2627 /* End */
2628 __ASM_EMIT("110:")
2629 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
2630 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7),
2631 [mask] "=&r"(mask)
2632 : [pv] "r" (pv), [p] "r" (p),
2633 [NEG] "m" (X_3D_MTOLERANCE)
2634 : "cc"
2635 );
2636
2637 return x0;
2638 }
2639
2640 float check_point3d_on_triangle_p3p_fma3(const point3d_t *p1, const point3d_t *p2, const point3d_t *p3, const point3d_t *p)
2641 {
2642 float x0, x1, x2, x3, x4, x5, x6, x7;
2643 uint32_t mask;
2644
2645 ARCH_X86_ASM
2646 (
2647 /* Load vectors */
2648 __ASM_EMIT("vmovups (%[p]), %[x3]") // x3 = px py pz 1
2649 __ASM_EMIT("vmovups (%[p1]), %[x0]") // x0 = x0 y0 z0 1
2650 __ASM_EMIT("vmovups (%[p2]), %[x1]") // x1 = x1 y1 z1 1
2651 __ASM_EMIT("vmovups (%[p3]), %[x2]") // x2 = x2 y2 z2 1
2652 __ASM_EMIT("vsubps %[x3], %[x0], %[x0]") // x0 = v0 = dx0 dy0 dz0 0
2653 __ASM_EMIT("vsubps %[x3], %[x1], %[x1]") // x1 = v1 = dx1 dy1 dz1 0
2654 __ASM_EMIT("vsubps %[x3], %[x2], %[x2]") // x2 = v2 = dx2 dy2 dz2 0
2655 /* 3x vector multiplications */
2656 VECTOR_CROSS3_X3_FMA3("[x0]", "[x1]", "[x2]", "[x3]", "[x4]", "[x5]", "[x6]", "[x7]")
2657 /* 3x scalar multiplications */
2658 /* x0 = m0 = v0 cross v1 */
2659 /* x1 = m1 = v1 cross v2 */
2660 /* x2 = m2 = v2 cross v0 */
2661 VECTOR_DOT3_X3("[x0]", "[x1]", "[x2]", "[x3]")
2662 /* Compare with zeros */
2663 /* x0 = r0 = m0 dot m1 */
2664 /* x1 = r1 = m1 dot m2 */
2665 /* x2 = r2 = m2 dot m0 */
2666 __ASM_EMIT("vunpcklps %[x1], %[x0], %[x0]") // x0 = r0 r1 ? ?
2667 __ASM_EMIT("vmovlhps %[x2], %[x0], %[x0]") // x0 = r0 r1 r2 ?
2668 __ASM_EMIT("vxorps %[x4], %[x4], %[x4]") // x4 = 0
2669 __ASM_EMIT("vcmpps $1, %[x4], %[x0], %[x3]") // x3 = [ r0 < 0, r1 < 0, r2 < 0 ]
2670 __ASM_EMIT("vmovmskps %[x3], %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2671 __ASM_EMIT("testl $0x07, %k[mask]") // mask = r0 < 0 || r1 < 0 || r2 < 0
2672 __ASM_EMIT("jnz 100f")
2673 __ASM_EMIT("vmulss %[x0], %[x1], %[x0]") // x0 = r0 * r1
2674 __ASM_EMIT("vmulss %[x0], %[x2], %[x0]") // x0 = r0 * r1 * r2
2675 __ASM_EMIT("jmp 110f")
2676 __ASM_EMIT("100:")
2677 __ASM_EMIT("vmovss %[NEG], %[x0]") // x0 = r1
2678 /* End */
2679 __ASM_EMIT("110:")
2680 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
2681 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7),
2682 [mask] "=&r"(mask)
2683 : [p1] "r" (p1), [p2] "r" (p2), [p3] "r" (p3), [p] "r" (p),
2684 [NEG] "m" (X_3D_MTOLERANCE)
2685 : "cc"
2686 );
2687
2688 return x0;
2689 }
2690
2691 } /* namespace avx */
2692 } /* namespace lsp */
2693
2694 #endif /* INCLUDE_PRIVATE_DSP_ARCH_X86_AVX_3DMATH_3DMATH_H_ */