/****************************************************************************
-* Copyright (C) 2014-2015 Intel Corporation. All Rights Reserved.
+* Copyright (C) 2014-2016 Intel Corporation. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
#include <cfloat>
#include <cmath>
#include <cstdio>
+#include <new>
#include "core/api.h"
#include "core/backend.h"
#include "core/context.h"
+#include "core/depthstencil.h"
#include "core/frontend.h"
#include "core/rasterizer.h"
#include "core/rdtsc_core.h"
#include "core/threads.h"
#include "core/tilemgr.h"
#include "core/clip.h"
+#include "core/utils.h"
#include "common/simdintrin.h"
#include "common/os.h"
+#include "archrast/archrast.h"
+
+static const SWR_RECT g_MaxScissorRect = { 0, 0, KNOB_MAX_SCISSOR_X, KNOB_MAX_SCISSOR_Y };
+
void SetupDefaultState(SWR_CONTEXT *pContext);
+static INLINE SWR_CONTEXT* GetContext(HANDLE hContext)
+{
+ return (SWR_CONTEXT*)hContext;
+}
+
//////////////////////////////////////////////////////////////////////////
/// @brief Create SWR Context.
/// @param pCreateInfo - pointer to creation info.
RDTSC_RESET();
RDTSC_INIT(0);
- void* pContextMem = _aligned_malloc(sizeof(SWR_CONTEXT), KNOB_SIMD_WIDTH * 4);
+ void* pContextMem = AlignedMalloc(sizeof(SWR_CONTEXT), KNOB_SIMD_WIDTH * 4);
memset(pContextMem, 0, sizeof(SWR_CONTEXT));
SWR_CONTEXT *pContext = new (pContextMem) SWR_CONTEXT();
pContext->dcRing.Init(KNOB_MAX_DRAWS_IN_FLIGHT);
pContext->dsRing.Init(KNOB_MAX_DRAWS_IN_FLIGHT);
+ pContext->pMacroTileManagerArray = (MacroTileMgr*)AlignedMalloc(sizeof(MacroTileMgr) * KNOB_MAX_DRAWS_IN_FLIGHT, 64);
+ pContext->pDispatchQueueArray = (DispatchQueue*)AlignedMalloc(sizeof(DispatchQueue) * KNOB_MAX_DRAWS_IN_FLIGHT, 64);
+
for (uint32_t dc = 0; dc < KNOB_MAX_DRAWS_IN_FLIGHT; ++dc)
{
- pContext->dcRing[dc].pArena = new Arena();
- pContext->dcRing[dc].pTileMgr = new MacroTileMgr(*(pContext->dcRing[dc].pArena));
- pContext->dcRing[dc].pDispatch = new DispatchQueue(); /// @todo Could lazily allocate this if Dispatch seen.
+ pContext->dcRing[dc].pArena = new CachingArena(pContext->cachingArenaAllocator);
+ new (&pContext->pMacroTileManagerArray[dc]) MacroTileMgr(*pContext->dcRing[dc].pArena);
+ new (&pContext->pDispatchQueueArray[dc]) DispatchQueue();
- pContext->dsRing[dc].pArena = new Arena();
+ pContext->dsRing[dc].pArena = new CachingArena(pContext->cachingArenaAllocator);
}
- if (!KNOB_SINGLE_THREADED)
- {
- memset(&pContext->WaitLock, 0, sizeof(pContext->WaitLock));
- memset(&pContext->FifosNotEmpty, 0, sizeof(pContext->FifosNotEmpty));
- new (&pContext->WaitLock) std::mutex();
- new (&pContext->FifosNotEmpty) std::condition_variable();
-
- CreateThreadPool(pContext, &pContext->threadPool);
- }
+ pContext->threadInfo.MAX_WORKER_THREADS = KNOB_MAX_WORKER_THREADS;
+ pContext->threadInfo.MAX_NUMA_NODES = KNOB_MAX_NUMA_NODES;
+ pContext->threadInfo.MAX_CORES_PER_NUMA_NODE = KNOB_MAX_CORES_PER_NUMA_NODE;
+ pContext->threadInfo.MAX_THREADS_PER_CORE = KNOB_MAX_THREADS_PER_CORE;
+ pContext->threadInfo.SINGLE_THREADED = KNOB_SINGLE_THREADED;
- // Calling createThreadPool() above can set SINGLE_THREADED
- if (KNOB_SINGLE_THREADED)
+ if (pCreateInfo->pThreadInfo)
{
- pContext->NumWorkerThreads = 1;
+ pContext->threadInfo = *pCreateInfo->pThreadInfo;
}
+ memset(&pContext->WaitLock, 0, sizeof(pContext->WaitLock));
+ memset(&pContext->FifosNotEmpty, 0, sizeof(pContext->FifosNotEmpty));
+ new (&pContext->WaitLock) std::mutex();
+ new (&pContext->FifosNotEmpty) std::condition_variable();
+
+ CreateThreadPool(pContext, &pContext->threadPool);
+
+ pContext->ppScratch = new uint8_t*[pContext->NumWorkerThreads];
+ pContext->pStats = new SWR_STATS[pContext->NumWorkerThreads];
+
+ // Setup ArchRast thread contexts which includes +1 for API thread.
+ pContext->pArContext = new HANDLE[pContext->NumWorkerThreads+1];
+ pContext->pArContext[pContext->NumWorkerThreads] = ArchRast::CreateThreadContext();
+
// Allocate scratch space for workers.
///@note We could lazily allocate this but its rather small amount of memory.
for (uint32_t i = 0; i < pContext->NumWorkerThreads; ++i)
{
- ///@todo Use numa API for allocations using numa information from thread data (if exists).
- pContext->pScratch[i] = (uint8_t*)_aligned_malloc((32 * 1024), KNOB_SIMD_WIDTH * 4);
+#if defined(_WIN32)
+ uint32_t numaNode = pContext->threadPool.pThreadData ?
+ pContext->threadPool.pThreadData[i].numaId : 0;
+ pContext->ppScratch[i] = (uint8_t*)VirtualAllocExNuma(
+ GetCurrentProcess(), nullptr, 32 * sizeof(KILOBYTE),
+ MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE,
+ numaNode);
+#else
+ pContext->ppScratch[i] = (uint8_t*)AlignedMalloc(32 * sizeof(KILOBYTE), KNOB_SIMD_WIDTH * 4);
+#endif
+
+ // Initialize worker thread context for ArchRast.
+ pContext->pArContext[i] = ArchRast::CreateThreadContext();
}
// State setup AFTER context is fully initialized
// initialize function pointer tables
InitClearTilesTable();
- // initialize store tiles function
+ // initialize callback functions
pContext->pfnLoadTile = pCreateInfo->pfnLoadTile;
pContext->pfnStoreTile = pCreateInfo->pfnStoreTile;
pContext->pfnClearTile = pCreateInfo->pfnClearTile;
+ pContext->pfnUpdateSoWriteOffset = pCreateInfo->pfnUpdateSoWriteOffset;
+ pContext->pfnUpdateStats = pCreateInfo->pfnUpdateStats;
+ pContext->pfnUpdateStatsFE = pCreateInfo->pfnUpdateStatsFE;
// pass pointer to bucket manager back to caller
#ifdef KNOB_ENABLE_RDTSC
void SwrDestroyContext(HANDLE hContext)
{
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ SWR_CONTEXT *pContext = GetContext(hContext);
DestroyThreadPool(pContext, &pContext->threadPool);
// free the fifos
for (uint32_t i = 0; i < KNOB_MAX_DRAWS_IN_FLIGHT; ++i)
{
+ delete [] pContext->dcRing[i].dynState.pStats;
delete pContext->dcRing[i].pArena;
delete pContext->dsRing[i].pArena;
- delete(pContext->dcRing[i].pTileMgr);
- delete(pContext->dcRing[i].pDispatch);
+ pContext->pMacroTileManagerArray[i].~MacroTileMgr();
+ pContext->pDispatchQueueArray[i].~DispatchQueue();
}
+ AlignedFree(pContext->pDispatchQueueArray);
+ AlignedFree(pContext->pMacroTileManagerArray);
+
// Free scratch space.
for (uint32_t i = 0; i < pContext->NumWorkerThreads; ++i)
{
- _aligned_free(pContext->pScratch[i]);
+#if defined(_WIN32)
+ VirtualFree(pContext->ppScratch[i], 0, MEM_RELEASE);
+#else
+ AlignedFree(pContext->ppScratch[i]);
+#endif
+
+ ArchRast::DestroyThreadContext(pContext->pArContext[i]);
}
+ delete [] pContext->ppScratch;
+ delete [] pContext->pArContext;
+ delete [] pContext->pStats;
+
delete(pContext->pHotTileMgr);
pContext->~SWR_CONTEXT();
- _aligned_free((SWR_CONTEXT*)hContext);
+ AlignedFree(GetContext(hContext));
}
void CopyState(DRAW_STATE& dst, const DRAW_STATE& src)
template<bool IsDraw>
void QueueWork(SWR_CONTEXT *pContext)
{
+ DRAW_CONTEXT* pDC = pContext->pCurDrawContext;
+ uint32_t dcIndex = pDC->drawId % KNOB_MAX_DRAWS_IN_FLIGHT;
+
if (IsDraw)
{
- // Each worker thread looks at a DC for both FE and BE work at different times and so we
- // multiply threadDone by 2. When the threadDone counter has reached 0 then all workers
- // have moved past this DC. (i.e. Each worker has checked this DC for both FE and BE work and
- // then moved on if all work is done.)
- pContext->pCurDrawContext->threadsDone =
- pContext->NumWorkerThreads ? pContext->NumWorkerThreads * 2 : 2;
+ pDC->pTileMgr = &pContext->pMacroTileManagerArray[dcIndex];
+ pDC->pTileMgr->initialize();
}
- else
+
+ // Each worker thread looks at a DC for both FE and BE work at different times and so we
+ // multiply threadDone by 2. When the threadDone counter has reached 0 then all workers
+ // have moved past this DC. (i.e. Each worker has checked this DC for both FE and BE work and
+ // then moved on if all work is done.)
+ pContext->pCurDrawContext->threadsDone = pContext->NumFEThreads + pContext->NumBEThreads;
+
+ if (IsDraw)
{
- pContext->pCurDrawContext->threadsDone =
- pContext->NumWorkerThreads ? pContext->NumWorkerThreads : 1;
+ InterlockedIncrement((volatile LONG*)&pContext->drawsOutstandingFE);
}
_ReadWriteBarrier();
pContext->dcRing.Enqueue();
}
- if (KNOB_SINGLE_THREADED)
+ if (pContext->threadInfo.SINGLE_THREADED)
{
// flush denormals to 0
uint32_t mxcsr = _mm_getcsr();
if (IsDraw)
{
- std::unordered_set<uint32_t> lockedTiles;
- uint64_t curDraw[2] = { pContext->pCurDrawContext->drawId, pContext->pCurDrawContext->drawId };
- WorkOnFifoFE(pContext, 0, curDraw[0], 0);
- WorkOnFifoBE(pContext, 0, curDraw[1], lockedTiles);
+ uint32_t curDraw[2] = { pContext->pCurDrawContext->drawId, pContext->pCurDrawContext->drawId };
+ WorkOnFifoFE(pContext, 0, curDraw[0]);
+ WorkOnFifoBE(pContext, 0, curDraw[1], pContext->singleThreadLockedTiles, 0, 0);
}
else
{
- uint64_t curDispatch = pContext->pCurDrawContext->drawId;
+ uint32_t curDispatch = pContext->pCurDrawContext->drawId;
WorkOnCompute(pContext, 0, curDispatch);
}
// Dequeue the work here, if not already done, since we're single threaded (i.e. no workers).
- if (!pContext->dcRing.IsEmpty())
- {
- pContext->dcRing.Dequeue();
- }
+ while (CompleteDrawContext(pContext, pContext->pCurDrawContext) > 0) {}
// restore csr
_mm_setcsr(mxcsr);
_mm_pause();
}
- uint32_t dcIndex = pContext->dcRing.GetHead() % KNOB_MAX_DRAWS_IN_FLIGHT;
+ uint64_t curDraw = pContext->dcRing.GetHead();
+ uint32_t dcIndex = curDraw % KNOB_MAX_DRAWS_IN_FLIGHT;
+
+ if ((pContext->frameCount - pContext->lastFrameChecked) > 2 ||
+ (curDraw - pContext->lastDrawChecked) > 0x10000)
+ {
+ // Take this opportunity to clean-up old arena allocations
+ pContext->cachingArenaAllocator.FreeOldBlocks();
+
+ pContext->lastFrameChecked = pContext->frameCount;
+ pContext->lastDrawChecked = curDraw;
+ }
DRAW_CONTEXT* pCurDrawContext = &pContext->dcRing[dcIndex];
pContext->pCurDrawContext = pCurDrawContext;
uint32_t dsIndex = pContext->curStateId % KNOB_MAX_DRAWS_IN_FLIGHT;
pCurDrawContext->pState = &pContext->dsRing[dsIndex];
- Arena& stateArena = *(pCurDrawContext->pState->pArena);
-
// Copy previous state to current state.
if (pContext->pPrevDrawContext)
{
{
CopyState(*pCurDrawContext->pState, *pPrevDrawContext->pState);
- stateArena.Reset(true); // Reset memory.
+ // Should have been cleaned up previously
+ SWR_ASSERT(pCurDrawContext->pState->pArena->IsEmpty() == true);
+
pCurDrawContext->pState->pPrivateState = nullptr;
pContext->curStateId++; // Progress state ring index forward.
// If its a split draw then just copy the state pointer over
// since its the same draw.
pCurDrawContext->pState = pPrevDrawContext->pState;
+ SWR_ASSERT(pPrevDrawContext->cleanupState == false);
}
}
else
{
- stateArena.Reset(); // Reset memory.
+ SWR_ASSERT(pCurDrawContext->pState->pArena->IsEmpty() == true);
pContext->curStateId++; // Progress state ring index forward.
}
- pCurDrawContext->dependency = 0;
- pCurDrawContext->pArena->Reset();
+ SWR_ASSERT(pCurDrawContext->pArena->IsEmpty() == true);
+
+ pCurDrawContext->dependent = false;
pCurDrawContext->pContext = pContext;
pCurDrawContext->isCompute = false; // Dispatch has to set this to true.
pCurDrawContext->doneFE = false;
pCurDrawContext->FeLock = 0;
pCurDrawContext->threadsDone = 0;
+ pCurDrawContext->retireCallback.pfnCallbackFunc = nullptr;
- pCurDrawContext->pTileMgr->initialize();
+ pCurDrawContext->dynState.Reset(pContext->NumWorkerThreads);
// Assign unique drawId for this DC
pCurDrawContext->drawId = pContext->dcRing.GetHead();
+
+ pCurDrawContext->cleanupState = true;
}
else
{
void* pOutputStateBlock,
size_t memSize)
{
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ SWR_CONTEXT *pContext = GetContext(hContext);
auto pSrc = GetDrawState(pContext);
SWR_ASSERT(pOutputStateBlock && memSize >= sizeof(*pSrc));
const void* pStateBlock,
size_t memSize)
{
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ SWR_CONTEXT *pContext = GetContext(hContext);
auto pDst = GetDrawState(pContext);
SWR_ASSERT(pStateBlock && memSize >= sizeof(*pDst));
pState->rastState.frontWinding = SWR_FRONTWINDING_CCW;
}
-static INLINE SWR_CONTEXT* GetContext(HANDLE hContext)
-{
- return (SWR_CONTEXT*)hContext;
-}
-
void SwrSync(HANDLE hContext, PFN_CALLBACK_FUNC pfnFunc, uint64_t userData, uint64_t userData2, uint64_t userData3)
{
RDTSC_START(APISync);
pDC->FeWork.type = SYNC;
pDC->FeWork.pfnWork = ProcessSync;
- pDC->FeWork.desc.sync.pfnCallbackFunc = pfnFunc;
- pDC->FeWork.desc.sync.userData = userData;
- pDC->FeWork.desc.sync.userData2 = userData2;
- pDC->FeWork.desc.sync.userData3 = userData3;
- // cannot execute until all previous draws have completed
- pDC->dependency = pDC->drawId - 1;
+ // Setup callback function
+ pDC->retireCallback.pfnCallbackFunc = pfnFunc;
+ pDC->retireCallback.userData = userData;
+ pDC->retireCallback.userData2 = userData2;
+ pDC->retireCallback.userData3 = userData3;
//enqueue
QueueDraw(pContext);
RDTSC_STOP(APIWaitForIdle, 1, 0);
}
+void SwrWaitForIdleFE(HANDLE hContext)
+{
+ SWR_CONTEXT *pContext = GetContext(hContext);
+
+ RDTSC_START(APIWaitForIdle);
+
+ while (pContext->drawsOutstandingFE > 0)
+ {
+ _mm_pause();
+ }
+
+ RDTSC_STOP(APIWaitForIdle, 1, 0);
+}
+
void SwrSetVertexBuffers(
HANDLE hContext,
uint32_t numBuffers,
void SwrSetCsFunc(
HANDLE hContext,
PFN_CS_FUNC pfnCsFunc,
- uint32_t totalThreadsInGroup)
+ uint32_t totalThreadsInGroup,
+ uint32_t totalSpillFillSize)
{
API_STATE* pState = GetDrawState(GetContext(hContext));
pState->pfnCsFunc = pfnCsFunc;
pState->totalThreadsInGroup = totalThreadsInGroup;
+ pState->totalSpillFillSize = totalSpillFillSize;
}
void SwrSetTsState(
pState->pfnBlendFunc[renderTarget] = pfnBlendFunc;
}
-void SwrSetLinkage(
- HANDLE hContext,
- uint32_t mask,
- const uint8_t* pMap)
+// update guardband multipliers for the viewport
+void updateGuardbands(API_STATE *pState)
{
- API_STATE* pState = GetDrawState(GetContext(hContext));
+ uint32_t numGbs = pState->gsState.emitsRenderTargetArrayIndex ? KNOB_NUM_VIEWPORTS_SCISSORS : 1;
- static const uint8_t IDENTITY_MAP[] =
+ for(uint32_t i = 0; i < numGbs; ++i)
{
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
- };
- static_assert(sizeof(IDENTITY_MAP) == sizeof(pState->linkageMap),
- "Update for new value of MAX_ATTRIBUTES");
-
- pState->linkageMask = mask;
- pState->linkageCount = _mm_popcnt_u32(mask);
-
- if (!pMap)
- {
- pMap = IDENTITY_MAP;
+ // guardband center is viewport center
+ pState->gbState.left[i] = KNOB_GUARDBAND_WIDTH / pState->vp[i].width;
+ pState->gbState.right[i] = KNOB_GUARDBAND_WIDTH / pState->vp[i].width;
+ pState->gbState.top[i] = KNOB_GUARDBAND_HEIGHT / pState->vp[i].height;
+ pState->gbState.bottom[i] = KNOB_GUARDBAND_HEIGHT / pState->vp[i].height;
}
- memcpy(pState->linkageMap, pMap, pState->linkageCount);
-}
-
-// update guardband multipliers for the viewport
-void updateGuardband(API_STATE *pState)
-{
- // guardband center is viewport center
- pState->gbState.left = KNOB_GUARDBAND_WIDTH / pState->vp[0].width;
- pState->gbState.right = KNOB_GUARDBAND_WIDTH / pState->vp[0].width;
- pState->gbState.top = KNOB_GUARDBAND_HEIGHT / pState->vp[0].height;
- pState->gbState.bottom = KNOB_GUARDBAND_HEIGHT / pState->vp[0].height;
}
void SwrSetRastState(
HANDLE hContext,
uint32_t numViewports,
const SWR_VIEWPORT* pViewports,
- const SWR_VIEWPORT_MATRIX* pMatrices)
+ const SWR_VIEWPORT_MATRICES* pMatrices)
{
SWR_ASSERT(numViewports <= KNOB_NUM_VIEWPORTS_SCISSORS,
"Invalid number of viewports.");
if (pMatrices != nullptr)
{
- memcpy(&pState->vpMatrix[0], pMatrices, sizeof(SWR_VIEWPORT_MATRIX) * numViewports);
+ // @todo Faster to copy portions of the SOA or just copy all of it?
+ memcpy(&pState->vpMatrices, pMatrices, sizeof(SWR_VIEWPORT_MATRICES));
}
else
{
{
if (pContext->driverType == DX)
{
- pState->vpMatrix[i].m00 = pState->vp[i].width / 2.0f;
- pState->vpMatrix[i].m11 = -pState->vp[i].height / 2.0f;
- pState->vpMatrix[i].m22 = pState->vp[i].maxZ - pState->vp[i].minZ;
- pState->vpMatrix[i].m30 = pState->vp[i].x + pState->vpMatrix[i].m00;
- pState->vpMatrix[i].m31 = pState->vp[i].y - pState->vpMatrix[i].m11;
- pState->vpMatrix[i].m32 = pState->vp[i].minZ;
+ pState->vpMatrices.m00[i] = pState->vp[i].width / 2.0f;
+ pState->vpMatrices.m11[i] = -pState->vp[i].height / 2.0f;
+ pState->vpMatrices.m22[i] = pState->vp[i].maxZ - pState->vp[i].minZ;
+ pState->vpMatrices.m30[i] = pState->vp[i].x + pState->vpMatrices.m00[i];
+ pState->vpMatrices.m31[i] = pState->vp[i].y - pState->vpMatrices.m11[i];
+ pState->vpMatrices.m32[i] = pState->vp[i].minZ;
}
else
{
// Standard, with the exception that Y is inverted.
- pState->vpMatrix[i].m00 = (pState->vp[i].width - pState->vp[i].x) / 2.0f;
- pState->vpMatrix[i].m11 = (pState->vp[i].y - pState->vp[i].height) / 2.0f;
- pState->vpMatrix[i].m22 = (pState->vp[i].maxZ - pState->vp[i].minZ) / 2.0f;
- pState->vpMatrix[i].m30 = pState->vp[i].x + pState->vpMatrix[i].m00;
- pState->vpMatrix[i].m31 = pState->vp[i].height + pState->vpMatrix[i].m11;
- pState->vpMatrix[i].m32 = pState->vp[i].minZ + pState->vpMatrix[i].m22;
+ pState->vpMatrices.m00[i] = (pState->vp[i].width - pState->vp[i].x) / 2.0f;
+ pState->vpMatrices.m11[i] = (pState->vp[i].y - pState->vp[i].height) / 2.0f;
+ pState->vpMatrices.m22[i] = (pState->vp[i].maxZ - pState->vp[i].minZ) / 2.0f;
+ pState->vpMatrices.m30[i] = pState->vp[i].x + pState->vpMatrices.m00[i];
+ pState->vpMatrices.m31[i] = pState->vp[i].height + pState->vpMatrices.m11[i];
+ pState->vpMatrices.m32[i] = pState->vp[i].minZ + pState->vpMatrices.m22[i];
// Now that the matrix is calculated, clip the view coords to screen size.
// OpenGL allows for -ve x,y in the viewport.
}
}
- updateGuardband(pState);
+ updateGuardbands(pState);
}
void SwrSetScissorRects(
HANDLE hContext,
uint32_t numScissors,
- const BBOX* pScissors)
+ const SWR_RECT* pScissors)
{
SWR_ASSERT(numScissors <= KNOB_NUM_VIEWPORTS_SCISSORS,
"Invalid number of scissor rects.");
API_STATE* pState = GetDrawState(GetContext(hContext));
- memcpy(&pState->scissorRects[0], pScissors, numScissors * sizeof(BBOX));
+ memcpy(&pState->scissorRects[0], pScissors, numScissors * sizeof(pScissors[0]));
};
void SetupMacroTileScissors(DRAW_CONTEXT *pDC)
{
API_STATE *pState = &pDC->pState->state;
- uint32_t left, right, top, bottom;
+ uint32_t numScissors = pState->gsState.emitsViewportArrayIndex ? KNOB_NUM_VIEWPORTS_SCISSORS : 1;
+ pState->scissorsTileAligned = true;
- // Set up scissor dimensions based on scissor or viewport
- if (pState->rastState.scissorEnable)
- {
- // scissor rect right/bottom edge are exclusive, core expects scissor dimensions to be inclusive, so subtract one pixel from right/bottom edges
- left = pState->scissorRects[0].left;
- right = pState->scissorRects[0].right;
- top = pState->scissorRects[0].top;
- bottom = pState->scissorRects[0].bottom;
- }
- else
+ for (uint32_t index = 0; index < numScissors; ++index)
{
- left = (int32_t)pState->vp[0].x;
- right = (int32_t)pState->vp[0].x + (int32_t)pState->vp[0].width;
- top = (int32_t)pState->vp[0].y;
- bottom = (int32_t)pState->vp[0].y + (int32_t)pState->vp[0].height;
- }
+ SWR_RECT &scissorInFixedPoint = pState->scissorsInFixedPoint[index];
- right = std::min<uint32_t>(right, KNOB_MAX_SCISSOR_X);
- bottom = std::min<uint32_t>(bottom, KNOB_MAX_SCISSOR_Y);
+ // Set up scissor dimensions based on scissor or viewport
+ if (pState->rastState.scissorEnable)
+ {
+ scissorInFixedPoint = pState->scissorRects[index];
+ }
+ else
+ {
+ // the vp width and height must be added to origin un-rounded then the result round to -inf.
+ // The cast to int works for rounding assuming all [left, right, top, bottom] are positive.
+ scissorInFixedPoint.xmin = (int32_t)pState->vp[index].x;
+ scissorInFixedPoint.xmax = (int32_t)(pState->vp[index].x + pState->vp[index].width);
+ scissorInFixedPoint.ymin = (int32_t)pState->vp[index].y;
+ scissorInFixedPoint.ymax = (int32_t)(pState->vp[index].y + pState->vp[index].height);
+ }
- if (left > KNOB_MAX_SCISSOR_X || top > KNOB_MAX_SCISSOR_Y)
- {
- pState->scissorInFixedPoint.left = 0;
- pState->scissorInFixedPoint.right = 0;
- pState->scissorInFixedPoint.top = 0;
- pState->scissorInFixedPoint.bottom = 0;
- }
- else
- {
- pState->scissorInFixedPoint.left = left * FIXED_POINT_SCALE;
- pState->scissorInFixedPoint.right = right * FIXED_POINT_SCALE - 1;
- pState->scissorInFixedPoint.top = top * FIXED_POINT_SCALE;
- pState->scissorInFixedPoint.bottom = bottom * FIXED_POINT_SCALE - 1;
+ // Clamp to max rect
+ scissorInFixedPoint &= g_MaxScissorRect;
+
+ // Test for tile alignment
+ bool tileAligned;
+ tileAligned = (scissorInFixedPoint.xmin % KNOB_TILE_X_DIM) == 0;
+ tileAligned &= (scissorInFixedPoint.ymin % KNOB_TILE_Y_DIM) == 0;
+ tileAligned &= (scissorInFixedPoint.xmax % KNOB_TILE_X_DIM) == 0;
+ tileAligned &= (scissorInFixedPoint.xmax % KNOB_TILE_Y_DIM) == 0;
+
+ pState->scissorsTileAligned &= tileAligned;
+
+ // Scale to fixed point
+ scissorInFixedPoint.xmin *= FIXED_POINT_SCALE;
+ scissorInFixedPoint.xmax *= FIXED_POINT_SCALE;
+ scissorInFixedPoint.ymin *= FIXED_POINT_SCALE;
+ scissorInFixedPoint.ymax *= FIXED_POINT_SCALE;
+
+ // Make scissor inclusive
+ scissorInFixedPoint.xmax -= 1;
+ scissorInFixedPoint.ymax -= 1;
}
}
+
// templated backend function tables
-extern PFN_BACKEND_FUNC gBackendNullPs[SWR_MULTISAMPLE_TYPE_MAX];
-extern PFN_BACKEND_FUNC gBackendSingleSample[2][2];
-extern PFN_BACKEND_FUNC gBackendPixelRateTable[SWR_MULTISAMPLE_TYPE_MAX][SWR_MSAA_SAMPLE_PATTERN_MAX][SWR_INPUT_COVERAGE_MAX][2][2];
-extern PFN_BACKEND_FUNC gBackendSampleRateTable[SWR_MULTISAMPLE_TYPE_MAX][SWR_INPUT_COVERAGE_MAX][2];
-extern PFN_OUTPUT_MERGER gBackendOutputMergerTable[SWR_NUM_RENDERTARGETS + 1][SWR_MULTISAMPLE_TYPE_MAX];
-extern PFN_CALC_PIXEL_BARYCENTRICS gPixelBarycentricTable[2];
-extern PFN_CALC_SAMPLE_BARYCENTRICS gSampleBarycentricTable[2];
-extern PFN_CALC_CENTROID_BARYCENTRICS gCentroidBarycentricTable[SWR_MULTISAMPLE_TYPE_MAX][2][2][2];
+extern PFN_BACKEND_FUNC gBackendNullPs[SWR_MULTISAMPLE_TYPE_COUNT];
+extern PFN_BACKEND_FUNC gBackendSingleSample[SWR_INPUT_COVERAGE_COUNT][2][2];
+extern PFN_BACKEND_FUNC gBackendPixelRateTable[SWR_MULTISAMPLE_TYPE_COUNT][SWR_MSAA_SAMPLE_PATTERN_COUNT][SWR_INPUT_COVERAGE_COUNT][2][2][2];
+extern PFN_BACKEND_FUNC gBackendSampleRateTable[SWR_MULTISAMPLE_TYPE_COUNT][SWR_INPUT_COVERAGE_COUNT][2][2];
void SetupPipeline(DRAW_CONTEXT *pDC)
{
DRAW_STATE* pState = pDC->pState;
const SWR_RASTSTATE &rastState = pState->state.rastState;
const SWR_PS_STATE &psState = pState->state.psState;
BACKEND_FUNCS& backendFuncs = pState->backendFuncs;
- const uint32_t forcedSampleCount = (rastState.bForcedSampleCount) ? 1 : 0;
+ const uint32_t forcedSampleCount = (rastState.forcedSampleCount) ? 1 : 0;
// setup backend
if (psState.pfnPixelShader == nullptr)
{
backendFuncs.pfnBackend = gBackendNullPs[pState->state.rastState.sampleCount];
- // always need to generate I & J per sample for Z interpolation
- backendFuncs.pfnCalcSampleBarycentrics = gSampleBarycentricTable[1];
}
else
{
- const bool bMultisampleEnable = ((rastState.sampleCount > SWR_MULTISAMPLE_1X) || rastState.bForcedSampleCount) ? 1 : 0;
+ const bool bMultisampleEnable = ((rastState.sampleCount > SWR_MULTISAMPLE_1X) || rastState.forcedSampleCount) ? 1 : 0;
const uint32_t centroid = ((psState.barycentricsMask & SWR_BARYCENTRIC_CENTROID_MASK) > 0) ? 1 : 0;
+ const uint32_t canEarlyZ = (psState.forceEarlyZ || (!psState.writesODepth && !psState.usesSourceDepth && !psState.usesUAV)) ? 1 : 0;
- // currently only support 'normal' input coverage
- SWR_ASSERT(psState.inputCoverage == SWR_INPUT_COVERAGE_NORMAL ||
- psState.inputCoverage == SWR_INPUT_COVERAGE_NONE);
-
SWR_BARYCENTRICS_MASK barycentricsMask = (SWR_BARYCENTRICS_MASK)psState.barycentricsMask;
// select backend function
{
// always need to generate I & J per sample for Z interpolation
barycentricsMask = (SWR_BARYCENTRICS_MASK)(barycentricsMask | SWR_BARYCENTRIC_PER_SAMPLE_MASK);
- backendFuncs.pfnBackend = gBackendPixelRateTable[rastState.sampleCount][rastState.samplePattern][psState.inputCoverage][centroid][forcedSampleCount];
- backendFuncs.pfnOutputMerger = gBackendOutputMergerTable[psState.numRenderTargets][pState->state.blendState.sampleCount];
+ backendFuncs.pfnBackend = gBackendPixelRateTable[rastState.sampleCount][rastState.samplePattern][psState.inputCoverage][centroid][forcedSampleCount][canEarlyZ];
}
else
{
// always need to generate I & J per pixel for Z interpolation
barycentricsMask = (SWR_BARYCENTRICS_MASK)(barycentricsMask | SWR_BARYCENTRIC_PER_PIXEL_MASK);
- backendFuncs.pfnBackend = gBackendSingleSample[psState.inputCoverage][centroid];
- backendFuncs.pfnOutputMerger = gBackendOutputMergerTable[psState.numRenderTargets][SWR_MULTISAMPLE_1X];
+ backendFuncs.pfnBackend = gBackendSingleSample[psState.inputCoverage][centroid][canEarlyZ];
}
break;
case SWR_SHADING_RATE_SAMPLE:
SWR_ASSERT(rastState.samplePattern == SWR_MSAA_STANDARD_PATTERN);
// always need to generate I & J per sample for Z interpolation
barycentricsMask = (SWR_BARYCENTRICS_MASK)(barycentricsMask | SWR_BARYCENTRIC_PER_SAMPLE_MASK);
- backendFuncs.pfnBackend = gBackendSampleRateTable[rastState.sampleCount][psState.inputCoverage][centroid];
- backendFuncs.pfnOutputMerger = gBackendOutputMergerTable[psState.numRenderTargets][pState->state.blendState.sampleCount];
+ backendFuncs.pfnBackend = gBackendSampleRateTable[rastState.sampleCount][psState.inputCoverage][centroid][canEarlyZ];
break;
default:
SWR_ASSERT(0 && "Invalid shading rate");
break;
}
-
- // setup pointer to function that generates necessary barycentrics required by the PS
- bool bBarycentrics = (barycentricsMask & SWR_BARYCENTRIC_PER_PIXEL_MASK) > 0 ? 1 : 0;
- backendFuncs.pfnCalcPixelBarycentrics = gPixelBarycentricTable[bBarycentrics];
-
- bBarycentrics = (barycentricsMask & SWR_BARYCENTRIC_PER_SAMPLE_MASK) > 0 ? 1 : 0;
- backendFuncs.pfnCalcSampleBarycentrics = gSampleBarycentricTable[bBarycentrics];
-
- bBarycentrics = (barycentricsMask & SWR_BARYCENTRIC_CENTROID_MASK) > 0 ? 1 : 0;
- backendFuncs.pfnCalcCentroidBarycentrics = gCentroidBarycentricTable[rastState.sampleCount][bBarycentrics][rastState.samplePattern][forcedSampleCount];
}
PFN_PROCESS_PRIMS pfnBinner;
break;
default:
pState->pfnProcessPrims = ClipTriangles;
- pfnBinner = BinTriangles;
+ pfnBinner = GetBinTrianglesFunc((rastState.conservativeRast > 0));
break;
};
(pState->state.depthStencilState.depthWriteEnable == FALSE) &&
(pState->state.depthStencilState.stencilTestEnable == FALSE) &&
(pState->state.depthStencilState.stencilWriteEnable == FALSE) &&
- (pState->state.linkageCount == 0))
+ (pState->state.backendState.numAttributes == 0))
{
pState->pfnProcessPrims = nullptr;
- pState->state.linkageMask = 0;
}
if (pState->state.soState.rasterizerDisable == true)
{
pState->pfnProcessPrims = nullptr;
- pState->state.linkageMask = 0;
}
- // set up the frontend attrib mask
- pState->state.feAttribMask = pState->state.linkageMask;
+ // set up the frontend attribute count
+ pState->state.feNumAttributes = 0;
+ const SWR_BACKEND_STATE& backendState = pState->state.backendState;
+ if (backendState.swizzleEnable)
+ {
+ // attribute swizzling is enabled, iterate over the map and record the max attribute used
+ for (uint32_t i = 0; i < backendState.numAttributes; ++i)
+ {
+ pState->state.feNumAttributes = std::max(pState->state.feNumAttributes, (uint32_t)backendState.swizzleMap[i].sourceAttrib + 1);
+ }
+ }
+ else
+ {
+ pState->state.feNumAttributes = pState->state.backendState.numAttributes;
+ }
+
if (pState->state.soState.soEnable)
{
+ uint32_t streamMasks = 0;
for (uint32_t i = 0; i < 4; ++i)
{
- pState->state.feAttribMask |= pState->state.soState.streamMasks[i];
+ streamMasks |= pState->state.soState.streamMasks[i];
+ }
+
+ DWORD maxAttrib;
+ if (_BitScanReverse(&maxAttrib, streamMasks))
+ {
+ pState->state.feNumAttributes = std::max(pState->state.feNumAttributes, (uint32_t)(maxAttrib + 1));
}
}
!pState->state.blendState.renderTarget[rt].writeDisableBlue) ? (1 << rt) : 0;
}
}
+
+ // Setup depth quantization function
+ if (pState->state.depthHottileEnable)
+ {
+ switch (pState->state.rastState.depthFormat)
+ {
+ case R32_FLOAT_X8X24_TYPELESS: pState->state.pfnQuantizeDepth = QuantizeDepth < R32_FLOAT_X8X24_TYPELESS > ; break;
+ case R32_FLOAT: pState->state.pfnQuantizeDepth = QuantizeDepth < R32_FLOAT > ; break;
+ case R24_UNORM_X8_TYPELESS: pState->state.pfnQuantizeDepth = QuantizeDepth < R24_UNORM_X8_TYPELESS > ; break;
+ case R16_UNORM: pState->state.pfnQuantizeDepth = QuantizeDepth < R16_UNORM > ; break;
+ default: SWR_ASSERT(false, "Unsupported depth format for depth quantiztion.");
+ pState->state.pfnQuantizeDepth = QuantizeDepth < R32_FLOAT > ;
+ }
+ }
+ else
+ {
+ // set up pass-through quantize if depth isn't enabled
+ pState->state.pfnQuantizeDepth = QuantizeDepth < R32_FLOAT > ;
+ }
}
//////////////////////////////////////////////////////////////////////////
return vertsPerDraw;
}
-// Recursive template used to auto-nest conditionals. Converts dynamic boolean function
-// arguments to static template arguments.
-template <bool... ArgsB>
-struct FEDrawChooser
-{
- // Last Arg Terminator
- static PFN_FE_WORK_FUNC GetFunc(bool bArg)
- {
- if (bArg)
- {
- return ProcessDraw<ArgsB..., true>;
- }
-
- return ProcessDraw<ArgsB..., false>;
- }
-
- // Recursively parse args
- template <typename... TArgsT>
- static PFN_FE_WORK_FUNC GetFunc(bool bArg, TArgsT... remainingArgs)
- {
- if (bArg)
- {
- return FEDrawChooser<ArgsB..., true>::GetFunc(remainingArgs...);
- }
-
- return FEDrawChooser<ArgsB..., false>::GetFunc(remainingArgs...);
- }
-};
-
-// Selector for correct templated Draw front-end function
-INLINE
-static PFN_FE_WORK_FUNC GetFEDrawFunc(bool IsIndexed, bool HasTessellation, bool HasGeometryShader, bool HasStreamOut, bool RasterizerEnabled)
-{
- return FEDrawChooser<>::GetFunc(IsIndexed, HasTessellation, HasGeometryShader, HasStreamOut, RasterizerEnabled);
-}
-
//////////////////////////////////////////////////////////////////////////
/// @brief DrawInstanced
SWR_CONTEXT *pContext = GetContext(hContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
- int32_t maxVertsPerDraw = MaxVertsPerDraw(pDC, numVertices, topology);
+ uint32_t maxVertsPerDraw = MaxVertsPerDraw(pDC, numVertices, topology);
uint32_t primsPerDraw = GetNumPrims(topology, maxVertsPerDraw);
- int32_t remainingVerts = numVertices;
+ uint32_t remainingVerts = numVertices;
API_STATE *pState = &pDC->pState->state;
pState->topology = topology;
InitDraw(pDC, isSplitDraw);
pDC->FeWork.type = DRAW;
- pDC->FeWork.pfnWork = GetFEDrawFunc(
+ pDC->FeWork.pfnWork = GetProcessDrawFunc(
false, // IsIndexed
+ false, // bEnableCutIndex
pState->tsState.tsEnable,
pState->gsState.gsEnable,
pState->soState.soEnable,
pDC->FeWork.desc.draw.startPrimID = draw * primsPerDraw;
pDC->FeWork.desc.draw.startVertexID = draw * maxVertsPerDraw;
+ pDC->cleanupState = (remainingVerts == numVertsForDraw);
+
//enqueue DC
QueueDraw(pContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
API_STATE* pState = &pDC->pState->state;
- int32_t maxIndicesPerDraw = MaxVertsPerDraw(pDC, numIndices, topology);
+ AR_BEGIN(AR_API_CTX, APIDrawIndexed, pDC->drawId);
+ AR_EVENT(AR_API_CTX, DrawIndexedInstance(topology, numIndices, indexOffset, baseVertex, numInstances, startInstance));
+
+ uint32_t maxIndicesPerDraw = MaxVertsPerDraw(pDC, numIndices, topology);
uint32_t primsPerDraw = GetNumPrims(topology, maxIndicesPerDraw);
- int32_t remainingIndices = numIndices;
+ uint32_t remainingIndices = numIndices;
uint32_t indexSize = 0;
switch (pState->indexBuffer.format)
InitDraw(pDC, isSplitDraw);
pDC->FeWork.type = DRAW;
- pDC->FeWork.pfnWork = GetFEDrawFunc(
+ pDC->FeWork.pfnWork = GetProcessDrawFunc(
true, // IsIndexed
+ pState->frontendState.bEnableCutIndex,
pState->tsState.tsEnable,
pState->gsState.gsEnable,
pState->soState.soEnable,
pDC->FeWork.desc.draw.baseVertex = baseVertex;
pDC->FeWork.desc.draw.startPrimID = draw * primsPerDraw;
+ pDC->cleanupState = (remainingIndices == numIndicesForDraw);
+
//enqueue DC
QueueDraw(pContext);
pDC = GetDrawContext(pContext);
pDC->pState->state.rastState.cullMode = oldCullMode;
+ AR_END(AR_API_CTX, APIDrawIndexed, numIndices * numInstances);
RDTSC_STOP(APIDrawIndexed, numIndices * numInstances, 0);
}
/// @brief SwrInvalidateTiles
/// @param hContext - Handle passed back from SwrCreateContext
/// @param attachmentMask - The mask specifies which surfaces attached to the hottiles to invalidate.
-void SwrInvalidateTiles(
+/// @param invalidateRect - The pixel-coordinate rectangle to invalidate. This will be expanded to
+/// be hottile size-aligned.
+void SWR_API SwrInvalidateTiles(
HANDLE hContext,
- uint32_t attachmentMask)
+ uint32_t attachmentMask,
+ const SWR_RECT& invalidateRect)
{
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ if (KNOB_TOSS_DRAW)
+ {
+ return;
+ }
+
+ SWR_CONTEXT *pContext = GetContext(hContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
pDC->FeWork.type = DISCARDINVALIDATETILES;
pDC->FeWork.pfnWork = ProcessDiscardInvalidateTiles;
pDC->FeWork.desc.discardInvalidateTiles.attachmentMask = attachmentMask;
- memset(&pDC->FeWork.desc.discardInvalidateTiles.rect, 0, sizeof(SWR_RECT));
+ pDC->FeWork.desc.discardInvalidateTiles.rect = invalidateRect;
+ pDC->FeWork.desc.discardInvalidateTiles.rect &= g_MaxScissorRect;
pDC->FeWork.desc.discardInvalidateTiles.newTileState = SWR_TILE_INVALID;
pDC->FeWork.desc.discardInvalidateTiles.createNewTiles = false;
pDC->FeWork.desc.discardInvalidateTiles.fullTilesOnly = false;
/// @brief SwrDiscardRect
/// @param hContext - Handle passed back from SwrCreateContext
/// @param attachmentMask - The mask specifies which surfaces attached to the hottiles to discard.
-/// @param rect - if rect is all zeros, the entire attachment surface will be discarded
-void SwrDiscardRect(
+/// @param rect - The pixel-coordinate rectangle to discard. Only fully-covered hottiles will be
+/// discarded.
+void SWR_API SwrDiscardRect(
HANDLE hContext,
uint32_t attachmentMask,
- SWR_RECT rect)
+ const SWR_RECT& rect)
{
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ if (KNOB_TOSS_DRAW)
+ {
+ return;
+ }
+
+ SWR_CONTEXT *pContext = GetContext(hContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
// Queue a load to the hottile
pDC->FeWork.pfnWork = ProcessDiscardInvalidateTiles;
pDC->FeWork.desc.discardInvalidateTiles.attachmentMask = attachmentMask;
pDC->FeWork.desc.discardInvalidateTiles.rect = rect;
+ pDC->FeWork.desc.discardInvalidateTiles.rect &= g_MaxScissorRect;
pDC->FeWork.desc.discardInvalidateTiles.newTileState = SWR_TILE_RESOLVED;
pDC->FeWork.desc.discardInvalidateTiles.createNewTiles = true;
pDC->FeWork.desc.discardInvalidateTiles.fullTilesOnly = true;
}
RDTSC_START(APIDispatch);
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ SWR_CONTEXT *pContext = GetContext(hContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
pDC->isCompute = true; // This is a compute context.
- // Ensure spill fill pointers are initialized to nullptr.
- memset(pDC->pSpillFill, 0, sizeof(pDC->pSpillFill));
-
COMPUTE_DESC* pTaskData = (COMPUTE_DESC*)pDC->pArena->AllocAligned(sizeof(COMPUTE_DESC), 64);
pTaskData->threadGroupCountX = threadGroupCountX;
pTaskData->threadGroupCountZ = threadGroupCountZ;
uint32_t totalThreadGroups = threadGroupCountX * threadGroupCountY * threadGroupCountZ;
+ uint32_t dcIndex = pDC->drawId % KNOB_MAX_DRAWS_IN_FLIGHT;
+ pDC->pDispatch = &pContext->pDispatchQueueArray[dcIndex];
pDC->pDispatch->initialize(totalThreadGroups, pTaskData);
QueueDispatch(pContext);
// Deswizzles, converts and stores current contents of the hot tiles to surface
// described by pState
-void SwrStoreTiles(
+void SWR_API SwrStoreTiles(
HANDLE hContext,
SWR_RENDERTARGET_ATTACHMENT attachment,
- SWR_TILE_STATE postStoreTileState)
+ SWR_TILE_STATE postStoreTileState,
+ const SWR_RECT& storeRect)
{
+ if (KNOB_TOSS_DRAW)
+ {
+ return;
+ }
+
RDTSC_START(APIStoreTiles);
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ SWR_CONTEXT *pContext = GetContext(hContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
- SetupMacroTileScissors(pDC);
-
pDC->FeWork.type = STORETILES;
pDC->FeWork.pfnWork = ProcessStoreTiles;
pDC->FeWork.desc.storeTiles.attachment = attachment;
pDC->FeWork.desc.storeTiles.postStoreTileState = postStoreTileState;
+ pDC->FeWork.desc.storeTiles.rect = storeRect;
+ pDC->FeWork.desc.storeTiles.rect &= g_MaxScissorRect;
//enqueue
QueueDraw(pContext);
RDTSC_STOP(APIStoreTiles, 0, 0);
}
-void SwrClearRenderTarget(
+//////////////////////////////////////////////////////////////////////////
+/// @brief SwrClearRenderTarget - Clear attached render targets / depth / stencil
+/// @param hContext - Handle passed back from SwrCreateContext
+/// @param clearMask - combination of SWR_CLEAR_COLOR / SWR_CLEAR_DEPTH / SWR_CLEAR_STENCIL flags (or SWR_CLEAR_NONE)
+/// @param clearColor - color use for clearing render targets
+/// @param z - depth value use for clearing depth buffer
+/// @param stencil - stencil value used for clearing stencil buffer
+/// @param clearRect - The pixel-coordinate rectangle to clear in all cleared buffers
+void SWR_API SwrClearRenderTarget(
HANDLE hContext,
uint32_t clearMask,
const float clearColor[4],
float z,
- uint8_t stencil)
+ uint8_t stencil,
+ const SWR_RECT& clearRect)
{
- RDTSC_START(APIClearRenderTarget);
+ if (KNOB_TOSS_DRAW)
+ {
+ return;
+ }
- SWR_CONTEXT *pContext = (SWR_CONTEXT*)hContext;
+ RDTSC_START(APIClearRenderTarget);
+ SWR_CONTEXT *pContext = GetContext(hContext);
DRAW_CONTEXT* pDC = GetDrawContext(pContext);
- SetupMacroTileScissors(pDC);
-
CLEAR_FLAGS flags;
+ flags.bits = 0;
flags.mask = clearMask;
pDC->FeWork.type = CLEAR;
pDC->FeWork.pfnWork = ProcessClear;
+ pDC->FeWork.desc.clear.rect = clearRect;
+ pDC->FeWork.desc.clear.rect &= g_MaxScissorRect;
pDC->FeWork.desc.clear.flags = flags;
pDC->FeWork.desc.clear.clearDepth = z;
pDC->FeWork.desc.clear.clearRTColor[0] = clearColor[0];
return pDC->pState->pArena->AllocAligned(size, align);
}
-//////////////////////////////////////////////////////////////////////////
-/// @brief Returns pointer to SWR stats.
-/// @note The counters are atomically incremented by multiple threads.
-/// When calling this, you need to ensure all previous operations
-/// have completed.
-/// @todo If necessary, add a callback to avoid stalling the pipe to
-/// sample the counters.
-/// @param hContext - Handle passed back from SwrCreateContext
-/// @param pStats - SWR will fill this out for caller.
-void SwrGetStats(
- HANDLE hContext,
- SWR_STATS* pStats)
-{
- SWR_CONTEXT *pContext = GetContext(hContext);
- DRAW_CONTEXT* pDC = GetDrawContext(pContext);
-
- pDC->FeWork.type = QUERYSTATS;
- pDC->FeWork.pfnWork = ProcessQueryStats;
- pDC->FeWork.desc.queryStats.pStats = pStats;
-
- // cannot execute until all previous draws have completed
- pDC->dependency = pDC->drawId - 1;
-
- //enqueue
- QueueDraw(pContext);
-}
-
//////////////////////////////////////////////////////////////////////////
/// @brief Enables stats counting
/// @param hContext - Handle passed back from SwrCreateContext
HANDLE hContext)
{
RDTSC_ENDFRAME();
+ SWR_CONTEXT *pContext = GetContext(hContext);
+ pContext->frameCount++;
}
projects / mesa.git / blobdiff