1#include "ContextD3D11.h"
2#include "GraphicsDeviceD3D11.h"
3#include "FormatsD3D11.h"
5#include "Foundation/Logging/Logger.h"
19 } renderStats = { 0 };
26 const D3D11_PRIMITIVE_TOPOLOGY Topologies[] = {
27 D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST,
28 D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
29 D3D11_PRIMITIVE_TOPOLOGY_LINELIST,
30 D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP,
31 D3D11_PRIMITIVE_TOPOLOGY_POINTLIST,
32 D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ,
33 D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ,
34 D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ,
35 D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ,
36 D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST,
37 D3D11_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST,
38 D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST,
39 D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST,
42 const D3D11_MAP MapFlags[] = {
46 D3D11_MAP_WRITE_DISCARD
51Cogs::ContextD3D11::ContextD3D11() :
52 defaultBlendState(BlendStateHandle::InvalidHandle),
53 defaultDepthStencilState(DepthStencilStateHandle::InvalidHandle),
54 defaultRasterizerState(RasterizerStateHandle::InvalidHandle),
55 currentRenderTarget(RenderTargetHandle::InvalidHandle),
56 currentDepthStencil(DepthStencilHandle::InvalidHandle),
57 currentInputLayout(InputLayoutHandle::InvalidHandle),
63Cogs::ContextD3D11::~ContextD3D11()
65 if (immediateContext) {
66 immediateContext->ClearState();
67 immediateContext->Flush();
71void Cogs::ContextD3D11::initialize(GraphicsDeviceD3D11 * graphicsDevice, BuffersD3D11 * buffers, TexturesD3D11 * textures, EffectsD3D11 * effects, RenderTargetsD3D11 * renderTargets, SyncObjectsD3D11* sync)
73 this->constantBuffersUpdated =
false;
75 this->graphicsDevice = graphicsDevice;
76 this->buffers = buffers;
77 this->textures = textures;
78 this->effects = effects;
79 this->renderTargets = renderTargets;
80 this->syncObjects = sync;
85 this->renderTargets->rasterizerStates.pin(this->defaultRasterizerState);
88 this->renderTargets->blendStates.pin(this->defaultBlendState);
91 this->renderTargets->depthStencilStates.pin(this->defaultDepthStencilState);
94 this->textures->samplerStates.pin(this->defaultSamplerState);
96 HRESULT hr = immediateContext->QueryInterface(__uuidof(annotationInterface), annotationInterface.internalVoidPointer());
105void Cogs::ContextD3D11::setDevice(ResourcePointer<ID3D11Device>& device, ResourcePointer<ID3D11Device1>& device1)
107 assert(this->device ==
nullptr &&
"Device already set");
108 assert(this->device1 ==
nullptr &&
"Device1 already set");
109 assert(immediateContext ==
nullptr &&
"Immediate context already set");
110 assert(immediateContext1 ==
nullptr &&
"Immediate context already set");
112 this->device = device;
113 this->device1 = device1;
115 this->device1->GetImmediateContext1(this->immediateContext1.internalPointer());
117 this->device->GetImmediateContext(this->immediateContext.internalPointer());
119 if (HRESULT hr = immediateContext->QueryInterface(__uuidof(ID3D11DeviceContext4), immediateContext4.internalVoidPointer()); SUCCEEDED(hr)) {
120 LOG_DEBUG(logger,
"Got ID3D11DeviceContext4 interface");
126void Cogs::ContextD3D11::setDefaults()
128 this->constantBuffersUpdated =
false;
130 this->isCompute =
false;
132 immediateContext->RSSetScissorRects(0,
nullptr);
134 this->setBlendState(defaultBlendState,
nullptr);
135 this->setRasterizerState(defaultRasterizerState);
136 this->setDepthStencilState(defaultDepthStencilState);
141 ID3D11ShaderResourceView * shaderResourceViews[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { 0 };
142 immediateContext->VSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
143 immediateContext->GSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
144 immediateContext->PSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
145 immediateContext->CSSetShaderResources(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, shaderResourceViews);
147 ID3D11SamplerState * samplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = { this->textures->samplerStates[defaultSamplerState] };
148 immediateContext->VSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
149 immediateContext->GSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
150 immediateContext->PSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
151 immediateContext->CSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
153 ID3D11Buffer * constantBuffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { 0 };
154 immediateContext->VSSetConstantBuffers(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, constantBuffers);
155 immediateContext->GSSetConstantBuffers(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, constantBuffers);
156 immediateContext->PSSetConstantBuffers(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, constantBuffers);
160 constantBuffersUpdated =
false;
165 if (HandleIsValid(fenceHandle) && immediateContext4) {
166 FenceD3D11& fence = syncObjects->fences[fenceHandle];
167 immediateContext4->Signal(fence.fence, ++fence.value);
174 if (!annotationInterface)
return;
176 static thread_local std::wstring wname;
178 if (annotationInterface->GetStatus()) {
179 wname.assign(name.
begin(), name.
end());
181 annotationInterface->BeginEvent(wname.c_str());
187 if (!annotationInterface)
return;
189 if (annotationInterface->GetStatus()) {
190 annotationInterface->EndEvent();
196 if(!annotationInterface)
return;
198 static thread_local std::wstring wname;
200 if (annotationInterface->GetStatus()) {
201 wname.assign(name.
begin(), name.
end());
203 annotationInterface->SetMarker(wname.c_str());
209 iaState.numVertexBuffers = count;
211 for (
size_t i = 0; i < count; i++) {
212 auto & buffer = buffers->buffers[
BufferHandle(handles[i].handle)];
214 iaState.formats[i] = buffer.vertexBuffer.vertexFormat;
215 iaState.currentVertexBuffers[i] = buffer.buffer;
216 iaState.strides[i] = strides[i];
217 iaState.offsets[i] = offsets ? offsets[i] : 0;
221 immediateContext->IASetVertexBuffers(0,
static_cast<UINT
>(count), iaState.currentVertexBuffers, iaState.strides, iaState.offsets);
223 immediateContext->IASetVertexBuffers(0, 0,
nullptr,
nullptr,
nullptr);
229 uint32_t strides[kMaxVertexInputSlots];
230 uint32_t offsets[kMaxVertexInputSlots];
232 for (
size_t i = 0; i < count; i++) {
233 auto & buffer = buffers->buffers[
BufferHandle(handles[i].handle)];
235 assert(buffer.vertexBuffer.vertexFormat &&
"Vertex buffer must have been created with format information attached.");
237 strides[i] = getSize(*buffer.vertexBuffer.vertexFormat);
241 setVertexBuffers(handles, count, strides, offsets);
246 if (HandleIsValid(indexBufferHandle)) {
247 auto & indexBuffer = buffers->buffers[indexBufferHandle];
249 iaState.currentIndexBuffer = &indexBuffer;
253 auto format = stride == 0 ? iaState.currentIndexBuffer->indexBuffer.indexFormat : (stride == 4 ? DXGI_FORMAT_R32_UINT : DXGI_FORMAT_R16_UINT);
255 if (format == DXGI_FORMAT_UNKNOWN) {
256 iaState.currentIndexBuffer =
nullptr;
257 immediateContext->IASetIndexBuffer(
nullptr, DXGI_FORMAT_UNKNOWN, 0);
259 immediateContext->IASetIndexBuffer(indexBuffer.buffer, format, offset);
262 iaState.currentIndexBuffer =
nullptr;
263 immediateContext->IASetIndexBuffer(
nullptr, DXGI_FORMAT_UNKNOWN, 0);
269 auto & effect = effects->effects[currentEffect];
270 if (offset == 0 && size == ~0u) {
271 if (this->isCompute) {
272 const uint32_t csSlot = decode(bufferBinding.
handle);
274 if (HandleIsValid(bufferHandle)) {
275 auto & buffer = buffers->buffers[bufferHandle];
277 if (csSlot != NoBinding11) immediateContext->CSSetConstantBuffers(csSlot, 1, &buffer.buffer);
279 constantBuffersUpdated =
true;
281 for (
auto & constantBuffer : effect.shaders[ShaderType::ComputeShader].reflection.constantBuffers) {
282 if (constantBuffer.slot == csSlot) {
283 constantBuffer.manual =
true;
288 if (csSlot != NoBinding11) immediateContext->CSSetConstantBuffers(csSlot, 0,
nullptr);
292 uint32_t slots[ShaderType::NumShaderTypes];
293 decode(bufferBinding.
handle, slots);
295 if (HandleIsValid(bufferHandle)) {
296 auto & buffer = buffers->buffers[bufferHandle];
298 if (slots[0] != NoBinding11 && bufferHandle != state.vsCBs[slots[0]]) {
299 immediateContext->VSSetConstantBuffers(slots[0], 1, &buffer.buffer);
300 state.vsCBs[slots[0]] = bufferHandle;
302 if (slots[1] != NoBinding11) {
303 immediateContext->HSSetConstantBuffers(slots[1], 1, &buffer.buffer);
305 if (slots[2] != NoBinding11) {
306 immediateContext->DSSetConstantBuffers(slots[2], 1, &buffer.buffer);
308 if (slots[3] != NoBinding11) {
309 immediateContext->GSSetConstantBuffers(slots[3], 1, &buffer.buffer);
311 if (slots[4] != NoBinding11 && bufferHandle != state.psCBs[slots[4]]) {
312 immediateContext->PSSetConstantBuffers(slots[4], 1, &buffer.buffer);
313 state.psCBs[slots[4]] = bufferHandle;
316 for (
size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
317 for (
auto & constantBuffer : effect.shaders[i].reflection.constantBuffers) {
318 if (constantBuffer.slot == slots[i]) {
319 constantBuffer.manual =
true;
325 if (slots[0] != NoBinding11) {
326 immediateContext->VSSetConstantBuffers(slots[0], 0,
nullptr);
328 if (slots[1] != NoBinding11) {
329 immediateContext->GSSetConstantBuffers(slots[1], 0,
nullptr);
331 if (slots[2] != NoBinding11) {
332 immediateContext->PSSetConstantBuffers(slots[2], 0,
nullptr);
339 LOG_ERROR(logger,
"Binding part of a constant buffer requires DX 11.1");
342 assert(immediateContext1);
345 LOG_ERROR(logger,
"Constant buffer offset must be a multiple of 256 bytes.");
348 UINT firstConstant = offset / 16;
349 UINT numConstant = 4096;
352 LOG_ERROR(logger,
"Constant buffer size must be a multiple of 256 bytes.");
355 numConstant = size / 16;
356 if (4096 < numConstant) {
357 LOG_ERROR(logger,
"Constant buffer size cannot be larger than 16*4096 bytes.");
362 if (this->isCompute) {
363 const uint32_t csSlot = decode(bufferBinding.
handle);
365 if (HandleIsValid(bufferHandle)) {
366 auto & buffer = buffers->buffers[bufferHandle];
368 if (csSlot != NoBinding11) immediateContext1->CSSetConstantBuffers1(csSlot, 1, &buffer.buffer, &firstConstant, &numConstant);
370 constantBuffersUpdated =
true;
372 for (
auto & constantBuffer : effect.shaders[ShaderType::ComputeShader].reflection.constantBuffers) {
373 if (constantBuffer.slot == csSlot) {
374 constantBuffer.manual =
true;
379 if (csSlot != NoBinding11) immediateContext1->CSSetConstantBuffers1(csSlot, 0,
nullptr,
nullptr,
nullptr);
383 uint32_t slots[ShaderType::NumShaderTypes];
384 decode(bufferBinding.
handle, slots);
386 if (HandleIsValid(bufferHandle)) {
387 auto & buffer = buffers->buffers[bufferHandle];
389 if (slots[0] != NoBinding11) {
390 immediateContext1->VSSetConstantBuffers1(slots[0], 1, &buffer.buffer, &firstConstant, &numConstant);
393 if (slots[1] != NoBinding11) {
394 immediateContext1->HSSetConstantBuffers1(slots[1], 1, &buffer.buffer, &firstConstant, &numConstant);
396 if (slots[2] != NoBinding11) {
397 immediateContext1->DSSetConstantBuffers1(slots[2], 1, &buffer.buffer, &firstConstant, &numConstant);
399 if (slots[3] != NoBinding11) {
400 immediateContext1->GSSetConstantBuffers1(slots[3], 1, &buffer.buffer, &firstConstant, &numConstant);
402 if (slots[4] != NoBinding11) {
403 immediateContext1->PSSetConstantBuffers1(slots[4], 1, &buffer.buffer, &firstConstant, &numConstant);
407 for (
size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
408 for (
auto & constantBuffer : effect.shaders[i].reflection.constantBuffers) {
409 if (constantBuffer.slot == slots[i]) {
410 constantBuffer.manual =
true;
416 if (slots[0] != NoBinding11) {
417 immediateContext1->VSSetConstantBuffers1(slots[0], 0,
nullptr,
nullptr,
nullptr);
419 if (slots[1] != NoBinding11) {
420 immediateContext1->GSSetConstantBuffers1(slots[1], 0,
nullptr,
nullptr,
nullptr);
422 if (slots[2] != NoBinding11) {
423 immediateContext1->PSSetConstantBuffers1(slots[2], 0,
nullptr,
nullptr,
nullptr);
433 if (state.primitiveType != primitiveType) {
434 state.primitiveType = primitiveType;
435 immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
438 setupConstantBuffers();
440 immediateContext->Draw(
static_cast<UINT
>(numVertexes),
static_cast<UINT
>(startVertex));
442 renderStats.numFaces += numVertexes / 3;
443 renderStats.numVertices += numVertexes;
444 ++renderStats.drawCalls;
446 if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes,
false); }
451 if (state.primitiveType != primitiveType) {
452 state.primitiveType = primitiveType;
453 immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
456 setupConstantBuffers();
458 const UINT start =
static_cast<UINT
>(startIndex);
459 const UINT count = numIndexes == 0 ?
static_cast<UINT
>(iaState.currentIndexBuffer->indexBuffer.count) :
static_cast<UINT
>(numIndexes);
461 immediateContext->DrawIndexed(count, start,
static_cast<UINT
>(startVertex));
463 renderStats.numIndices += numIndexes;
464 renderStats.numFaces += numIndexes / 3;
465 renderStats.numVertices += numIndexes;
466 ++renderStats.drawCalls;
468 if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(count,
true); }
474 immediateContext->RSSetState(this->renderTargets->rasterizerStates[defaultRasterizerState]);
476 assert(this->renderTargets->rasterizerStates.hasResource(handle) &&
"Invalid rasterizer state handle.");
477 immediateContext->RSSetState(this->renderTargets->rasterizerStates[handle]);
484 immediateContext->OMSetBlendState(this->renderTargets->blendStates[defaultBlendState], 0, 0xffffffff);
486 assert(this->renderTargets->blendStates.hasResource(handle) &&
"Invalid blend state handle.");
487 immediateContext->OMSetBlendState(this->renderTargets->blendStates[handle], constant, 0xffffffff);
494 immediateContext->OMSetDepthStencilState(this->renderTargets->depthStencilStates[defaultDepthStencilState], 1);
496 assert(this->renderTargets->depthStencilStates.hasResource(handle) &&
"Invalid depth stencil state handle.");
497 immediateContext->OMSetDepthStencilState(this->renderTargets->depthStencilStates[handle], 1);
503 assert(!inRenderPass);
504 setRenderTarget(info.renderTargetHandle, info.depthStencilHandle);
506 auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
507 for (
size_t i = 0; i < renderTarget.numViews; ++i) {
508 if(info.loadOp[i] == LoadOp::Clear){
509 immediateContext->ClearRenderTargetView(renderTarget.views[i], info.clearValue[i]);
513 if(info.depthLoadOp == LoadOp::Clear){
514 clearDepth(info.depthClearValue);
517 renderPassInfo = info;
522 assert(inRenderPass);
523 if(HandleIsValid(renderPassInfo.renderTargetHandle)){
524 RenderTargetD3D11 &target = renderTargets->renderTargets[renderPassInfo.renderTargetHandle];
525 for(
size_t i=0; i<target.numViews; i++){
526 if(HandleIsValid(renderPassInfo.resolveHandle[i])){
527 resolveResource(target.texture[i], textures->textureViews[renderPassInfo.resolveHandle[i]].texture);
531 inRenderPass =
false;
538 SwapChainD3D11* swapChain = graphicsDevice->getDefaultSwapChain();
544 currentRenderTarget = handle;
545 currentDepthStencil = depthStencilHandle;
550 updateRenderTargets();
553void Cogs::ContextD3D11::endFrame()
560 D3D11_VIEWPORT viewport;
561 viewport.TopLeftX = x;
562 viewport.TopLeftY = y;
563 viewport.Width = width;
564 viewport.Height = height;
565 viewport.MinDepth = 0.0f;
566 viewport.MaxDepth = 1.0f;
568 immediateContext->RSSetViewports(1, &viewport);
573 D3D11_RECT scissor{ x, y, z, w };
575 immediateContext->RSSetScissorRects(1, &scissor);
580 clearRenderTarget(&value, 1);
585 assert(HandleIsValid(currentRenderTarget) &&
"No valid render target set.");
587 auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
589 for (
size_t i = 0; i < renderTarget.numViews; ++i) {
590 immediateContext->ClearRenderTargetView(renderTarget.views[i], numValues != 1 ? values[i] : values[0]);
596 assert(HandleIsValid(currentDepthStencil) &&
"No valid depth stencil target set.");
598 immediateContext->ClearDepthStencilView(renderTargets->depthStencilViews[currentDepthStencil], D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, depth, 0);
603 if (effectHandle == currentEffect)
return;
605 assert(HandleIsValid(effectHandle) &&
"Effect handle not valid.");
607 if (HandleIsValid(currentEffect)) {
609 ID3D11UnorderedAccessView * UAVs[D3D11_PS_CS_UAV_REGISTER_COUNT] = { 0 };
610 immediateContext->CSSetUnorderedAccessViews(0, D3D11_PS_CS_UAV_REGISTER_COUNT, UAVs,
nullptr);
612 for (
int i = 0; i < D3D11_PS_CS_UAV_REGISTER_COUNT; ++i) {
620 ID3D11SamplerState * samplerStates[D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT] = { this->textures->samplerStates[defaultSamplerState] };
621 immediateContext->VSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
622 immediateContext->GSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
623 immediateContext->PSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
624 immediateContext->CSSetSamplers(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, samplerStates);
626 ID3D11Buffer * constantBuffers[D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT] = { 0 };
627 if (state.dirtyCB[ShaderType::VertexShader]) {
628 immediateContext->VSSetConstantBuffers(0, state.dirtyCB[ShaderType::VertexShader], constantBuffers);
630 if (state.dirtyCB[ShaderType::GeometryShader]) {
631 immediateContext->GSSetConstantBuffers(0, state.dirtyCB[ShaderType::GeometryShader], constantBuffers);
633 if (state.dirtyCB[ShaderType::PixelShader]) {
634 immediateContext->PSSetConstantBuffers(0, state.dirtyCB[ShaderType::PixelShader], constantBuffers);
636 if (state.dirtyCB[ShaderType::ComputeShader]) {
637 immediateContext->CSSetConstantBuffers(0, state.dirtyCB[ShaderType::ComputeShader], constantBuffers);
645 currentEffect = effectHandle;
646 constantBuffersUpdated =
false;
649 auto & effect = effects->effects[currentEffect];
651 ContextCommon::setCurrentEffect(&effect);
653 bool wasCompute = isCompute;
654 if (effect.computeShader.shader) {
655 immediateContext->CSSetShader(effect.computeShader.shader.get<ID3D11ComputeShader>(),
nullptr, 0);
658 immediateContext->VSSetShader(effect.vertexShader.shader.get<ID3D11VertexShader>(),
nullptr, 0);
659 immediateContext->HSSetShader(effect.hullShader.shader.get<ID3D11HullShader>(),
nullptr, 0);
660 immediateContext->DSSetShader(effect.domainShader.shader.get<ID3D11DomainShader>(),
nullptr, 0);
661 immediateContext->GSSetShader(effect.geometryShader.shader.get<ID3D11GeometryShader>(),
nullptr, 0);
662 immediateContext->PSSetShader(effect.pixelShader.shader.get<ID3D11PixelShader>(),
nullptr, 0);
665 if (wasCompute != isCompute) {
666 updateRenderTargets();
672 if (inputLayoutHandle != currentInputLayout) {
673 if (HandleIsValid(inputLayoutHandle)) {
674 immediateContext->IASetInputLayout(buffers->inputLayouts[inputLayoutHandle].resource);
677 immediateContext->IASetInputLayout(
nullptr);
680 if (inputLayoutHandle) {
681 const auto & inputLayout = buffers->inputLayouts[inputLayoutHandle];
683 iaState.numVertexBuffers = inputLayout.numFormats;
684 for (
size_t i = 0; i < inputLayout.numFormats; ++i) {
685 iaState.formats[i] = inputLayout.formats[i];
689 currentInputLayout = inputLayoutHandle;
695 auto & source = textures->textures[sourceTexture];
696 auto & destination = textures->textures[destinationTexture];
700 immediateContext->ResolveSubresource(destination.resource(), 0, source.resource(), 0, formatD3D);
705 if (state.primitiveType != primitiveType) {
706 state.primitiveType = primitiveType;
707 immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
710 this->setupConstantBuffers();
712 immediateContext->DrawInstanced(
static_cast<UINT
>(numVertexes),
static_cast<UINT
>(numInstances),
static_cast<UINT
>(startVertex),
static_cast<UINT
>(startInstance));
714 renderStats.numFaces += numVertexes / 3 * numInstances;
715 renderStats.numVertices += numVertexes * numInstances;
717 if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(numVertexes * numInstances,
false); }
722 if (state.primitiveType != primitiveType) {
723 state.primitiveType = primitiveType;
724 immediateContext->IASetPrimitiveTopology(Direct3D11::Topologies[primitiveType]);
727 this->setupConstantBuffers();
729 UINT indexCount = (numIndexes == 0) ? iaState.currentIndexBuffer->indexBuffer.count :
static_cast<UINT
>(numIndexes);
731 immediateContext->DrawIndexedInstanced(indexCount,
static_cast<UINT
>(numInstances),
static_cast<UINT
>(startIndex), 0,
static_cast<UINT
>(startInstance));
733 renderStats.numFaces += numIndexes / 3 * numInstances;
734 renderStats.numVertices += numIndexes * numInstances;
736 if (frameStatisticsEnabled) { frameStatisticsAccountDrawCall(indexCount * numInstances,
true); }
741 if (!HandleIsValid(bufferHandle))
return;
743 auto & depthStencilView = renderTargets->depthStencilViews[currentDepthStencil];
746 depthStencilView->GetResource((ID3D11Resource **)&depthBuffer);
748 D3D11_TEXTURE2D_DESC depthBufferDesc;
749 depthBuffer->GetDesc(&depthBufferDesc);
751 D3D11_TEXTURE2D_DESC fpTextureDesc{};
752 fpTextureDesc.Width = depthBufferDesc.Width;
753 fpTextureDesc.Height = depthBufferDesc.Height;
754 fpTextureDesc.ArraySize = 1;
755 fpTextureDesc.MipLevels = 1;
756 fpTextureDesc.Format = DXGI_FORMAT_R32_FLOAT;
757 fpTextureDesc.SampleDesc.Count = depthBufferDesc.SampleDesc.Count;
758 fpTextureDesc.SampleDesc.Quality = depthBufferDesc.SampleDesc.Quality;
759 fpTextureDesc.Usage = D3D11_USAGE_DEFAULT;
760 fpTextureDesc.BindFlags = D3D11_BIND_RENDER_TARGET;
761 fpTextureDesc.CPUAccessFlags = 0;
762 fpTextureDesc.MiscFlags = 0;
765 HRESULT hr = device->CreateTexture2D(&fpTextureDesc,
nullptr, fpDepthTexture.internalPointer());
767 LOG_ERROR(logger,
"Failed to create depth readback texture (%s): %s", getString(fpTextureDesc), direct3D11ReturnCodeAsString(hr));
771 LOG_TRACE(logger,
"Created resource %p: %s", fpDepthTexture.get<
void>(), getString(fpTextureDesc));
776 immediateContext->CopyResource(fpDepthTexture, depthBuffer);
778 const bool isMultisampled = depthBufferDesc.SampleDesc.Count > 1;
781 if (isMultisampled) {
782 D3D11_TEXTURE2D_DESC resolveTextureDesc = {};
783 resolveTextureDesc.Width = depthBufferDesc.Width;
784 resolveTextureDesc.Height = depthBufferDesc.Height;
785 resolveTextureDesc.ArraySize = 1;
786 resolveTextureDesc.MipLevels = 1;
787 resolveTextureDesc.Format = DXGI_FORMAT_R32_FLOAT;
788 resolveTextureDesc.SampleDesc.Count = 1;
789 resolveTextureDesc.SampleDesc.Quality = 0;
790 resolveTextureDesc.Usage = D3D11_USAGE_DEFAULT;
791 resolveTextureDesc.BindFlags = 0;
792 resolveTextureDesc.CPUAccessFlags = 0;
793 resolveTextureDesc.MiscFlags = 0;
795 hr = device->CreateTexture2D(&resolveTextureDesc,
nullptr, resolvedDepthTexture.internalPointer());
797 LOG_ERROR(logger,
"Failed to create depth readback resolve texture (%s): %s", getString(resolveTextureDesc), direct3D11ReturnCodeAsString(hr));
801 LOG_TRACE(logger,
"Created resource %p: %s", resolvedDepthTexture.get<
void>(), getString(resolveTextureDesc));
804 immediateContext->ResolveSubresource(resolvedDepthTexture, 0, fpDepthTexture, 0, resolveTextureDesc.Format);
807 auto & buffer = buffers->buffers[bufferHandle];
809 if (!buffer.aliasedTexture || buffer.aliasedWidth != width || buffer.aliasedHeight != height) {
810 D3D11_TEXTURE2D_DESC readTextureDesc{};
811 readTextureDesc.Width = width;
812 readTextureDesc.Height = height;
813 readTextureDesc.ArraySize = 1;
814 readTextureDesc.MipLevels = 1;
815 readTextureDesc.Format = DXGI_FORMAT_R32_TYPELESS;
816 readTextureDesc.SampleDesc.Count = 1;
817 readTextureDesc.SampleDesc.Quality = 0;
818 readTextureDesc.Usage = D3D11_USAGE_STAGING;
819 readTextureDesc.BindFlags = 0;
820 readTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
821 readTextureDesc.MiscFlags = 0;
823 hr = device->CreateTexture2D(&readTextureDesc,
nullptr, buffer.aliasedTexture.internalPointer());
825 LOG_ERROR(logger,
"Failed to create depth readback staging texture (%s): %s", getString(readTextureDesc), direct3D11ReturnCodeAsString(hr));
829 LOG_TRACE(logger,
"Created resource %p: %s", buffer.aliasedTexture.get<
void>(), getString(readTextureDesc));
835 renderBox.right = x + width;
837 renderBox.bottom = y + height;
841 immediateContext->CopySubresourceRegion(buffer.aliasedTexture, 0, 0, 0, 0, isMultisampled ? resolvedDepthTexture : fpDepthTexture, 0, &renderBox);
846 auto & renderTarget = renderTargets->renderTargets[currentRenderTarget];
849 renderTarget.views[0]->GetResource((ID3D11Resource **)&renderTexture);
851 D3D11_TEXTURE2D_DESC renderBufferDesc;
852 renderTexture->GetDesc(&renderBufferDesc);
854 const bool isMultisampled = renderBufferDesc.SampleDesc.Count > 1;
857 if (isMultisampled) {
858 D3D11_TEXTURE2D_DESC resolveTextureDesc{};
859 resolveTextureDesc.Width = renderBufferDesc.Width;
860 resolveTextureDesc.Height = renderBufferDesc.Height;
861 resolveTextureDesc.ArraySize = 1;
862 resolveTextureDesc.MipLevels = 1;
863 resolveTextureDesc.Format = renderBufferDesc.Format;
864 resolveTextureDesc.SampleDesc.Count = 1;
865 resolveTextureDesc.SampleDesc.Quality = 0;
866 resolveTextureDesc.Usage = D3D11_USAGE_DEFAULT;
867 resolveTextureDesc.BindFlags = 0;
868 resolveTextureDesc.CPUAccessFlags = 0;
869 resolveTextureDesc.MiscFlags = 0;
871 HRESULT hr = device->CreateTexture2D(&resolveTextureDesc,
nullptr, resolvedRenderTexture.internalPointer());
873 LOG_ERROR(logger,
"Failed to create readback resolve texture (%s): %s", getString(resolveTextureDesc), direct3D11ReturnCodeAsString(hr));
877 LOG_TRACE(logger,
"Created resource %p: %s", resolvedRenderTexture.get<
void>(), getString(resolveTextureDesc));
879 immediateContext->ResolveSubresource(resolvedRenderTexture, 0, renderTexture, 0, renderBufferDesc.Format);
882 BufferD3D11 & buffer = buffers->buffers[bufferHandle];
884 if (!buffer.aliasedTexture || buffer.aliasedWidth != width || buffer.aliasedHeight != height) {
885 D3D11_TEXTURE2D_DESC renderTextureDesc{};
886 renderTextureDesc.Width = width;
887 renderTextureDesc.Height = height;
888 renderTextureDesc.ArraySize = 1;
889 renderTextureDesc.MipLevels = 1;
890 renderTextureDesc.Format = renderBufferDesc.Format;
891 renderTextureDesc.SampleDesc.Count = 1;
892 renderTextureDesc.SampleDesc.Quality = 0;
893 renderTextureDesc.Usage = D3D11_USAGE_STAGING;
894 renderTextureDesc.BindFlags = 0;
895 renderTextureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
896 renderTextureDesc.MiscFlags = 0;
898 HRESULT hr = device->CreateTexture2D(&renderTextureDesc,
nullptr, buffer.aliasedTexture.internalPointer());
900 LOG_ERROR(logger,
"Failed to create readback staging texture (%s): %s", getString(renderTextureDesc), direct3D11ReturnCodeAsString(hr));
904 LOG_TRACE(logger,
"Created resource %p: %s", buffer.aliasedTexture.get<
void>(), getString(renderTextureDesc));
906 buffer.aliasedWidth = width;
907 buffer.aliasedHeight = height;
912 renderBox.right = x + width;
914 renderBox.bottom = y + height;
918 immediateContext->CopySubresourceRegion(buffer.aliasedTexture, 0, 0, 0, 0, isMultisampled ? resolvedRenderTexture : renderTexture, 0, &renderBox);
923 auto & buffer = this->buffers->buffers[bufferHandle];
925 D3D11_MAPPED_SUBRESOURCE resource{};
928 HRESULT hr = immediateContext->Map(buffer.aliasedTexture, 0, Direct3D11::MapFlags[accessMode], 0, &resource);
929 buffer.aliasMapped =
true;
931 *stride = resource.RowPitch;
934 LOG_ERROR(logger,
"Failed to map alias texture resource %p: %s", buffer.aliasedTexture.get<
void>(), direct3D11ReturnCodeAsString(hr));
939 HRESULT hr = immediateContext->Map(buffer.buffer, 0, Direct3D11::MapFlags[accessMode], 0, &resource);
941 LOG_ERROR(logger,
"Failed to map buffer resource %p: %s", buffer.buffer.get<
void>(), direct3D11ReturnCodeAsString(hr));
946 return resource.pData;
951 auto & buffer = this->buffers->buffers[bufferHandle];
953 if (buffer.aliasMapped) {
954 immediateContext->Unmap(buffer.aliasedTexture, 0);
956 immediateContext->Unmap(buffer.buffer, 0);
962 auto & texture = textures->textures[textureHandle];
964 D3D11_MAPPED_SUBRESOURCE resource{};
965 HRESULT hr = immediateContext->Map(texture.resource(), 0, Direct3D11::MapFlags[accessMode], 0, &resource);
967 LOG_ERROR(logger,
"Failed to map texture resource %p: %s", texture.resource(), direct3D11ReturnCodeAsString(hr));
970 if (rowPitch) *rowPitch = resource.RowPitch;
971 if (depthPitch) *depthPitch = resource.DepthPitch;
972 return resource.pData;
977 auto & texture = textures->textures[textureHandle];
979 immediateContext->Unmap(texture.resource(), 0);
985 assert(HandleIsValid(textureHandle) &&
"Texture handle must be a valid texture.");
987 auto & texture = this->textures->textures[textureHandle];
989 const uint32_t width = Cogs::getMipSize(texture.width,
static_cast<uint32_t
>(level));
990 const uint32_t height = Cogs::getMipSize(texture.height,
static_cast<uint32_t
>(level));
994 rectangle.right = width;
996 rectangle.bottom = height;
1001 immediateContext->UpdateSubresource(texture.resource(),
static_cast<UINT
>(level), &rectangle, data, width *
static_cast<uint32_t
>(getBlockSize(texture.format)), 1);
1002 if(uploadStatisticsEnabled){
1004 size_t size = width * height * getBlockSize(texture.format);
1005 uploadStatisticsTextureUpload(size);
1011 assert(HandleIsValid(bufferHandle) &&
"Buffer handle must point to a valid buffer.");
1013 auto & buffer = this->buffers->buffers[bufferHandle];
1015 assert(buffer.size >= offset + size &&
"Buffer size not sufficient to hold data.");
1017 D3D11_BOX rectangle;
1018 rectangle.left =
static_cast<UINT
>(offset);
1019 rectangle.right =
static_cast<UINT
>(offset + size);
1021 rectangle.bottom = 1;
1022 rectangle.front = 0;
1025 immediateContext->UpdateSubresource(buffer.buffer, 0u, &rectangle, data, 0, 0);
1026 if(uploadStatisticsEnabled) uploadStatisticsBufferUpload(size);
1031 auto & destination = buffers->buffers[destinationHandle];
1032 auto & source = buffers->buffers[sourceHandle];
1034 immediateContext->CopyResource(destination.buffer, source.buffer);
1037void Cogs::ContextD3D11::copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle)
1039 auto & destination = textures->textures[destinationHandle];
1040 auto & source = textures->textures[sourceHandle];
1042 immediateContext->CopyResource(destination.resource(), source.resource());
1045void Cogs::ContextD3D11::copyTexture(TextureHandle dstHandle,
unsigned dstSub,
unsigned dstX,
unsigned dstY,
unsigned dstZ, TextureHandle sourceHandle,
unsigned srcSub)
1047 auto & destination = textures->textures[dstHandle];
1048 auto & source = textures->textures[sourceHandle];
1049 immediateContext->CopySubresourceRegion(destination.resource(), dstSub,
1051 source.resource(), srcSub, NULL);
1054void Cogs::ContextD3D11::clearResource(BufferHandle destinationHandle, uint32_t *Values)
1056 auto & destination = buffers->buffers[destinationHandle];
1057 immediateContext->ClearUnorderedAccessViewUint(destination.uav, Values);
1060void Cogs::ContextD3D11::clearResource(BufferHandle destinationHandle,
float *Values)
1062 auto & destination = buffers->buffers[destinationHandle];
1063 immediateContext->ClearUnorderedAccessViewFloat(destination.uav, Values);
1069 const uint32_t csSlot = decode(textureBindingHandle.
handle);
1071 if (HandleIsValid(textureHandle)) {
1072 auto & texture = textures->textures[textureHandle];
1074 if (texture.unorderedAccessView) {
1075 if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &texture.unorderedAccessView,
nullptr);
1077 if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &texture.shaderResourceView);
1080 ID3D11UnorderedAccessView * view =
nullptr;
1081 if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &view,
nullptr);
1082 ID3D11ShaderResourceView * shaderResourceView =
nullptr;
1083 if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &shaderResourceView);
1086 uint32_t slots[ShaderType::NumShaderTypes];
1087 decode(textureBindingHandle.
handle, slots);
1089 ID3D11ShaderResourceView * shaderResourceView =
nullptr;
1090 if (HandleIsValid(textureHandle)) {
1091 shaderResourceView = textures->textures[textureHandle].shaderResourceView;
1093 setShaderResources(slots, &shaderResourceView);
1097void Cogs::ContextD3D11::setShaderResources(uint32_t * slots, ID3D11ShaderResourceView *
const *ppShaderResourceViews) {
1098 if (slots[0] != NoBinding11) immediateContext->VSSetShaderResources(slots[0], 1, ppShaderResourceViews);
1099 if (slots[1] != NoBinding11) immediateContext->HSSetShaderResources(slots[1], 1, ppShaderResourceViews);
1100 if (slots[2] != NoBinding11) immediateContext->DSSetShaderResources(slots[2], 1, ppShaderResourceViews);
1101 if (slots[3] != NoBinding11) immediateContext->GSSetShaderResources(slots[3], 1, ppShaderResourceViews);
1102 if (slots[4] != NoBinding11) immediateContext->PSSetShaderResources(slots[4], 1, ppShaderResourceViews);
1104 for (
size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
1105 if (slots[i] != NoBinding11) {
1106 state.dirtySRV[i] = std::max(state.dirtySRV[i], slots[i] + 1);
1113 auto & view = textures->textureViews[textureViewHandle];
1114 auto & textureHandle = view.texture;
1117 const uint32_t csSlot = decode(textureBindingHandle.handle);
1120 auto & texture = textures->textures[textureHandle];
1122 if (texture.unorderedAccessView) {
1123 if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &texture.unorderedAccessView,
nullptr);
1125 if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &view.shaderResourceView);
1128 ID3D11UnorderedAccessView * unorderedAccessView =
nullptr;
1129 if (csSlot != NoBinding11) immediateContext->CSSetUnorderedAccessViews(csSlot, 1, &unorderedAccessView,
nullptr);
1130 ID3D11ShaderResourceView * shaderResourceView =
nullptr;
1131 if (csSlot != NoBinding11) immediateContext->CSSetShaderResources(csSlot, 1, &shaderResourceView);
1134 uint32_t slots[ShaderType::NumShaderTypes];
1135 decode(textureBindingHandle.handle, slots);
1137 ID3D11ShaderResourceView * shaderResourceView = view.shaderResourceView;
1138 setShaderResources(slots, &shaderResourceView);
1145 const uint32_t csSlot = decode(samplerStateBindingHandle.
handle);
1147 if (HandleIsValid(samplerStateHandle)) {
1148 auto & samplerState = textures->samplerStates[samplerStateHandle];
1150 if (csSlot != NoBinding11) immediateContext->CSSetSamplers(csSlot, 1, &samplerState);
1152 ID3D11SamplerState * samplerState =
nullptr;
1153 if (csSlot != NoBinding11) immediateContext->CSSetSamplers(csSlot, 1, &samplerState);
1156 uint32_t slots[ShaderType::NumShaderTypes];
1157 decode(samplerStateBindingHandle.
handle, slots);
1159 auto & samplerState = textures->samplerStates[HandleIsValid(samplerStateHandle) ? samplerStateHandle : defaultSamplerState];
1161 if (slots[0] != NoBinding11) immediateContext->VSSetSamplers(slots[0], 1, &samplerState);
1162 if (slots[1] != NoBinding11) immediateContext->HSSetSamplers(slots[1], 1, &samplerState);
1163 if (slots[2] != NoBinding11) immediateContext->DSSetSamplers(slots[2], 1, &samplerState);
1164 if (slots[3] != NoBinding11) immediateContext->GSSetSamplers(slots[3], 1, &samplerState);
1165 if (slots[4] != NoBinding11) immediateContext->PSSetSamplers(slots[4], 1, &samplerState);
1171 auto & buffer = buffers->buffers[bufferHandle];
1172 auto & binding = effects->bufferBindings[bufferBindingHandle];
1176 const uint32_t csSlot =
static_cast<uint32_t
>(binding.uavBindings);
1177 if (csSlot != NoBinding11) {
1178 uavs[csSlot] = buffer.uav;
1179 uavCounts[csSlot] = buffer.uavCount;
1180 minUavSlot = std::min(minUavSlot, csSlot);
1181 maxUavSlot = std::max(maxUavSlot, csSlot);
1184 updateRenderTargets();
1186 uavCounts[csSlot] = ~0u;
1187 buffer.uavCount = ~0u;
1192 uint32_t slots[ShaderType::NumShaderTypes];
1193 decode(binding.uavBindings, slots);
1195 uint32_t psSlot = slots[ShaderType::PixelShader];
1197 if (psSlot != NoBinding11) {
1198 uavs[psSlot] = buffer.uav;
1199 uavCounts[psSlot] = buffer.uavCount;
1200 minUavSlot = std::min(minUavSlot, psSlot);
1201 maxUavSlot = std::max(maxUavSlot, psSlot);
1204 updateRenderTargets();
1206 uavCounts[psSlot] = ~0u;
1207 buffer.uavCount = ~0u;
1212 uint32_t slots[ShaderType::NumShaderTypes];
1213 decode(binding.srvBindings, slots);
1215 setShaderResources(slots, &buffer.srv);
1222 auto & buffer = buffers->buffers[bufferHandle];
1224 buffer.uavCount = value;
1234 auto & buffer = buffers->buffers[bufferHandle];
1235 auto & dstBuffer = buffers->buffers[destinationBufferHandle];
1237 immediateContext->CopyStructureCount(dstBuffer.buffer, 0, buffer.uav);
1244 getBufferCounter(bufferHandle, dstBuffer);
1248 return mapped ? *mapped : 0;
1251void Cogs::ContextD3D11::resetSRVBindings()
1253 ID3D11ShaderResourceView * resourceViews[D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT] = { 0 };
1254 if (state.dirtySRV[ShaderType::VertexShader]) immediateContext->VSSetShaderResources(0, state.dirtySRV[ShaderType::VertexShader], resourceViews);
1255 if (state.dirtySRV[ShaderType::GeometryShader]) immediateContext->GSSetShaderResources(0, state.dirtySRV[ShaderType::GeometryShader], resourceViews);
1256 if (state.dirtySRV[ShaderType::PixelShader]) immediateContext->PSSetShaderResources(0, state.dirtySRV[ShaderType::PixelShader], resourceViews);
1257 if (state.dirtySRV[ShaderType::ComputeShader]) immediateContext->CSSetShaderResources(0, state.dirtySRV[ShaderType::ComputeShader], resourceViews);
1259 for (
size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
1260 state.dirtySRV[i] = 0;
1264void Cogs::ContextD3D11::updateRenderTargets()
1266 ID3D11RenderTargetView * views[kMaxRenderTargets11];
1269 if ((minUavSlot <= maxUavSlot) && uavDirty) {
1270 immediateContext->CSSetUnorderedAccessViews(minUavSlot,
1271 maxUavSlot - minUavSlot + 1,
1273 uavCounts + minUavSlot);
1278 uint32_t numViews = 0;
1280 RenderTargetD3D11& renderTarget = renderTargets->renderTargets[currentRenderTarget];
1281 numViews =
static_cast<uint32_t
>(renderTarget.numViews);
1282 for (uint32_t i = 0; i < renderTarget.numViews; ++i) {
1283 views[i] = renderTarget.views[i];
1287 ID3D11DepthStencilView * depthStencilView =
nullptr;
1289 depthStencilView = renderTargets->depthStencilViews[currentDepthStencil];
1292 if ((minUavSlot <= maxUavSlot) && uavDirty) {
1293 immediateContext->OMSetRenderTargetsAndUnorderedAccessViews(
static_cast<UINT
>(numViews),
1297 maxUavSlot - minUavSlot + 1,
1299 uavCounts + minUavSlot);
1303 immediateContext->OMSetRenderTargets(numViews, views, depthStencilView);
1308void Cogs::ContextD3D11::setupConstantBuffers()
1310 ContextCommon::updateConstantBuffers();
1312 auto & effect = effects->effects[currentEffect];
1314 for (
auto & constantBuffer : effect.vertexShader.reflection.constantBuffers) {
1315 if (
HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.vsCBs[constantBuffer.slot]) {
1316 immediateContext->VSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
1317 state.vsCBs[constantBuffer.slot] = constantBuffer.buffer;
1321 for (
auto & constantBuffer : effect.hullShader.reflection.constantBuffers) {
1322 if (
HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
1323 immediateContext->HSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
1327 for (
auto & constantBuffer : effect.domainShader.reflection.constantBuffers) {
1328 if (
HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
1329 immediateContext->DSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
1333 for (
auto & constantBuffer : effect.geometryShader.reflection.constantBuffers) {
1334 if (
HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
1335 immediateContext->GSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
1339 for (
auto & constantBuffer : effect.pixelShader.reflection.constantBuffers) {
1340 if (
HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual && constantBuffer.buffer != state.psCBs[constantBuffer.slot]) {
1341 immediateContext->PSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
1342 state.psCBs[constantBuffer.slot] = constantBuffer.buffer;
1346 for (
auto & constantBuffer : effect.computeShader.reflection.constantBuffers) {
1347 if (
HandleIsValid(constantBuffer.buffer) && !constantBuffer.manual) {
1348 immediateContext->CSSetConstantBuffers(constantBuffer.slot, 1, &buffers->buffers[constantBuffer.buffer].buffer);
1352 constantBuffersUpdated =
true;
1357 this->setupConstantBuffers();
1359 immediateContext->Dispatch(threadGroupsX, threadGroupsY, threadGroupsZ);
Log implementation class.
Provides a weakly referenced view over the contents of a string.
constexpr iterator begin() noexcept
Iterator to the beginning of the string.
constexpr iterator end() noexcept
Iterator to the end of the string.
virtual const DepthStencilHandle & getDepthStencil() const override
Returns the depth stencil managed by this swap chain.
virtual const RenderTargetHandle & getRenderTarget() const override
Returns the render target managed by this swap chain.
bool HandleIsValid(const ResourceHandle_t< T > &handle)
Check if the given resource is valid, that is not equal to NoHandle or InvalidHandle.
const DXGI_FORMAT Formats[]
Must match up to Format definition.
constexpr Log getLogger(const char(&name)[LEN]) noexcept
Contains all Cogs related functionality.
@ Direct3D11
Graphics device using the Direct3D 11 API.
@ EnableTraceLogging
Enables trace logging.
@ Read
The buffer can be mapped and read from by the CPU after creation.
@ IndexBuffer
The buffer can be bound as input to the vertex shader stage as an index buffer.
@ None
The buffer will not be bound to the graphics pipeline. Suitable for staging resources.
static BlendState DefaultState()
Creates a blend state object initialized with the default settings.
void updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void *data) override
Update a region of data in a buffer.
void pushCommandGroupAnnotation(const StringView &name) override
Begin to tag a sequence of commands as a group in graphics debugger.
void resolveResource(TextureHandle sourceTexture, TextureHandle destination)
Resolves the given source resource target into the given destination texture.
void setBufferCounter(BufferHandle bufferHandle, uint32_t value)
Set the associated counter of a buffer.
void draw(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
Draws non-indexed, non-instanced primitives.
void setRenderTarget(const RenderTargetHandle handle, const DepthStencilHandle depthStencilHandle) override
Sets the current render target and an associated depth stencil target.
void setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle)
Sets the sampler state binding given to the given sampler state.
void setBuffer(const BufferBindingHandle bufferBindingHandle, BufferHandle bufferHandle)
Sets a buffer to bind to the given binding.
void setBlendState(const BlendStateHandle handle, const float *constant) override
Set the current blend state.
void readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer framebuffer)
Reads data from the current depth target into the given bufferHandle.
void setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle)
Sets the texture given to the binding given by textureBindingHandle.
void drawInstancedIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes)
Draws indexed, instanced primitives.
void setRasterizerState(const RasterizerStateHandle handle)
Set the current rasterizer state.
void updateSubTexture(TextureHandle textureHandle, const size_t level, const void *data)
Update the data of a level in the given texture.
void setEffect(EffectHandle handle)
Set the current effect.
void popCommandGroupAnnotation() override
End to tag a sequence of commands as a group in graphics debugger.
void setDepthStencilState(const DepthStencilStateHandle handle)
Set the current depth stencil state.
void endRenderPass() override
End a render pass.
void setInputLayout(const InputLayoutHandle inputLayoutHandle)
Sets the current input layout.
void getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle)
Get the associated counter of a buffer.
void unmap(BufferHandle bufferHandle)
Unmaps the given buffer, applying any synchronization necessary to reflect changes in the mapped memo...
void drawIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex=0)
Draws indexed, non-instanced primitives.
void * map(BufferHandle bufferHandle, MapMode::EMapMode accessMode, uint32_t *stride)
Maps the given buffer so it can be accessed.
void signal(FenceHandle fenceHandle) override
Insert a fence in the command stream that will signal when all commands before the fence are complete...
void setVertexBuffers(const VertexBufferHandle *vertexBufferHandles, const size_t count, const uint32_t *strides, const uint32_t *offsets)
Sets the current vertex buffers.
void setScissor(const int x, const int y, const int width, const int height)
Sets the current scissor rectangle.
void dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ)
Dispatch computing work on the graphics device using the desired thread group count.
void clearDepth(const float depth=1.0f)
Clear the currently set depth/stencil target to the given depth.
void beginRenderPass(const RenderPassInfo &info) override
Begin a render pass.
void setViewport(const float x, const float y, const float width, const float height)
Sets the current viewport to the given location and dimensions.
void setIndexBuffer(IndexBufferHandle indexBufferHandle, uint32_t stride, uint32_t offset)
Sets the current index buffer.
void drawInstanced(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
Draws non-indexed, instanced primitives.
void clearRenderTarget(const float *value)
Clear the currently set render target to the given value (4 component floating point RGBA).
void readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer framebuffer)
Reads data from the current render target into the given bufferHandle.
void setAnnotationMarker(const StringView &name) override
Add a tag in the sequence of commands in graphics debugger.
void setConstantBuffer(const ConstantBufferBindingHandle bufferBinding, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
Sets a constant buffer to the given constant buffer binding.
static DepthStencilState DefaultState()
Constructs a depth stencil state object initialized with the default values.
Handle template class used to provide opaque, non-converting handles.
static const Handle_t NoHandle
Represents a handle to nothing.
handle_type handle
Internal resource handle.
EMapMode
Mapping mode enumeration.
Provides RAII style mapping of a buffer resource.
EPrimitiveType
Primitive type enumeration.
static RasterizerState DefaultState()
Constructs a rasterizer state initialized with the default values.
static SamplerState & DefaultState()
Constructs a sampler state initialized with the default values.
@ Dynamic
Buffer will be loaded and modified with some frequency.