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

   1 /****************************************************************************
   2 * Copyright (C) 2014-2016 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 api.h
  24 *
  25 * @brief API definitions
  26 *
  27 ******************************************************************************/
  28
  29 #ifndef __SWR_API_H__
  30 #define __SWR_API_H__
  31
  32 #include "common/os.h"
  33
  34 #include <assert.h>
  35 #include <algorithm>
  36
  37 #include "common/intrin.h"
  38 #include "common/formats.h"
  39 #include "core/state.h"
  40
  41 typedef void(SWR_API *PFN_CALLBACK_FUNC)(uint64_t data, uint64_t data2, uint64_t data3);
  42
  43 //////////////////////////////////////////////////////////////////////////
  44 /// @brief Rectangle structure
  45 struct SWR_RECT
  46 {
  47     int32_t xmin; ///< inclusive
  48     int32_t ymin; ///< inclusive
  49     int32_t xmax; ///< exclusive
  50     int32_t ymax; ///< exclusive
  51
  52     bool operator == (const SWR_RECT& rhs)
  53     {
  54         return (this->ymin == rhs.ymin &&
  55             this->ymax == rhs.ymax &&
  56             this->xmin == rhs.xmin &&
  57             this->xmax == rhs.xmax);
  58     }
  59
  60     bool operator != (const SWR_RECT& rhs)
  61     {
  62         return !(*this == rhs);
  63     }
  64
  65     SWR_RECT& Intersect(const SWR_RECT& other)
  66     {
  67         this->xmin = std::max(this->xmin, other.xmin);
  68         this->ymin = std::max(this->ymin, other.ymin);
  69         this->xmax = std::min(this->xmax, other.xmax);
  70         this->ymax = std::min(this->ymax, other.ymax);
  71
  72         if (xmax - xmin < 0 ||
  73             ymax - ymin < 0)
  74         {
  75             // Zero area
  76             ymin = ymax = xmin = xmax = 0;
  77         }
  78
  79         return *this;
  80     }
  81     SWR_RECT& operator &= (const SWR_RECT& other)
  82     {
  83         return Intersect(other);
  84     }
  85
  86     SWR_RECT& Union(const SWR_RECT& other)
  87     {
  88         this->xmin = std::min(this->xmin, other.xmin);
  89         this->ymin = std::min(this->ymin, other.ymin);
  90         this->xmax = std::max(this->xmax, other.xmax);
  91         this->ymax = std::max(this->ymax, other.ymax);
  92
  93         return *this;
  94     }
  95
  96     SWR_RECT& operator |= (const SWR_RECT& other)
  97     {
  98         return Union(other);
  99     }
 100
 101     void Translate(int32_t x, int32_t y)
 102     {
 103         xmin += x;
 104         ymin += y;
 105         xmax += x;
 106         ymax += y;
 107     }
 108 };
 109
 110 //////////////////////////////////////////////////////////////////////////
 111 /// @brief Function signature for load hot tiles
 112 /// @param hPrivateContext - handle to private data
 113 /// @param dstFormat - format of the hot tile
 114 /// @param renderTargetIndex - render target to store, can be color, depth or stencil
 115 /// @param x - destination x coordinate
 116 /// @param y - destination y coordinate
 117 /// @param pDstHotTile - pointer to the hot tile surface
 118 typedef void(SWR_API *PFN_LOAD_TILE)(HANDLE hPrivateContext, SWR_FORMAT dstFormat,
 119     SWR_RENDERTARGET_ATTACHMENT renderTargetIndex,
 120     uint32_t x, uint32_t y, uint32_t renderTargetArrayIndex, uint8_t *pDstHotTile);
 121
 122 //////////////////////////////////////////////////////////////////////////
 123 /// @brief Function signature for store hot tiles
 124 /// @param hPrivateContext - handle to private data
 125 /// @param srcFormat - format of the hot tile
 126 /// @param renderTargetIndex - render target to store, can be color, depth or stencil
 127 /// @param x - destination x coordinate
 128 /// @param y - destination y coordinate
 129 /// @param pSrcHotTile - pointer to the hot tile surface
 130 typedef void(SWR_API *PFN_STORE_TILE)(HANDLE hPrivateContext, SWR_FORMAT srcFormat,
 131     SWR_RENDERTARGET_ATTACHMENT renderTargetIndex,
 132     uint32_t x, uint32_t y, uint32_t renderTargetArrayIndex, uint8_t *pSrcHotTile);
 133
 134 //////////////////////////////////////////////////////////////////////////
 135 /// @brief Function signature for clearing from the hot tiles clear value
 136 /// @param hPrivateContext - handle to private data
 137 /// @param renderTargetIndex - render target to store, can be color, depth or stencil
 138 /// @param x - destination x coordinate
 139 /// @param y - destination y coordinate
 140 /// @param renderTargetArrayIndex - render target array offset from arrayIndex
 141 /// @param pClearColor - pointer to the hot tile's clear value
 142 typedef void(SWR_API *PFN_CLEAR_TILE)(HANDLE hPrivateContext,
 143     SWR_RENDERTARGET_ATTACHMENT rtIndex,
 144     uint32_t x, uint32_t y, uint32_t renderTargetArrayIndex, const float* pClearColor);
 145
 146 //////////////////////////////////////////////////////////////////////////
 147 /// @brief Callback to allow driver to update their copy of streamout write offset.
 148 ///        This is call is made for any draw operation that has streamout enabled
 149 ///        and has updated the write offset.
 150 /// @param hPrivateContext - handle to private data
 151 /// @param soBufferSlot - buffer slot for write offset
 152 /// @param soWriteOffset - update value for so write offset.
 153 typedef void(SWR_API *PFN_UPDATE_SO_WRITE_OFFSET)(HANDLE hPrivateContext,
 154     uint32_t soBufferSlot, uint32_t soWriteOffset);
 155
 156 //////////////////////////////////////////////////////////////////////////
 157 /// @brief Callback to allow driver to update their copy of stats.
 158 /// @param hPrivateContext - handle to private data
 159 /// @param pStats - pointer to draw stats
 160 typedef void(SWR_API *PFN_UPDATE_STATS)(HANDLE hPrivateContext,
 161     const SWR_STATS* pStats);
 162
 163 //////////////////////////////////////////////////////////////////////////
 164 /// @brief Callback to allow driver to update their copy of FE stats.
 165 /// @note Its optimal to have a separate callback for FE stats since
 166 ///       there is only one DC per FE thread. This means we do not have
 167 ///       to sum up the stats across all of the workers.
 168 /// @param hPrivateContext - handle to private data
 169 /// @param pStats - pointer to draw stats
 170 typedef void(SWR_API *PFN_UPDATE_STATS_FE)(HANDLE hPrivateContext,
 171     const SWR_STATS_FE* pStats);
 172
 173 //////////////////////////////////////////////////////////////////////////
 174 /// BucketManager
 175 /// Forward Declaration (see rdtsc_buckets.h for full definition)
 176 /////////////////////////////////////////////////////////////////////////
 177 class BucketManager;
 178
 179 //////////////////////////////////////////////////////////////////////////
 180 /// SWR_THREADING_INFO
 181 /////////////////////////////////////////////////////////////////////////
 182 struct SWR_THREADING_INFO
 183 {
 184     uint32_t    BASE_NUMA_NODE;
 185     uint32_t    BASE_CORE;
 186     uint32_t    BASE_THREAD;
 187     uint32_t    MAX_WORKER_THREADS;
 188     uint32_t    MAX_NUMA_NODES;
 189     uint32_t    MAX_CORES_PER_NUMA_NODE;
 190     uint32_t    MAX_THREADS_PER_CORE;
 191     bool        SINGLE_THREADED;
 192 };
 193
 194 //////////////////////////////////////////////////////////////////////////
 195 /// SWR_API_THREADING_INFO
 196 /// Data used to reserve HW threads for API use
 197 /// API Threads are reserved from numa nodes / cores used for
 198 /// SWR Worker threads.  Specifying reserved threads here can reduce
 199 /// the total number of SWR worker threads.
 200 /////////////////////////////////////////////////////////////////////////
 201 struct SWR_API_THREADING_INFO
 202 {
 203     uint32_t numAPIReservedThreads; // Default is 1 if SWR_API_THREADING_INFO is not sent
 204     uint32_t bindAPIThread0;        // Default is true if numAPIReservedThreads is > 0,
 205                                     // binds thread used in SwrCreateContext to API Reserved
 206                                     // thread 0
 207     uint32_t numAPIThreadsPerCore;  // 0 - means use all threads per core, else clamp to this number.
 208                                     // Independent of KNOB_MAX_THREADS_PER_CORE.
 209 };
 210
 211
 212 //////////////////////////////////////////////////////////////////////////
 213 /// SWR_CREATECONTEXT_INFO
 214 /////////////////////////////////////////////////////////////////////////
 215 struct SWR_CREATECONTEXT_INFO
 216 {
 217     // External functions (e.g. sampler) need per draw context state.
 218     // Use SwrGetPrivateContextState() to access private state.
 219     uint32_t privateStateSize;
 220
 221     // Callback functions
 222     PFN_LOAD_TILE               pfnLoadTile;
 223     PFN_STORE_TILE              pfnStoreTile;
 224     PFN_CLEAR_TILE              pfnClearTile;
 225     PFN_UPDATE_SO_WRITE_OFFSET  pfnUpdateSoWriteOffset;
 226     PFN_UPDATE_STATS            pfnUpdateStats;
 227     PFN_UPDATE_STATS_FE         pfnUpdateStatsFE;
 228
 229
 230     // Pointer to rdtsc buckets mgr returned to the caller.
 231     // Only populated when KNOB_ENABLE_RDTSC is set
 232     BucketManager* pBucketMgr;
 233
 234     // Output: size required memory passed to for SwrSaveState / SwrRestoreState
 235     size_t  contextSaveSize;
 236
 237     // ArchRast event manager.
 238     HANDLE  hArEventManager;
 239
 240     // Input (optional): Threading info that overrides any set KNOB values.
 241     SWR_THREADING_INFO* pThreadInfo;
 242
 243     // Input (optional}: Info for reserving API threads
 244     SWR_API_THREADING_INFO* pApiThreadInfo;
 245
 246     // Input: if set to non-zero value, overrides KNOB value for maximum
 247     // number of draws in flight
 248     uint32_t MAX_DRAWS_IN_FLIGHT;
 249 };
 250
 251 //////////////////////////////////////////////////////////////////////////
 252 /// @brief Create SWR Context.
 253 /// @param pCreateInfo - pointer to creation info.
 254 SWR_FUNC(HANDLE, SwrCreateContext,
 255     SWR_CREATECONTEXT_INFO* pCreateInfo);
 256
 257 //////////////////////////////////////////////////////////////////////////
 258 /// @brief Destroys SWR Context.
 259 /// @param hContext - Handle passed back from SwrCreateContext
 260 SWR_FUNC(void, SwrDestroyContext,
 261     HANDLE hContext);
 262
 263 //////////////////////////////////////////////////////////////////////////
 264 /// @brief Bind current thread to an API reserved HW thread
 265 /// @param hContext - Handle passed back from SwrCreateContext
 266 /// @param apiThreadId - index of reserved HW thread to bind to.
 267 SWR_FUNC(void, SwrBindApiThread,
 268     HANDLE hContext,
 269     uint32_t apiThreadId);
 270
 271 //////////////////////////////////////////////////////////////////////////
 272 /// @brief Saves API state associated with hContext
 273 /// @param hContext - Handle passed back from SwrCreateContext
 274 /// @param pOutputStateBlock - Memory block to receive API state data
 275 /// @param memSize - Size of memory pointed to by pOutputStateBlock
 276 SWR_FUNC(void, SwrSaveState,
 277     HANDLE hContext,
 278     void* pOutputStateBlock,
 279     size_t memSize);
 280
 281 //////////////////////////////////////////////////////////////////////////
 282 /// @brief Restores API state to hContext previously saved with SwrSaveState
 283 /// @param hContext - Handle passed back from SwrCreateContext
 284 /// @param pStateBlock - Memory block to read API state data from
 285 /// @param memSize - Size of memory pointed to by pStateBlock
 286 SWR_FUNC(void, SwrRestoreState,
 287     HANDLE hContext,
 288     const void* pStateBlock,
 289     size_t memSize);
 290
 291 //////////////////////////////////////////////////////////////////////////
 292 /// @brief Sync cmd. Executes the callback func when all rendering up to this sync
 293 ///        has been completed
 294 /// @param hContext - Handle passed back from SwrCreateContext
 295 /// @param pfnFunc - pointer to callback function,
 296 /// @param userData - user data to pass back
 297 SWR_FUNC(void, SwrSync,
 298     HANDLE hContext,
 299     PFN_CALLBACK_FUNC pfnFunc,
 300     uint64_t userData,
 301     uint64_t userData2,
 302     uint64_t userData3);
 303
 304 //////////////////////////////////////////////////////////////////////////
 305 /// @brief Stall cmd. Stalls the backend until all previous work has been completed.
 306 ///        Frontend work can continue to make progress
 307 /// @param hContext - Handle passed back from SwrCreateContext
 308 SWR_FUNC(void, SwrStallBE,
 309     HANDLE hContext);
 310
 311 //////////////////////////////////////////////////////////////////////////
 312 /// @brief Blocks until all rendering has been completed.
 313 /// @param hContext - Handle passed back from SwrCreateContext
 314 SWR_FUNC(void, SwrWaitForIdle,
 315     HANDLE hContext);
 316
 317 //////////////////////////////////////////////////////////////////////////
 318 /// @brief Blocks until all FE rendering has been completed.
 319 /// @param hContext - Handle passed back from SwrCreateContext
 320 SWR_FUNC(void, SwrWaitForIdleFE,
 321     HANDLE hContext);
 322
 323 //////////////////////////////////////////////////////////////////////////
 324 /// @brief Set vertex buffer state.
 325 /// @param hContext - Handle passed back from SwrCreateContext
 326 /// @param numBuffers - Number of vertex buffer state descriptors.
 327 /// @param pVertexBuffers - Array of vertex buffer state descriptors.
 328 SWR_FUNC(void, SwrSetVertexBuffers,
 329     HANDLE hContext,
 330     uint32_t numBuffers,
 331     const SWR_VERTEX_BUFFER_STATE* pVertexBuffers);
 332
 333 //////////////////////////////////////////////////////////////////////////
 334 /// @brief Set index buffer
 335 /// @param hContext - Handle passed back from SwrCreateContext
 336 /// @param pIndexBuffer - Index buffer.
 337 SWR_FUNC(void, SwrSetIndexBuffer,
 338     HANDLE hContext,
 339     const SWR_INDEX_BUFFER_STATE* pIndexBuffer);
 340
 341 //////////////////////////////////////////////////////////////////////////
 342 /// @brief Set fetch shader pointer.
 343 /// @param hContext - Handle passed back from SwrCreateContext
 344 /// @param pfnFetchFunc - Pointer to shader.
 345 SWR_FUNC(void, SwrSetFetchFunc,
 346     HANDLE hContext,
 347     PFN_FETCH_FUNC    pfnFetchFunc);
 348
 349 //////////////////////////////////////////////////////////////////////////
 350 /// @brief Set streamout shader pointer.
 351 /// @param hContext - Handle passed back from SwrCreateContext
 352 /// @param pfnSoFunc - Pointer to shader.
 353 /// @param streamIndex - specifies stream
 354 SWR_FUNC(void, SwrSetSoFunc,
 355     HANDLE hContext,
 356     PFN_SO_FUNC    pfnSoFunc,
 357     uint32_t streamIndex);
 358
 359 //////////////////////////////////////////////////////////////////////////
 360 /// @brief Set streamout state
 361 /// @param hContext - Handle passed back from SwrCreateContext
 362 /// @param pSoState - Pointer to streamout state.
 363 SWR_FUNC(void, SwrSetSoState,
 364     HANDLE hContext,
 365     SWR_STREAMOUT_STATE* pSoState);
 366
 367 //////////////////////////////////////////////////////////////////////////
 368 /// @brief Set streamout buffer state
 369 /// @param hContext - Handle passed back from SwrCreateContext
 370 /// @param pSoBuffer - Pointer to streamout buffer.
 371 /// @param slot - Slot to bind SO buffer to.
 372 SWR_FUNC(void, SwrSetSoBuffers,
 373     HANDLE hContext,
 374     SWR_STREAMOUT_BUFFER* pSoBuffer,
 375     uint32_t slot);
 376
 377 //////////////////////////////////////////////////////////////////////////
 378 /// @brief Set vertex shader pointer.
 379 /// @param hContext - Handle passed back from SwrCreateContext
 380 /// @param pfnVertexFunc - Pointer to shader.
 381 SWR_FUNC(void, SwrSetVertexFunc,
 382     HANDLE hContext,
 383     PFN_VERTEX_FUNC pfnVertexFunc);
 384
 385 //////////////////////////////////////////////////////////////////////////
 386 /// @brief Set frontend state.
 387 /// @param hContext - Handle passed back from SwrCreateContext
 388 /// @param pState - Pointer to state
 389 SWR_FUNC(void, SwrSetFrontendState,
 390     HANDLE hContext,
 391     SWR_FRONTEND_STATE *pState);
 392
 393 //////////////////////////////////////////////////////////////////////////
 394 /// @brief Set geometry shader state.
 395 /// @param hContext - Handle passed back from SwrCreateContext
 396 /// @param pState - Pointer to state
 397 SWR_FUNC(void, SwrSetGsState,
 398     HANDLE hContext,
 399     SWR_GS_STATE *pState);
 400
 401 //////////////////////////////////////////////////////////////////////////
 402 /// @brief Set geometry shader
 403 /// @param hContext - Handle passed back from SwrCreateContext
 404 /// @param pState - Pointer to geometry shader function
 405 SWR_FUNC(void, SwrSetGsFunc,
 406     HANDLE hContext,
 407     PFN_GS_FUNC pfnGsFunc);
 408
 409 //////////////////////////////////////////////////////////////////////////
 410 /// @brief Set compute shader
 411 /// @param hContext - Handle passed back from SwrCreateContext
 412 /// @param pfnCsFunc - Pointer to compute shader function
 413 /// @param totalThreadsInGroup - product of thread group dimensions.
 414 /// @param totalSpillFillSize - size in bytes needed for spill/fill.
 415 /// @param scratchSpaceSizePerInstance - size of the scratch space needed per simd instance
 416 /// @param numInstances - number of simd instances that are run per execution of the shader
 417 SWR_FUNC(void, SwrSetCsFunc,
 418     HANDLE hContext,
 419     PFN_CS_FUNC pfnCsFunc,
 420     uint32_t totalThreadsInGroup,
 421     uint32_t totalSpillFillSize,
 422     uint32_t scratchSpaceSizePerInstance,
 423     uint32_t numInstances
 424     );
 425
 426 //////////////////////////////////////////////////////////////////////////
 427 /// @brief Set tessellation state.
 428 /// @param hContext - Handle passed back from SwrCreateContext
 429 /// @param pState - Pointer to state
 430 SWR_FUNC(void, SwrSetTsState,
 431     HANDLE hContext,
 432     SWR_TS_STATE *pState);
 433
 434 //////////////////////////////////////////////////////////////////////////
 435 /// @brief Set hull shader
 436 /// @param hContext - Handle passed back from SwrCreateContext
 437 /// @param pfnFunc - Pointer to shader function
 438 SWR_FUNC(void, SwrSetHsFunc,
 439     HANDLE hContext,
 440     PFN_HS_FUNC pfnFunc);
 441
 442 //////////////////////////////////////////////////////////////////////////
 443 /// @brief Set domain shader
 444 /// @param hContext - Handle passed back from SwrCreateContext
 445 /// @param pfnFunc - Pointer to shader function
 446 SWR_FUNC(void, SwrSetDsFunc,
 447     HANDLE hContext,
 448     PFN_DS_FUNC pfnFunc);
 449
 450 //////////////////////////////////////////////////////////////////////////
 451 /// @brief Set depth stencil state
 452 /// @param hContext - Handle passed back from SwrCreateContext
 453 /// @param pState - Pointer to state.
 454 SWR_FUNC(void, SwrSetDepthStencilState,
 455     HANDLE hContext,
 456     SWR_DEPTH_STENCIL_STATE *pState);
 457
 458 //////////////////////////////////////////////////////////////////////////
 459 /// @brief Set backend state
 460 /// @param hContext - Handle passed back from SwrCreateContext
 461 /// @param pState - Pointer to state.
 462 SWR_FUNC(void, SwrSetBackendState,
 463     HANDLE hContext,
 464     SWR_BACKEND_STATE *pState);
 465
 466 //////////////////////////////////////////////////////////////////////////
 467 /// @brief Set depth bounds state
 468 /// @param hContext - Handle passed back from SwrCreateContext
 469 /// @param pState - Pointer to state.
 470 SWR_FUNC(void, SwrSetDepthBoundsState,
 471     HANDLE hContext,
 472     SWR_DEPTH_BOUNDS_STATE *pState);
 473
 474 //////////////////////////////////////////////////////////////////////////
 475 /// @brief Set pixel shader state
 476 /// @param hContext - Handle passed back from SwrCreateContext
 477 /// @param pState - Pointer to state.
 478 SWR_FUNC(void, SwrSetPixelShaderState,
 479     HANDLE hContext,
 480     SWR_PS_STATE *pState);
 481
 482 //////////////////////////////////////////////////////////////////////////
 483 /// @brief Set blend state
 484 /// @param hContext - Handle passed back from SwrCreateContext
 485 /// @param pState - Pointer to state.
 486 SWR_FUNC(void, SwrSetBlendState,
 487     HANDLE hContext,
 488     SWR_BLEND_STATE *pState);
 489
 490 //////////////////////////////////////////////////////////////////////////
 491 /// @brief Set blend function
 492 /// @param hContext - Handle passed back from SwrCreateContext
 493 /// @param renderTarget - render target index
 494 /// @param pfnBlendFunc - function pointer
 495 SWR_FUNC(void, SwrSetBlendFunc,
 496     HANDLE hContext,
 497     uint32_t renderTarget,
 498     PFN_BLEND_JIT_FUNC pfnBlendFunc);
 499
 500 //////////////////////////////////////////////////////////////////////////
 501 /// @brief SwrDraw
 502 /// @param hContext - Handle passed back from SwrCreateContext
 503 /// @param topology - Specifies topology for draw.
 504 /// @param startVertex - Specifies start vertex in vertex buffer for draw.
 505 /// @param primCount - Number of vertices.
 506 SWR_FUNC(void, SwrDraw,
 507     HANDLE hContext,
 508     PRIMITIVE_TOPOLOGY topology,
 509     uint32_t startVertex,
 510     uint32_t primCount);
 511
 512 //////////////////////////////////////////////////////////////////////////
 513 /// @brief SwrDrawInstanced
 514 /// @param hContext - Handle passed back from SwrCreateContext
 515 /// @param topology - Specifies topology for draw.
 516 /// @param numVertsPerInstance - How many vertices to read sequentially from vertex data.
 517 /// @param numInstances - How many instances to render.
 518 /// @param startVertex - Specifies start vertex for draw. (vertex data)
 519 /// @param startInstance - Which instance to start sequentially fetching from in each buffer (instanced data)
 520 SWR_FUNC(void, SwrDrawInstanced,
 521     HANDLE hContext,
 522     PRIMITIVE_TOPOLOGY topology,
 523     uint32_t numVertsPerInstance,
 524     uint32_t numInstances,
 525     uint32_t startVertex,
 526     uint32_t startInstance);
 527
 528 //////////////////////////////////////////////////////////////////////////
 529 /// @brief DrawIndexed
 530 /// @param hContext - Handle passed back from SwrCreateContext
 531 /// @param topology - Specifies topology for draw.
 532 /// @param numIndices - Number of indices to read sequentially from index buffer.
 533 /// @param indexOffset - Starting index into index buffer.
 534 /// @param baseVertex - Vertex in vertex buffer to consider as index "0". Note value is signed.
 535 SWR_FUNC(void, SwrDrawIndexed,
 536     HANDLE hContext,
 537     PRIMITIVE_TOPOLOGY topology,
 538     uint32_t numIndices,
 539     uint32_t indexOffset,
 540     int32_t baseVertex);
 541
 542 //////////////////////////////////////////////////////////////////////////
 543 /// @brief SwrDrawIndexedInstanced
 544 /// @param hContext - Handle passed back from SwrCreateContext
 545 /// @param topology - Specifies topology for draw.
 546 /// @param numIndices - Number of indices to read sequentially from index buffer.
 547 /// @param numInstances - Number of instances to render.
 548 /// @param indexOffset - Starting index into index buffer.
 549 /// @param baseVertex - Vertex in vertex buffer to consider as index "0". Note value is signed.
 550 /// @param startInstance - Which instance to start sequentially fetching from in each buffer (instanced data)
 551 SWR_FUNC(void, SwrDrawIndexedInstanced,
 552     HANDLE hContext,
 553     PRIMITIVE_TOPOLOGY topology,
 554     uint32_t numIndices,
 555     uint32_t numInstances,
 556     uint32_t indexOffset,
 557     int32_t baseVertex,
 558     uint32_t startInstance);
 559
 560 //////////////////////////////////////////////////////////////////////////
 561 /// @brief SwrInvalidateTiles
 562 /// @param hContext - Handle passed back from SwrCreateContext
 563 /// @param attachmentMask - The mask specifies which surfaces attached to the hottiles to invalidate.
 564 /// @param invalidateRect - The pixel-coordinate rectangle to invalidate.  This will be expanded to
 565 ///                         be hottile size-aligned.
 566 SWR_FUNC(void, SwrInvalidateTiles,
 567     HANDLE hContext,
 568     uint32_t attachmentMask,
 569     const SWR_RECT& invalidateRect);
 570
 571 //////////////////////////////////////////////////////////////////////////
 572 /// @brief SwrDiscardRect
 573 /// @param hContext - Handle passed back from SwrCreateContext
 574 /// @param attachmentMask - The mask specifies which surfaces attached to the hottiles to discard.
 575 /// @param rect - The pixel-coordinate rectangle to discard.  Only fully-covered hottiles will be
 576 ///               discarded.
 577 SWR_FUNC(void, SwrDiscardRect,
 578     HANDLE hContext,
 579     uint32_t attachmentMask,
 580     const SWR_RECT& rect);
 581
 582 //////////////////////////////////////////////////////////////////////////
 583 /// @brief SwrDispatch
 584 /// @param hContext - Handle passed back from SwrCreateContext
 585 /// @param threadGroupCountX - Number of thread groups dispatched in X direction
 586 /// @param threadGroupCountY - Number of thread groups dispatched in Y direction
 587 /// @param threadGroupCountZ - Number of thread groups dispatched in Z direction
 588 SWR_FUNC(void, SwrDispatch,
 589     HANDLE hContext,
 590     uint32_t threadGroupCountX,
 591     uint32_t threadGroupCountY,
 592     uint32_t threadGroupCountZ);
 593
 594
 595 enum SWR_TILE_STATE
 596 {
 597     SWR_TILE_INVALID    = 0,    // tile is in unitialized state and should be loaded with surface contents before rendering
 598     SWR_TILE_DIRTY      = 2,    // tile contains newer data than surface it represents
 599     SWR_TILE_RESOLVED   = 3,    // is in sync with surface it represents
 600 };
 601
 602 /// @todo Add a good description for what attachments are and when and why you would use the different SWR_TILE_STATEs.
 603 SWR_FUNC(void, SwrStoreTiles,
 604     HANDLE hContext,
 605     uint32_t attachmentMask,
 606     SWR_TILE_STATE postStoreTileState,
 607     const SWR_RECT& storeRect);
 608
 609
 610 //////////////////////////////////////////////////////////////////////////
 611 /// @brief SwrClearRenderTarget - Clear attached render targets / depth / stencil
 612 /// @param hContext - Handle passed back from SwrCreateContext
 613 /// @param attachmentMask - combination of SWR_ATTACHMENT_*_BIT attachments to clear
 614 /// @param renderTargetArrayIndex - the RT array index to clear
 615 /// @param clearColor - color use for clearing render targets
 616 /// @param z - depth value use for clearing depth buffer
 617 /// @param stencil - stencil value used for clearing stencil buffer
 618 /// @param clearRect - The pixel-coordinate rectangle to clear in all cleared buffers
 619 SWR_FUNC(void, SwrClearRenderTarget,
 620     HANDLE hContext,
 621     uint32_t attachmentMask,
 622     uint32_t renderTargetArrayIndex,
 623     const float clearColor[4],
 624     float z,
 625     uint8_t stencil,
 626     const SWR_RECT& clearRect);
 627
 628 //////////////////////////////////////////////////////////////////////////
 629 /// @brief SwrSetRastState
 630 /// @param hContext - Handle passed back from SwrCreateContext
 631 /// @param pRastState - New SWR_RASTSTATE used for SwrDraw* commands
 632 SWR_FUNC(void, SwrSetRastState,
 633     HANDLE hContext,
 634     const SWR_RASTSTATE *pRastState);
 635
 636 //////////////////////////////////////////////////////////////////////////
 637 /// @brief SwrSetViewports
 638 /// @param hContext - Handle passed back from SwrCreateContext
 639 /// @param numViewports - number of viewports passed in
 640 /// @param pViewports - Specifies extents of viewport.
 641 /// @param pMatrices - If not specified then SWR computes a default one.
 642 SWR_FUNC(void, SwrSetViewports,
 643     HANDLE hContext,
 644     uint32_t numViewports,
 645     const SWR_VIEWPORT* pViewports,
 646     const SWR_VIEWPORT_MATRICES* pMatrices);
 647
 648 //////////////////////////////////////////////////////////////////////////
 649 /// @brief SwrSetScissorRects
 650 /// @param hContext - Handle passed back from SwrCreateContext
 651 /// @param numScissors - number of scissors passed in
 652 /// @param pScissors - array of scissors
 653 SWR_FUNC(void, SwrSetScissorRects,
 654     HANDLE hContext,
 655     uint32_t numScissors,
 656     const SWR_RECT* pScissors);
 657
 658 //////////////////////////////////////////////////////////////////////////
 659 /// @brief Returns a pointer to the private context state for the current
 660 ///        draw operation. This is used for external componets such as the
 661 ///        sampler.
 662 ///
 663 /// @note  Client needs to resend private state prior to each draw call.
 664 ///        Also, SWR is responsible for the private state memory.
 665 /// @param hContext - Handle passed back from SwrCreateContext
 666 SWR_FUNC(void*, SwrGetPrivateContextState,
 667     HANDLE hContext);
 668
 669 //////////////////////////////////////////////////////////////////////////
 670 /// @brief Clients can use this to allocate memory for draw/dispatch
 671 ///        operations. The memory will automatically be freed once operation
 672 ///        has completed. Client can use this to allocate binding tables,
 673 ///        etc. needed for shader execution.
 674 /// @param hContext - Handle passed back from SwrCreateContext
 675 /// @param size - Size of allocation
 676 /// @param align - Alignment needed for allocation.
 677 SWR_FUNC(void*, SwrAllocDrawContextMemory,
 678     HANDLE hContext,
 679     uint32_t size,
 680     uint32_t align);
 681
 682 //////////////////////////////////////////////////////////////////////////
 683 /// @brief Enables stats counting
 684 /// @param hContext - Handle passed back from SwrCreateContext
 685 /// @param enable - If true then counts are incremented.
 686 SWR_FUNC(void, SwrEnableStatsFE,
 687     HANDLE hContext,
 688     bool enable);
 689
 690 //////////////////////////////////////////////////////////////////////////
 691 /// @brief Enables stats counting
 692 /// @param hContext - Handle passed back from SwrCreateContext
 693 /// @param enable - If true then counts are incremented.
 694 SWR_FUNC(void, SwrEnableStatsBE,
 695     HANDLE hContext,
 696     bool enable);
 697
 698 //////////////////////////////////////////////////////////////////////////
 699 /// @brief Mark end of frame - used for performance profiling
 700 /// @param hContext - Handle passed back from SwrCreateContext
 701 SWR_FUNC(void, SwrEndFrame,
 702     HANDLE hContext);
 703
 704 //////////////////////////////////////////////////////////////////////////
 705 /// @brief Initialize swr backend and memory internal tables
 706 SWR_FUNC(void, SwrInit);
 707
 708
 709 //////////////////////////////////////////////////////////////////////////
 710 /// @brief Loads a full hottile from a render surface
 711 /// @param hPrivateContext - Handle to private DC
 712 /// @param dstFormat - Format for hot tile.
 713 /// @param renderTargetIndex - Index to src render target
 714 /// @param x, y - Coordinates to raster tile.
 715 /// @param pDstHotTile - Pointer to Hot Tile
 716 SWR_FUNC(void, SwrLoadHotTile,
 717     const SWR_SURFACE_STATE *pSrcSurface,
 718     SWR_FORMAT dstFormat,
 719     SWR_RENDERTARGET_ATTACHMENT renderTargetIndex,
 720     uint32_t x, uint32_t y, uint32_t renderTargetArrayIndex,
 721     uint8_t *pDstHotTile);
 722
 723 //////////////////////////////////////////////////////////////////////////
 724 /// @brief Deswizzles and stores a full hottile to a render surface
 725 /// @param hPrivateContext - Handle to private DC
 726 /// @param srcFormat - Format for hot tile.
 727 /// @param renderTargetIndex - Index to destination render target
 728 /// @param x, y - Coordinates to raster tile.
 729 /// @param pSrcHotTile - Pointer to Hot Tile
 730 SWR_FUNC(void, SwrStoreHotTileToSurface,
 731     SWR_SURFACE_STATE *pDstSurface,
 732     SWR_FORMAT srcFormat,
 733     SWR_RENDERTARGET_ATTACHMENT renderTargetIndex,
 734     uint32_t x, uint32_t y, uint32_t renderTargetArrayIndex,
 735     uint8_t *pSrcHotTile);
 736
 737 //////////////////////////////////////////////////////////////////////////
 738 /// @brief Writes clear color to every pixel of a render surface
 739 /// @param hPrivateContext - Handle to private DC
 740 /// @param renderTargetIndex - Index to destination render target
 741 /// @param x, y - Coordinates to raster tile.
 742 /// @param pClearColor - Pointer to clear color
 743 SWR_FUNC(void, SwrStoreHotTileClear,
 744          SWR_SURFACE_STATE *pDstSurface,
 745          SWR_RENDERTARGET_ATTACHMENT renderTargetIndex,
 746          uint32_t x,
 747          uint32_t y,
 748          uint32_t renderTargetArrayIndex,
 749          const float* pClearColor);
 750
 751 struct SWR_INTERFACE
 752 {
 753     PFNSwrCreateContext pfnSwrCreateContext;
 754     PFNSwrDestroyContext pfnSwrDestroyContext;
 755     PFNSwrBindApiThread pfnSwrBindApiThread;
 756     PFNSwrSaveState pfnSwrSaveState;
 757     PFNSwrRestoreState pfnSwrRestoreState;
 758     PFNSwrSync pfnSwrSync;
 759     PFNSwrStallBE pfnSwrStallBE;
 760     PFNSwrWaitForIdle pfnSwrWaitForIdle;
 761     PFNSwrWaitForIdleFE pfnSwrWaitForIdleFE;
 762     PFNSwrSetVertexBuffers pfnSwrSetVertexBuffers;
 763     PFNSwrSetIndexBuffer pfnSwrSetIndexBuffer;
 764     PFNSwrSetFetchFunc pfnSwrSetFetchFunc;
 765     PFNSwrSetSoFunc pfnSwrSetSoFunc;
 766     PFNSwrSetSoState pfnSwrSetSoState;
 767     PFNSwrSetSoBuffers pfnSwrSetSoBuffers;
 768     PFNSwrSetVertexFunc pfnSwrSetVertexFunc;
 769     PFNSwrSetFrontendState pfnSwrSetFrontendState;
 770     PFNSwrSetGsState pfnSwrSetGsState;
 771     PFNSwrSetGsFunc pfnSwrSetGsFunc;
 772     PFNSwrSetCsFunc pfnSwrSetCsFunc;
 773     PFNSwrSetTsState pfnSwrSetTsState;
 774     PFNSwrSetHsFunc pfnSwrSetHsFunc;
 775     PFNSwrSetDsFunc pfnSwrSetDsFunc;
 776     PFNSwrSetDepthStencilState pfnSwrSetDepthStencilState;
 777     PFNSwrSetBackendState pfnSwrSetBackendState;
 778     PFNSwrSetDepthBoundsState pfnSwrSetDepthBoundsState;
 779     PFNSwrSetPixelShaderState pfnSwrSetPixelShaderState;
 780     PFNSwrSetBlendState pfnSwrSetBlendState;
 781     PFNSwrSetBlendFunc pfnSwrSetBlendFunc;
 782     PFNSwrDraw pfnSwrDraw;
 783     PFNSwrDrawInstanced pfnSwrDrawInstanced;
 784     PFNSwrDrawIndexed pfnSwrDrawIndexed;
 785     PFNSwrDrawIndexedInstanced pfnSwrDrawIndexedInstanced;
 786     PFNSwrInvalidateTiles pfnSwrInvalidateTiles;
 787     PFNSwrDiscardRect pfnSwrDiscardRect;
 788     PFNSwrDispatch pfnSwrDispatch;
 789     PFNSwrStoreTiles pfnSwrStoreTiles;
 790     PFNSwrClearRenderTarget pfnSwrClearRenderTarget;
 791     PFNSwrSetRastState pfnSwrSetRastState;
 792     PFNSwrSetViewports pfnSwrSetViewports;
 793     PFNSwrSetScissorRects pfnSwrSetScissorRects;
 794     PFNSwrGetPrivateContextState pfnSwrGetPrivateContextState;
 795     PFNSwrAllocDrawContextMemory pfnSwrAllocDrawContextMemory;
 796     PFNSwrEnableStatsFE pfnSwrEnableStatsFE;
 797     PFNSwrEnableStatsBE pfnSwrEnableStatsBE;
 798     PFNSwrEndFrame pfnSwrEndFrame;
 799     PFNSwrInit pfnSwrInit;
 800     PFNSwrLoadHotTile pfnSwrLoadHotTile;
 801     PFNSwrStoreHotTileToSurface pfnSwrStoreHotTileToSurface;
 802     PFNSwrStoreHotTileClear pfnSwrStoreHotTileClear;
 803 };
 804
 805 extern "C" {
 806 typedef void (SWR_API * PFNSwrGetInterface)(SWR_INTERFACE &out_funcs);
 807 SWR_VISIBLE void SWR_API SwrGetInterface(SWR_INTERFACE &out_funcs);
 808 }
 809
 810 #endif