1// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#include "VertexRoutine.hpp"
16
17#include "VertexShader.hpp"
18#include "Constants.hpp"
19#include "Renderer/Vertex.hpp"
20#include "Renderer/Renderer.hpp"
21#include "Common/Half.hpp"
22#include "Common/Debug.hpp"
23
24namespace sw
25{
26 extern bool halfIntegerCoordinates; // Pixel centers are not at integer coordinates
27 extern bool symmetricNormalizedDepth; // [-1, 1] instead of [0, 1]
28
29 VertexRoutine::VertexRoutine(const VertexProcessor::State &state, const VertexShader *shader)
30 : v(shader && shader->indirectAddressableInput),
31 o(shader && shader->indirectAddressableOutput),
32 state(state)
33 {
34 }
35
36 VertexRoutine::~VertexRoutine()
37 {
38 }
39
40 void VertexRoutine::generate()
41 {
42 const bool textureSampling = state.textureSampling;
43
44 Pointer<Byte> cache = task + OFFSET(VertexTask,vertexCache);
45 Pointer<Byte> vertexCache = cache + OFFSET(VertexCache,vertex);
46 Pointer<Byte> tagCache = cache + OFFSET(VertexCache,tag);
47
48 UInt vertexCount = *Pointer<UInt>(task + OFFSET(VertexTask,vertexCount));
49 UInt primitiveNumber = *Pointer<UInt>(task + OFFSET(VertexTask, primitiveStart));
50 UInt indexInPrimitive = 0;
51
52 constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
53
54 Do
55 {
56 UInt index = *Pointer<UInt>(batch);
57 UInt tagIndex = index & 0x0000003C;
58 UInt indexQ = !textureSampling ? UInt(index & 0xFFFFFFFC) : index; // FIXME: TEXLDL hack to have independent LODs, hurts performance.
59
60 If(*Pointer<UInt>(tagCache + tagIndex) != indexQ)
61 {
62 *Pointer<UInt>(tagCache + tagIndex) = indexQ;
63
64 readInput(indexQ);
65 pipeline(indexQ);
66 postTransform();
67 computeClipFlags();
68
69 Pointer<Byte> cacheLine0 = vertexCache + tagIndex * UInt((int)sizeof(Vertex));
70 writeCache(cacheLine0);
71 }
72
73 UInt cacheIndex = index & 0x0000003F;
74 Pointer<Byte> cacheLine = vertexCache + cacheIndex * UInt((int)sizeof(Vertex));
75 writeVertex(vertex, cacheLine);
76
77 if(state.transformFeedbackEnabled != 0)
78 {
79 transformFeedback(vertex, primitiveNumber, indexInPrimitive);
80
81 indexInPrimitive++;
82 If(indexInPrimitive == 3)
83 {
84 primitiveNumber++;
85 indexInPrimitive = 0;
86 }
87 }
88
89 vertex += sizeof(Vertex);
90 batch += sizeof(unsigned int);
91 vertexCount--;
92 }
93 Until(vertexCount == 0)
94
95 Return();
96 }
97
98 void VertexRoutine::readInput(UInt &index)
99 {
100 for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
101 {
102 Pointer<Byte> input = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,input) + sizeof(void*) * i);
103 UInt stride = *Pointer<UInt>(data + OFFSET(DrawData,stride) + sizeof(unsigned int) * i);
104
105 v[i] = readStream(input, stride, state.input[i], index);
106 }
107 }
108
109 void VertexRoutine::computeClipFlags()
110 {
111 int pos = state.positionRegister;
112
113 Int4 maxX = CmpLT(o[pos].w, o[pos].x);
114 Int4 maxY = CmpLT(o[pos].w, o[pos].y);
115 Int4 maxZ = CmpLT(o[pos].w, o[pos].z);
116 Int4 minX = CmpNLE(-o[pos].w, o[pos].x);
117 Int4 minY = CmpNLE(-o[pos].w, o[pos].y);
118 Int4 minZ = symmetricNormalizedDepth ? CmpNLE(-o[pos].w, o[pos].z) : CmpNLE(Float4(0.0f), o[pos].z);
119
120 clipFlags = *Pointer<Int>(constants + OFFSET(Constants,maxX) + SignMask(maxX) * 4); // FIXME: Array indexing
121 clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,maxY) + SignMask(maxY) * 4);
122 clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,maxZ) + SignMask(maxZ) * 4);
123 clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minX) + SignMask(minX) * 4);
124 clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minY) + SignMask(minY) * 4);
125 clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minZ) + SignMask(minZ) * 4);
126
127 Int4 finiteX = CmpLE(Abs(o[pos].x), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
128 Int4 finiteY = CmpLE(Abs(o[pos].y), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
129 Int4 finiteZ = CmpLE(Abs(o[pos].z), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
130
131 Int4 finiteXYZ = finiteX & finiteY & finiteZ;
132 clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,fini) + SignMask(finiteXYZ) * 4);
133
134 if(state.preTransformed)
135 {
136 clipFlags &= 0xFBFBFBFB; // Don't clip against far clip plane
137 }
138 }
139
140 Vector4f VertexRoutine::readStream(Pointer<Byte> &buffer, UInt &stride, const Stream &stream, const UInt &index)
141 {
142 const bool textureSampling = state.textureSampling;
143
144 Vector4f v;
145
146 Pointer<Byte> source0 = buffer + index * stride;
147 Pointer<Byte> source1 = source0 + (!textureSampling ? stride : 0);
148 Pointer<Byte> source2 = source1 + (!textureSampling ? stride : 0);
149 Pointer<Byte> source3 = source2 + (!textureSampling ? stride : 0);
150
151 bool isNativeFloatAttrib = (stream.attribType == VertexShader::ATTRIBTYPE_FLOAT) || stream.normalized;
152
153 switch(stream.type)
154 {
155 case STREAMTYPE_FLOAT:
156 {
157 if(stream.count == 0)
158 {
159 // Null stream, all default components
160 }
161 else
162 {
163 if(stream.count == 1)
164 {
165 v.x.x = *Pointer<Float>(source0);
166 v.x.y = *Pointer<Float>(source1);
167 v.x.z = *Pointer<Float>(source2);
168 v.x.w = *Pointer<Float>(source3);
169 }
170 else
171 {
172 v.x = *Pointer<Float4>(source0);
173 v.y = *Pointer<Float4>(source1);
174 v.z = *Pointer<Float4>(source2);
175 v.w = *Pointer<Float4>(source3);
176
177 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
178 }
179
180 switch(stream.attribType)
181 {
182 case VertexShader::ATTRIBTYPE_INT:
183 if(stream.count >= 1) v.x = As<Float4>(Int4(v.x));
184 if(stream.count >= 2) v.x = As<Float4>(Int4(v.y));
185 if(stream.count >= 3) v.x = As<Float4>(Int4(v.z));
186 if(stream.count >= 4) v.x = As<Float4>(Int4(v.w));
187 break;
188 case VertexShader::ATTRIBTYPE_UINT:
189 if(stream.count >= 1) v.x = As<Float4>(UInt4(v.x));
190 if(stream.count >= 2) v.x = As<Float4>(UInt4(v.y));
191 if(stream.count >= 3) v.x = As<Float4>(UInt4(v.z));
192 if(stream.count >= 4) v.x = As<Float4>(UInt4(v.w));
193 break;
194 default:
195 break;
196 }
197 }
198 }
199 break;
200 case STREAMTYPE_BYTE:
201 if(isNativeFloatAttrib) // Stream: UByte, Shader attrib: Float
202 {
203 v.x = Float4(*Pointer<Byte4>(source0));
204 v.y = Float4(*Pointer<Byte4>(source1));
205 v.z = Float4(*Pointer<Byte4>(source2));
206 v.w = Float4(*Pointer<Byte4>(source3));
207
208 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
209
210 if(stream.normalized)
211 {
212 if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
213 if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
214 if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
215 if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
216 }
217 }
218 else // Stream: UByte, Shader attrib: Int / UInt
219 {
220 v.x = As<Float4>(Int4(*Pointer<Byte4>(source0)));
221 v.y = As<Float4>(Int4(*Pointer<Byte4>(source1)));
222 v.z = As<Float4>(Int4(*Pointer<Byte4>(source2)));
223 v.w = As<Float4>(Int4(*Pointer<Byte4>(source3)));
224
225 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
226 }
227 break;
228 case STREAMTYPE_SBYTE:
229 if(isNativeFloatAttrib) // Stream: SByte, Shader attrib: Float
230 {
231 v.x = Float4(*Pointer<SByte4>(source0));
232 v.y = Float4(*Pointer<SByte4>(source1));
233 v.z = Float4(*Pointer<SByte4>(source2));
234 v.w = Float4(*Pointer<SByte4>(source3));
235
236 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
237
238 if(stream.normalized)
239 {
240 if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
241 if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
242 if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
243 if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
244 }
245 }
246 else // Stream: SByte, Shader attrib: Int / UInt
247 {
248 v.x = As<Float4>(Int4(*Pointer<SByte4>(source0)));
249 v.y = As<Float4>(Int4(*Pointer<SByte4>(source1)));
250 v.z = As<Float4>(Int4(*Pointer<SByte4>(source2)));
251 v.w = As<Float4>(Int4(*Pointer<SByte4>(source3)));
252
253 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
254 }
255 break;
256 case STREAMTYPE_COLOR:
257 {
258 v.x = Float4(*Pointer<Byte4>(source0)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
259 v.y = Float4(*Pointer<Byte4>(source1)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
260 v.z = Float4(*Pointer<Byte4>(source2)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
261 v.w = Float4(*Pointer<Byte4>(source3)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
262
263 transpose4x4(v.x, v.y, v.z, v.w);
264
265 // Swap red and blue
266 Float4 t = v.x;
267 v.x = v.z;
268 v.z = t;
269 }
270 break;
271 case STREAMTYPE_SHORT:
272 if(isNativeFloatAttrib) // Stream: Int, Shader attrib: Float
273 {
274 v.x = Float4(*Pointer<Short4>(source0));
275 v.y = Float4(*Pointer<Short4>(source1));
276 v.z = Float4(*Pointer<Short4>(source2));
277 v.w = Float4(*Pointer<Short4>(source3));
278
279 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
280
281 if(stream.normalized)
282 {
283 if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
284 if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
285 if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
286 if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
287 }
288 }
289 else // Stream: Short, Shader attrib: Int/UInt, no type conversion
290 {
291 v.x = As<Float4>(Int4(*Pointer<Short4>(source0)));
292 v.y = As<Float4>(Int4(*Pointer<Short4>(source1)));
293 v.z = As<Float4>(Int4(*Pointer<Short4>(source2)));
294 v.w = As<Float4>(Int4(*Pointer<Short4>(source3)));
295
296 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
297 }
298 break;
299 case STREAMTYPE_USHORT:
300 if(isNativeFloatAttrib) // Stream: Int, Shader attrib: Float
301 {
302 v.x = Float4(*Pointer<UShort4>(source0));
303 v.y = Float4(*Pointer<UShort4>(source1));
304 v.z = Float4(*Pointer<UShort4>(source2));
305 v.w = Float4(*Pointer<UShort4>(source3));
306
307 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
308
309 if(stream.normalized)
310 {
311 if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
312 if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
313 if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
314 if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
315 }
316 }
317 else // Stream: UShort, Shader attrib: Int/UInt, no type conversion
318 {
319 v.x = As<Float4>(Int4(*Pointer<UShort4>(source0)));
320 v.y = As<Float4>(Int4(*Pointer<UShort4>(source1)));
321 v.z = As<Float4>(Int4(*Pointer<UShort4>(source2)));
322 v.w = As<Float4>(Int4(*Pointer<UShort4>(source3)));
323
324 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
325 }
326 break;
327 case STREAMTYPE_INT:
328 if(isNativeFloatAttrib) // Stream: Int, Shader attrib: Float
329 {
330 v.x = Float4(*Pointer<Int4>(source0));
331 v.y = Float4(*Pointer<Int4>(source1));
332 v.z = Float4(*Pointer<Int4>(source2));
333 v.w = Float4(*Pointer<Int4>(source3));
334
335 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
336
337 if(stream.normalized)
338 {
339 if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
340 if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
341 if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
342 if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
343 }
344 }
345 else // Stream: Int, Shader attrib: Int/UInt, no type conversion
346 {
347 v.x = *Pointer<Float4>(source0);
348 v.y = *Pointer<Float4>(source1);
349 v.z = *Pointer<Float4>(source2);
350 v.w = *Pointer<Float4>(source3);
351
352 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
353 }
354 break;
355 case STREAMTYPE_UINT:
356 if(isNativeFloatAttrib) // Stream: UInt, Shader attrib: Float
357 {
358 v.x = Float4(*Pointer<UInt4>(source0));
359 v.y = Float4(*Pointer<UInt4>(source1));
360 v.z = Float4(*Pointer<UInt4>(source2));
361 v.w = Float4(*Pointer<UInt4>(source3));
362
363 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
364
365 if(stream.normalized)
366 {
367 if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
368 if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
369 if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
370 if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
371 }
372 }
373 else // Stream: UInt, Shader attrib: Int/UInt, no type conversion
374 {
375 v.x = *Pointer<Float4>(source0);
376 v.y = *Pointer<Float4>(source1);
377 v.z = *Pointer<Float4>(source2);
378 v.w = *Pointer<Float4>(source3);
379
380 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
381 }
382 break;
383 case STREAMTYPE_UDEC3:
384 {
385 // FIXME: Vectorize
386 {
387 Int x, y, z;
388
389 x = y = z = *Pointer<Int>(source0);
390
391 v.x.x = Float(x & 0x000003FF);
392 v.x.y = Float(y & 0x000FFC00);
393 v.x.z = Float(z & 0x3FF00000);
394 }
395
396 {
397 Int x, y, z;
398
399 x = y = z = *Pointer<Int>(source1);
400
401 v.y.x = Float(x & 0x000003FF);
402 v.y.y = Float(y & 0x000FFC00);
403 v.y.z = Float(z & 0x3FF00000);
404 }
405
406 {
407 Int x, y, z;
408
409 x = y = z = *Pointer<Int>(source2);
410
411 v.z.x = Float(x & 0x000003FF);
412 v.z.y = Float(y & 0x000FFC00);
413 v.z.z = Float(z & 0x3FF00000);
414 }
415
416 {
417 Int x, y, z;
418
419 x = y = z = *Pointer<Int>(source3);
420
421 v.w.x = Float(x & 0x000003FF);
422 v.w.y = Float(y & 0x000FFC00);
423 v.w.z = Float(z & 0x3FF00000);
424 }
425
426 transpose4x3(v.x, v.y, v.z, v.w);
427
428 v.y *= Float4(1.0f / 0x00000400);
429 v.z *= Float4(1.0f / 0x00100000);
430 }
431 break;
432 case STREAMTYPE_DEC3N:
433 {
434 // FIXME: Vectorize
435 {
436 Int x, y, z;
437
438 x = y = z = *Pointer<Int>(source0);
439
440 v.x.x = Float((x << 22) & 0xFFC00000);
441 v.x.y = Float((y << 12) & 0xFFC00000);
442 v.x.z = Float((z << 2) & 0xFFC00000);
443 }
444
445 {
446 Int x, y, z;
447
448 x = y = z = *Pointer<Int>(source1);
449
450 v.y.x = Float((x << 22) & 0xFFC00000);
451 v.y.y = Float((y << 12) & 0xFFC00000);
452 v.y.z = Float((z << 2) & 0xFFC00000);
453 }
454
455 {
456 Int x, y, z;
457
458 x = y = z = *Pointer<Int>(source2);
459
460 v.z.x = Float((x << 22) & 0xFFC00000);
461 v.z.y = Float((y << 12) & 0xFFC00000);
462 v.z.z = Float((z << 2) & 0xFFC00000);
463 }
464
465 {
466 Int x, y, z;
467
468 x = y = z = *Pointer<Int>(source3);
469
470 v.w.x = Float((x << 22) & 0xFFC00000);
471 v.w.y = Float((y << 12) & 0xFFC00000);
472 v.w.z = Float((z << 2) & 0xFFC00000);
473 }
474
475 transpose4x3(v.x, v.y, v.z, v.w);
476
477 v.x *= Float4(1.0f / 0x00400000 / 511.0f);
478 v.y *= Float4(1.0f / 0x00400000 / 511.0f);
479 v.z *= Float4(1.0f / 0x00400000 / 511.0f);
480 }
481 break;
482 case STREAMTYPE_FIXED:
483 {
484 v.x = Float4(*Pointer<Int4>(source0)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
485 v.y = Float4(*Pointer<Int4>(source1)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
486 v.z = Float4(*Pointer<Int4>(source2)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
487 v.w = Float4(*Pointer<Int4>(source3)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
488
489 transpose4xN(v.x, v.y, v.z, v.w, stream.count);
490 }
491 break;
492 case STREAMTYPE_HALF:
493 {
494 if(stream.count >= 1)
495 {
496 UShort x0 = *Pointer<UShort>(source0 + 0);
497 UShort x1 = *Pointer<UShort>(source1 + 0);
498 UShort x2 = *Pointer<UShort>(source2 + 0);
499 UShort x3 = *Pointer<UShort>(source3 + 0);
500
501 v.x.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x0) * 4);
502 v.x.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x1) * 4);
503 v.x.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x2) * 4);
504 v.x.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x3) * 4);
505 }
506
507 if(stream.count >= 2)
508 {
509 UShort y0 = *Pointer<UShort>(source0 + 2);
510 UShort y1 = *Pointer<UShort>(source1 + 2);
511 UShort y2 = *Pointer<UShort>(source2 + 2);
512 UShort y3 = *Pointer<UShort>(source3 + 2);
513
514 v.y.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y0) * 4);
515 v.y.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y1) * 4);
516 v.y.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y2) * 4);
517 v.y.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y3) * 4);
518 }
519
520 if(stream.count >= 3)
521 {
522 UShort z0 = *Pointer<UShort>(source0 + 4);
523 UShort z1 = *Pointer<UShort>(source1 + 4);
524 UShort z2 = *Pointer<UShort>(source2 + 4);
525 UShort z3 = *Pointer<UShort>(source3 + 4);
526
527 v.z.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z0) * 4);
528 v.z.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z1) * 4);
529 v.z.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z2) * 4);
530 v.z.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z3) * 4);
531 }
532
533 if(stream.count >= 4)
534 {
535 UShort w0 = *Pointer<UShort>(source0 + 6);
536 UShort w1 = *Pointer<UShort>(source1 + 6);
537 UShort w2 = *Pointer<UShort>(source2 + 6);
538 UShort w3 = *Pointer<UShort>(source3 + 6);
539
540 v.w.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w0) * 4);
541 v.w.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w1) * 4);
542 v.w.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w2) * 4);
543 v.w.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w3) * 4);
544 }
545 }
546 break;
547 case STREAMTYPE_INDICES:
548 {
549 v.x.x = *Pointer<Float>(source0);
550 v.x.y = *Pointer<Float>(source1);
551 v.x.z = *Pointer<Float>(source2);
552 v.x.w = *Pointer<Float>(source3);
553 }
554 break;
555 case STREAMTYPE_2_10_10_10_INT:
556 {
557 Int4 src;
558 src = Insert(src, *Pointer<Int>(source0), 0);
559 src = Insert(src, *Pointer<Int>(source1), 1);
560 src = Insert(src, *Pointer<Int>(source2), 2);
561 src = Insert(src, *Pointer<Int>(source3), 3);
562
563 v.x = Float4((src << 22) >> 22);
564 v.y = Float4((src << 12) >> 22);
565 v.z = Float4((src << 02) >> 22);
566 v.w = Float4(src >> 30);
567
568 if(stream.normalized)
569 {
570 v.x = Max(v.x * Float4(1.0f / 0x1FF), Float4(-1.0f));
571 v.y = Max(v.y * Float4(1.0f / 0x1FF), Float4(-1.0f));
572 v.z = Max(v.z * Float4(1.0f / 0x1FF), Float4(-1.0f));
573 v.w = Max(v.w, Float4(-1.0f));
574 }
575 }
576 break;
577 case STREAMTYPE_2_10_10_10_UINT:
578 {
579 Int4 src;
580 src = Insert(src, *Pointer<Int>(source0), 0);
581 src = Insert(src, *Pointer<Int>(source1), 1);
582 src = Insert(src, *Pointer<Int>(source2), 2);
583 src = Insert(src, *Pointer<Int>(source3), 3);
584
585 v.x = Float4(src & Int4(0x3FF));
586 v.y = Float4((src >> 10) & Int4(0x3FF));
587 v.z = Float4((src >> 20) & Int4(0x3FF));
588 v.w = Float4((src >> 30) & Int4(0x3));
589
590 if(stream.normalized)
591 {
592 v.x *= Float4(1.0f / 0x3FF);
593 v.y *= Float4(1.0f / 0x3FF);
594 v.z *= Float4(1.0f / 0x3FF);
595 v.w *= Float4(1.0f / 0x3);
596 }
597 }
598 break;
599 default:
600 ASSERT(false);
601 }
602
603 if(stream.count < 1) v.x = Float4(0.0f);
604 if(stream.count < 2) v.y = Float4(0.0f);
605 if(stream.count < 3) v.z = Float4(0.0f);
606 if(stream.count < 4) v.w = isNativeFloatAttrib ? As<Float4>(Float4(1.0f)) : As<Float4>(Int4(0));
607
608 return v;
609 }
610
611 void VertexRoutine::postTransform()
612 {
613 int pos = state.positionRegister;
614
615 // Backtransform
616 if(state.preTransformed)
617 {
618 Float4 rhw = Float4(1.0f) / o[pos].w;
619
620 Float4 W = *Pointer<Float4>(data + OFFSET(DrawData,Wx16)) * Float4(1.0f / 16.0f);
621 Float4 H = *Pointer<Float4>(data + OFFSET(DrawData,Hx16)) * Float4(1.0f / 16.0f);
622 Float4 L = *Pointer<Float4>(data + OFFSET(DrawData,X0x16)) * Float4(1.0f / 16.0f);
623 Float4 T = *Pointer<Float4>(data + OFFSET(DrawData,Y0x16)) * Float4(1.0f / 16.0f);
624
625 o[pos].x = (o[pos].x - L) / W * rhw;
626 o[pos].y = (o[pos].y - T) / H * rhw;
627 o[pos].z = o[pos].z * rhw;
628 o[pos].w = rhw;
629 }
630
631 if(!halfIntegerCoordinates && !state.preTransformed)
632 {
633 o[pos].x = o[pos].x + *Pointer<Float4>(data + OFFSET(DrawData,halfPixelX)) * o[pos].w;
634 o[pos].y = o[pos].y + *Pointer<Float4>(data + OFFSET(DrawData,halfPixelY)) * o[pos].w;
635 }
636
637 if(state.superSampling)
638 {
639 o[pos].x = o[pos].x + *Pointer<Float4>(data + OFFSET(DrawData,XXXX)) * o[pos].w;
640 o[pos].y = o[pos].y + *Pointer<Float4>(data + OFFSET(DrawData,YYYY)) * o[pos].w;
641 }
642 }
643
644 void VertexRoutine::writeCache(Pointer<Byte> &cacheLine)
645 {
646 Vector4f v;
647
648 for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
649 {
650 if(state.output[i].write)
651 {
652 v.x = o[i].x;
653 v.y = o[i].y;
654 v.z = o[i].z;
655 v.w = o[i].w;
656
657 if(state.output[i].xClamp)
658 {
659 v.x = Max(v.x, Float4(0.0f));
660 v.x = Min(v.x, Float4(1.0f));
661 }
662
663 if(state.output[i].yClamp)
664 {
665 v.y = Max(v.y, Float4(0.0f));
666 v.y = Min(v.y, Float4(1.0f));
667 }
668
669 if(state.output[i].zClamp)
670 {
671 v.z = Max(v.z, Float4(0.0f));
672 v.z = Min(v.z, Float4(1.0f));
673 }
674
675 if(state.output[i].wClamp)
676 {
677 v.w = Max(v.w, Float4(0.0f));
678 v.w = Min(v.w, Float4(1.0f));
679 }
680
681 if(state.output[i].write == 0x01)
682 {
683 *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 0) = v.x.x;
684 *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 1) = v.x.y;
685 *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 2) = v.x.z;
686 *Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 3) = v.x.w;
687 }
688 else
689 {
690 if(state.output[i].write == 0x03)
691 {
692 transpose2x4(v.x, v.y, v.z, v.w);
693 }
694 else
695 {
696 transpose4x4(v.x, v.y, v.z, v.w);
697 }
698
699 *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 0, 16) = v.x;
700 *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 1, 16) = v.y;
701 *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 2, 16) = v.z;
702 *Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 3, 16) = v.w;
703 }
704 }
705 }
706
707 *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 0) = (clipFlags >> 0) & 0x0000000FF;
708 *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 1) = (clipFlags >> 8) & 0x0000000FF;
709 *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 2) = (clipFlags >> 16) & 0x0000000FF;
710 *Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 3) = (clipFlags >> 24) & 0x0000000FF;
711
712 // Viewport transform
713 int pos = state.positionRegister;
714
715 v.x = o[pos].x;
716 v.y = o[pos].y;
717 v.z = o[pos].z;
718 v.w = o[pos].w;
719
720 if(symmetricNormalizedDepth)
721 {
722 v.z = (v.z + v.w) * Float4(0.5f); // [-1, 1] -> [0, 1]
723 }
724
725 Float4 w = As<Float4>(As<Int4>(v.w) | (As<Int4>(CmpEQ(v.w, Float4(0.0f))) & As<Int4>(Float4(1.0f))));
726 Float4 rhw = Float4(1.0f) / w;
727
728 v.x = As<Float4>(RoundInt(*Pointer<Float4>(data + OFFSET(DrawData,X0x16)) + v.x * rhw * *Pointer<Float4>(data + OFFSET(DrawData,Wx16))));
729 v.y = As<Float4>(RoundInt(*Pointer<Float4>(data + OFFSET(DrawData,Y0x16)) + v.y * rhw * *Pointer<Float4>(data + OFFSET(DrawData,Hx16))));
730 v.z = v.z * rhw;
731 v.w = rhw;
732
733 transpose4x4(v.x, v.y, v.z, v.w);
734
735 *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 0, 16) = v.x;
736 *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 1, 16) = v.y;
737 *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 2, 16) = v.z;
738 *Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 3, 16) = v.w;
739 }
740
741 void VertexRoutine::writeVertex(const Pointer<Byte> &vertex, Pointer<Byte> &cache)
742 {
743 for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
744 {
745 if(state.output[i].write)
746 {
747 *Pointer<Int4>(vertex + OFFSET(Vertex,v[i]), 16) = *Pointer<Int4>(cache + OFFSET(Vertex,v[i]), 16);
748 }
749 }
750
751 *Pointer<Int4>(vertex + OFFSET(Vertex,X)) = *Pointer<Int4>(cache + OFFSET(Vertex,X));
752 *Pointer<Int>(vertex + OFFSET(Vertex,clipFlags)) = *Pointer<Int>(cache + OFFSET(Vertex,clipFlags));
753 }
754
755 void VertexRoutine::transformFeedback(const Pointer<Byte> &vertex, const UInt &primitiveNumber, const UInt &indexInPrimitive)
756 {
757 If(indexInPrimitive < state.verticesPerPrimitive)
758 {
759 UInt tOffset = primitiveNumber * state.verticesPerPrimitive + indexInPrimitive;
760
761 for(int i = 0; i < MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; i++)
762 {
763 if(state.transformFeedbackEnabled & (1ULL << i))
764 {
765 UInt reg = *Pointer<UInt>(data + OFFSET(DrawData, vs.reg[i]));
766 UInt row = *Pointer<UInt>(data + OFFSET(DrawData, vs.row[i]));
767 UInt col = *Pointer<UInt>(data + OFFSET(DrawData, vs.col[i]));
768 UInt str = *Pointer<UInt>(data + OFFSET(DrawData, vs.str[i]));
769
770 Pointer<Byte> t = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, vs.t[i])) + (tOffset * str * sizeof(float));
771 Pointer<Byte> v = vertex + OFFSET(Vertex, v) + reg * sizeof(float);
772
773 For(UInt r = 0, r < row, r++)
774 {
775 UInt rOffsetX = r * col * sizeof(float);
776 UInt rOffset4 = r * sizeof(float4);
777
778 For(UInt c = 0, c < col, c++)
779 {
780 UInt cOffset = c * sizeof(float);
781 *Pointer<Float>(t + rOffsetX + cOffset) = *Pointer<Float>(v + rOffset4 + cOffset);
782 }
783 }
784 }
785 }
786 }
787 }
788}
789