Debian Codegraph @

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

raw
1 /*
2 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2020 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-dsp-lib
6 * Created on: 31 мар. 2020 г.
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_SSE3_3DMATH_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE3_3DMATH_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_SSE3_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_SSE3_IMPL */
28
29 namespace lsp
30 {
31 namespace sse3
32 {
33 using namespace dsp;
34
35 IF_ARCH_X86(
36 static const float X_3D_TOLERANCE[] __lsp_aligned16 = { LSP_DSP_VEC4(DSP_3D_TOLERANCE) };
37 static const float X_3D_MTOLERANCE[] __lsp_aligned16 = { LSP_DSP_VEC4(-DSP_3D_TOLERANCE) };
38
39 static const uint32_t IONE[] __lsp_aligned16 = { LSP_DSP_VEC4(1) };
40 static const uint32_t ICULL3[] __lsp_aligned16 = { 0x01, 0x04, 0x10, 0 };
41 )
42
43 void calc_split_point_p2v1(point3d_t *sp, const point3d_t *l0, const point3d_t *l1, const vector3d_t *pl)
44 {
45 float x0, x1, x2, x3;
46
47 ARCH_X86_ASM
48 (
49 __ASM_EMIT("movups (%[l0]), %[x1]") /* xmm1 = l0 = lx0 ly0 lz0 1 */
50 __ASM_EMIT("movups (%[l1]), %[x0]") /* xmm0 = l1 = lx1 ly1 lz1 1 */
51 __ASM_EMIT("movaps %[x1], %[x3]") /* xmm4 = lx0 ly0 lz0 1 */
52 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm2 = pl = nx ny nz nw */
53 __ASM_EMIT("subps %[x1], %[x0]") /* xmm0 = d = l1 - l0 = dx dy dz 0 */
54
55 __ASM_EMIT("mulps %[x2], %[x1]") /* xmm1 = nx*lx0 ny*ly0 nz*lz0 nw */
56 __ASM_EMIT("mulps %[x0], %[x2]") /* xmm2 = nx*dx ny*dy nz*dz 0 */
57 __ASM_EMIT("haddps %[x1], %[x1]") /* xmm1 = nx*lx0+ny*ly0 nz*lz0+nw nx*lx0+ny*ly0 nz*lz0+nw */
58 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = nx*dx+ny*dy nz*dz nx*dx+ny*dy nz*dz */
59 __ASM_EMIT("haddps %[x1], %[x1]") /* xmm1 = nx*lx0+ny*ly0+nz*lz0+nw = T T T T */
60 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = nx*dx+ny*dy nz*dz B B B B */
61 __ASM_EMIT("divps %[x2], %[x1]") /* xmm1 = T/B T/B T/B T/B = W */
62 __ASM_EMIT("mulps %[x1], %[x0]") /* xmm0 = dx*W dy*W dz*W 0 */
63 __ASM_EMIT("subps %[x0], %[x3]") /* xmm0 = lx0-dx*W ly0-dy*W lz0-dz*W 1 */
64
65 __ASM_EMIT("movups %[x3], (%[sp])")
66 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
67 : [sp] "r" (sp), [l0] "r" (l0), [l1] "r" (l1), [pl] "r" (pl)
68 : "memory"
69 );
70 }
71
72 void calc_split_point_pvv1(point3d_t *sp, const point3d_t *lv, const vector3d_t *pl)
73 {
74 float x0, x1, x2, x3;
75
76 ARCH_X86_ASM
77 (
78 __ASM_EMIT("movups 0x00(%[lv]), %[x1]") /* xmm1 = l0 = lx0 ly0 lz0 ? */
79 __ASM_EMIT("movups 0x10(%[lv]), %[x0]") /* xmm0 = l1 = lx1 ly1 lz1 ? */
80 __ASM_EMIT("movaps %[x1], %[x3]") /* xmm4 = lx0 ly0 lz0 1 */
81 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm2 = pl = nx ny nz nw */
82 __ASM_EMIT("subps %[x1], %[x0]") /* xmm0 = d = l1 - l0 = dx dy dz 0 */
83
84 __ASM_EMIT("mulps %[x2], %[x1]") /* xmm1 = nx*lx0 ny*ly0 nz*lz0 nw */
85 __ASM_EMIT("mulps %[x0], %[x2]") /* xmm2 = nx*dx ny*dy nz*dz 0 */
86 __ASM_EMIT("haddps %[x1], %[x1]") /* xmm1 = nx*lx0+ny*ly0 nz*lz0+nw nx*lx0+ny*ly0 nz*lz0+nw */
87 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = nx*dx+ny*dy nz*dz nx*dx+ny*dy nz*dz */
88 __ASM_EMIT("haddps %[x1], %[x1]") /* xmm1 = nx*lx0+ny*ly0+nz*lz0+nw = T T T T */
89 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = nx*dx+ny*dy nz*dz B B B B */
90 __ASM_EMIT("divps %[x2], %[x1]") /* xmm1 = T/B T/B T/B T/B = W */
91 __ASM_EMIT("mulps %[x1], %[x0]") /* xmm0 = dx*W dy*W dz*W 0 */
92 __ASM_EMIT("subps %[x0], %[x3]") /* xmm0 = lx0-dx*W ly0-dy*W lz0-dz*W 1 */
93
94 __ASM_EMIT("movups %[x3], (%[sp])")
95
96 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
97 : [sp] "r" (sp), [lv] "r" (lv), [pl] "r" (pl)
98 : "cc", "memory"
99 );
100 }
101
102 size_t colocation_x2_v1p2(const vector3d_t *pl, const point3d_t *p0, const point3d_t *p1)
103 {
104 float x0, x1, x2;
105 float res[4] __lsp_aligned16;
106
107 ARCH_X86_ASM
108 (
109 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm3 = pl */
110 __ASM_EMIT("movups (%[p0]), %[x0]") /* xmm0 = p0 */
111 __ASM_EMIT("movups (%[p1]), %[x1]") /* xmm1 = p1 */
112
113 __ASM_EMIT("mulps %[x2], %[x0]") /* xmm0 = x0*px y0*py z0*pz w0*pw */
114 __ASM_EMIT("mulps %[x2], %[x1]") /* xmm1 = x1*px y1*py z1*pz w1*pw */
115 __ASM_EMIT("haddps %[x1], %[x0]") /* xmm0 = x0*px+y0*py z0*pz+w0*pw x1*px+y1*py z1*pz+w1*pw */
116 __ASM_EMIT("haddps %[x0], %[x0]") /* xmm0 = x1*px+y1*py+z1*pz+w1*pw x1*px+y1*py+z1*pz+w1*pw ? ? = k0 k1 ? ? */
117 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 ? ? */
118
119 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL ? ? */
120 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL ? ? */
121 __ASM_EMIT("andps %[IONE], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
122 __ASM_EMIT("andps %[IONE], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
123 __ASM_EMIT("paddd %[x1], %[x0]")
124 __ASM_EMIT("movdqa %[x0], (%[res])")
125 __ASM_EMIT32("movl 0x00(%[res]), %[p0]")
126 __ASM_EMIT32("movl 0x04(%[res]), %[p1]")
127 __ASM_EMIT64("movl 0x00(%[res]), %k[p0]")
128 __ASM_EMIT64("movl 0x04(%[res]), %k[p1]")
129 __ASM_EMIT("lea (%[p0], %[p1], 4), %[p0]")
130 : [p0] "+r" (p0), [p1] "+r" (p1),
131 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
132 : [pl] "r" (pl),
133 [res] "r" (res),
134 [PTOL] "m" (X_3D_TOLERANCE),
135 [MTOL] "m" (X_3D_MTOLERANCE),
136 [IONE] "m" (IONE)
137 : "cc", "memory"
138 );
139
140 return size_t(p0);
141 }
142
143 size_t colocation_x2_v1pv(const vector3d_t *pl, const point3d_t *pv)
144 {
145 float x0, x1, x2;
146 float res[4] __lsp_aligned16;
147
148 ARCH_X86_ASM
149 (
150 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm3 = pl */
151 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
152 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
153
154 __ASM_EMIT("mulps %[x2], %[x0]") /* xmm0 = x0*px y0*py z0*pz w0*pw */
155 __ASM_EMIT("mulps %[x2], %[x1]") /* xmm1 = x1*px y1*py z1*pz w1*pw */
156 __ASM_EMIT("haddps %[x1], %[x0]") /* xmm0 = x0*px+y0*py z0*pz+w0*pw x1*px+y1*py z1*pz+w1*pw */
157 __ASM_EMIT("haddps %[x0], %[x0]") /* xmm0 = x1*px+y1*py+z1*pz+w1*pw x1*px+y1*py+z1*pz+w1*pw ? ? = k0 k1 ? ? */
158 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 ? ? */
159
160 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL ? ? */
161 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL ? ? */
162 __ASM_EMIT("andps %[IONE], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] ? ? */
163 __ASM_EMIT("andps %[IONE], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] ? ? */
164 __ASM_EMIT("paddd %[x1], %[x0]")
165 __ASM_EMIT("movdqa %[x0], (%[res])")
166 __ASM_EMIT32("movl 0x00(%[res]), %[pl]")
167 __ASM_EMIT32("movl 0x04(%[res]), %[pv]")
168 __ASM_EMIT64("movl 0x00(%[res]), %k[pl]")
169 __ASM_EMIT64("movl 0x04(%[res]), %k[pv]")
170 __ASM_EMIT("lea (%[pl], %[pv], 4), %[pl]")
171 : [pl] "+r" (pl), [pv] "+r" (pv),
172 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2)
173 : [res] "r" (res),
174 [PTOL] "m" (X_3D_TOLERANCE),
175 [MTOL] "m" (X_3D_MTOLERANCE),
176 [IONE] "m" (IONE)
177 : "cc", "memory"
178 );
179
180 return size_t(pl);
181 }
182
183 size_t colocation_x3_v1p3(const vector3d_t *pl, const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
184 {
185 float x0, x1, x2, x3;
186 float res[4] __lsp_aligned16;
187
188 ARCH_X86_ASM
189 (
190 __ASM_EMIT("movups (%[pl]), %[x3]") /* xmm3 = pl */
191 __ASM_EMIT("movups (%[p0]), %[x0]") /* xmm0 = p0 */
192 __ASM_EMIT("movups (%[p1]), %[x1]") /* xmm1 = p1 */
193 __ASM_EMIT("movups (%[p2]), %[x2]") /* xmm2 = p2 */
194
195 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl */
196 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl */
197 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl */
198 __ASM_EMIT("haddps %[x1], %[x0]")
199 __ASM_EMIT("haddps %[x3], %[x2]")
200 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = k0 k1 k2 ? */
201 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 ? */
202 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL ? */
203 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL ? */
204 __ASM_EMIT("andps %[IONE], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] ? */
205 __ASM_EMIT("andps %[IONE], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] ? */
206 __ASM_EMIT("paddd %[x1], %[x0]")
207 __ASM_EMIT("movdqa %[x0],(%[res])")
208 __ASM_EMIT32("movl 0x00(%[res]), %[p0]")
209 __ASM_EMIT32("movl 0x04(%[res]), %[p1]")
210 __ASM_EMIT32("movl 0x08(%[res]), %[p2]")
211 __ASM_EMIT64("movl 0x00(%[res]), %k[p0]")
212 __ASM_EMIT64("movl 0x04(%[res]), %k[p1]")
213 __ASM_EMIT64("movl 0x08(%[res]), %k[p2]")
214 __ASM_EMIT("lea (%[p1], %[p2], 4), %[p1]")
215 __ASM_EMIT("lea (%[p0], %[p1], 4), %[p0]")
216 : [p0] "+r" (p0), [p1] "+r" (p1), [p2] "+r" (p2),
217 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
218 : [pl] "r" (pl),
219 [res] "r" (res),
220 [PTOL] "m" (X_3D_TOLERANCE),
221 [MTOL] "m" (X_3D_MTOLERANCE),
222 [IONE] "m" (IONE)
223 : "cc", "memory"
224 );
225
226 return size_t(p0);
227 }
228
229 size_t colocation_x3_v1pv(const vector3d_t *pl, const point3d_t *pv)
230 {
231 float x0, x1, x2, x3;
232 float res[4] __lsp_aligned16;
233 size_t pt;
234
235 ARCH_X86_ASM
236 (
237 __ASM_EMIT("movups (%[pl]), %[x3]") /* xmm3 = pl */
238 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
239 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
240 __ASM_EMIT("movups 0x20(%[pv]), %[x2]") /* xmm2 = p2 */
241
242 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl */
243 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl */
244 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl */
245 __ASM_EMIT("haddps %[x1], %[x0]")
246 __ASM_EMIT("haddps %[x3], %[x2]")
247 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = k0 k1 k2 ? */
248 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 ? */
249 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL ? */
250 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL ? */
251 __ASM_EMIT("andps %[IONE], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] ? */
252 __ASM_EMIT("andps %[IONE], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] ? */
253 __ASM_EMIT("paddd %[x1], %[x0]")
254 __ASM_EMIT("movdqa %[x0], (%[res])")
255 __ASM_EMIT32("movl 0x00(%[res]), %[pt]")
256 __ASM_EMIT32("movl 0x04(%[res]), %[pl]")
257 __ASM_EMIT32("movl 0x08(%[res]), %[pv]")
258 __ASM_EMIT64("movl 0x00(%[res]), %k[pt]")
259 __ASM_EMIT64("movl 0x04(%[res]), %k[pl]")
260 __ASM_EMIT64("movl 0x08(%[res]), %k[pv]")
261 __ASM_EMIT("lea (%[pl], %[pv], 4), %[pl]")
262 __ASM_EMIT("lea (%[pt], %[pl], 4), %[pt]")
263 : [pl] "+r" (pl), [pv] "+r" (pv), [pt] "=&r" (pt),
264 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
265 : [res] "r" (res),
266 [PTOL] "m" (X_3D_TOLERANCE),
267 [MTOL] "m" (X_3D_MTOLERANCE),
268 [IONE] "m" (IONE)
269 : "cc", "memory"
270 );
271
272 return pt;
273 }
274
275 size_t colocation_x3_v3p1(const vector3d_t *v0, const vector3d_t *v1, const vector3d_t *v2, const point3d_t *p)
276 {
277 float x0, x1, x2, x3;
278 float res[4] __lsp_aligned16;
279
280 ARCH_X86_ASM
281 (
282 __ASM_EMIT("movups (%[p]), %[x3]") /* xmm3 = p */
283 __ASM_EMIT("movups (%[v0]), %[x0]") /* xmm0 = v0 */
284 __ASM_EMIT("movups (%[v1]), %[x1]") /* xmm1 = v1 */
285 __ASM_EMIT("movups (%[v2]), %[x2]") /* xmm2 = v2 */
286
287 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl */
288 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl */
289 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl */
290 __ASM_EMIT("haddps %[x1], %[x0]")
291 __ASM_EMIT("haddps %[x3], %[x2]")
292 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = k0 k1 k2 ? */
293 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 ? */
294 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL ? */
295 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL ? */
296 __ASM_EMIT("andps %[IONE], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] ? */
297 __ASM_EMIT("andps %[IONE], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] ? */
298 __ASM_EMIT("paddd %[x1], %[x0]")
299 __ASM_EMIT("movdqa %[x0], (%[res])")
300 __ASM_EMIT32("movl 0x00(%[res]), %[v0]")
301 __ASM_EMIT32("movl 0x04(%[res]), %[v1]")
302 __ASM_EMIT32("movl 0x08(%[res]), %[v2]")
303 __ASM_EMIT64("movl 0x00(%[res]), %k[v0]")
304 __ASM_EMIT64("movl 0x04(%[res]), %k[v1]")
305 __ASM_EMIT64("movl 0x08(%[res]), %k[v2]")
306 __ASM_EMIT("lea (%[v1], %[v2], 4), %[v1]")
307 __ASM_EMIT("lea (%[v0], %[v1], 4), %[v0]")
308
309 : [v0] "+r" (v0), [v1] "+r" (v1), [v2] "+r" (v2),
310 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
311 : [p] "r" (p),
312 [res] "r" (res),
313 [PTOL] "m" (X_3D_TOLERANCE),
314 [MTOL] "m" (X_3D_MTOLERANCE),
315 [IONE] "m" (IONE)
316 : "cc", "memory"
317 );
318
319 return size_t(v0);
320 }
321
322 size_t colocation_x3_vvp1(const vector3d_t *vv, const point3d_t *p)
323 {
324 float x0, x1, x2, x3;
325 float res[4] __lsp_aligned16;
326 size_t pt;
327
328 ARCH_X86_ASM
329 (
330 __ASM_EMIT("movups (%[p]), %[x3]") /* xmm3 = p */
331 __ASM_EMIT("movups 0x00(%[vv]), %[x0]") /* xmm0 = v0 */
332 __ASM_EMIT("movups 0x10(%[vv]), %[x1]") /* xmm1 = v1 */
333 __ASM_EMIT("movups 0x20(%[vv]), %[x2]") /* xmm2 = v2 */
334
335 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl */
336 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl */
337 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl */
338 __ASM_EMIT("haddps %[x1], %[x0]")
339 __ASM_EMIT("haddps %[x3], %[x2]")
340 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = k0 k1 k2 ? */
341 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 ? */
342 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL ? */
343 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL ? */
344 __ASM_EMIT("andps %[IONE], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] ? */
345 __ASM_EMIT("andps %[IONE], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] ? */
346 __ASM_EMIT("paddd %[x1], %[x0]")
347 __ASM_EMIT("movdqa %[x0], (%[res])")
348 __ASM_EMIT32("movl 0x00(%[res]), %[pt]")
349 __ASM_EMIT32("movl 0x04(%[res]), %[vv]")
350 __ASM_EMIT32("movl 0x08(%[res]), %[p]")
351 __ASM_EMIT64("movl 0x00(%[res]), %k[pt]")
352 __ASM_EMIT64("movl 0x04(%[res]), %k[vv]")
353 __ASM_EMIT64("movl 0x08(%[res]), %k[p]")
354 __ASM_EMIT("lea (%[vv], %[p], 4), %[vv]")
355 __ASM_EMIT("lea (%[pt], %[vv], 4), %[pt]")
356
357 : [p] "+r" (p), [vv] "+r" (vv), [pt] "=&r" (pt),
358 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3)
359 : [res] "r" (res),
360 [PTOL] "m" (X_3D_TOLERANCE),
361 [MTOL] "m" (X_3D_MTOLERANCE),
362 [IONE] "m" (IONE)
363 : "cc", "memory"
364 );
365
366 return pt;
367 }
368
369 float calc_min_distance_p3(const point3d_t *sp, const point3d_t *p0, const point3d_t *p1, const point3d_t *p2)
370 {
371 float x0, x1, x2, x3, x4;
372
373 ARCH_X86_ASM
374 (
375 __ASM_EMIT("movups (%[sp]), %[x3]") /* xmm3 = pl */
376 __ASM_EMIT("movups (%[p0]), %[x0]") /* xmm0 = p0 */
377 __ASM_EMIT("movups (%[p1]), %[x1]") /* xmm1 = p1 */
378 __ASM_EMIT("movups (%[p2]), %[x2]") /* xmm2 = p2 */
379
380 __ASM_EMIT("subps %[x3], %[x0]") /* xmm0 = d0 */
381 __ASM_EMIT("subps %[x3], %[x1]") /* xmm1 = d1 */
382 __ASM_EMIT("mulps %[x0], %[x0]") /* xmm0 = d0 * d0 */
383 __ASM_EMIT("subps %[x3], %[x2]") /* xmm2 = d2 */
384 __ASM_EMIT("mulps %[x1], %[x1]") /* xmm1 = d1 * d1 */
385 __ASM_EMIT("mulps %[x2], %[x2]") /* xmm2 = d2 * d2 */
386 __ASM_EMIT("haddps %[x1], %[x0]")
387 __ASM_EMIT("haddps %[x3], %[x2]")
388 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = k0 k1 k2 ? */
389 __ASM_EMIT("sqrtps %[x0], %[x0]") /* xmm0 = sqrtf(k0) sqrtf(k1) sqrtf(k2) ? */
390 __ASM_EMIT("movhlps %[x0], %[x1]") /* xmm1 = sqrtf(k2) */
391 __ASM_EMIT("unpcklps %[x0], %[x0]") /* xmm0 = sqrtf(k0) sqrtf(k0) sqrtf(k1) sqrtf(k1) */
392 __ASM_EMIT("movhlps %[x0], %[x2]") /* xmm1 = sqrtf(k2) */
393 __ASM_EMIT("minss %[x1], %[x0]")
394 __ASM_EMIT("minss %[x2], %[x0]")
395
396 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
397 [x4] "=&x" (x4)
398 : [sp] "r" (sp), [p0] "r" (p0), [p1] "r" (p1), [p2] "r" (p2)
399 :
400 );
401
402 return x0;
403 }
404
405 float calc_min_distance_pv(const point3d_t *sp, const point3d_t *pv)
406 {
407 float x0, x1, x2, x3, x4;
408
409 ARCH_X86_ASM
410 (
411 __ASM_EMIT("movups (%[sp]), %[x3]") /* xmm3 = pl */
412 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
413 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
414 __ASM_EMIT("movups 0x20(%[pv]), %[x2]") /* xmm2 = p2 */
415
416 __ASM_EMIT("subps %[x3], %[x0]") /* xmm0 = d0 */
417 __ASM_EMIT("subps %[x3], %[x1]") /* xmm1 = d1 */
418 __ASM_EMIT("mulps %[x0], %[x0]") /* xmm0 = d0 * d0 */
419 __ASM_EMIT("subps %[x3], %[x2]") /* xmm2 = d2 */
420 __ASM_EMIT("mulps %[x1], %[x1]") /* xmm1 = d1 * d1 */
421 __ASM_EMIT("mulps %[x2], %[x2]") /* xmm2 = d2 * d2 */
422 __ASM_EMIT("haddps %[x1], %[x0]")
423 __ASM_EMIT("haddps %[x3], %[x2]")
424 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = k0 k1 k2 ? */
425 __ASM_EMIT("sqrtps %[x0], %[x0]") /* xmm0 = sqrtf(k0) sqrtf(k1) sqrtf(k2) ? */
426 __ASM_EMIT("movhlps %[x0], %[x1]") /* xmm1 = sqrtf(k2) */
427 __ASM_EMIT("unpcklps %[x0], %[x0]") /* xmm0 = sqrtf(k0) sqrtf(k0) sqrtf(k1) sqrtf(k1) */
428 __ASM_EMIT("movhlps %[x0], %[x2]") /* xmm1 = sqrtf(k2) */
429 __ASM_EMIT("minss %[x1], %[x0]")
430 __ASM_EMIT("minss %[x2], %[x0]")
431
432 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
433 [x4] "=&x" (x4)
434 : [sp] "r" (sp), [pv] "r" (pv)
435 :
436 );
437
438 return x0;
439 }
440
441 void split_triangle_raw(
442 raw_triangle_t *out,
443 size_t *n_out,
444 raw_triangle_t *in,
445 size_t *n_in,
446 const vector3d_t *pl,
447 const raw_triangle_t *pv
448 )
449 {
450 float x0, x1, x2, x3, x4, x5, x6, x7;
451 float k[4] __lsp_aligned16;
452 size_t t0;
453
454 in += *n_in;
455 out += *n_out;
456
457 // Estimate co-location of triangle and point
458 ARCH_X86_ASM
459 (
460 __ASM_EMIT("movups (%[pl]), %[x3]") /* xmm3 = pl */
461 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
462 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
463 __ASM_EMIT("movups 0x20(%[pv]), %[x2]") /* xmm2 = p2 */
464
465 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl = sx0 sy0 sz0 sw0 */
466 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl = sx1 sy1 sz1 sw1 */
467 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl = sx2 sy2 sz2 sw2 */
468 __ASM_EMIT("haddps %[x1], %[x0]") /* xmm0 = sx0+sy0 sz0+sw0 sx1+sy1 sz1+sw1 */
469 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = sx2+sy2 sz2+sw2 sx2+sy2 sz2+sw2 */
470 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = sx0+sy0+sz0+sw0 sx1+sy1+sz1+sw1 sx2+sy2+sz2+sw2 sx2+sy2+sz2+sw2 = k0 k1 k2 k2 */
471 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 k2 */
472 __ASM_EMIT("movaps %[x0], (%[k])") /* *k = xmm0 */
473 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL k2 <= +TOL */
474 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL k2 < -TOL */
475 __ASM_EMIT("pand %[ICULL3], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] 0 */
476 __ASM_EMIT("pand %[ICULL3], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] 0 */
477 __ASM_EMIT("paddd %[x1], %[x0]") /* xmm0 = x0 x1 x2 0 */
478 __ASM_EMIT("movdqa %[x0], %[x2]") /* xmm2 = x0 x1 x2 0 */
479 __ASM_EMIT("movdqa %[x0], %[x1]") /* xmm1 = x0 x1 x2 0 */
480 __ASM_EMIT("psrldq $8, %[x2]") /* xmm2 = x2 0 0 0 */
481 __ASM_EMIT("psrldq $4, %[x1]") /* xmm1 = x1 x2 0 0 */
482 __ASM_EMIT("por %[x2], %[x0]")
483 __ASM_EMIT("por %[x1], %[x0]")
484 __ASM_EMIT32("movd %[x0], %[t0]")
485 __ASM_EMIT64("movd %[x0], %k[t0]")
486
487 : [t0] "=&r" (t0),
488 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
489 [x4] "=&x" (x4)
490 : [pl] "r" (pl), [pv] "r" (pv),
491 [k] "r" (k),
492 [PTOL] "m" (X_3D_TOLERANCE),
493 [MTOL] "m" (X_3D_MTOLERANCE),
494 [ICULL3] "m" (ICULL3)
495 : "cc", "memory"
496 );
497
498 #define STR_COPY_TO(tgt) \
499 ARCH_X86_ASM( \
500 __ASM_EMIT("movups 0x00(%[src]), %[x0]") \
501 __ASM_EMIT("movups 0x10(%[src]), %[x1]") \
502 __ASM_EMIT("movups 0x20(%[src]), %[x2]") \
503 __ASM_EMIT("movups %[x0], 0x00(%[dst])") \
504 __ASM_EMIT("movups %[x1], 0x10(%[dst])") \
505 __ASM_EMIT("movups %[x2], 0x20(%[dst])") \
506 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2) \
507 : [dst] "r" (tgt), \
508 [src] "r" (pv) \
509 : "cc", "memory" \
510 );
511
512 #define STR_SPLIT_1P(off0, off1, koff, store) \
513 ARCH_X86_ASM( \
514 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
515 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x1]") /* xmm1 = p1 = lx1 ly1 lz1 1 */ \
516 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm2 = pl = nx ny nz nw */ \
517 \
518 __ASM_EMIT("subps %[x0], %[x1]") /* xmm1 = d = p1 - p0 = dx dy dz 0 */ \
519 __ASM_EMIT("movss 0x" koff "(%[k]), %[x3]") /* xmm3 = k 0 0 0 */ \
520 __ASM_EMIT("mulps %[x1], %[x2]") /* xmm2 = dx*nx dy*ny dz*nz 0 */ \
521 __ASM_EMIT("shufps $0x00, %[x3], %[x3]") /* xmm3 = k k k k */ \
522 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny dz*nz dx*nx+dy*ny dz*nz */ \
523 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = k*dx k*dy k*dz 0 */ \
524 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny+dz*nz = b b b b */ \
525 __ASM_EMIT("divps %[x2], %[x1]") /* xmm1 = k*dx/b k*dy/b k*dz/b 0 */ \
526 __ASM_EMIT("subps %[x1], %[x0]") /* xmm0 = lx0-k*dx/b ly0-k*dy/b lz0-k*dz/b 1 */ \
527 \
528 store \
529 \
530 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4) \
531 : [st] "r" (pv), [pl] "r" (pl), [out] "r" (out), [in] "r" (in), \
532 [k] "r" (k) \
533 : "cc", "memory" \
534 );
535
536 #define STR_SPLIT_2P(off0, off1, off2, koff, store) \
537 ARCH_X86_ASM( \
538 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
539 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x2]") /* xmm2 = p1 = lx1 ly1 lz1 1 */ \
540 __ASM_EMIT("movups 0x" off2 "(%[st]), %[x3]") /* xmm3 = p2 = lx2 ly2 lz2 1 */ \
541 __ASM_EMIT("movups (%[pl]), %[x4]") /* xmm4 = pl = nx ny nz nw */ \
542 \
543 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = pl = nx ny nz nw */ \
544 __ASM_EMIT("movaps %[x4], %[x5]") /* xmm5 = pl = nx ny nz nw */ \
545 __ASM_EMIT("subps %[x0], %[x2]") /* xmm2 = d1 = p1 - p0 = dx1 dy1 dz1 0 */ \
546 __ASM_EMIT("subps %[x1], %[x3]") /* xmm3 = d2 = p2 - p0 = dx2 dy2 dz2 0 */ \
547 __ASM_EMIT("mulps %[x2], %[x4]") /* xmm4 = dx1*nx dy1*ny dz1*nz 0 */ \
548 __ASM_EMIT("mulps %[x3], %[x5]") /* xmm5 = dx2*nx dy2*ny dz2*nz 0 */ \
549 __ASM_EMIT("movss 0x" koff "(%[k]), %[x6]") /* xmm6 = k */ \
550 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny dz1*nz dx1*nx+dy1*ny dz1*nz */ \
551 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny dz2*nz dx2*nx+dy2*ny dz2*nz */ \
552 __ASM_EMIT("shufps $0x00, %[x6], %[x6]") /* xmm6 = k k k k */ \
553 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny+dz1*nz = b1 b1 b1 b1 */ \
554 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny+dz2*nz = b2 b2 b2 b2 */ \
555 __ASM_EMIT("divps %[x4], %[x2]") /* xmm2 = dx1/b1 dy1/b1 dz1/b1 0 */ \
556 __ASM_EMIT("divps %[x5], %[x3]") /* xmm3 = dx2/b2 dy2/b2 dz2/b2 0 */ \
557 __ASM_EMIT("mulps %[x6], %[x2]") /* xmm2 = k*dx1/b1 k*dy1/b1 k*dz1/b1 0 */ \
558 __ASM_EMIT("mulps %[x6], %[x3]") /* xmm3 = k*dx2/b2 k*dy2/b2 k*dz2/b2 0 */ \
559 __ASM_EMIT("subps %[x2], %[x0]") /* xmm0 = lx0-k*dx1/b1 ly0-k*dy1/b1 lz0-k*dz1/b1 1 */ \
560 __ASM_EMIT("subps %[x3], %[x1]") /* xmm1 = lx1-k*dx2/b2 ly1-k*dy2/b2 lz1-k*dz2/b2 1 */ \
561 \
562 store \
563 \
564 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), \
565 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7) \
566 : [st] "r" (pv), [pl] "r" (pl), [out] "r" (out), [in] "r" (in), \
567 [k] "r" (k) \
568 : "cc", "memory" \
569 );
570
571 switch (t0)
572 {
573 // 0 intersections, triangle is above
574 case 0x00: // 0 0 0
575 case 0x01: // 0 0 1
576 case 0x04: // 0 1 0
577 case 0x05: // 0 1 1
578 case 0x10: // 1 0 0
579 case 0x11: // 1 0 1
580 case 0x14: // 1 1 0
581 case 0x15: // 1 1 1
582 STR_COPY_TO(out);
583 ++(*n_out);
584 break;
585
586 // 0 intersections, triangle is below
587 case 0x16: // 1 1 2
588 case 0x19: // 1 2 1
589 case 0x1a: // 1 2 2
590 case 0x25: // 2 1 1
591 case 0x26: // 2 1 2
592 case 0x29: // 2 2 1
593 case 0x2a: // 2 2 2
594 STR_COPY_TO(in);
595 ++(*n_in);
596 break;
597
598 // 1 intersection, 1 triangle above, 1 triangle below, counter-clockwise
599 case 0x06: // 0 1 2
600 STR_SPLIT_1P("00", "20", "00",
601 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
602 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
603 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
604 __ASM_EMIT("movups %[x1], 0x00(%[in])")
605 __ASM_EMIT("movups %[x2], 0x10(%[in])")
606 __ASM_EMIT("movups %[x0], 0x20(%[in])")
607 __ASM_EMIT("movups %[x2], 0x00(%[out])")
608 __ASM_EMIT("movups %[x3], 0x10(%[out])")
609 __ASM_EMIT("movups %[x0], 0x20(%[out])")
610 );
611 ++(*n_out); ++(*n_in);
612 break;
613 case 0x21: // 2 0 1
614 STR_SPLIT_1P("00", "10", "00",
615 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
616 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
617 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
618 __ASM_EMIT("movups %[x3], 0x00(%[in])")
619 __ASM_EMIT("movups %[x1], 0x10(%[in])")
620 __ASM_EMIT("movups %[x0], 0x20(%[in])")
621 __ASM_EMIT("movups %[x2], 0x00(%[out])")
622 __ASM_EMIT("movups %[x0], 0x10(%[out])")
623 __ASM_EMIT("movups %[x1], 0x20(%[out])")
624 );
625 ++(*n_out); ++(*n_in);
626 break;
627 case 0x18: // 1 2 0
628 STR_SPLIT_1P("10", "20", "04",
629 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
630 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
631 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
632 __ASM_EMIT("movups %[x2], 0x00(%[in])")
633 __ASM_EMIT("movups %[x3], 0x10(%[in])")
634 __ASM_EMIT("movups %[x0], 0x20(%[in])")
635 __ASM_EMIT("movups %[x1], 0x00(%[out])")
636 __ASM_EMIT("movups %[x0], 0x10(%[out])")
637 __ASM_EMIT("movups %[x3], 0x20(%[out])")
638 );
639 ++(*n_out); ++(*n_in);
640 break;
641
642 // 1 intersection, 1 triangle above, 1 triangle below, clockwise
643 case 0x24: // 2 1 0
644 STR_SPLIT_1P("00", "20", "00",
645 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
646 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
647 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
648 __ASM_EMIT("movups %[x3], 0x00(%[in])")
649 __ASM_EMIT("movups %[x0], 0x10(%[in])")
650 __ASM_EMIT("movups %[x1], 0x20(%[in])")
651 __ASM_EMIT("movups %[x1], 0x00(%[out])")
652 __ASM_EMIT("movups %[x2], 0x10(%[out])")
653 __ASM_EMIT("movups %[x0], 0x20(%[out])")
654 );
655 ++(*n_out); ++(*n_in);
656 break;
657 case 0x12: // 1 0 2
658 STR_SPLIT_1P("00", "10", "00",
659 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
660 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
661 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
662 __ASM_EMIT("movups %[x1], 0x00(%[in])")
663 __ASM_EMIT("movups %[x0], 0x10(%[in])")
664 __ASM_EMIT("movups %[x3], 0x20(%[in])")
665 __ASM_EMIT("movups %[x2], 0x00(%[out])")
666 __ASM_EMIT("movups %[x3], 0x10(%[out])")
667 __ASM_EMIT("movups %[x0], 0x20(%[out])")
668 );
669 ++(*n_out); ++(*n_in);
670 break;
671 case 0x09: // 0 2 1
672 STR_SPLIT_1P("10", "20", "04",
673 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
674 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
675 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
676 __ASM_EMIT("movups %[x2], 0x00(%[in])")
677 __ASM_EMIT("movups %[x0], 0x10(%[in])")
678 __ASM_EMIT("movups %[x1], 0x20(%[in])")
679 __ASM_EMIT("movups %[x3], 0x00(%[out])")
680 __ASM_EMIT("movups %[x1], 0x10(%[out])")
681 __ASM_EMIT("movups %[x0], 0x20(%[out])")
682 );
683 ++(*n_out); ++(*n_in);
684 break;
685
686 // 2 intersections, 1 triangle below, 2 triangles above
687 case 0x02: // 0 0 2
688 STR_SPLIT_2P("00", "10", "20", "00",
689 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
690 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
691 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
692 __ASM_EMIT("movups %[x2], 0x00(%[in])")
693 __ASM_EMIT("movups %[x0], 0x10(%[in])")
694 __ASM_EMIT("movups %[x1], 0x20(%[in])")
695 __ASM_EMIT("movups %[x3], 0x00(%[out])")
696 __ASM_EMIT("movups %[x1], 0x10(%[out])")
697 __ASM_EMIT("movups %[x0], 0x20(%[out])")
698 __ASM_EMIT("movups %[x4], 0x30(%[out])")
699 __ASM_EMIT("movups %[x1], 0x40(%[out])")
700 __ASM_EMIT("movups %[x3], 0x50(%[out])")
701 );
702 (*n_out) += 2; ++(*n_in);
703 break;
704 case 0x08: // 0 2 0
705 STR_SPLIT_2P("10", "00", "20", "04",
706 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
707 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
708 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
709 __ASM_EMIT("movups %[x3], 0x00(%[in])")
710 __ASM_EMIT("movups %[x1], 0x10(%[in])")
711 __ASM_EMIT("movups %[x0], 0x20(%[in])")
712 __ASM_EMIT("movups %[x4], 0x00(%[out])")
713 __ASM_EMIT("movups %[x0], 0x10(%[out])")
714 __ASM_EMIT("movups %[x1], 0x20(%[out])")
715 __ASM_EMIT("movups %[x2], 0x30(%[out])")
716 __ASM_EMIT("movups %[x0], 0x40(%[out])")
717 __ASM_EMIT("movups %[x4], 0x50(%[out])")
718 );
719 (*n_out) += 2; ++(*n_in);
720 break;
721 case 0x20: // 2 0 0
722 STR_SPLIT_2P("20", "00", "10", "08",
723 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
724 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
725 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
726 __ASM_EMIT("movups %[x4], 0x00(%[in])")
727 __ASM_EMIT("movups %[x0], 0x10(%[in])")
728 __ASM_EMIT("movups %[x1], 0x20(%[in])")
729 __ASM_EMIT("movups %[x2], 0x00(%[out])")
730 __ASM_EMIT("movups %[x1], 0x10(%[out])")
731 __ASM_EMIT("movups %[x0], 0x20(%[out])")
732 __ASM_EMIT("movups %[x3], 0x30(%[out])")
733 __ASM_EMIT("movups %[x1], 0x40(%[out])")
734 __ASM_EMIT("movups %[x2], 0x50(%[out])")
735 );
736 (*n_out) += 2; ++(*n_in);
737 break;
738
739 // 2 intersections, 1 triangle above, 2 triangles below
740 case 0x28: // 2 2 0
741 STR_SPLIT_2P("00", "10", "20", "00",
742 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
743 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
744 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
745 __ASM_EMIT("movups %[x3], 0x00(%[in])")
746 __ASM_EMIT("movups %[x1], 0x10(%[in])")
747 __ASM_EMIT("movups %[x0], 0x20(%[in])")
748 __ASM_EMIT("movups %[x4], 0x30(%[in])")
749 __ASM_EMIT("movups %[x1], 0x40(%[in])")
750 __ASM_EMIT("movups %[x3], 0x50(%[in])")
751 __ASM_EMIT("movups %[x2], 0x00(%[out])")
752 __ASM_EMIT("movups %[x0], 0x10(%[out])")
753 __ASM_EMIT("movups %[x1], 0x20(%[out])")
754 );
755 ++(*n_out); (*n_in) += 2;
756 break;
757
758 case 0x22: // 2 0 2
759 STR_SPLIT_2P("10", "00", "20", "04",
760 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
761 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
762 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
763 __ASM_EMIT("movups %[x4], 0x00(%[in])")
764 __ASM_EMIT("movups %[x0], 0x10(%[in])")
765 __ASM_EMIT("movups %[x1], 0x20(%[in])")
766 __ASM_EMIT("movups %[x2], 0x30(%[in])")
767 __ASM_EMIT("movups %[x0], 0x40(%[in])")
768 __ASM_EMIT("movups %[x4], 0x50(%[in])")
769 __ASM_EMIT("movups %[x3], 0x00(%[out])")
770 __ASM_EMIT("movups %[x1], 0x10(%[out])")
771 __ASM_EMIT("movups %[x0], 0x20(%[out])")
772 );
773 ++(*n_out); (*n_in) += 2;
774 break;
775
776 case 0x0a: // 0 2 2
777 STR_SPLIT_2P("20", "00", "10", "08",
778 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
779 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
780 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
781 __ASM_EMIT("movups %[x2], 0x00(%[in])")
782 __ASM_EMIT("movups %[x1], 0x10(%[in])")
783 __ASM_EMIT("movups %[x0], 0x20(%[in])")
784 __ASM_EMIT("movups %[x3], 0x30(%[in])")
785 __ASM_EMIT("movups %[x1], 0x40(%[in])")
786 __ASM_EMIT("movups %[x2], 0x50(%[in])")
787 __ASM_EMIT("movups %[x4], 0x00(%[out])")
788 __ASM_EMIT("movups %[x0], 0x10(%[out])")
789 __ASM_EMIT("movups %[x1], 0x20(%[out])")
790 );
791 ++(*n_out); (*n_in) += 2;
792 break;
793
794 default:
795 break;
796 }
797
798 #undef STR_COPY_TO
799 #undef STR_SPLIT_1P
800 #undef STR_SPLIT_2P
801 }
802
803 void split_triangle_raw_ssse3(
804 raw_triangle_t *out,
805 size_t *n_out,
806 raw_triangle_t *in,
807 size_t *n_in,
808 const vector3d_t *pl,
809 const raw_triangle_t *pv
810 )
811 {
812 float x0, x1, x2, x3, x4, x5, x6, x7;
813 float k[4] __lsp_aligned16;
814 size_t t0;
815
816 in += *n_in;
817 out += *n_out;
818
819 // Estimate co-location of triangle and point
820 ARCH_X86_ASM
821 (
822 __ASM_EMIT("movups (%[pl]), %[x3]") /* xmm3 = pl */
823 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
824 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
825 __ASM_EMIT("movups 0x20(%[pv]), %[x2]") /* xmm2 = p2 */
826
827 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl = sx0 sy0 sz0 sw0 */
828 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl = sx1 sy1 sz1 sw1 */
829 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl = sx2 sy2 sz2 sw2 */
830 __ASM_EMIT("haddps %[x1], %[x0]") /* xmm0 = sx0+sy0 sz0+sw0 sx1+sy1 sz1+sw1 */
831 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = sx2+sy2 sz2+sw2 sx2+sy2 sz2+sw2 */
832 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = sx0+sy0+sz0+sw0 sx1+sy1+sz1+sw1 sx2+sy2+sz2+sw2 sx2+sy2+sz2+sw2 = k0 k1 k2 k2 */
833 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 k2 */
834 __ASM_EMIT("movaps %[x0], (%[k])") /* *k = xmm0 */
835 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL k2 <= +TOL */
836 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL k2 < -TOL */
837 __ASM_EMIT("pand %[ICULL3], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] 0 */
838 __ASM_EMIT("pand %[ICULL3], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] 0 */
839 __ASM_EMIT("paddd %[x1], %[x0]") /* xmm0 = x0 x1 x2 0 */
840 __ASM_EMIT("phaddd %[x0], %[x0]") /* xmm0 = x0+x1 x2+0 x0+x1 x2+0 */
841 __ASM_EMIT("phaddd %[x0], %[x0]") /* xmm0 = x0+x1+x2+0 x0+x1+x2+0 x0+x1+x2+0 */
842 __ASM_EMIT32("movd %[x0], %[t0]")
843 __ASM_EMIT64("movd %[x0], %k[t0]")
844
845 : [t0] "=&r" (t0),
846 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
847 [x4] "=&x" (x4)
848 : [pl] "r" (pl), [pv] "r" (pv),
849 [k] "r" (k),
850 [PTOL] "m" (X_3D_TOLERANCE),
851 [MTOL] "m" (X_3D_MTOLERANCE),
852 [ICULL3] "m" (ICULL3)
853 : "cc", "memory"
854 );
855
856 #define STR_COPY_TO(tgt) \
857 ARCH_X86_ASM( \
858 __ASM_EMIT("movups 0x00(%[src]), %[x0]") \
859 __ASM_EMIT("movups 0x10(%[src]), %[x1]") \
860 __ASM_EMIT("movups 0x20(%[src]), %[x2]") \
861 __ASM_EMIT("movups %[x0], 0x00(%[dst])") \
862 __ASM_EMIT("movups %[x1], 0x10(%[dst])") \
863 __ASM_EMIT("movups %[x2], 0x20(%[dst])") \
864 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2) \
865 : [dst] "r" (tgt), \
866 [src] "r" (pv) \
867 : "cc", "memory" \
868 );
869
870 #define STR_SPLIT_1P(off0, off1, koff, store) \
871 ARCH_X86_ASM( \
872 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
873 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x1]") /* xmm1 = p1 = lx1 ly1 lz1 1 */ \
874 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm2 = pl = nx ny nz nw */ \
875 \
876 __ASM_EMIT("subps %[x0], %[x1]") /* xmm1 = d = p1 - p0 = dx dy dz 0 */ \
877 __ASM_EMIT("movss 0x" koff "(%[k]), %[x3]") /* xmm3 = k 0 0 0 */ \
878 __ASM_EMIT("mulps %[x1], %[x2]") /* xmm2 = dx*nx dy*ny dz*nz 0 */ \
879 __ASM_EMIT("shufps $0x00, %[x3], %[x3]") /* xmm3 = k k k k */ \
880 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny dz*nz dx*nx+dy*ny dz*nz */ \
881 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = k*dx k*dy k*dz 0 */ \
882 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny+dz*nz = b b b b */ \
883 __ASM_EMIT("divps %[x2], %[x1]") /* xmm1 = k*dx/b k*dy/b k*dz/b 0 */ \
884 __ASM_EMIT("subps %[x1], %[x0]") /* xmm0 = lx0-k*dx/b ly0-k*dy/b lz0-k*dz/b 1 */ \
885 \
886 store \
887 \
888 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4) \
889 : [st] "r" (pv), [pl] "r" (pl), [out] "r" (out), [in] "r" (in), \
890 [k] "r" (k) \
891 : "cc", "memory" \
892 );
893
894 #define STR_SPLIT_2P(off0, off1, off2, koff, store) \
895 ARCH_X86_ASM( \
896 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
897 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x2]") /* xmm2 = p1 = lx1 ly1 lz1 1 */ \
898 __ASM_EMIT("movups 0x" off2 "(%[st]), %[x3]") /* xmm3 = p2 = lx2 ly2 lz2 1 */ \
899 __ASM_EMIT("movups (%[pl]), %[x4]") /* xmm4 = pl = nx ny nz nw */ \
900 \
901 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = pl = nx ny nz nw */ \
902 __ASM_EMIT("movaps %[x4], %[x5]") /* xmm5 = pl = nx ny nz nw */ \
903 __ASM_EMIT("subps %[x0], %[x2]") /* xmm2 = d1 = p1 - p0 = dx1 dy1 dz1 0 */ \
904 __ASM_EMIT("subps %[x1], %[x3]") /* xmm3 = d2 = p2 - p0 = dx2 dy2 dz2 0 */ \
905 __ASM_EMIT("mulps %[x2], %[x4]") /* xmm4 = dx1*nx dy1*ny dz1*nz 0 */ \
906 __ASM_EMIT("mulps %[x3], %[x5]") /* xmm5 = dx2*nx dy2*ny dz2*nz 0 */ \
907 __ASM_EMIT("movss 0x" koff "(%[k]), %[x6]") /* xmm6 = k */ \
908 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny dz1*nz dx1*nx+dy1*ny dz1*nz */ \
909 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny dz2*nz dx2*nx+dy2*ny dz2*nz */ \
910 __ASM_EMIT("shufps $0x00, %[x6], %[x6]") /* xmm6 = k k k k */ \
911 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny+dz1*nz = b1 b1 b1 b1 */ \
912 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny+dz2*nz = b2 b2 b2 b2 */ \
913 __ASM_EMIT("divps %[x4], %[x2]") /* xmm2 = dx1/b1 dy1/b1 dz1/b1 0 */ \
914 __ASM_EMIT("divps %[x5], %[x3]") /* xmm3 = dx2/b2 dy2/b2 dz2/b2 0 */ \
915 __ASM_EMIT("mulps %[x6], %[x2]") /* xmm2 = k*dx1/b1 k*dy1/b1 k*dz1/b1 0 */ \
916 __ASM_EMIT("mulps %[x6], %[x3]") /* xmm3 = k*dx2/b2 k*dy2/b2 k*dz2/b2 0 */ \
917 __ASM_EMIT("subps %[x2], %[x0]") /* xmm0 = lx0-k*dx1/b1 ly0-k*dy1/b1 lz0-k*dz1/b1 1 */ \
918 __ASM_EMIT("subps %[x3], %[x1]") /* xmm1 = lx1-k*dx2/b2 ly1-k*dy2/b2 lz1-k*dz2/b2 1 */ \
919 \
920 store \
921 \
922 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), \
923 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7) \
924 : [st] "r" (pv), [pl] "r" (pl), [out] "r" (out), [in] "r" (in), \
925 [k] "r" (k) \
926 : "cc", "memory" \
927 );
928
929 switch (t0)
930 {
931 // 0 intersections, triangle is above
932 case 0x00: // 0 0 0
933 case 0x01: // 0 0 1
934 case 0x04: // 0 1 0
935 case 0x05: // 0 1 1
936 case 0x10: // 1 0 0
937 case 0x11: // 1 0 1
938 case 0x14: // 1 1 0
939 case 0x15: // 1 1 1
940 STR_COPY_TO(out);
941 ++(*n_out);
942 break;
943
944 // 0 intersections, triangle is below
945 case 0x16: // 1 1 2
946 case 0x19: // 1 2 1
947 case 0x1a: // 1 2 2
948 case 0x25: // 2 1 1
949 case 0x26: // 2 1 2
950 case 0x29: // 2 2 1
951 case 0x2a: // 2 2 2
952 STR_COPY_TO(in);
953 ++(*n_in);
954 break;
955
956 // 1 intersection, 1 triangle above, 1 triangle below, counter-clockwise
957 case 0x06: // 0 1 2
958 STR_SPLIT_1P("00", "20", "00",
959 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
960 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
961 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
962 __ASM_EMIT("movups %[x1], 0x00(%[in])")
963 __ASM_EMIT("movups %[x2], 0x10(%[in])")
964 __ASM_EMIT("movups %[x0], 0x20(%[in])")
965 __ASM_EMIT("movups %[x2], 0x00(%[out])")
966 __ASM_EMIT("movups %[x3], 0x10(%[out])")
967 __ASM_EMIT("movups %[x0], 0x20(%[out])")
968 );
969 ++(*n_out); ++(*n_in);
970 break;
971 case 0x21: // 2 0 1
972 STR_SPLIT_1P("00", "10", "00",
973 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
974 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
975 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
976 __ASM_EMIT("movups %[x3], 0x00(%[in])")
977 __ASM_EMIT("movups %[x1], 0x10(%[in])")
978 __ASM_EMIT("movups %[x0], 0x20(%[in])")
979 __ASM_EMIT("movups %[x2], 0x00(%[out])")
980 __ASM_EMIT("movups %[x0], 0x10(%[out])")
981 __ASM_EMIT("movups %[x1], 0x20(%[out])")
982 );
983 ++(*n_out); ++(*n_in);
984 break;
985 case 0x18: // 1 2 0
986 STR_SPLIT_1P("10", "20", "04",
987 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
988 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
989 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
990 __ASM_EMIT("movups %[x2], 0x00(%[in])")
991 __ASM_EMIT("movups %[x3], 0x10(%[in])")
992 __ASM_EMIT("movups %[x0], 0x20(%[in])")
993 __ASM_EMIT("movups %[x1], 0x00(%[out])")
994 __ASM_EMIT("movups %[x0], 0x10(%[out])")
995 __ASM_EMIT("movups %[x3], 0x20(%[out])")
996 );
997 ++(*n_out); ++(*n_in);
998 break;
999
1000 // 1 intersection, 1 triangle above, 1 triangle below, clockwise
1001 case 0x24: // 2 1 0
1002 STR_SPLIT_1P("00", "20", "00",
1003 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1004 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1005 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1006 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1007 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1008 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1009 __ASM_EMIT("movups %[x1], 0x00(%[out])")
1010 __ASM_EMIT("movups %[x2], 0x10(%[out])")
1011 __ASM_EMIT("movups %[x0], 0x20(%[out])")
1012 );
1013 ++(*n_out); ++(*n_in);
1014 break;
1015 case 0x12: // 1 0 2
1016 STR_SPLIT_1P("00", "10", "00",
1017 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1018 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1019 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1020 __ASM_EMIT("movups %[x1], 0x00(%[in])")
1021 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1022 __ASM_EMIT("movups %[x3], 0x20(%[in])")
1023 __ASM_EMIT("movups %[x2], 0x00(%[out])")
1024 __ASM_EMIT("movups %[x3], 0x10(%[out])")
1025 __ASM_EMIT("movups %[x0], 0x20(%[out])")
1026 );
1027 ++(*n_out); ++(*n_in);
1028 break;
1029 case 0x09: // 0 2 1
1030 STR_SPLIT_1P("10", "20", "04",
1031 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1032 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1033 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1034 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1035 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1036 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1037 __ASM_EMIT("movups %[x3], 0x00(%[out])")
1038 __ASM_EMIT("movups %[x1], 0x10(%[out])")
1039 __ASM_EMIT("movups %[x0], 0x20(%[out])")
1040 );
1041 ++(*n_out); ++(*n_in);
1042 break;
1043
1044 // 2 intersections, 1 triangle below, 2 triangles above
1045 case 0x02: // 0 0 2
1046 STR_SPLIT_2P("00", "10", "20", "00",
1047 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1048 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1049 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1050 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1051 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1052 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1053 __ASM_EMIT("movups %[x3], 0x00(%[out])")
1054 __ASM_EMIT("movups %[x1], 0x10(%[out])")
1055 __ASM_EMIT("movups %[x0], 0x20(%[out])")
1056 __ASM_EMIT("movups %[x4], 0x30(%[out])")
1057 __ASM_EMIT("movups %[x1], 0x40(%[out])")
1058 __ASM_EMIT("movups %[x3], 0x50(%[out])")
1059 );
1060 (*n_out) += 2; ++(*n_in);
1061 break;
1062 case 0x08: // 0 2 0
1063 STR_SPLIT_2P("10", "00", "20", "04",
1064 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1065 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1066 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1067 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1068 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1069 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1070 __ASM_EMIT("movups %[x4], 0x00(%[out])")
1071 __ASM_EMIT("movups %[x0], 0x10(%[out])")
1072 __ASM_EMIT("movups %[x1], 0x20(%[out])")
1073 __ASM_EMIT("movups %[x2], 0x30(%[out])")
1074 __ASM_EMIT("movups %[x0], 0x40(%[out])")
1075 __ASM_EMIT("movups %[x4], 0x50(%[out])")
1076 );
1077 (*n_out) += 2; ++(*n_in);
1078 break;
1079 case 0x20: // 2 0 0
1080 STR_SPLIT_2P("20", "00", "10", "08",
1081 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1082 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1083 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1084 __ASM_EMIT("movups %[x4], 0x00(%[in])")
1085 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1086 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1087 __ASM_EMIT("movups %[x2], 0x00(%[out])")
1088 __ASM_EMIT("movups %[x1], 0x10(%[out])")
1089 __ASM_EMIT("movups %[x0], 0x20(%[out])")
1090 __ASM_EMIT("movups %[x3], 0x30(%[out])")
1091 __ASM_EMIT("movups %[x1], 0x40(%[out])")
1092 __ASM_EMIT("movups %[x2], 0x50(%[out])")
1093 );
1094 (*n_out) += 2; ++(*n_in);
1095 break;
1096
1097 // 2 intersections, 1 triangle above, 2 triangles below
1098 case 0x28: // 2 2 0
1099 STR_SPLIT_2P("00", "10", "20", "00",
1100 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1101 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1102 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1103 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1104 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1105 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1106 __ASM_EMIT("movups %[x4], 0x30(%[in])")
1107 __ASM_EMIT("movups %[x1], 0x40(%[in])")
1108 __ASM_EMIT("movups %[x3], 0x50(%[in])")
1109 __ASM_EMIT("movups %[x2], 0x00(%[out])")
1110 __ASM_EMIT("movups %[x0], 0x10(%[out])")
1111 __ASM_EMIT("movups %[x1], 0x20(%[out])")
1112 );
1113 ++(*n_out); (*n_in) += 2;
1114 break;
1115
1116 case 0x22: // 2 0 2
1117 STR_SPLIT_2P("10", "00", "20", "04",
1118 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1119 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1120 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1121 __ASM_EMIT("movups %[x4], 0x00(%[in])")
1122 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1123 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1124 __ASM_EMIT("movups %[x2], 0x30(%[in])")
1125 __ASM_EMIT("movups %[x0], 0x40(%[in])")
1126 __ASM_EMIT("movups %[x4], 0x50(%[in])")
1127 __ASM_EMIT("movups %[x3], 0x00(%[out])")
1128 __ASM_EMIT("movups %[x1], 0x10(%[out])")
1129 __ASM_EMIT("movups %[x0], 0x20(%[out])")
1130 );
1131 ++(*n_out); (*n_in) += 2;
1132 break;
1133
1134 case 0x0a: // 0 2 2
1135 STR_SPLIT_2P("20", "00", "10", "08",
1136 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1137 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1138 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1139 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1140 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1141 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1142 __ASM_EMIT("movups %[x3], 0x30(%[in])")
1143 __ASM_EMIT("movups %[x1], 0x40(%[in])")
1144 __ASM_EMIT("movups %[x2], 0x50(%[in])")
1145 __ASM_EMIT("movups %[x4], 0x00(%[out])")
1146 __ASM_EMIT("movups %[x0], 0x10(%[out])")
1147 __ASM_EMIT("movups %[x1], 0x20(%[out])")
1148 );
1149 ++(*n_out); (*n_in) += 2;
1150 break;
1151
1152 default:
1153 break;
1154 }
1155
1156 #undef STR_COPY_TO
1157 #undef STR_SPLIT_1P
1158 #undef STR_SPLIT_2P
1159 }
1160
1161 void cull_triangle_raw(
1162 raw_triangle_t *in,
1163 size_t *n_in,
1164 const vector3d_t *pl,
1165 const raw_triangle_t *pv
1166 )
1167 {
1168 float x0, x1, x2, x3, x4, x5, x6, x7;
1169 float k[4] __lsp_aligned16;
1170 size_t t0;
1171
1172 in += *n_in;
1173
1174 // Estimate co-location of triangle and point
1175 ARCH_X86_ASM
1176 (
1177 __ASM_EMIT("movups (%[pl]), %[x3]") /* xmm3 = pl */
1178 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
1179 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
1180 __ASM_EMIT("movups 0x20(%[pv]), %[x2]") /* xmm2 = p2 */
1181
1182 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl = sx0 sy0 sz0 sw0 */
1183 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl = sx1 sy1 sz1 sw1 */
1184 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl = sx2 sy2 sz2 sw2 */
1185 __ASM_EMIT("haddps %[x1], %[x0]") /* xmm0 = sx0+sy0 sz0+sw0 sx1+sy1 sz1+sw1 */
1186 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = sx2+sy2 sz2+sw2 sx2+sy2 sz2+sw2 */
1187 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = sx0+sy0+sz0+sw0 sx1+sy1+sz1+sw1 sx2+sy2+sz2+sw2 sx2+sy2+sz2+sw2 = k0 k1 k2 k2 */
1188 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 k2 */
1189 __ASM_EMIT("movaps %[x0], (%[k])") /* *k = xmm0 */
1190 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL k2 <= +TOL */
1191 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL k2 < -TOL */
1192 __ASM_EMIT("pand %[ICULL3], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] 0 */
1193 __ASM_EMIT("pand %[ICULL3], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] 0 */
1194 __ASM_EMIT("paddd %[x1], %[x0]") /* xmm0 = x0 x1 x2 0 */
1195 __ASM_EMIT("movdqa %[x0], %[x2]") /* xmm2 = x0 x1 x2 0 */
1196 __ASM_EMIT("movdqa %[x0], %[x1]") /* xmm1 = x0 x1 x2 0 */
1197 __ASM_EMIT("psrldq $8, %[x2]") /* xmm2 = x2 0 0 0 */
1198 __ASM_EMIT("psrldq $4, %[x1]") /* xmm1 = x1 x2 0 0 */
1199 __ASM_EMIT("por %[x2], %[x0]")
1200 __ASM_EMIT("por %[x1], %[x0]")
1201 __ASM_EMIT32("movd %[x0], %[t0]")
1202 __ASM_EMIT64("movd %[x0], %k[t0]")
1203
1204 : [t0] "=&r" (t0),
1205 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
1206 [x4] "=&x" (x4)
1207 : [pl] "r" (pl), [pv] "r" (pv),
1208 [k] "r" (k),
1209 [PTOL] "m" (X_3D_TOLERANCE),
1210 [MTOL] "m" (X_3D_MTOLERANCE),
1211 [ICULL3] "m" (ICULL3)
1212 : "cc", "memory"
1213 );
1214
1215 #define STR_COPY_TO(tgt) \
1216 ARCH_X86_ASM( \
1217 __ASM_EMIT("movups 0x00(%[src]), %[x0]") \
1218 __ASM_EMIT("movups 0x10(%[src]), %[x1]") \
1219 __ASM_EMIT("movups 0x20(%[src]), %[x2]") \
1220 __ASM_EMIT("movups %[x0], 0x00(%[dst])") \
1221 __ASM_EMIT("movups %[x1], 0x10(%[dst])") \
1222 __ASM_EMIT("movups %[x2], 0x20(%[dst])") \
1223 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2) \
1224 : [dst] "r" (tgt), \
1225 [src] "r" (pv) \
1226 : "cc", "memory" \
1227 );
1228
1229 #define STR_SPLIT_1P(off0, off1, koff, store) \
1230 ARCH_X86_ASM( \
1231 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
1232 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x1]") /* xmm1 = p1 = lx1 ly1 lz1 1 */ \
1233 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm2 = pl = nx ny nz nw */ \
1234 \
1235 __ASM_EMIT("subps %[x0], %[x1]") /* xmm1 = d = p1 - p0 = dx dy dz 0 */ \
1236 __ASM_EMIT("movss 0x" koff "(%[k]), %[x3]") /* xmm3 = k 0 0 0 */ \
1237 __ASM_EMIT("mulps %[x1], %[x2]") /* xmm2 = dx*nx dy*ny dz*nz 0 */ \
1238 __ASM_EMIT("shufps $0x00, %[x3], %[x3]") /* xmm3 = k k k k */ \
1239 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny dz*nz dx*nx+dy*ny dz*nz */ \
1240 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = k*dx k*dy k*dz 0 */ \
1241 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny+dz*nz = b b b b */ \
1242 __ASM_EMIT("divps %[x2], %[x1]") /* xmm1 = k*dx/b k*dy/b k*dz/b 0 */ \
1243 __ASM_EMIT("subps %[x1], %[x0]") /* xmm0 = lx0-k*dx/b ly0-k*dy/b lz0-k*dz/b 1 */ \
1244 \
1245 store \
1246 \
1247 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4) \
1248 : [st] "r" (pv), [pl] "r" (pl), [in] "r" (in), \
1249 [k] "r" (k) \
1250 : "cc", "memory" \
1251 );
1252
1253 #define STR_SPLIT_2P(off0, off1, off2, koff, store) \
1254 ARCH_X86_ASM( \
1255 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
1256 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x2]") /* xmm2 = p1 = lx1 ly1 lz1 1 */ \
1257 __ASM_EMIT("movups 0x" off2 "(%[st]), %[x3]") /* xmm3 = p2 = lx2 ly2 lz2 1 */ \
1258 __ASM_EMIT("movups (%[pl]), %[x4]") /* xmm4 = pl = nx ny nz nw */ \
1259 \
1260 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = pl = nx ny nz nw */ \
1261 __ASM_EMIT("movaps %[x4], %[x5]") /* xmm5 = pl = nx ny nz nw */ \
1262 __ASM_EMIT("subps %[x0], %[x2]") /* xmm2 = d1 = p1 - p0 = dx1 dy1 dz1 0 */ \
1263 __ASM_EMIT("subps %[x1], %[x3]") /* xmm3 = d2 = p2 - p0 = dx2 dy2 dz2 0 */ \
1264 __ASM_EMIT("mulps %[x2], %[x4]") /* xmm4 = dx1*nx dy1*ny dz1*nz 0 */ \
1265 __ASM_EMIT("mulps %[x3], %[x5]") /* xmm5 = dx2*nx dy2*ny dz2*nz 0 */ \
1266 __ASM_EMIT("movss 0x" koff "(%[k]), %[x6]") /* xmm6 = k */ \
1267 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny dz1*nz dx1*nx+dy1*ny dz1*nz */ \
1268 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny dz2*nz dx2*nx+dy2*ny dz2*nz */ \
1269 __ASM_EMIT("shufps $0x00, %[x6], %[x6]") /* xmm6 = k k k k */ \
1270 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny+dz1*nz = b1 b1 b1 b1 */ \
1271 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny+dz2*nz = b2 b2 b2 b2 */ \
1272 __ASM_EMIT("divps %[x4], %[x2]") /* xmm2 = dx1/b1 dy1/b1 dz1/b1 0 */ \
1273 __ASM_EMIT("divps %[x5], %[x3]") /* xmm3 = dx2/b2 dy2/b2 dz2/b2 0 */ \
1274 __ASM_EMIT("mulps %[x6], %[x2]") /* xmm2 = k*dx1/b1 k*dy1/b1 k*dz1/b1 0 */ \
1275 __ASM_EMIT("mulps %[x6], %[x3]") /* xmm3 = k*dx2/b2 k*dy2/b2 k*dz2/b2 0 */ \
1276 __ASM_EMIT("subps %[x2], %[x0]") /* xmm0 = lx0-k*dx1/b1 ly0-k*dy1/b1 lz0-k*dz1/b1 1 */ \
1277 __ASM_EMIT("subps %[x3], %[x1]") /* xmm1 = lx1-k*dx2/b2 ly1-k*dy2/b2 lz1-k*dz2/b2 1 */ \
1278 \
1279 store \
1280 \
1281 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), \
1282 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7) \
1283 : [st] "r" (pv), [pl] "r" (pl), [in] "r" (in), \
1284 [k] "r" (k) \
1285 : "cc", "memory" \
1286 );
1287
1288 switch (t0)
1289 {
1290 // 0 intersections, triangle is above
1291 case 0x00: // 0 0 0
1292 case 0x01: // 0 0 1
1293 case 0x04: // 0 1 0
1294 case 0x05: // 0 1 1
1295 case 0x10: // 1 0 0
1296 case 0x11: // 1 0 1
1297 case 0x14: // 1 1 0
1298 case 0x15: // 1 1 1
1299 break;
1300
1301 // 0 intersections, triangle is below
1302 case 0x16: // 1 1 2
1303 case 0x19: // 1 2 1
1304 case 0x1a: // 1 2 2
1305 case 0x25: // 2 1 1
1306 case 0x26: // 2 1 2
1307 case 0x29: // 2 2 1
1308 case 0x2a: // 2 2 2
1309 STR_COPY_TO(in);
1310 ++(*n_in);
1311 break;
1312
1313 // 1 intersection, 1 triangle above, 1 triangle below, counter-clockwise
1314 case 0x06: // 0 1 2
1315 STR_SPLIT_1P("00", "20", "00",
1316 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1317 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1318 __ASM_EMIT("movups %[x1], 0x00(%[in])")
1319 __ASM_EMIT("movups %[x2], 0x10(%[in])")
1320 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1321 );
1322 ++(*n_in);
1323 break;
1324 case 0x21: // 2 0 1
1325 STR_SPLIT_1P("00", "10", "00",
1326 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1327 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1328 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1329 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1330 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1331 );
1332 ++(*n_in);
1333 break;
1334 case 0x18: // 1 2 0
1335 STR_SPLIT_1P("10", "20", "04",
1336 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1337 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1338 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1339 __ASM_EMIT("movups %[x3], 0x10(%[in])")
1340 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1341 );
1342 ++(*n_in);
1343 break;
1344
1345 // 1 intersection, 1 triangle above, 1 triangle below, clockwise
1346 case 0x24: // 2 1 0
1347 STR_SPLIT_1P("00", "20", "00",
1348 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1349 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1350 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1351 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1352 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1353 );
1354 ++(*n_in);
1355 break;
1356 case 0x12: // 1 0 2
1357 STR_SPLIT_1P("00", "10", "00",
1358 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1359 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1360 __ASM_EMIT("movups %[x1], 0x00(%[in])")
1361 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1362 __ASM_EMIT("movups %[x3], 0x20(%[in])")
1363 );
1364 ++(*n_in);
1365 break;
1366 case 0x09: // 0 2 1
1367 STR_SPLIT_1P("10", "20", "04",
1368 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1369 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1370 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1371 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1372 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1373 );
1374 ++(*n_in);
1375 break;
1376
1377 // 2 intersections, 1 triangle below, 2 triangles above
1378 case 0x02: // 0 0 2
1379 STR_SPLIT_2P("00", "10", "20", "00",
1380 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1381 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1382 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1383 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1384 );
1385 ++(*n_in);
1386 break;
1387 case 0x08: // 0 2 0
1388 STR_SPLIT_2P("10", "00", "20", "04",
1389 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1390 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1391 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1392 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1393 );
1394 ++(*n_in);
1395 break;
1396 case 0x20: // 2 0 0
1397 STR_SPLIT_2P("20", "00", "10", "08",
1398 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1399 __ASM_EMIT("movups %[x4], 0x00(%[in])")
1400 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1401 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1402 );
1403 ++(*n_in);
1404 break;
1405
1406 // 2 intersections, 1 triangle above, 2 triangles below
1407 case 0x28: // 2 2 0
1408 STR_SPLIT_2P("00", "10", "20", "00",
1409 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1410 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1411 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1412 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1413 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1414 __ASM_EMIT("movups %[x4], 0x30(%[in])")
1415 __ASM_EMIT("movups %[x1], 0x40(%[in])")
1416 __ASM_EMIT("movups %[x3], 0x50(%[in])")
1417 );
1418 (*n_in) += 2;
1419 break;
1420
1421 case 0x22: // 2 0 2
1422 STR_SPLIT_2P("10", "00", "20", "04",
1423 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1424 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1425 __ASM_EMIT("movups %[x4], 0x00(%[in])")
1426 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1427 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1428 __ASM_EMIT("movups %[x2], 0x30(%[in])")
1429 __ASM_EMIT("movups %[x0], 0x40(%[in])")
1430 __ASM_EMIT("movups %[x4], 0x50(%[in])")
1431 );
1432 (*n_in) += 2;
1433 break;
1434
1435 case 0x0a: // 0 2 2
1436 STR_SPLIT_2P("20", "00", "10", "08",
1437 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1438 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1439 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1440 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1441 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1442 __ASM_EMIT("movups %[x3], 0x30(%[in])")
1443 __ASM_EMIT("movups %[x1], 0x40(%[in])")
1444 __ASM_EMIT("movups %[x2], 0x50(%[in])")
1445 );
1446 (*n_in) += 2;
1447 break;
1448
1449 default:
1450 break;
1451 }
1452
1453 #undef STR_COPY_TO
1454 #undef STR_SPLIT_1P
1455 #undef STR_SPLIT_2P
1456 }
1457
1458 void cull_triangle_raw_ssse3(
1459 raw_triangle_t *in,
1460 size_t *n_in,
1461 const vector3d_t *pl,
1462 const raw_triangle_t *pv
1463 )
1464 {
1465 float x0, x1, x2, x3, x4, x5, x6, x7;
1466 float k[4] __lsp_aligned16;
1467 size_t t0;
1468
1469 in += *n_in;
1470
1471 // Estimate co-location of triangle and point
1472 ARCH_X86_ASM
1473 (
1474 __ASM_EMIT("movups (%[pl]), %[x3]") /* xmm3 = pl */
1475 __ASM_EMIT("movups 0x00(%[pv]), %[x0]") /* xmm0 = p0 */
1476 __ASM_EMIT("movups 0x10(%[pv]), %[x1]") /* xmm1 = p1 */
1477 __ASM_EMIT("movups 0x20(%[pv]), %[x2]") /* xmm2 = p2 */
1478
1479 __ASM_EMIT("mulps %[x3], %[x0]") /* xmm0 = p0 * pl = sx0 sy0 sz0 sw0 */
1480 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = p1 * pl = sx1 sy1 sz1 sw1 */
1481 __ASM_EMIT("mulps %[x3], %[x2]") /* xmm2 = p2 * pl = sx2 sy2 sz2 sw2 */
1482 __ASM_EMIT("haddps %[x1], %[x0]") /* xmm0 = sx0+sy0 sz0+sw0 sx1+sy1 sz1+sw1 */
1483 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = sx2+sy2 sz2+sw2 sx2+sy2 sz2+sw2 */
1484 __ASM_EMIT("haddps %[x2], %[x0]") /* xmm0 = sx0+sy0+sz0+sw0 sx1+sy1+sz1+sw1 sx2+sy2+sz2+sw2 sx2+sy2+sz2+sw2 = k0 k1 k2 k2 */
1485 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = k0 k1 k2 k2 */
1486 __ASM_EMIT("movaps %[x0], (%[k])") /* *k = xmm0 */
1487 __ASM_EMIT("cmpps $2, %[PTOL], %[x0]") /* xmm0 = k0 <= +TOL k1 <= +TOL k2 <= +TOL k2 <= +TOL */
1488 __ASM_EMIT("cmpps $1, %[MTOL], %[x1]") /* xmm1 = k0 < -TOL k1 < -TOL k2 < -TOL k2 < -TOL */
1489 __ASM_EMIT("pand %[ICULL3], %[x0]") /* xmm0 = 1*[k0 <= +TOL] 1*[k1 <= +TOL] 1*[k2 <= +TOL] 0 */
1490 __ASM_EMIT("pand %[ICULL3], %[x1]") /* xmm1 = 1*[k0 < -TOL] 1*[k1 < -TOL] 1*[k2 < -TOL] 0 */
1491 __ASM_EMIT("paddd %[x1], %[x0]") /* xmm0 = x0 x1 x2 0 */
1492 __ASM_EMIT("phaddd %[x0], %[x0]") /* xmm0 = x0+x1 x2+0 x0+x1 x2+0 */
1493 __ASM_EMIT("phaddd %[x0], %[x0]") /* xmm0 = x0+x1+x2+0 x0+x1+x2+0 x0+x1+x2+0 */
1494 __ASM_EMIT32("movd %[x0], %[t0]")
1495 __ASM_EMIT64("movd %[x0], %k[t0]")
1496
1497 : [t0] "=&r" (t0),
1498 [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3),
1499 [x4] "=&x" (x4)
1500 : [pl] "r" (pl), [pv] "r" (pv),
1501 [k] "r" (k),
1502 [PTOL] "m" (X_3D_TOLERANCE),
1503 [MTOL] "m" (X_3D_MTOLERANCE),
1504 [ICULL3] "m" (ICULL3)
1505 : "cc", "memory"
1506 );
1507
1508 #define STR_COPY_TO(tgt) \
1509 ARCH_X86_ASM( \
1510 __ASM_EMIT("movups 0x00(%[src]), %[x0]") \
1511 __ASM_EMIT("movups 0x10(%[src]), %[x1]") \
1512 __ASM_EMIT("movups 0x20(%[src]), %[x2]") \
1513 __ASM_EMIT("movups %[x0], 0x00(%[dst])") \
1514 __ASM_EMIT("movups %[x1], 0x10(%[dst])") \
1515 __ASM_EMIT("movups %[x2], 0x20(%[dst])") \
1516 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2) \
1517 : [dst] "r" (tgt), \
1518 [src] "r" (pv) \
1519 : "cc", "memory" \
1520 );
1521
1522 #define STR_SPLIT_1P(off0, off1, koff, store) \
1523 ARCH_X86_ASM( \
1524 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
1525 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x1]") /* xmm1 = p1 = lx1 ly1 lz1 1 */ \
1526 __ASM_EMIT("movups (%[pl]), %[x2]") /* xmm2 = pl = nx ny nz nw */ \
1527 \
1528 __ASM_EMIT("subps %[x0], %[x1]") /* xmm1 = d = p1 - p0 = dx dy dz 0 */ \
1529 __ASM_EMIT("movss 0x" koff "(%[k]), %[x3]") /* xmm3 = k 0 0 0 */ \
1530 __ASM_EMIT("mulps %[x1], %[x2]") /* xmm2 = dx*nx dy*ny dz*nz 0 */ \
1531 __ASM_EMIT("shufps $0x00, %[x3], %[x3]") /* xmm3 = k k k k */ \
1532 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny dz*nz dx*nx+dy*ny dz*nz */ \
1533 __ASM_EMIT("mulps %[x3], %[x1]") /* xmm1 = k*dx k*dy k*dz 0 */ \
1534 __ASM_EMIT("haddps %[x2], %[x2]") /* xmm2 = dx*nx+dy*ny+dz*nz = b b b b */ \
1535 __ASM_EMIT("divps %[x2], %[x1]") /* xmm1 = k*dx/b k*dy/b k*dz/b 0 */ \
1536 __ASM_EMIT("subps %[x1], %[x0]") /* xmm0 = lx0-k*dx/b ly0-k*dy/b lz0-k*dz/b 1 */ \
1537 \
1538 store \
1539 \
1540 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), [x4] "=&x" (x4) \
1541 : [st] "r" (pv), [pl] "r" (pl), [in] "r" (in), \
1542 [k] "r" (k) \
1543 : "cc", "memory" \
1544 );
1545
1546 #define STR_SPLIT_2P(off0, off1, off2, koff, store) \
1547 ARCH_X86_ASM( \
1548 __ASM_EMIT("movups 0x" off0 "(%[st]), %[x0]") /* xmm0 = p0 = lx0 ly0 lz0 1 */ \
1549 __ASM_EMIT("movups 0x" off1 "(%[st]), %[x2]") /* xmm2 = p1 = lx1 ly1 lz1 1 */ \
1550 __ASM_EMIT("movups 0x" off2 "(%[st]), %[x3]") /* xmm3 = p2 = lx2 ly2 lz2 1 */ \
1551 __ASM_EMIT("movups (%[pl]), %[x4]") /* xmm4 = pl = nx ny nz nw */ \
1552 \
1553 __ASM_EMIT("movaps %[x0], %[x1]") /* xmm1 = pl = nx ny nz nw */ \
1554 __ASM_EMIT("movaps %[x4], %[x5]") /* xmm5 = pl = nx ny nz nw */ \
1555 __ASM_EMIT("subps %[x0], %[x2]") /* xmm2 = d1 = p1 - p0 = dx1 dy1 dz1 0 */ \
1556 __ASM_EMIT("subps %[x1], %[x3]") /* xmm3 = d2 = p2 - p0 = dx2 dy2 dz2 0 */ \
1557 __ASM_EMIT("mulps %[x2], %[x4]") /* xmm4 = dx1*nx dy1*ny dz1*nz 0 */ \
1558 __ASM_EMIT("mulps %[x3], %[x5]") /* xmm5 = dx2*nx dy2*ny dz2*nz 0 */ \
1559 __ASM_EMIT("movss 0x" koff "(%[k]), %[x6]") /* xmm6 = k */ \
1560 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny dz1*nz dx1*nx+dy1*ny dz1*nz */ \
1561 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny dz2*nz dx2*nx+dy2*ny dz2*nz */ \
1562 __ASM_EMIT("shufps $0x00, %[x6], %[x6]") /* xmm6 = k k k k */ \
1563 __ASM_EMIT("haddps %[x4], %[x4]") /* xmm4 = dx1*nx+dy1*ny+dz1*nz = b1 b1 b1 b1 */ \
1564 __ASM_EMIT("haddps %[x5], %[x5]") /* xmm5 = dx2*nx+dy2*ny+dz2*nz = b2 b2 b2 b2 */ \
1565 __ASM_EMIT("divps %[x4], %[x2]") /* xmm2 = dx1/b1 dy1/b1 dz1/b1 0 */ \
1566 __ASM_EMIT("divps %[x5], %[x3]") /* xmm3 = dx2/b2 dy2/b2 dz2/b2 0 */ \
1567 __ASM_EMIT("mulps %[x6], %[x2]") /* xmm2 = k*dx1/b1 k*dy1/b1 k*dz1/b1 0 */ \
1568 __ASM_EMIT("mulps %[x6], %[x3]") /* xmm3 = k*dx2/b2 k*dy2/b2 k*dz2/b2 0 */ \
1569 __ASM_EMIT("subps %[x2], %[x0]") /* xmm0 = lx0-k*dx1/b1 ly0-k*dy1/b1 lz0-k*dz1/b1 1 */ \
1570 __ASM_EMIT("subps %[x3], %[x1]") /* xmm1 = lx1-k*dx2/b2 ly1-k*dy2/b2 lz1-k*dz2/b2 1 */ \
1571 \
1572 store \
1573 \
1574 : [x0] "=&x" (x0), [x1] "=&x" (x1), [x2] "=&x" (x2), [x3] "=&x" (x3), \
1575 [x4] "=&x" (x4), [x5] "=&x" (x5), [x6] "=&x" (x6), [x7] "=&x" (x7) \
1576 : [st] "r" (pv), [pl] "r" (pl), [in] "r" (in), \
1577 [k] "r" (k) \
1578 : "cc", "memory" \
1579 );
1580
1581 switch (t0)
1582 {
1583 // 0 intersections, triangle is above
1584 case 0x00: // 0 0 0
1585 case 0x01: // 0 0 1
1586 case 0x04: // 0 1 0
1587 case 0x05: // 0 1 1
1588 case 0x10: // 1 0 0
1589 case 0x11: // 1 0 1
1590 case 0x14: // 1 1 0
1591 case 0x15: // 1 1 1
1592 break;
1593
1594 // 0 intersections, triangle is below
1595 case 0x16: // 1 1 2
1596 case 0x19: // 1 2 1
1597 case 0x1a: // 1 2 2
1598 case 0x25: // 2 1 1
1599 case 0x26: // 2 1 2
1600 case 0x29: // 2 2 1
1601 case 0x2a: // 2 2 2
1602 STR_COPY_TO(in);
1603 ++(*n_in);
1604 break;
1605
1606 // 1 intersection, 1 triangle above, 1 triangle below, counter-clockwise
1607 case 0x06: // 0 1 2
1608 STR_SPLIT_1P("00", "20", "00",
1609 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1610 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1611 __ASM_EMIT("movups %[x1], 0x00(%[in])")
1612 __ASM_EMIT("movups %[x2], 0x10(%[in])")
1613 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1614 );
1615 ++(*n_in);
1616 break;
1617 case 0x21: // 2 0 1
1618 STR_SPLIT_1P("00", "10", "00",
1619 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1620 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1621 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1622 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1623 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1624 );
1625 ++(*n_in);
1626 break;
1627 case 0x18: // 1 2 0
1628 STR_SPLIT_1P("10", "20", "04",
1629 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1630 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1631 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1632 __ASM_EMIT("movups %[x3], 0x10(%[in])")
1633 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1634 );
1635 ++(*n_in);
1636 break;
1637
1638 // 1 intersection, 1 triangle above, 1 triangle below, clockwise
1639 case 0x24: // 2 1 0
1640 STR_SPLIT_1P("00", "20", "00",
1641 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1642 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1643 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1644 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1645 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1646 );
1647 ++(*n_in);
1648 break;
1649 case 0x12: // 1 0 2
1650 STR_SPLIT_1P("00", "10", "00",
1651 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1652 __ASM_EMIT("movups 0x20(%[st]), %[x3]")
1653 __ASM_EMIT("movups %[x1], 0x00(%[in])")
1654 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1655 __ASM_EMIT("movups %[x3], 0x20(%[in])")
1656 );
1657 ++(*n_in);
1658 break;
1659 case 0x09: // 0 2 1
1660 STR_SPLIT_1P("10", "20", "04",
1661 __ASM_EMIT("movups 0x00(%[st]), %[x1]")
1662 __ASM_EMIT("movups 0x10(%[st]), %[x2]")
1663 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1664 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1665 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1666 );
1667 ++(*n_in);
1668 break;
1669
1670 // 2 intersections, 1 triangle below, 2 triangles above
1671 case 0x02: // 0 0 2
1672 STR_SPLIT_2P("00", "10", "20", "00",
1673 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1674 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1675 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1676 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1677 );
1678 ++(*n_in);
1679 break;
1680 case 0x08: // 0 2 0
1681 STR_SPLIT_2P("10", "00", "20", "04",
1682 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1683 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1684 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1685 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1686 );
1687 ++(*n_in);
1688 break;
1689 case 0x20: // 2 0 0
1690 STR_SPLIT_2P("20", "00", "10", "08",
1691 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1692 __ASM_EMIT("movups %[x4], 0x00(%[in])")
1693 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1694 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1695 );
1696 ++(*n_in);
1697 break;
1698
1699 // 2 intersections, 1 triangle above, 2 triangles below
1700 case 0x28: // 2 2 0
1701 STR_SPLIT_2P("00", "10", "20", "00",
1702 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1703 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1704 __ASM_EMIT("movups %[x3], 0x00(%[in])")
1705 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1706 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1707 __ASM_EMIT("movups %[x4], 0x30(%[in])")
1708 __ASM_EMIT("movups %[x1], 0x40(%[in])")
1709 __ASM_EMIT("movups %[x3], 0x50(%[in])")
1710 );
1711 (*n_in) += 2;
1712 break;
1713
1714 case 0x22: // 2 0 2
1715 STR_SPLIT_2P("10", "00", "20", "04",
1716 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1717 __ASM_EMIT("movups 0x20(%[st]), %[x4]")
1718 __ASM_EMIT("movups %[x4], 0x00(%[in])")
1719 __ASM_EMIT("movups %[x0], 0x10(%[in])")
1720 __ASM_EMIT("movups %[x1], 0x20(%[in])")
1721 __ASM_EMIT("movups %[x2], 0x30(%[in])")
1722 __ASM_EMIT("movups %[x0], 0x40(%[in])")
1723 __ASM_EMIT("movups %[x4], 0x50(%[in])")
1724 );
1725 (*n_in) += 2;
1726 break;
1727
1728 case 0x0a: // 0 2 2
1729 STR_SPLIT_2P("20", "00", "10", "08",
1730 __ASM_EMIT("movups 0x00(%[st]), %[x2]")
1731 __ASM_EMIT("movups 0x10(%[st]), %[x3]")
1732 __ASM_EMIT("movups %[x2], 0x00(%[in])")
1733 __ASM_EMIT("movups %[x1], 0x10(%[in])")
1734 __ASM_EMIT("movups %[x0], 0x20(%[in])")
1735 __ASM_EMIT("movups %[x3], 0x30(%[in])")
1736 __ASM_EMIT("movups %[x1], 0x40(%[in])")
1737 __ASM_EMIT("movups %[x2], 0x50(%[in])")
1738 );
1739 (*n_in) += 2;
1740 break;
1741
1742 default:
1743 break;
1744 }
1745
1746 #undef STR_COPY_TO
1747 #undef STR_SPLIT_1P
1748 #undef STR_SPLIT_2P
1749 }
1750 } /* namespace sse3 */
1751 } /* namespace lsp */
1752
1753 #endif /* PRIVATE_DSP_ARCH_X86_SSE3_3DMATH_H_ */