src/gallium/drivers/swr/rasterizer/core/frontend.h

   1 /****************************************************************************
   2 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the next
  12 * paragraph) shall be included in all copies or substantial portions of the
  13 * Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21 * IN THE SOFTWARE.
  22 *
  23 * @file frontend.h
  24 *
  25 * @brief Definitions for Frontend which handles vertex processing,
  26 *        primitive assembly, clipping, binning, etc.
  27 *
  28 ******************************************************************************/
  29 #pragma once
  30 #include "context.h"
  31 #include "common/simdintrin.h"
  32 #include <type_traits>
  33
  34 // Calculates the A and B coefficients for the 3 edges of the triangle
  35 //
  36 // maths for edge equations:
  37 //   standard form of a line in 2d
  38 //   Ax + By + C = 0
  39 //   A = y0 - y1
  40 //   B = x1 - x0
  41 //   C = x0y1 - x1y0
  42 INLINE
  43 void triangleSetupAB(const __m128 vX, const __m128 vY, __m128 & vA, __m128 & vB)
  44 {
  45     // vYsub = y1 y2 y0 dc
  46     __m128 vYsub = _mm_shuffle_ps(vY, vY, _MM_SHUFFLE(3, 0, 2, 1));
  47     // vY =    y0 y1 y2 dc
  48     vA = _mm_sub_ps(vY, vYsub);
  49
  50     // Result:
  51     // A[0] = y0 - y1
  52     // A[1] = y1 - y2
  53     // A[2] = y2 - y0
  54
  55     // vXsub = x1 x2 x0 dc
  56     __m128 vXsub = _mm_shuffle_ps(vX, vX, _MM_SHUFFLE(3, 0, 2, 1));
  57     // vX =    x0 x1 x2 dc
  58     vB = _mm_sub_ps(vXsub, vX);
  59
  60     // Result:
  61     // B[0] = x1 - x0
  62     // B[1] = x2 - x1
  63     // B[2] = x0 - x2
  64 }
  65
  66 INLINE
  67 void triangleSetupABInt(const __m128i vX, const __m128i vY, __m128i & vA, __m128i & vB)
  68 {
  69     // generate edge equations
  70     // A = y0 - y1
  71     // B = x1 - x0
  72     // C = x0y1 - x1y0
  73     __m128i vYsub = _mm_shuffle_epi32(vY, _MM_SHUFFLE(3, 0, 2, 1));
  74     vA = _mm_sub_epi32(vY, vYsub);
  75
  76     __m128i vXsub = _mm_shuffle_epi32(vX, _MM_SHUFFLE(3, 0, 2, 1));
  77     vB = _mm_sub_epi32(vXsub, vX);
  78 }
  79
  80 INLINE
  81 void triangleSetupABIntVertical(const simdscalari vX[3], const simdscalari vY[3], simdscalari (&vA)[3], simdscalari (&vB)[3])
  82 {
  83     // A = y0 - y1
  84     // B = x1 - x0
  85     vA[0] = _simd_sub_epi32(vY[0], vY[1]);
  86     vA[1] = _simd_sub_epi32(vY[1], vY[2]);
  87     vA[2] = _simd_sub_epi32(vY[2], vY[0]);
  88
  89     vB[0] = _simd_sub_epi32(vX[1], vX[0]);
  90     vB[1] = _simd_sub_epi32(vX[2], vX[1]);
  91     vB[2] = _simd_sub_epi32(vX[0], vX[2]);
  92 }
  93
  94 #if ENABLE_AVX512_SIMD16
  95 INLINE
  96 void triangleSetupABIntVertical(const simd16scalari vX[3], const simd16scalari vY[3], simd16scalari(&vA)[3], simd16scalari(&vB)[3])
  97 {
  98     // A = y0 - y1
  99     // B = x1 - x0
 100     vA[0] = _simd16_sub_epi32(vY[0], vY[1]);
 101     vA[1] = _simd16_sub_epi32(vY[1], vY[2]);
 102     vA[2] = _simd16_sub_epi32(vY[2], vY[0]);
 103
 104     vB[0] = _simd16_sub_epi32(vX[1], vX[0]);
 105     vB[1] = _simd16_sub_epi32(vX[2], vX[1]);
 106     vB[2] = _simd16_sub_epi32(vX[0], vX[2]);
 107 }
 108
 109 #endif
 110 // Calculate the determinant of the triangle
 111 // 2 vectors between the 3 points: P, Q
 112 // Px = x0-x2, Py = y0-y2
 113 // Qx = x1-x2, Qy = y1-y2
 114 //       |Px Qx|
 115 // det = |     | = PxQy - PyQx
 116 //       |Py Qy|
 117 // simplifies to : (x0-x2)*(y1-y2) - (y0-y2)*(x1-x2)
 118 //               try to reuse our A & B coef's already calculated. factor out a -1 from Py and Qx
 119 //               : B[2]*A[1] - (-(y2-y0))*(-(x2-x1))
 120 //               : B[2]*A[1] - (-1)(-1)(y2-y0)*(x2-x1)
 121 //               : B[2]*A[1] - A[2]*B[1]
 122 INLINE
 123 float calcDeterminantInt(const __m128i vA, const __m128i vB)
 124 {
 125     // vAShuf = [A1, A0, A2, A0]
 126     __m128i vAShuf = _mm_shuffle_epi32(vA, _MM_SHUFFLE(0, 2, 0, 1));
 127     // vBShuf = [B2, B0, B1, B0]
 128     __m128i vBShuf = _mm_shuffle_epi32(vB, _MM_SHUFFLE(0, 1, 0, 2));
 129     // vMul = [A1*B2, B1*A2]
 130     __m128i vMul   = _mm_mul_epi32(vAShuf, vBShuf);
 131
 132     // shuffle upper to lower
 133     // vMul2 = [B1*A2, B1*A2]
 134     __m128i vMul2 = _mm_shuffle_epi32(vMul, _MM_SHUFFLE(3, 2, 3, 2));
 135     //vMul = [A1*B2 - B1*A2]
 136     vMul = _mm_sub_epi64(vMul, vMul2);
 137
 138     int64_t result;
 139     _mm_store_sd((double*)&result, _mm_castsi128_pd(vMul));
 140
 141     double dResult = (double)result;
 142     dResult = dResult * (1.0 / FIXED_POINT16_SCALE);
 143
 144     return (float)dResult;
 145 }
 146
 147 INLINE
 148 void calcDeterminantIntVertical(const simdscalari vA[3], const simdscalari vB[3], simdscalari *pvDet)
 149 {
 150     // refer to calcDeterminantInt comment for calculation explanation
 151
 152     // A1*B2
 153     simdscalari vA1Lo = _simd_unpacklo_epi32(vA[1], vA[1]);     // 0 0 1 1 4 4 5 5
 154     simdscalari vA1Hi = _simd_unpackhi_epi32(vA[1], vA[1]);     // 2 2 3 3 6 6 7 7
 155
 156     simdscalari vB2Lo = _simd_unpacklo_epi32(vB[2], vB[2]);
 157     simdscalari vB2Hi = _simd_unpackhi_epi32(vB[2], vB[2]);
 158
 159     simdscalari vA1B2Lo = _simd_mul_epi32(vA1Lo, vB2Lo);        // 0 1 4 5
 160     simdscalari vA1B2Hi = _simd_mul_epi32(vA1Hi, vB2Hi);        // 2 3 6 7
 161
 162     // B1*A2
 163     simdscalari vA2Lo = _simd_unpacklo_epi32(vA[2], vA[2]);
 164     simdscalari vA2Hi = _simd_unpackhi_epi32(vA[2], vA[2]);
 165
 166     simdscalari vB1Lo = _simd_unpacklo_epi32(vB[1], vB[1]);
 167     simdscalari vB1Hi = _simd_unpackhi_epi32(vB[1], vB[1]);
 168
 169     simdscalari vA2B1Lo = _simd_mul_epi32(vA2Lo, vB1Lo);
 170     simdscalari vA2B1Hi = _simd_mul_epi32(vA2Hi, vB1Hi);
 171
 172     // A1*B2 - A2*B1
 173     simdscalari detLo = _simd_sub_epi64(vA1B2Lo, vA2B1Lo);
 174     simdscalari detHi = _simd_sub_epi64(vA1B2Hi, vA2B1Hi);
 175
 176     // shuffle 0 1 4 5 2 3 6 7 -> 0 1 2 3
 177     simdscalari vResultLo = _simd_permute2f128_si(detLo, detHi, 0x20);
 178
 179     // shuffle 0 1 4 5 2 3 6 7 -> 4 5 6 7
 180     simdscalari vResultHi = _simd_permute2f128_si(detLo, detHi, 0x31);
 181
 182     pvDet[0] = vResultLo;
 183     pvDet[1] = vResultHi;
 184 }
 185
 186 #if ENABLE_AVX512_SIMD16
 187 INLINE
 188 void calcDeterminantIntVertical(const simd16scalari vA[3], const simd16scalari vB[3], simd16scalari *pvDet)
 189 {
 190     // refer to calcDeterminantInt comment for calculation explanation
 191
 192     // A1*B2
 193     simd16scalari vA1_lo = _simd16_unpacklo_epi32(vA[1], vA[1]);                // X 0 X 1 X 4 X 5 X 8 X 9 X C X D (32b)
 194     simd16scalari vA1_hi = _simd16_unpackhi_epi32(vA[1], vA[1]);                // X 2 X 3 X 6 X 7 X A X B X E X F
 195
 196     simd16scalari vB2_lo = _simd16_unpacklo_epi32(vB[2], vB[2]);
 197     simd16scalari vB2_hi = _simd16_unpackhi_epi32(vB[2], vB[2]);
 198
 199     simd16scalari vA1B2_lo = _simd16_mul_epi32(vA1_lo, vB2_lo);                 // 0 1 4 5 8 9 C D (64b)
 200     simd16scalari vA1B2_hi = _simd16_mul_epi32(vA1_hi, vB2_hi);                 // 2 3 6 7 A B E F
 201
 202     // B1*A2
 203     simd16scalari vA2_lo = _simd16_unpacklo_epi32(vA[2], vA[2]);
 204     simd16scalari vA2_hi = _simd16_unpackhi_epi32(vA[2], vA[2]);
 205
 206     simd16scalari vB1_lo = _simd16_unpacklo_epi32(vB[1], vB[1]);
 207     simd16scalari vB1_hi = _simd16_unpackhi_epi32(vB[1], vB[1]);
 208
 209     simd16scalari vA2B1_lo = _simd16_mul_epi32(vA2_lo, vB1_lo);
 210     simd16scalari vA2B1_hi = _simd16_mul_epi32(vA2_hi, vB1_hi);
 211
 212     // A1*B2 - A2*B1
 213     simd16scalari difflo = _simd16_sub_epi64(vA1B2_lo, vA2B1_lo);               // 0 1 4 5 8 9 C D (64b)
 214     simd16scalari diffhi = _simd16_sub_epi64(vA1B2_hi, vA2B1_hi);               // 2 3 6 7 A B E F
 215
 216     // (1, 0, 1, 0) = 01 00 01 00 = 0x44, (3, 2, 3, 2) = 11 10 11 10 = 0xEE
 217     simd16scalari templo = _simd16_permute2f128_si(difflo, diffhi, 0x44);       // 0 1 4 5 2 3 6 7 (64b)
 218     simd16scalari temphi = _simd16_permute2f128_si(difflo, diffhi, 0xEE);       // 8 9 C D A B E F
 219
 220     // (3, 1, 2, 0) = 11 01 10 00 = 0xD8
 221     pvDet[0] = _simd16_permute2f128_si(templo, templo, 0xD8);                   // 0 1 2 3 4 5 6 7 (64b)
 222     pvDet[1] = _simd16_permute2f128_si(temphi, temphi, 0xD8);                   // 8 9 A B C D E F
 223 }
 224
 225 #endif
 226 INLINE
 227 void triangleSetupC(const __m128 vX, const __m128 vY, const __m128 vA, const __m128 &vB, __m128 &vC)
 228 {
 229     // C = -Ax - By
 230     vC  = _mm_mul_ps(vA, vX);
 231     __m128 vCy = _mm_mul_ps(vB, vY);
 232     vC  = _mm_mul_ps(vC, _mm_set1_ps(-1.0f));
 233     vC  = _mm_sub_ps(vC, vCy);
 234 }
 235
 236 template<uint32_t NumVerts>
 237 INLINE
 238 void viewportTransform(simdvector *v, const SWR_VIEWPORT_MATRICES & vpMatrices)
 239 {
 240     simdscalar m00 = _simd_load1_ps(&vpMatrices.m00[0]);
 241     simdscalar m30 = _simd_load1_ps(&vpMatrices.m30[0]);
 242     simdscalar m11 = _simd_load1_ps(&vpMatrices.m11[0]);
 243     simdscalar m31 = _simd_load1_ps(&vpMatrices.m31[0]);
 244     simdscalar m22 = _simd_load1_ps(&vpMatrices.m22[0]);
 245     simdscalar m32 = _simd_load1_ps(&vpMatrices.m32[0]);
 246
 247     for (uint32_t i = 0; i < NumVerts; ++i)
 248     {
 249         v[i].x = _simd_fmadd_ps(v[i].x, m00, m30);
 250         v[i].y = _simd_fmadd_ps(v[i].y, m11, m31);
 251         v[i].z = _simd_fmadd_ps(v[i].z, m22, m32);
 252     }
 253 }
 254
 255 #if USE_SIMD16_FRONTEND
 256 template<uint32_t NumVerts>
 257 INLINE
 258 void viewportTransform(simd16vector *v, const SWR_VIEWPORT_MATRICES & vpMatrices)
 259 {
 260     const simd16scalar m00 = _simd16_broadcast_ss(&vpMatrices.m00[0]);
 261     const simd16scalar m30 = _simd16_broadcast_ss(&vpMatrices.m30[0]);
 262     const simd16scalar m11 = _simd16_broadcast_ss(&vpMatrices.m11[0]);
 263     const simd16scalar m31 = _simd16_broadcast_ss(&vpMatrices.m31[0]);
 264     const simd16scalar m22 = _simd16_broadcast_ss(&vpMatrices.m22[0]);
 265     const simd16scalar m32 = _simd16_broadcast_ss(&vpMatrices.m32[0]);
 266
 267     for (uint32_t i = 0; i < NumVerts; ++i)
 268     {
 269         v[i].x = _simd16_fmadd_ps(v[i].x, m00, m30);
 270         v[i].y = _simd16_fmadd_ps(v[i].y, m11, m31);
 271         v[i].z = _simd16_fmadd_ps(v[i].z, m22, m32);
 272     }
 273 }
 274
 275 #endif
 276 template<uint32_t NumVerts>
 277 INLINE
 278 void viewportTransform(simdvector *v, const SWR_VIEWPORT_MATRICES & vpMatrices, simdscalari const &vViewportIdx)
 279 {
 280     // perform a gather of each matrix element based on the viewport array indexes
 281     simdscalar m00 = _simd_i32gather_ps(&vpMatrices.m00[0], vViewportIdx, 4);
 282     simdscalar m30 = _simd_i32gather_ps(&vpMatrices.m30[0], vViewportIdx, 4);
 283     simdscalar m11 = _simd_i32gather_ps(&vpMatrices.m11[0], vViewportIdx, 4);
 284     simdscalar m31 = _simd_i32gather_ps(&vpMatrices.m31[0], vViewportIdx, 4);
 285     simdscalar m22 = _simd_i32gather_ps(&vpMatrices.m22[0], vViewportIdx, 4);
 286     simdscalar m32 = _simd_i32gather_ps(&vpMatrices.m32[0], vViewportIdx, 4);
 287
 288     for (uint32_t i = 0; i < NumVerts; ++i)
 289     {
 290         v[i].x = _simd_fmadd_ps(v[i].x, m00, m30);
 291         v[i].y = _simd_fmadd_ps(v[i].y, m11, m31);
 292         v[i].z = _simd_fmadd_ps(v[i].z, m22, m32);
 293     }
 294 }
 295
 296 #if USE_SIMD16_FRONTEND
 297 template<uint32_t NumVerts>
 298 INLINE
 299 void viewportTransform(simd16vector *v, const SWR_VIEWPORT_MATRICES & vpMatrices, simd16scalari const &vViewportIdx)
 300 {
 301     // perform a gather of each matrix element based on the viewport array indexes
 302     const simd16scalar m00 = _simd16_i32gather_ps(&vpMatrices.m00[0], vViewportIdx, 4);
 303     const simd16scalar m30 = _simd16_i32gather_ps(&vpMatrices.m30[0], vViewportIdx, 4);
 304     const simd16scalar m11 = _simd16_i32gather_ps(&vpMatrices.m11[0], vViewportIdx, 4);
 305     const simd16scalar m31 = _simd16_i32gather_ps(&vpMatrices.m31[0], vViewportIdx, 4);
 306     const simd16scalar m22 = _simd16_i32gather_ps(&vpMatrices.m22[0], vViewportIdx, 4);
 307     const simd16scalar m32 = _simd16_i32gather_ps(&vpMatrices.m32[0], vViewportIdx, 4);
 308
 309     for (uint32_t i = 0; i < NumVerts; ++i)
 310     {
 311         v[i].x = _simd16_fmadd_ps(v[i].x, m00, m30);
 312         v[i].y = _simd16_fmadd_ps(v[i].y, m11, m31);
 313         v[i].z = _simd16_fmadd_ps(v[i].z, m22, m32);
 314     }
 315 }
 316
 317 #endif
 318 INLINE
 319 void calcBoundingBoxInt(const __m128i &vX, const __m128i &vY, SWR_RECT &bbox)
 320 {
 321     // Need horizontal fp min here
 322     __m128i vX1 = _mm_shuffle_epi32(vX, _MM_SHUFFLE(3, 2, 0, 1));
 323     __m128i vX2 = _mm_shuffle_epi32(vX, _MM_SHUFFLE(3, 0, 1, 2));
 324
 325     __m128i vY1 = _mm_shuffle_epi32(vY, _MM_SHUFFLE(3, 2, 0, 1));
 326     __m128i vY2 = _mm_shuffle_epi32(vY, _MM_SHUFFLE(3, 0, 1, 2));
 327
 328
 329     __m128i vMinX = _mm_min_epi32(vX, vX1);
 330             vMinX = _mm_min_epi32(vMinX, vX2);
 331
 332     __m128i vMaxX = _mm_max_epi32(vX, vX1);
 333             vMaxX = _mm_max_epi32(vMaxX, vX2);
 334
 335     __m128i vMinY = _mm_min_epi32(vY, vY1);
 336             vMinY = _mm_min_epi32(vMinY, vY2);
 337
 338     __m128i vMaxY = _mm_max_epi32(vY, vY1);
 339             vMaxY = _mm_max_epi32(vMaxY, vY2);
 340
 341     bbox.xmin = _mm_extract_epi32(vMinX, 0);
 342     bbox.xmax = _mm_extract_epi32(vMaxX, 0);
 343     bbox.ymin = _mm_extract_epi32(vMinY, 0);
 344     bbox.ymax = _mm_extract_epi32(vMaxY, 0);
 345 }
 346
 347 INLINE
 348 bool CanUseSimplePoints(DRAW_CONTEXT *pDC)
 349 {
 350     const API_STATE& state = GetApiState(pDC);
 351
 352     return (state.rastState.sampleCount == SWR_MULTISAMPLE_1X &&
 353             state.rastState.pointSize == 1.0f &&
 354             !state.rastState.pointParam &&
 355             !state.rastState.pointSpriteEnable &&
 356             !state.backendState.clipDistanceMask);
 357 }
 358
 359 INLINE
 360 bool vHasNaN(const __m128& vec)
 361 {
 362     const __m128 result = _mm_cmpunord_ps(vec, vec);
 363     const int32_t mask = _mm_movemask_ps(result);
 364     return (mask != 0);
 365 }
 366
 367 uint32_t GetNumPrims(PRIMITIVE_TOPOLOGY mode, uint32_t numElements);
 368 uint32_t NumVertsPerPrim(PRIMITIVE_TOPOLOGY topology, bool includeAdjVerts);
 369
 370
 371 // ProcessDraw front-end function.  All combinations of parameter values are available
 372 PFN_FE_WORK_FUNC GetProcessDrawFunc(
 373     bool IsIndexed,
 374     bool IsCutIndexEnabled,
 375     bool HasTessellation,
 376     bool HasGeometryShader,
 377     bool HasStreamOut,
 378     bool HasRasterization);
 379
 380 void ProcessClear(SWR_CONTEXT *pContext, DRAW_CONTEXT *pDC, uint32_t workerId, void *pUserData);
 381 void ProcessStoreTiles(SWR_CONTEXT *pContext, DRAW_CONTEXT *pDC, uint32_t workerId, void *pUserData);
 382 void ProcessDiscardInvalidateTiles(SWR_CONTEXT *pContext, DRAW_CONTEXT *pDC, uint32_t workerId, void *pUserData);
 383 void ProcessSync(SWR_CONTEXT *pContext, DRAW_CONTEXT *pDC, uint32_t workerId, void *pUserData);
 384 void ProcessShutdown(SWR_CONTEXT *pContext, DRAW_CONTEXT *pDC, uint32_t workerId, void *pUserData);
 385
 386 PFN_PROCESS_PRIMS GetBinTrianglesFunc(bool IsConservative);
 387 #if USE_SIMD16_FRONTEND
 388 PFN_PROCESS_PRIMS_SIMD16 GetBinTrianglesFunc_simd16(bool IsConservative);
 389 #endif
 390
 391 struct PA_STATE_BASE;  // forward decl
 392 void BinPoints(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simdvector prims[3], uint32_t primMask, simdscalari const &primID, simdscalari const &viewportIdx, simdscalari const &rtIdx);
 393 void BinLines(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simdvector prims[3], uint32_t primMask, simdscalari const &primID, simdscalari const &viewportIdx, simdscalari const &rtIdx);
 394 #if USE_SIMD16_FRONTEND
 395 void SIMDCALL BinPoints_simd16(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simd16vector prims[3], uint32_t primMask, simd16scalari const &primID, simd16scalari const &viewportIdx, simd16scalari const &rtIdx);
 396 void SIMDCALL BinLines_simd16(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simd16vector prims[3], uint32_t primMask, simd16scalari const &primID, simd16scalari const &viewportIdx, simd16scalari const &rtIdx);
 397 #endif
 398