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 "SetupRoutine.hpp" 16 17 #include "Constants.hpp" 18 #include "Renderer/Primitive.hpp" 19 #include "Renderer/Polygon.hpp" 20 #include "Renderer/Renderer.hpp" 21 #include "Reactor/Reactor.hpp" 22 23 namespace sw 24 { 25 extern bool complementaryDepthBuffer; 26 extern TranscendentalPrecision logPrecision; 27 extern bool leadingVertexFirst; 28 SetupRoutine(const SetupProcessor::State & state)29 SetupRoutine::SetupRoutine(const SetupProcessor::State &state) : state(state) 30 { 31 routine = 0; 32 } 33 ~SetupRoutine()34 SetupRoutine::~SetupRoutine() 35 { 36 } 37 generate()38 void SetupRoutine::generate() 39 { 40 Function<Bool(Pointer<Byte>, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>)> function; 41 { 42 Pointer<Byte> primitive(function.Arg<0>()); 43 Pointer<Byte> tri(function.Arg<1>()); 44 Pointer<Byte> polygon(function.Arg<2>()); 45 Pointer<Byte> data(function.Arg<3>()); 46 47 Pointer<Byte> constants = *Pointer<Pointer<Byte> >(data + OFFSET(DrawData,constants)); 48 49 const bool point = state.isDrawPoint; 50 const bool sprite = state.pointSprite; 51 const bool line = state.isDrawLine; 52 const bool triangle = state.isDrawSolidTriangle || sprite; 53 const bool solidTriangle = state.isDrawSolidTriangle; 54 55 const int V0 = OFFSET(Triangle,v0); 56 const int V1 = (triangle || line) ? OFFSET(Triangle,v1) : OFFSET(Triangle,v0); 57 const int V2 = triangle ? OFFSET(Triangle,v2) : (line ? OFFSET(Triangle,v1) : OFFSET(Triangle,v0)); 58 59 int pos = state.positionRegister; 60 61 Pointer<Byte> v0 = tri + V0; 62 Pointer<Byte> v1 = tri + V1; 63 Pointer<Byte> v2 = tri + V2; 64 65 Array<Int> X(16); 66 Array<Int> Y(16); 67 68 X[0] = *Pointer<Int>(v0 + OFFSET(Vertex,X)); 69 X[1] = *Pointer<Int>(v1 + OFFSET(Vertex,X)); 70 X[2] = *Pointer<Int>(v2 + OFFSET(Vertex,X)); 71 72 Y[0] = *Pointer<Int>(v0 + OFFSET(Vertex,Y)); 73 Y[1] = *Pointer<Int>(v1 + OFFSET(Vertex,Y)); 74 Y[2] = *Pointer<Int>(v2 + OFFSET(Vertex,Y)); 75 76 Int d = 1; // Winding direction 77 78 // Culling 79 if(solidTriangle) 80 { 81 Float x0 = Float(X[0]); 82 Float x1 = Float(X[1]); 83 Float x2 = Float(X[2]); 84 85 Float y0 = Float(Y[0]); 86 Float y1 = Float(Y[1]); 87 Float y2 = Float(Y[2]); 88 89 Float A = (y2 - y0) * x1 + (y1 - y2) * x0 + (y0 - y1) * x2; // Area 90 91 If(A == 0.0f) 92 { 93 Return(false); 94 } 95 96 Int w0w1w2 = *Pointer<Int>(v0 + pos * 16 + 12) ^ 97 *Pointer<Int>(v1 + pos * 16 + 12) ^ 98 *Pointer<Int>(v2 + pos * 16 + 12); 99 100 A = IfThenElse(w0w1w2 < 0, -A, A); 101 102 if(state.cullMode == CULL_CLOCKWISE) 103 { 104 If(A >= 0.0f) Return(false); 105 } 106 else if(state.cullMode == CULL_COUNTERCLOCKWISE) 107 { 108 If(A <= 0.0f) Return(false); 109 } 110 111 d = IfThenElse(A < 0.0f, d, Int(0)); 112 113 if(state.twoSidedStencil) 114 { 115 If(A > 0.0f) 116 { 117 *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF); 118 *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); 119 } 120 Else 121 { 122 *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); 123 *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF); 124 } 125 } 126 127 if(state.vFace) 128 { 129 *Pointer<Float>(primitive + OFFSET(Primitive,area)) = 0.5f * A; 130 } 131 } 132 else 133 { 134 if(state.twoSidedStencil) 135 { 136 *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF); 137 *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); 138 } 139 } 140 141 Int n = *Pointer<Int>(polygon + OFFSET(Polygon,n)); 142 Int m = *Pointer<Int>(polygon + OFFSET(Polygon,i)); 143 144 If(m != 0 || Bool(!solidTriangle)) // Clipped triangle; reproject 145 { 146 Pointer<Byte> V = polygon + OFFSET(Polygon,P) + m * sizeof(void*) * 16; 147 148 Int i = 0; 149 150 Do 151 { 152 Pointer<Float4> p = *Pointer<Pointer<Float4> >(V + i * sizeof(void*)); 153 Float4 v = *Pointer<Float4>(p, 16); 154 155 Float w = v.w; 156 Float rhw = IfThenElse(w != 0.0f, 1.0f / w, Float(1.0f)); 157 158 X[i] = RoundInt(*Pointer<Float>(data + OFFSET(DrawData,X0x16)) + v.x * rhw * *Pointer<Float>(data + OFFSET(DrawData,Wx16))); 159 Y[i] = RoundInt(*Pointer<Float>(data + OFFSET(DrawData,Y0x16)) + v.y * rhw * *Pointer<Float>(data + OFFSET(DrawData,Hx16))); 160 161 i++; 162 } 163 Until(i >= n) 164 } 165 166 // Vertical range 167 Int yMin = Y[0]; 168 Int yMax = Y[0]; 169 170 Int i = 1; 171 172 Do 173 { 174 yMin = Min(Y[i], yMin); 175 yMax = Max(Y[i], yMax); 176 177 i++; 178 } 179 Until(i >= n) 180 181 if(state.multiSample > 1) 182 { 183 yMin = (yMin + 0x0A) >> 4; 184 yMax = (yMax + 0x14) >> 4; 185 } 186 else 187 { 188 yMin = (yMin + 0x0F) >> 4; 189 yMax = (yMax + 0x0F) >> 4; 190 } 191 192 If(yMin == yMax) 193 { 194 Return(false); 195 } 196 197 yMin = Max(yMin, *Pointer<Int>(data + OFFSET(DrawData,scissorY0))); 198 yMax = Min(yMax, *Pointer<Int>(data + OFFSET(DrawData,scissorY1))); 199 200 For(Int q = 0, q < state.multiSample, q++) 201 { 202 Array<Int> Xq(16); 203 Array<Int> Yq(16); 204 205 Int i = 0; 206 207 Do 208 { 209 Xq[i] = X[i]; 210 Yq[i] = Y[i]; 211 212 if(state.multiSample > 1) 213 { 214 Xq[i] = Xq[i] + *Pointer<Int>(constants + OFFSET(Constants,Xf) + q * sizeof(int)); 215 Yq[i] = Yq[i] + *Pointer<Int>(constants + OFFSET(Constants,Yf) + q * sizeof(int)); 216 } 217 218 i++; 219 } 220 Until(i >= n) 221 222 Pointer<Byte> leftEdge = Pointer<Byte>(primitive + OFFSET(Primitive,outline->left)) + q * sizeof(Primitive); 223 Pointer<Byte> rightEdge = Pointer<Byte>(primitive + OFFSET(Primitive,outline->right)) + q * sizeof(Primitive); 224 225 if(state.multiSample > 1) 226 { 227 Short x = Short((X[0] + 0xF) >> 4); 228 229 For(Int y = yMin - 1, y < yMax + 1, y++) 230 { 231 *Pointer<Short>(leftEdge + y * sizeof(Primitive::Span)) = x; 232 *Pointer<Short>(rightEdge + y * sizeof(Primitive::Span)) = x; 233 } 234 } 235 236 Xq[n] = Xq[0]; 237 Yq[n] = Yq[0]; 238 239 // Rasterize 240 { 241 Int i = 0; 242 243 Do 244 { 245 edge(primitive, data, Xq[i + 1 - d], Yq[i + 1 - d], Xq[i + d], Yq[i + d], q); 246 247 i++; 248 } 249 Until(i >= n) 250 } 251 252 if(state.multiSample == 1) 253 { 254 For(, yMin < yMax && *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span)) == *Pointer<Short>(rightEdge + yMin * sizeof(Primitive::Span)), yMin++) 255 { 256 // Increments yMin 257 } 258 259 For(, yMax > yMin && *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span)) == *Pointer<Short>(rightEdge + (yMax - 1) * sizeof(Primitive::Span)), yMax--) 260 { 261 // Decrements yMax 262 } 263 264 If(yMin == yMax) 265 { 266 Return(false); 267 } 268 269 *Pointer<Short>(leftEdge + (yMin - 1) * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span)); 270 *Pointer<Short>(rightEdge + (yMin - 1) * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span)); 271 *Pointer<Short>(leftEdge + yMax * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span)); 272 *Pointer<Short>(rightEdge + yMax * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span)); 273 } 274 } 275 276 *Pointer<Int>(primitive + OFFSET(Primitive,yMin)) = yMin; 277 *Pointer<Int>(primitive + OFFSET(Primitive,yMax)) = yMax; 278 279 // Sort by minimum y 280 if(solidTriangle && logPrecision >= WHQL) 281 { 282 Float y0 = *Pointer<Float>(v0 + pos * 16 + 4); 283 Float y1 = *Pointer<Float>(v1 + pos * 16 + 4); 284 Float y2 = *Pointer<Float>(v2 + pos * 16 + 4); 285 286 Float yMin = Min(Min(y0, y1), y2); 287 288 conditionalRotate1(yMin == y1, v0, v1, v2); 289 conditionalRotate2(yMin == y2, v0, v1, v2); 290 } 291 292 // Sort by maximum w 293 if(solidTriangle) 294 { 295 Float w0 = *Pointer<Float>(v0 + pos * 16 + 12); 296 Float w1 = *Pointer<Float>(v1 + pos * 16 + 12); 297 Float w2 = *Pointer<Float>(v2 + pos * 16 + 12); 298 299 Float wMax = Max(Max(w0, w1), w2); 300 301 conditionalRotate1(wMax == w1, v0, v1, v2); 302 conditionalRotate2(wMax == w2, v0, v1, v2); 303 } 304 305 Float w0 = *Pointer<Float>(v0 + pos * 16 + 12); 306 Float w1 = *Pointer<Float>(v1 + pos * 16 + 12); 307 Float w2 = *Pointer<Float>(v2 + pos * 16 + 12); 308 309 Float4 w012; 310 311 w012.x = w0; 312 w012.y = w1; 313 w012.z = w2; 314 w012.w = 1; 315 316 Float rhw0 = *Pointer<Float>(v0 + OFFSET(Vertex,W)); 317 318 Int X0 = *Pointer<Int>(v0 + OFFSET(Vertex,X)); 319 Int X1 = *Pointer<Int>(v1 + OFFSET(Vertex,X)); 320 Int X2 = *Pointer<Int>(v2 + OFFSET(Vertex,X)); 321 322 Int Y0 = *Pointer<Int>(v0 + OFFSET(Vertex,Y)); 323 Int Y1 = *Pointer<Int>(v1 + OFFSET(Vertex,Y)); 324 Int Y2 = *Pointer<Int>(v2 + OFFSET(Vertex,Y)); 325 326 if(line) 327 { 328 X2 = X1 + Y1 - Y0; 329 Y2 = Y1 + X0 - X1; 330 } 331 332 Float dx = Float(X0) * (1.0f / 16.0f); 333 Float dy = Float(Y0) * (1.0f / 16.0f); 334 335 X1 -= X0; 336 Y1 -= Y0; 337 338 X2 -= X0; 339 Y2 -= Y0; 340 341 Float x1 = w1 * (1.0f / 16.0f) * Float(X1); 342 Float y1 = w1 * (1.0f / 16.0f) * Float(Y1); 343 344 Float x2 = w2 * (1.0f / 16.0f) * Float(X2); 345 Float y2 = w2 * (1.0f / 16.0f) * Float(Y2); 346 347 Float a = x1 * y2 - x2 * y1; 348 349 Float4 xQuad = Float4(0, 1, 0, 1) - Float4(dx); 350 Float4 yQuad = Float4(0, 0, 1, 1) - Float4(dy); 351 352 *Pointer<Float4>(primitive + OFFSET(Primitive,xQuad), 16) = xQuad; 353 *Pointer<Float4>(primitive + OFFSET(Primitive,yQuad), 16) = yQuad; 354 355 Float4 M[3]; 356 357 M[0] = Float4(0, 0, 0, 0); 358 M[1] = Float4(0, 0, 0, 0); 359 M[2] = Float4(0, 0, 0, 0); 360 361 M[0].z = rhw0; 362 363 If(a != 0.0f) 364 { 365 Float A = 1.0f / a; 366 Float D = A * rhw0; 367 368 M[0].x = (y1 * w2 - y2 * w1) * D; 369 M[0].y = (x2 * w1 - x1 * w2) * D; 370 // M[0].z = rhw0; 371 // M[0].w = 0; 372 373 M[1].x = y2 * A; 374 M[1].y = -x2 * A; 375 // M[1].z = 0; 376 // M[1].w = 0; 377 378 M[2].x = -y1 * A; 379 M[2].y = x1 * A; 380 // M[2].z = 0; 381 // M[2].w = 0; 382 } 383 384 if(state.interpolateW) 385 { 386 Float4 ABC = M[0] + M[1] + M[2]; 387 388 Float4 A = ABC.x; 389 Float4 B = ABC.y; 390 Float4 C = ABC.z; 391 392 *Pointer<Float4>(primitive + OFFSET(Primitive,w.A), 16) = A; 393 *Pointer<Float4>(primitive + OFFSET(Primitive,w.B), 16) = B; 394 *Pointer<Float4>(primitive + OFFSET(Primitive,w.C), 16) = C; 395 } 396 397 if(state.interpolateZ) 398 { 399 Float z0 = *Pointer<Float>(v0 + OFFSET(Vertex,Z)); 400 Float z1 = *Pointer<Float>(v1 + OFFSET(Vertex,Z)); 401 Float z2 = *Pointer<Float>(v2 + OFFSET(Vertex,Z)); 402 403 z1 -= z0; 404 z2 -= z0; 405 406 Float4 A; 407 Float4 B; 408 Float4 C; 409 410 if(!point) 411 { 412 Float x1 = Float(X1) * (1.0f / 16.0f); 413 Float y1 = Float(Y1) * (1.0f / 16.0f); 414 Float x2 = Float(X2) * (1.0f / 16.0f); 415 Float y2 = Float(Y2) * (1.0f / 16.0f); 416 417 Float D = *Pointer<Float>(data + OFFSET(DrawData,depthRange)) / (x1 * y2 - x2 * y1); 418 419 Float a = (y2 * z1 - y1 * z2) * D; 420 Float b = (x1 * z2 - x2 * z1) * D; 421 422 A = Float4(a); 423 B = Float4(b); 424 } 425 else 426 { 427 A = Float4(0, 0, 0, 0); 428 B = Float4(0, 0, 0, 0); 429 } 430 431 *Pointer<Float4>(primitive + OFFSET(Primitive,z.A), 16) = A; 432 *Pointer<Float4>(primitive + OFFSET(Primitive,z.B), 16) = B; 433 434 Float c = z0; 435 436 if(state.isDrawTriangle && state.slopeDepthBias) 437 { 438 Float bias = Max(Abs(Float(A.x)), Abs(Float(B.x))); 439 bias *= *Pointer<Float>(data + OFFSET(DrawData,slopeDepthBias)); 440 441 if(complementaryDepthBuffer) 442 { 443 bias = -bias; 444 } 445 446 c += bias; 447 } 448 449 C = Float4(c * *Pointer<Float>(data + OFFSET(DrawData,depthRange)) + *Pointer<Float>(data + OFFSET(DrawData,depthNear))); 450 451 *Pointer<Float4>(primitive + OFFSET(Primitive,z.C), 16) = C; 452 } 453 454 for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++) 455 { 456 for(int component = 0; component < 4; component++) 457 { 458 int attribute = state.gradient[interpolant][component].attribute; 459 bool flat = state.gradient[interpolant][component].flat; 460 bool wrap = state.gradient[interpolant][component].wrap; 461 462 if(attribute != Unused) 463 { 464 setupGradient(primitive, tri, w012, M, v0, v1, v2, OFFSET(Vertex,v[attribute][component]), OFFSET(Primitive,V[interpolant][component]), flat, sprite, state.perspective, wrap, component); 465 } 466 } 467 } 468 469 if(state.fog.attribute == Fog) 470 { 471 setupGradient(primitive, tri, w012, M, v0, v1, v2, OFFSET(Vertex,f), OFFSET(Primitive,f), state.fog.flat, false, state.perspective, false, 0); 472 } 473 474 Return(true); 475 } 476 477 routine = function(L"SetupRoutine"); 478 } 479 setupGradient(Pointer<Byte> & primitive,Pointer<Byte> & triangle,Float4 & w012,Float4 (& m)[3],Pointer<Byte> & v0,Pointer<Byte> & v1,Pointer<Byte> & v2,int attribute,int planeEquation,bool flat,bool sprite,bool perspective,bool wrap,int component)480 void SetupRoutine::setupGradient(Pointer<Byte> &primitive, Pointer<Byte> &triangle, Float4 &w012, Float4 (&m)[3], Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2, int attribute, int planeEquation, bool flat, bool sprite, bool perspective, bool wrap, int component) 481 { 482 Float4 i; 483 484 if(!flat) 485 { 486 if(!sprite) 487 { 488 i.x = *Pointer<Float>(v0 + attribute); 489 i.y = *Pointer<Float>(v1 + attribute); 490 i.z = *Pointer<Float>(v2 + attribute); 491 i.w = 0; 492 } 493 else 494 { 495 if(component == 0) i.x = 0.5f; 496 if(component == 1) i.x = 0.5f; 497 if(component == 2) i.x = 0.0f; 498 if(component == 3) i.x = 1.0f; 499 500 if(component == 0) i.y = 1.0f; 501 if(component == 1) i.y = 0.5f; 502 if(component == 2) i.y = 0.0f; 503 if(component == 3) i.y = 1.0f; 504 505 if(component == 0) i.z = 0.5f; 506 if(component == 1) i.z = 1.0f; 507 if(component == 2) i.z = 0.0f; 508 if(component == 3) i.z = 1.0f; 509 510 i.w = 0; 511 } 512 513 if(wrap) 514 { 515 Float m; 516 517 m = *Pointer<Float>(v0 + attribute); 518 m = Max(m, *Pointer<Float>(v1 + attribute)); 519 m = Max(m, *Pointer<Float>(v2 + attribute)); 520 m -= 0.5f; 521 522 // FIXME: Vectorize 523 If(Float(i.x) < m) i.x = i.x + 1.0f; 524 If(Float(i.y) < m) i.y = i.y + 1.0f; 525 If(Float(i.z) < m) i.z = i.z + 1.0f; 526 } 527 528 if(!perspective) 529 { 530 i *= w012; 531 } 532 533 Float4 A = i.xxxx * m[0]; 534 Float4 B = i.yyyy * m[1]; 535 Float4 C = i.zzzz * m[2]; 536 537 C = A + B + C; 538 539 A = C.xxxx; 540 B = C.yyyy; 541 C = C.zzzz; 542 543 *Pointer<Float4>(primitive + planeEquation + 0, 16) = A; 544 *Pointer<Float4>(primitive + planeEquation + 16, 16) = B; 545 *Pointer<Float4>(primitive + planeEquation + 32, 16) = C; 546 } 547 else 548 { 549 int leadingVertex = leadingVertexFirst ? OFFSET(Triangle,v0) : OFFSET(Triangle,v2); 550 Float C = *Pointer<Float>(triangle + leadingVertex + attribute); 551 552 *Pointer<Float4>(primitive + planeEquation + 0, 16) = Float4(0, 0, 0, 0); 553 *Pointer<Float4>(primitive + planeEquation + 16, 16) = Float4(0, 0, 0, 0); 554 *Pointer<Float4>(primitive + planeEquation + 32, 16) = Float4(C); 555 } 556 } 557 edge(Pointer<Byte> & primitive,Pointer<Byte> & data,const Int & Xa,const Int & Ya,const Int & Xb,const Int & Yb,Int & q)558 void SetupRoutine::edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &Xa, const Int &Ya, const Int &Xb, const Int &Yb, Int &q) 559 { 560 If(Ya != Yb) 561 { 562 Bool swap = Yb < Ya; 563 564 Int X1 = IfThenElse(swap, Xb, Xa); 565 Int X2 = IfThenElse(swap, Xa, Xb); 566 Int Y1 = IfThenElse(swap, Yb, Ya); 567 Int Y2 = IfThenElse(swap, Ya, Yb); 568 569 Int y1 = Max((Y1 + 0x0000000F) >> 4, *Pointer<Int>(data + OFFSET(DrawData,scissorY0))); 570 Int y2 = Min((Y2 + 0x0000000F) >> 4, *Pointer<Int>(data + OFFSET(DrawData,scissorY1))); 571 572 If(y1 < y2) 573 { 574 Int xMin = *Pointer<Int>(data + OFFSET(DrawData,scissorX0)); 575 Int xMax = *Pointer<Int>(data + OFFSET(DrawData,scissorX1)); 576 577 Pointer<Byte> leftEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->left); 578 Pointer<Byte> rightEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->right); 579 Pointer<Byte> edge = IfThenElse(swap, rightEdge, leftEdge); 580 581 // Deltas 582 Int DX12 = X2 - X1; 583 Int DY12 = Y2 - Y1; 584 585 Int FDX12 = DX12 << 4; 586 Int FDY12 = DY12 << 4; 587 588 Int X = DX12 * ((y1 << 4) - Y1) + (X1 & 0x0000000F) * DY12; 589 Int x = (X1 >> 4) + X / FDY12; // Edge 590 Int d = X % FDY12; // Error-term 591 Int ceil = -d >> 31; // Ceiling division: remainder <= 0 592 x -= ceil; 593 d -= ceil & FDY12; 594 595 Int Q = FDX12 / FDY12; // Edge-step 596 Int R = FDX12 % FDY12; // Error-step 597 Int floor = R >> 31; // Flooring division: remainder >= 0 598 Q += floor; 599 R += floor & FDY12; 600 601 Int D = FDY12; // Error-overflow 602 Int y = y1; 603 604 Do 605 { 606 *Pointer<Short>(edge + y * sizeof(Primitive::Span)) = Short(Clamp(x, xMin, xMax)); 607 608 x += Q; 609 d += R; 610 611 Int overflow = -d >> 31; 612 613 d -= D & overflow; 614 x -= overflow; 615 616 y++; 617 } 618 Until(y >= y2) 619 } 620 } 621 } 622 conditionalRotate1(Bool condition,Pointer<Byte> & v0,Pointer<Byte> & v1,Pointer<Byte> & v2)623 void SetupRoutine::conditionalRotate1(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2) 624 { 625 #if 0 // Rely on LLVM optimization 626 If(condition) 627 { 628 Pointer<Byte> vX; 629 630 vX = v0; 631 v0 = v1; 632 v1 = v2; 633 v2 = vX; 634 } 635 #else 636 Pointer<Byte> vX = v0; 637 v0 = IfThenElse(condition, v1, v0); 638 v1 = IfThenElse(condition, v2, v1); 639 v2 = IfThenElse(condition, vX, v2); 640 #endif 641 } 642 conditionalRotate2(Bool condition,Pointer<Byte> & v0,Pointer<Byte> & v1,Pointer<Byte> & v2)643 void SetupRoutine::conditionalRotate2(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2) 644 { 645 #if 0 // Rely on LLVM optimization 646 If(condition) 647 { 648 Pointer<Byte> vX; 649 650 vX = v2; 651 v2 = v1; 652 v1 = v0; 653 v0 = vX; 654 } 655 #else 656 Pointer<Byte> vX = v2; 657 v2 = IfThenElse(condition, v1, v2); 658 v1 = IfThenElse(condition, v0, v1); 659 v0 = IfThenElse(condition, vX, v0); 660 #endif 661 } 662 getRoutine()663 Routine *SetupRoutine::getRoutine() 664 { 665 return routine; 666 } 667 } 668