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 rasterizer.cpp 24 * 25 * @brief Implementation for the rasterizer. 26 * 27 ******************************************************************************/ 28 29 #include <vector> 30 #include <algorithm> 31 32 #include "rasterizer.h" 33 #include "backends/gen_rasterizer.hpp" 34 #include "rdtsc_core.h" 35 #include "backend.h" 36 #include "utils.h" 37 #include "frontend.h" 38 #include "tilemgr.h" 39 #include "memory/tilingtraits.h" 40 #include "rasterizer_impl.h" 41 42 PFN_WORK_FUNC gRasterizerFuncs[SWR_MULTISAMPLE_TYPE_COUNT][2][2][SWR_INPUT_COVERAGE_COUNT][STATE_VALID_TRI_EDGE_COUNT][2]; 43 44 void RasterizeLine(DRAW_CONTEXT *pDC, uint32_t workerId, uint32_t macroTile, void *pData) 45 { 46 SWR_CONTEXT *pContext = pDC->pContext; 47 const TRIANGLE_WORK_DESC &workDesc = *((TRIANGLE_WORK_DESC*)pData); 48 #if KNOB_ENABLE_TOSS_POINTS 49 if (KNOB_TOSS_BIN_TRIS) 50 { 51 return; 52 } 53 #endif 54 55 // bloat line to two tris and call the triangle rasterizer twice 56 AR_BEGIN(BERasterizeLine, pDC->drawId); 57 58 const API_STATE &state = GetApiState(pDC); 59 const SWR_RASTSTATE &rastState = state.rastState; 60 61 // macrotile dimensioning 62 uint32_t macroX, macroY; 63 MacroTileMgr::getTileIndices(macroTile, macroX, macroY); 64 int32_t macroBoxLeft = macroX * KNOB_MACROTILE_X_DIM_FIXED; 65 int32_t macroBoxRight = macroBoxLeft + KNOB_MACROTILE_X_DIM_FIXED - 1; 66 int32_t macroBoxTop = macroY * KNOB_MACROTILE_Y_DIM_FIXED; 67 int32_t macroBoxBottom = macroBoxTop + KNOB_MACROTILE_Y_DIM_FIXED - 1; 68 69 const SWR_RECT &scissorInFixedPoint = state.scissorsInFixedPoint[workDesc.triFlags.viewportIndex]; 70 71 // create a copy of the triangle buffer to write our adjusted vertices to 72 OSALIGNSIMD(float) newTriBuffer[4 * 4]; 73 TRIANGLE_WORK_DESC newWorkDesc = workDesc; 74 newWorkDesc.pTriBuffer = &newTriBuffer[0]; 75 76 // create a copy of the attrib buffer to write our adjusted attribs to 77 OSALIGNSIMD(float) newAttribBuffer[4 * 3 * SWR_VTX_NUM_SLOTS]; 78 newWorkDesc.pAttribs = &newAttribBuffer[0]; 79 80 const __m128 vBloat0 = _mm_set_ps(0.5f, -0.5f, -0.5f, 0.5f); 81 const __m128 vBloat1 = _mm_set_ps(0.5f, 0.5f, 0.5f, -0.5f); 82 83 __m128 vX, vY, vZ, vRecipW; 84 85 vX = _mm_load_ps(workDesc.pTriBuffer); 86 vY = _mm_load_ps(workDesc.pTriBuffer + 4); 87 vZ = _mm_load_ps(workDesc.pTriBuffer + 8); 88 vRecipW = _mm_load_ps(workDesc.pTriBuffer + 12); 89 90 // triangle 0 91 // v0,v1 -> v0,v0,v1 92 __m128 vXa = _mm_shuffle_ps(vX, vX, _MM_SHUFFLE(1, 1, 0, 0)); 93 __m128 vYa = _mm_shuffle_ps(vY, vY, _MM_SHUFFLE(1, 1, 0, 0)); 94 __m128 vZa = _mm_shuffle_ps(vZ, vZ, _MM_SHUFFLE(1, 1, 0, 0)); 95 __m128 vRecipWa = _mm_shuffle_ps(vRecipW, vRecipW, _MM_SHUFFLE(1, 1, 0, 0)); 96 97 __m128 vLineWidth = _mm_set1_ps(pDC->pState->state.rastState.lineWidth); 98 __m128 vAdjust = _mm_mul_ps(vLineWidth, vBloat0); 99 if (workDesc.triFlags.yMajor) 100 { 101 vXa = _mm_add_ps(vAdjust, vXa); 102 } 103 else 104 { 105 vYa = _mm_add_ps(vAdjust, vYa); 106 } 107 108 // Store triangle description for rasterizer 109 _mm_store_ps((float*)&newTriBuffer[0], vXa); 110 _mm_store_ps((float*)&newTriBuffer[4], vYa); 111 _mm_store_ps((float*)&newTriBuffer[8], vZa); 112 _mm_store_ps((float*)&newTriBuffer[12], vRecipWa); 113 114 // binner bins 3 edges for lines as v0, v1, v1 115 // tri0 needs v0, v0, v1 116 for (uint32_t a = 0; a < workDesc.numAttribs; ++a) 117 { 118 __m128 vAttrib0 = _mm_load_ps(&workDesc.pAttribs[a * 12 + 0]); 119 __m128 vAttrib1 = _mm_load_ps(&workDesc.pAttribs[a * 12 + 4]); 120 121 _mm_store_ps((float*)&newAttribBuffer[a * 12 + 0], vAttrib0); 122 _mm_store_ps((float*)&newAttribBuffer[a * 12 + 4], vAttrib0); 123 _mm_store_ps((float*)&newAttribBuffer[a * 12 + 8], vAttrib1); 124 } 125 126 // Store user clip distances for triangle 0 127 float newClipBuffer[3 * 8]; 128 uint32_t numClipDist = _mm_popcnt_u32(state.backendState.clipDistanceMask); 129 if (numClipDist) 130 { 131 newWorkDesc.pUserClipBuffer = newClipBuffer; 132 133 float* pOldBuffer = workDesc.pUserClipBuffer; 134 float* pNewBuffer = newClipBuffer; 135 for (uint32_t i = 0; i < numClipDist; ++i) 136 { 137 // read barycentric coeffs from binner 138 float a = *(pOldBuffer++); 139 float b = *(pOldBuffer++); 140 141 // reconstruct original clip distance at vertices 142 float c0 = a + b; 143 float c1 = b; 144 145 // construct triangle barycentrics 146 *(pNewBuffer++) = c0 - c1; 147 *(pNewBuffer++) = c0 - c1; 148 *(pNewBuffer++) = c1; 149 } 150 } 151 152 // setup triangle rasterizer function 153 PFN_WORK_FUNC pfnTriRast; 154 // conservative rast not supported for points/lines 155 pfnTriRast = GetRasterizerFunc(rastState.sampleCount, rastState.bIsCenterPattern, false, 156 SWR_INPUT_COVERAGE_NONE, EdgeValToEdgeState(ALL_EDGES_VALID), (pDC->pState->state.scissorsTileAligned == false)); 157 158 // make sure this macrotile intersects the triangle 159 __m128i vXai = fpToFixedPoint(vXa); 160 __m128i vYai = fpToFixedPoint(vYa); 161 OSALIGNSIMD(SWR_RECT) bboxA; 162 calcBoundingBoxInt(vXai, vYai, bboxA); 163 164 if (!(bboxA.xmin > macroBoxRight || 165 bboxA.xmin > scissorInFixedPoint.xmax || 166 bboxA.xmax - 1 < macroBoxLeft || 167 bboxA.xmax - 1 < scissorInFixedPoint.xmin || 168 bboxA.ymin > macroBoxBottom || 169 bboxA.ymin > scissorInFixedPoint.ymax || 170 bboxA.ymax - 1 < macroBoxTop || 171 bboxA.ymax - 1 < scissorInFixedPoint.ymin)) { 172 // rasterize triangle 173 pfnTriRast(pDC, workerId, macroTile, (void*)&newWorkDesc); 174 } 175 176 // triangle 1 177 // v0,v1 -> v1,v1,v0 178 vXa = _mm_shuffle_ps(vX, vX, _MM_SHUFFLE(1, 0, 1, 1)); 179 vYa = _mm_shuffle_ps(vY, vY, _MM_SHUFFLE(1, 0, 1, 1)); 180 vZa = _mm_shuffle_ps(vZ, vZ, _MM_SHUFFLE(1, 0, 1, 1)); 181 vRecipWa = _mm_shuffle_ps(vRecipW, vRecipW, _MM_SHUFFLE(1, 0, 1, 1)); 182 183 vAdjust = _mm_mul_ps(vLineWidth, vBloat1); 184 if (workDesc.triFlags.yMajor) 185 { 186 vXa = _mm_add_ps(vAdjust, vXa); 187 } 188 else 189 { 190 vYa = _mm_add_ps(vAdjust, vYa); 191 } 192 193 // Store triangle description for rasterizer 194 _mm_store_ps((float*)&newTriBuffer[0], vXa); 195 _mm_store_ps((float*)&newTriBuffer[4], vYa); 196 _mm_store_ps((float*)&newTriBuffer[8], vZa); 197 _mm_store_ps((float*)&newTriBuffer[12], vRecipWa); 198 199 // binner bins 3 edges for lines as v0, v1, v1 200 // tri1 needs v1, v1, v0 201 for (uint32_t a = 0; a < workDesc.numAttribs; ++a) 202 { 203 __m128 vAttrib0 = _mm_load_ps(&workDesc.pAttribs[a * 12 + 0]); 204 __m128 vAttrib1 = _mm_load_ps(&workDesc.pAttribs[a * 12 + 4]); 205 206 _mm_store_ps((float*)&newAttribBuffer[a * 12 + 0], vAttrib1); 207 _mm_store_ps((float*)&newAttribBuffer[a * 12 + 4], vAttrib1); 208 _mm_store_ps((float*)&newAttribBuffer[a * 12 + 8], vAttrib0); 209 } 210 211 // store user clip distance for triangle 1 212 if (numClipDist) 213 { 214 float* pOldBuffer = workDesc.pUserClipBuffer; 215 float* pNewBuffer = newClipBuffer; 216 for (uint32_t i = 0; i < numClipDist; ++i) 217 { 218 // read barycentric coeffs from binner 219 float a = *(pOldBuffer++); 220 float b = *(pOldBuffer++); 221 222 // reconstruct original clip distance at vertices 223 float c0 = a + b; 224 float c1 = b; 225 226 // construct triangle barycentrics 227 *(pNewBuffer++) = c1 - c0; 228 *(pNewBuffer++) = c1 - c0; 229 *(pNewBuffer++) = c0; 230 } 231 } 232 233 vXai = fpToFixedPoint(vXa); 234 vYai = fpToFixedPoint(vYa); 235 calcBoundingBoxInt(vXai, vYai, bboxA); 236 237 if (!(bboxA.xmin > macroBoxRight || 238 bboxA.xmin > scissorInFixedPoint.xmax || 239 bboxA.xmax - 1 < macroBoxLeft || 240 bboxA.xmax - 1 < scissorInFixedPoint.xmin || 241 bboxA.ymin > macroBoxBottom || 242 bboxA.ymin > scissorInFixedPoint.ymax || 243 bboxA.ymax - 1 < macroBoxTop || 244 bboxA.ymax - 1 < scissorInFixedPoint.ymin)) { 245 // rasterize triangle 246 pfnTriRast(pDC, workerId, macroTile, (void*)&newWorkDesc); 247 } 248 249 AR_END(BERasterizeLine, 1); 250 } 251 252 void RasterizeSimplePoint(DRAW_CONTEXT *pDC, uint32_t workerId, uint32_t macroTile, void* pData) 253 { 254 SWR_CONTEXT *pContext = pDC->pContext; 255 256 #if KNOB_ENABLE_TOSS_POINTS 257 if (KNOB_TOSS_BIN_TRIS) 258 { 259 return; 260 } 261 #endif 262 263 const TRIANGLE_WORK_DESC& workDesc = *(const TRIANGLE_WORK_DESC*)pData; 264 const BACKEND_FUNCS& backendFuncs = pDC->pState->backendFuncs; 265 266 // map x,y relative offsets from start of raster tile to bit position in 267 // coverage mask for the point 268 static const uint32_t coverageMap[8][8] = { 269 { 0, 1, 4, 5, 8, 9, 12, 13 }, 270 { 2, 3, 6, 7, 10, 11, 14, 15 }, 271 { 16, 17, 20, 21, 24, 25, 28, 29 }, 272 { 18, 19, 22, 23, 26, 27, 30, 31 }, 273 { 32, 33, 36, 37, 40, 41, 44, 45 }, 274 { 34, 35, 38, 39, 42, 43, 46, 47 }, 275 { 48, 49, 52, 53, 56, 57, 60, 61 }, 276 { 50, 51, 54, 55, 58, 59, 62, 63 } 277 }; 278 279 OSALIGNSIMD(SWR_TRIANGLE_DESC) triDesc; 280 281 // pull point information from triangle buffer 282 // @todo use structs for readability 283 uint32_t tileAlignedX = *(uint32_t*)workDesc.pTriBuffer; 284 uint32_t tileAlignedY = *(uint32_t*)(workDesc.pTriBuffer + 1); 285 float z = *(workDesc.pTriBuffer + 2); 286 287 // construct triangle descriptor for point 288 // no interpolation, set up i,j for constant interpolation of z and attribs 289 // @todo implement an optimized backend that doesn't require triangle information 290 291 // compute coverage mask from x,y packed into the coverageMask flag 292 // mask indices by the maximum valid index for x/y of coveragemap. 293 uint32_t tX = workDesc.triFlags.coverageMask & 0x7; 294 uint32_t tY = (workDesc.triFlags.coverageMask >> 4) & 0x7; 295 // todo: multisample points? 296 triDesc.coverageMask[0] = 1ULL << coverageMap[tY][tX]; 297 298 // no persp divide needed for points 299 triDesc.pAttribs = triDesc.pPerspAttribs = workDesc.pAttribs; 300 triDesc.triFlags = workDesc.triFlags; 301 triDesc.recipDet = 1.0f; 302 triDesc.OneOverW[0] = triDesc.OneOverW[1] = triDesc.OneOverW[2] = 1.0f; 303 triDesc.I[0] = triDesc.I[1] = triDesc.I[2] = 0.0f; 304 triDesc.J[0] = triDesc.J[1] = triDesc.J[2] = 0.0f; 305 triDesc.Z[0] = triDesc.Z[1] = triDesc.Z[2] = z; 306 307 RenderOutputBuffers renderBuffers; 308 GetRenderHotTiles(pDC, macroTile, tileAlignedX >> KNOB_TILE_X_DIM_SHIFT , tileAlignedY >> KNOB_TILE_Y_DIM_SHIFT, 309 renderBuffers, triDesc.triFlags.renderTargetArrayIndex); 310 311 AR_BEGIN(BEPixelBackend, pDC->drawId); 312 backendFuncs.pfnBackend(pDC, workerId, tileAlignedX, tileAlignedY, triDesc, renderBuffers); 313 AR_END(BEPixelBackend, 0); 314 } 315 316 void RasterizeTriPoint(DRAW_CONTEXT *pDC, uint32_t workerId, uint32_t macroTile, void* pData) 317 { 318 const TRIANGLE_WORK_DESC& workDesc = *(const TRIANGLE_WORK_DESC*)pData; 319 const SWR_RASTSTATE& rastState = pDC->pState->state.rastState; 320 const SWR_BACKEND_STATE& backendState = pDC->pState->state.backendState; 321 322 bool isPointSpriteTexCoordEnabled = backendState.pointSpriteTexCoordMask != 0; 323 324 // load point vertex 325 float x = *workDesc.pTriBuffer; 326 float y = *(workDesc.pTriBuffer + 1); 327 float z = *(workDesc.pTriBuffer + 2); 328 329 // create a copy of the triangle buffer to write our adjusted vertices to 330 OSALIGNSIMD(float) newTriBuffer[4 * 4]; 331 TRIANGLE_WORK_DESC newWorkDesc = workDesc; 332 newWorkDesc.pTriBuffer = &newTriBuffer[0]; 333 334 // create a copy of the attrib buffer to write our adjusted attribs to 335 OSALIGNSIMD(float) newAttribBuffer[4 * 3 * SWR_VTX_NUM_SLOTS]; 336 newWorkDesc.pAttribs = &newAttribBuffer[0]; 337 338 newWorkDesc.pUserClipBuffer = workDesc.pUserClipBuffer; 339 newWorkDesc.numAttribs = workDesc.numAttribs; 340 newWorkDesc.triFlags = workDesc.triFlags; 341 342 // construct two tris by bloating point by point size 343 float halfPointSize = workDesc.triFlags.pointSize * 0.5f; 344 float lowerX = x - halfPointSize; 345 float upperX = x + halfPointSize; 346 float lowerY = y - halfPointSize; 347 float upperY = y + halfPointSize; 348 349 // tri 0 350 float *pBuf = &newTriBuffer[0]; 351 *pBuf++ = lowerX; 352 *pBuf++ = lowerX; 353 *pBuf++ = upperX; 354 pBuf++; 355 *pBuf++ = lowerY; 356 *pBuf++ = upperY; 357 *pBuf++ = upperY; 358 pBuf++; 359 _mm_store_ps(pBuf, _mm_set1_ps(z)); 360 _mm_store_ps(pBuf += 4, _mm_set1_ps(1.0f)); 361 362 // setup triangle rasterizer function 363 PFN_WORK_FUNC pfnTriRast; 364 // conservative rast not supported for points/lines 365 pfnTriRast = GetRasterizerFunc(rastState.sampleCount, rastState.bIsCenterPattern, false, 366 SWR_INPUT_COVERAGE_NONE, EdgeValToEdgeState(ALL_EDGES_VALID), (pDC->pState->state.scissorsTileAligned == false)); 367 368 // overwrite texcoords for point sprites 369 if (isPointSpriteTexCoordEnabled) 370 { 371 // copy original attribs 372 memcpy(&newAttribBuffer[0], workDesc.pAttribs, 4 * 3 * workDesc.numAttribs * sizeof(float)); 373 newWorkDesc.pAttribs = &newAttribBuffer[0]; 374 375 // overwrite texcoord for point sprites 376 uint32_t texCoordMask = backendState.pointSpriteTexCoordMask; 377 DWORD texCoordAttrib = 0; 378 379 while (_BitScanForward(&texCoordAttrib, texCoordMask)) 380 { 381 texCoordMask &= ~(1 << texCoordAttrib); 382 __m128* pTexAttrib = (__m128*)&newAttribBuffer[0] + 3 * texCoordAttrib; 383 if (rastState.pointSpriteTopOrigin) 384 { 385 pTexAttrib[0] = _mm_set_ps(1, 0, 0, 0); 386 pTexAttrib[1] = _mm_set_ps(1, 0, 1, 0); 387 pTexAttrib[2] = _mm_set_ps(1, 0, 1, 1); 388 } 389 else 390 { 391 pTexAttrib[0] = _mm_set_ps(1, 0, 1, 0); 392 pTexAttrib[1] = _mm_set_ps(1, 0, 0, 0); 393 pTexAttrib[2] = _mm_set_ps(1, 0, 0, 1); 394 } 395 } 396 } 397 else 398 { 399 // no texcoord overwrite, can reuse the attrib buffer from frontend 400 newWorkDesc.pAttribs = workDesc.pAttribs; 401 } 402 403 pfnTriRast(pDC, workerId, macroTile, (void*)&newWorkDesc); 404 405 // tri 1 406 pBuf = &newTriBuffer[0]; 407 *pBuf++ = lowerX; 408 *pBuf++ = upperX; 409 *pBuf++ = upperX; 410 pBuf++; 411 *pBuf++ = lowerY; 412 *pBuf++ = upperY; 413 *pBuf++ = lowerY; 414 // z, w unchanged 415 416 if (isPointSpriteTexCoordEnabled) 417 { 418 uint32_t texCoordMask = backendState.pointSpriteTexCoordMask; 419 DWORD texCoordAttrib = 0; 420 421 while (_BitScanForward(&texCoordAttrib, texCoordMask)) 422 { 423 texCoordMask &= ~(1 << texCoordAttrib); 424 __m128* pTexAttrib = (__m128*)&newAttribBuffer[0] + 3 * texCoordAttrib; 425 if (rastState.pointSpriteTopOrigin) 426 { 427 pTexAttrib[0] = _mm_set_ps(1, 0, 0, 0); 428 pTexAttrib[1] = _mm_set_ps(1, 0, 1, 1); 429 pTexAttrib[2] = _mm_set_ps(1, 0, 0, 1); 430 431 } 432 else 433 { 434 pTexAttrib[0] = _mm_set_ps(1, 0, 1, 0); 435 pTexAttrib[1] = _mm_set_ps(1, 0, 0, 1); 436 pTexAttrib[2] = _mm_set_ps(1, 0, 1, 1); 437 } 438 } 439 } 440 441 pfnTriRast(pDC, workerId, macroTile, (void*)&newWorkDesc); 442 } 443 444 void InitRasterizerFunctions() 445 { 446 InitRasterizerFuncs(); 447 } 448 449 // Selector for correct templated RasterizeTriangle function 450 PFN_WORK_FUNC GetRasterizerFunc( 451 SWR_MULTISAMPLE_COUNT numSamples, 452 bool IsCenter, 453 bool IsConservative, 454 SWR_INPUT_COVERAGE InputCoverage, 455 uint32_t EdgeEnable, 456 bool RasterizeScissorEdges 457 ) 458 { 459 SWR_ASSERT(numSamples >= 0 && numSamples < SWR_MULTISAMPLE_TYPE_COUNT); 460 SWR_ASSERT(InputCoverage >= 0 && InputCoverage < SWR_INPUT_COVERAGE_COUNT); 461 SWR_ASSERT(EdgeEnable < STATE_VALID_TRI_EDGE_COUNT); 462 463 PFN_WORK_FUNC func = gRasterizerFuncs[numSamples][IsCenter][IsConservative][InputCoverage][EdgeEnable][RasterizeScissorEdges]; 464 SWR_ASSERT(func); 465 466 return func; 467 } 468
