diff options
Diffstat (limited to 'tools')
29 files changed, 4559 insertions, 4029 deletions
diff --git a/tools/gfx/d3d11/d3d11-base.h b/tools/gfx/d3d11/d3d11-base.h new file mode 100644 index 000000000..d47682f18 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-base.h @@ -0,0 +1,70 @@ +// d3d11-base.h +// Shared header file for D3D11 implementation +#pragma once + +#include "../immediate-renderer-base.h" +#include "../d3d/d3d-util.h" +#include "../d3d/d3d-swapchain.h" +#include "../nvapi/nvapi-util.h" +#include "../mutable-shader-object.h" +#include "core/slang-basic.h" +#include "core/slang-blob.h" + +#include "slang-com-ptr.h" +#include "../flag-combiner.h" + +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX +#include <Windows.h> +#undef WIN32_LEAN_AND_MEAN +#undef NOMINMAX + +#include <d3d11_2.h> +#include <d3dcompiler.h> + +#ifdef GFX_NVAPI +// NVAPI integration is described here +// https://developer.nvidia.com/unlocking-gpu-intrinsics-hlsl + +# include "../nvapi/nvapi-include.h" +#endif + +// We will use the C standard library just for printing error messages. +#include <stdio.h> + +#ifdef _MSC_VER +#include <stddef.h> +#if (_MSC_VER < 1900) +#define snprintf sprintf_s +#endif +#endif + +namespace gfx +{ +namespace d3d11 +{ + class DeviceImpl; + class ShaderProgramImpl; + class BufferResourceImpl; + class TextureResourceImpl; + class SamplerStateImpl; + class ResourceViewImpl; + class ShaderResourceViewImpl; + class UnorderedAccessViewImpl; + class DepthStencilViewImpl; + class RenderTargetViewImpl; + class FramebufferLayoutImpl; + class FramebufferImpl; + class SwapchainImpl; + class InputLayoutImpl; + class QueryPoolImpl; + class PipelineStateImpl; + class GraphicsPipelineStateImpl; + class ComputePipelineStateImpl; + class ShaderObjectLayoutImpl; + class RootShaderObjectLayoutImpl; + class ShaderObjectImpl; + class MutableShaderObjectImpl; + class RootShaderObjectImpl; +} +} diff --git a/tools/gfx/d3d11/d3d11-buffer.cpp b/tools/gfx/d3d11/d3d11-buffer.cpp new file mode 100644 index 000000000..aa51b999f --- /dev/null +++ b/tools/gfx/d3d11/d3d11-buffer.cpp @@ -0,0 +1,32 @@ +// d3d11-buffer.cpp +#include "d3d11-buffer.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +SLANG_NO_THROW DeviceAddress SLANG_MCALL BufferResourceImpl::getDeviceAddress() +{ + return 0; +} + +SLANG_NO_THROW Result SLANG_MCALL + BufferResourceImpl::map(MemoryRange* rangeToRead, void** outPointer) +{ + SLANG_UNUSED(rangeToRead); + SLANG_UNUSED(outPointer); + return SLANG_FAIL; +} + +SLANG_NO_THROW Result SLANG_MCALL BufferResourceImpl::unmap(MemoryRange* writtenRange) +{ + SLANG_UNUSED(writtenRange); + return SLANG_FAIL; +} + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-buffer.h b/tools/gfx/d3d11/d3d11-buffer.h new file mode 100644 index 000000000..f5462b029 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-buffer.h @@ -0,0 +1,37 @@ +// d3d11-buffer.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class BufferResourceImpl : public BufferResource +{ +public: + typedef BufferResource Parent; + + BufferResourceImpl(const IBufferResource::Desc& desc) : + Parent(desc) + { + } + + MapFlavor m_mapFlavor; + D3D11_USAGE m_d3dUsage; + ComPtr<ID3D11Buffer> m_buffer; + ComPtr<ID3D11Buffer> m_staging; + List<uint8_t> m_uploadStagingBuffer; + + virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() override; + virtual SLANG_NO_THROW Result SLANG_MCALL + map(MemoryRange* rangeToRead, void** outPointer) override; + virtual SLANG_NO_THROW Result SLANG_MCALL unmap(MemoryRange* writtenRange) override; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-device.cpp b/tools/gfx/d3d11/d3d11-device.cpp new file mode 100644 index 000000000..1b2f6ec1d --- /dev/null +++ b/tools/gfx/d3d11/d3d11-device.cpp @@ -0,0 +1,1619 @@ +// d3d11-device.cpp +#define _CRT_SECURE_NO_WARNINGS +#include "d3d11-device.h" + +#include "d3d11-buffer.h" +#include "d3d11-query.h" +#include "d3d11-resource-views.h" +#include "d3d11-sampler.h" +#include "d3d11-scopeNVAPI.h" +#include "d3d11-shader-object.h" +#include "d3d11-shader-object-layout.h" +#include "d3d11-shader-program.h" +#include "d3d11-swap-chain.h" +#include "d3d11-texture.h" +#include "d3d11-vertex-layout.h" + +#include "d3d11-helper-functions.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ +SlangResult DeviceImpl::initialize(const Desc& desc) +{ + SLANG_RETURN_ON_FAIL(slangContext.initialize( + desc.slang, + SLANG_DXBC, + "sm_5_0", + makeArray(slang::PreprocessorMacroDesc{ "__D3D11__", "1" }).getView())); + + SLANG_RETURN_ON_FAIL(RendererBase::initialize(desc)); + + // Initialize DeviceInfo + { + m_info.deviceType = DeviceType::DirectX11; + m_info.bindingStyle = BindingStyle::DirectX; + m_info.projectionStyle = ProjectionStyle::DirectX; + m_info.apiName = "Direct3D 11"; + static const float kIdentity[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }; + ::memcpy(m_info.identityProjectionMatrix, kIdentity, sizeof(kIdentity)); + } + + m_desc = desc; + + // Rather than statically link against D3D, we load it dynamically. + HMODULE d3dModule = LoadLibraryA("d3d11.dll"); + if (!d3dModule) + { + fprintf(stderr, "error: failed load 'd3d11.dll'\n"); + return SLANG_FAIL; + } + + PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN D3D11CreateDeviceAndSwapChain_ = + (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)GetProcAddress(d3dModule, "D3D11CreateDeviceAndSwapChain"); + if (!D3D11CreateDeviceAndSwapChain_) + { + fprintf(stderr, + "error: failed load symbol 'D3D11CreateDeviceAndSwapChain'\n"); + return SLANG_FAIL; + } + + PFN_D3D11_CREATE_DEVICE D3D11CreateDevice_ = + (PFN_D3D11_CREATE_DEVICE)GetProcAddress(d3dModule, "D3D11CreateDevice"); + if (!D3D11CreateDevice_) + { + fprintf(stderr, + "error: failed load symbol 'D3D11CreateDevice'\n"); + return SLANG_FAIL; + } + + // We will ask for the highest feature level that can be supported. + const D3D_FEATURE_LEVEL featureLevels[] = { + D3D_FEATURE_LEVEL_11_1, + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_1, + D3D_FEATURE_LEVEL_10_0, + D3D_FEATURE_LEVEL_9_3, + D3D_FEATURE_LEVEL_9_2, + D3D_FEATURE_LEVEL_9_1, + }; + D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_9_1; + const int totalNumFeatureLevels = SLANG_COUNT_OF(featureLevels); + + { + // On a machine that does not have an up-to-date version of D3D installed, + // the `D3D11CreateDeviceAndSwapChain` call will fail with `E_INVALIDARG` + // if you ask for feature level 11_1 (DeviceCheckFlag::UseFullFeatureLevel). + // The workaround is to call `D3D11CreateDeviceAndSwapChain` the first time + // with 11_1 and then back off to 11_0 if that fails. + + FlagCombiner combiner; + // TODO: we should probably provide a command-line option + // to override UseDebug of default rather than leave it + // up to each back-end to specify. + +#if _DEBUG + combiner.add(DeviceCheckFlag::UseDebug, ChangeType::OnOff); ///< First try debug then non debug +#else + combiner.add(DeviceCheckFlag::UseDebug, ChangeType::Off); ///< Don't bother with debug +#endif + combiner.add(DeviceCheckFlag::UseHardwareDevice, ChangeType::OnOff); ///< First try hardware, then reference + combiner.add(DeviceCheckFlag::UseFullFeatureLevel, ChangeType::OnOff); ///< First try fully featured, then degrade features + + + const int numCombinations = combiner.getNumCombinations(); + Result res = SLANG_FAIL; + for (int i = 0; i < numCombinations; ++i) + { + const auto deviceCheckFlags = combiner.getCombination(i); + D3DUtil::createFactory(deviceCheckFlags, m_dxgiFactory); + + // If we have an adapter set on the desc, look it up. We only need to do so for hardware + ComPtr<IDXGIAdapter> adapter; + if (desc.adapter && (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice)) + { + List<ComPtr<IDXGIAdapter>> dxgiAdapters; + D3DUtil::findAdapters(deviceCheckFlags, Slang::UnownedStringSlice(desc.adapter), dxgiAdapters); + if (dxgiAdapters.getCount() == 0) + { + continue; + } + adapter = dxgiAdapters[0]; + } + + // The adapter can be nullptr - that just means 'default', but when so we need to select the driver type + D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_UNKNOWN; + if (adapter == nullptr) + { + // If we don't have an adapter, select directly + driverType = (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice) ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_REFERENCE; + } + + const int startFeatureIndex = (deviceCheckFlags & DeviceCheckFlag::UseFullFeatureLevel) ? 0 : 1; + const UINT deviceFlags = (deviceCheckFlags & DeviceCheckFlag::UseDebug) ? D3D11_CREATE_DEVICE_DEBUG : 0; + + res = D3D11CreateDevice_( + adapter, + driverType, + nullptr, + deviceFlags, + &featureLevels[startFeatureIndex], + totalNumFeatureLevels - startFeatureIndex, + D3D11_SDK_VERSION, + m_device.writeRef(), + &featureLevel, + m_immediateContext.writeRef()); + // Check if successfully constructed - if so we are done. + if (SLANG_SUCCEEDED(res)) + { + break; + } + } + // If res is failure, means all styles have have failed, and so initialization fails. + if (SLANG_FAILED(res)) + { + return res; + } + // Check we have a swap chain, context and device + SLANG_ASSERT(m_immediateContext && m_device); + + ComPtr<IDXGIDevice> dxgiDevice; + if (m_device->QueryInterface(dxgiDevice.writeRef()) == 0) + { + ComPtr<IDXGIAdapter> dxgiAdapter; + dxgiDevice->GetAdapter(dxgiAdapter.writeRef()); + DXGI_ADAPTER_DESC adapterDesc; + dxgiAdapter->GetDesc(&adapterDesc); + m_adapterName = String::fromWString(adapterDesc.Description); + m_info.adapterName = m_adapterName.begin(); + } + } + + // NVAPI + if (desc.nvapiExtnSlot >= 0) + { + if (SLANG_FAILED(NVAPIUtil::initialize())) + { + return SLANG_E_NOT_AVAILABLE; + } + +#ifdef GFX_NVAPI + if (NvAPI_D3D11_SetNvShaderExtnSlot(m_device, NvU32(desc.nvapiExtnSlot)) != NVAPI_OK) + { + return SLANG_E_NOT_AVAILABLE; + } + + if (isSupportedNVAPIOp(m_device, NV_EXTN_OP_UINT64_ATOMIC)) + { + m_features.add("atomic-int64"); + } + if (isSupportedNVAPIOp(m_device, NV_EXTN_OP_FP32_ATOMIC)) + { + m_features.add("atomic-float"); + } + + m_nvapi = true; +#endif + } + + { + // Create a TIMESTAMP_DISJOINT query object to query/update frequency info. + D3D11_QUERY_DESC disjointQueryDesc = {}; + disjointQueryDesc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT; + SLANG_RETURN_ON_FAIL(m_device->CreateQuery( + &disjointQueryDesc, m_disjointQuery.writeRef())); + m_immediateContext->Begin(m_disjointQuery); + m_immediateContext->End(m_disjointQuery); + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData = {}; + m_immediateContext->GetData(m_disjointQuery, &disjointData, sizeof(disjointData), 0); + m_info.timestampFrequency = disjointData.Frequency; + } + return SLANG_OK; +} + +void DeviceImpl::clearFrame(uint32_t colorBufferMask, bool clearDepth, bool clearStencil) +{ + uint32_t mask = 1; + for (auto rtv : m_currentFramebuffer->renderTargetViews) + { + if (colorBufferMask & mask) + m_immediateContext->ClearRenderTargetView(rtv->m_rtv, rtv->m_clearValue); + mask <<= 1; + } + + if (m_currentFramebuffer->depthStencilView) + { + UINT clearFlags = 0; + if (clearDepth) + clearFlags = D3D11_CLEAR_DEPTH; + if (clearStencil) + clearFlags |= D3D11_CLEAR_STENCIL; + if (clearFlags) + { + m_immediateContext->ClearDepthStencilView( + m_currentFramebuffer->depthStencilView->m_dsv, + clearFlags, + m_currentFramebuffer->depthStencilView->m_clearValue.depth, + m_currentFramebuffer->depthStencilView->m_clearValue.stencil); + } + } +} + +Result DeviceImpl::createSwapchain( + const ISwapchain::Desc& desc, WindowHandle window, ISwapchain** outSwapchain) +{ + RefPtr<SwapchainImpl> swapchain = new SwapchainImpl(); + SLANG_RETURN_ON_FAIL(swapchain->init(this, desc, window)); + returnComPtr(outSwapchain, swapchain); + return SLANG_OK; +} + +Result DeviceImpl::createFramebufferLayout( + const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout) +{ + RefPtr<FramebufferLayoutImpl> layout = new FramebufferLayoutImpl(); + layout->m_renderTargets.setCount(desc.renderTargetCount); + for (GfxIndex i = 0; i < desc.renderTargetCount; i++) + { + layout->m_renderTargets[i] = desc.renderTargets[i]; + } + + if (desc.depthStencil) + { + layout->m_hasDepthStencil = true; + layout->m_depthStencil = *desc.depthStencil; + } + else + { + layout->m_hasDepthStencil = false; + } + returnComPtr(outLayout, layout); + return SLANG_OK; +} + +Result DeviceImpl::createFramebuffer( + const IFramebuffer::Desc& desc, IFramebuffer** outFramebuffer) +{ + RefPtr<FramebufferImpl> framebuffer = new FramebufferImpl(); + framebuffer->renderTargetViews.setCount(desc.renderTargetCount); + framebuffer->d3dRenderTargetViews.setCount(desc.renderTargetCount); + for (GfxIndex i = 0; i < desc.renderTargetCount; i++) + { + framebuffer->renderTargetViews[i] = static_cast<RenderTargetViewImpl*>(desc.renderTargetViews[i]); + framebuffer->d3dRenderTargetViews[i] = framebuffer->renderTargetViews[i]->m_rtv; + } + framebuffer->depthStencilView = static_cast<DepthStencilViewImpl*>(desc.depthStencilView); + framebuffer->d3dDepthStencilView = framebuffer->depthStencilView ? framebuffer->depthStencilView->m_dsv : nullptr; + returnComPtr(outFramebuffer, framebuffer); + return SLANG_OK; +} + +void DeviceImpl::setFramebuffer(IFramebuffer* frameBuffer) +{ + // Note: the framebuffer state will be flushed to the pipeline as part + // of binding the root shader object. + // + // TODO: alternatively we could call `OMSetRenderTargets` here and then + // call `OMSetRenderTargetsAndUnorderedAccessViews` later with the option + // that preserves the existing RTV/DSV bindings. + // + m_currentFramebuffer = static_cast<FramebufferImpl*>(frameBuffer); +} + +void DeviceImpl::setStencilReference(uint32_t referenceValue) +{ + m_stencilRef = referenceValue; + m_depthStencilStateDirty = true; +} + +SlangResult DeviceImpl::readTextureResource( + ITextureResource* resource, + ResourceState state, + ISlangBlob** outBlob, + size_t* outRowPitch, + size_t* outPixelSize) +{ + SLANG_UNUSED(state); + + auto texture = static_cast<TextureResourceImpl*>(resource); + // Don't bother supporting MSAA for right now + if (texture->getDesc()->sampleDesc.numSamples > 1) + { + fprintf(stderr, "ERROR: cannot capture multi-sample texture\n"); + return E_INVALIDARG; + } + + FormatInfo sizeInfo; + gfxGetFormatInfo(texture->getDesc()->format, &sizeInfo); + size_t bytesPerPixel = sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock; + size_t rowPitch = int(texture->getDesc()->size.width) * bytesPerPixel; + size_t bufferSize = rowPitch * int(texture->getDesc()->size.height); + if (outRowPitch) + *outRowPitch = rowPitch; + if (outPixelSize) + *outPixelSize = bytesPerPixel; + + D3D11_TEXTURE2D_DESC textureDesc; + auto d3d11Texture = ((ID3D11Texture2D*)texture->m_resource.get()); + d3d11Texture->GetDesc(&textureDesc); + + HRESULT hr = S_OK; + ComPtr<ID3D11Texture2D> stagingTexture; + + if (textureDesc.Usage == D3D11_USAGE_STAGING && + (textureDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ)) + { + stagingTexture = d3d11Texture; + } + else + { + // Modify the descriptor to give us a staging texture + textureDesc.BindFlags = 0; + textureDesc.MiscFlags &= ~D3D11_RESOURCE_MISC_TEXTURECUBE; + textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + textureDesc.Usage = D3D11_USAGE_STAGING; + + hr = m_device->CreateTexture2D(&textureDesc, 0, stagingTexture.writeRef()); + if (FAILED(hr)) + { + fprintf(stderr, "ERROR: failed to create staging texture\n"); + return hr; + } + + m_immediateContext->CopyResource(stagingTexture, d3d11Texture); + } + + // Now just read back texels from the staging textures + { + D3D11_MAPPED_SUBRESOURCE mappedResource; + SLANG_RETURN_ON_FAIL(m_immediateContext->Map(stagingTexture, 0, D3D11_MAP_READ, 0, &mappedResource)); + RefPtr<ListBlob> blob = new ListBlob(); + blob->m_data.setCount(bufferSize); + char* buffer = (char*)blob->m_data.begin(); + for (size_t y = 0; y < textureDesc.Height; y++) + { + memcpy( + (char*)buffer + y * (*outRowPitch), + (char*)mappedResource.pData + y * mappedResource.RowPitch, + *outRowPitch); + } + // Make sure to unmap + m_immediateContext->Unmap(stagingTexture, 0); + returnComPtr(outBlob, blob); + return SLANG_OK; + } +} + +Result DeviceImpl::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource) +{ + TextureResource::Desc srcDesc = fixupTextureDesc(descIn); + + const int effectiveArraySize = calcEffectiveArraySize(srcDesc); + + const DXGI_FORMAT format = D3DUtil::getMapFormat(srcDesc.format); + if (format == DXGI_FORMAT_UNKNOWN) + { + return SLANG_FAIL; + } + + const int bindFlags = _calcResourceBindFlags(srcDesc.allowedStates); + + // Set up the initialize data + List<D3D11_SUBRESOURCE_DATA> subRes; + D3D11_SUBRESOURCE_DATA* subResourcesPtr = nullptr; + if (initData) + { + subRes.setCount(srcDesc.numMipLevels * effectiveArraySize); + { + int subResourceIndex = 0; + for (int i = 0; i < effectiveArraySize; i++) + { + for (int j = 0; j < srcDesc.numMipLevels; j++) + { + const int mipHeight = calcMipSize(srcDesc.size.height, j); + + D3D11_SUBRESOURCE_DATA& data = subRes[subResourceIndex]; + auto& srcData = initData[subResourceIndex]; + + data.pSysMem = srcData.data; + data.SysMemPitch = UINT(srcData.strideY); + data.SysMemSlicePitch = UINT(srcData.strideZ); + + subResourceIndex++; + } + } + } + subResourcesPtr = subRes.getBuffer(); + } + + const int accessFlags = _calcResourceAccessFlags(srcDesc.memoryType); + + RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc)); + + switch (srcDesc.type) + { + case IResource::Type::Texture1D: + { + D3D11_TEXTURE1D_DESC desc = { 0 }; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = accessFlags; + desc.Format = format; + desc.MiscFlags = 0; + desc.MipLevels = srcDesc.numMipLevels; + desc.ArraySize = effectiveArraySize; + desc.Width = srcDesc.size.width; + desc.Usage = D3D11_USAGE_DEFAULT; + + ComPtr<ID3D11Texture1D> texture1D; + SLANG_RETURN_ON_FAIL(m_device->CreateTexture1D(&desc, subResourcesPtr, texture1D.writeRef())); + + texture->m_resource = texture1D; + break; + } + case IResource::Type::TextureCube: + case IResource::Type::Texture2D: + { + D3D11_TEXTURE2D_DESC desc = { 0 }; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = accessFlags; + desc.Format = format; + desc.MiscFlags = 0; + desc.MipLevels = srcDesc.numMipLevels; + desc.ArraySize = effectiveArraySize; + + desc.Width = srcDesc.size.width; + desc.Height = srcDesc.size.height; + desc.Usage = D3D11_USAGE_DEFAULT; + desc.SampleDesc.Count = srcDesc.sampleDesc.numSamples; + desc.SampleDesc.Quality = srcDesc.sampleDesc.quality; + + if (srcDesc.type == IResource::Type::TextureCube) + { + desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE; + } + + ComPtr<ID3D11Texture2D> texture2D; + SLANG_RETURN_ON_FAIL(m_device->CreateTexture2D(&desc, subResourcesPtr, texture2D.writeRef())); + + texture->m_resource = texture2D; + break; + } + case IResource::Type::Texture3D: + { + D3D11_TEXTURE3D_DESC desc = { 0 }; + desc.BindFlags = bindFlags; + desc.CPUAccessFlags = accessFlags; + desc.Format = format; + desc.MiscFlags = 0; + desc.MipLevels = srcDesc.numMipLevels; + desc.Width = srcDesc.size.width; + desc.Height = srcDesc.size.height; + desc.Depth = srcDesc.size.depth; + desc.Usage = D3D11_USAGE_DEFAULT; + + ComPtr<ID3D11Texture3D> texture3D; + SLANG_RETURN_ON_FAIL(m_device->CreateTexture3D(&desc, subResourcesPtr, texture3D.writeRef())); + + texture->m_resource = texture3D; + break; + } + default: + return SLANG_FAIL; + } + + returnComPtr(outResource, texture); + return SLANG_OK; +} + +Result DeviceImpl::createBufferResource(const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) +{ + IBufferResource::Desc srcDesc = fixupBufferDesc(descIn); + + auto d3dBindFlags = _calcResourceBindFlags(srcDesc.allowedStates); + + size_t alignedSizeInBytes = srcDesc.sizeInBytes; + + if (d3dBindFlags & D3D11_BIND_CONSTANT_BUFFER) + { + // Make aligned to 256 bytes... not sure why, but if you remove this the tests do fail. + alignedSizeInBytes = D3DUtil::calcAligned(alignedSizeInBytes, 256); + } + + // Hack to make the initialization never read from out of bounds memory, by copying into a buffer + List<uint8_t> initDataBuffer; + if (initData && alignedSizeInBytes > srcDesc.sizeInBytes) + { + initDataBuffer.setCount(alignedSizeInBytes); + ::memcpy(initDataBuffer.getBuffer(), initData, srcDesc.sizeInBytes); + initData = initDataBuffer.getBuffer(); + } + + D3D11_BUFFER_DESC bufferDesc = { 0 }; + bufferDesc.ByteWidth = UINT(alignedSizeInBytes); + bufferDesc.BindFlags = d3dBindFlags; + // For read we'll need to do some staging + bufferDesc.CPUAccessFlags = _calcResourceAccessFlags(descIn.memoryType); + bufferDesc.Usage = D3D11_USAGE_DEFAULT; + + // If written by CPU, make it dynamic + if (descIn.memoryType == MemoryType::Upload && + !descIn.allowedStates.contains(ResourceState::UnorderedAccess)) + { + bufferDesc.Usage = D3D11_USAGE_DYNAMIC; + } + + if (srcDesc.memoryType == MemoryType::ReadBack) + { + bufferDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_READ; + bufferDesc.Usage = D3D11_USAGE_STAGING; + } + + switch (descIn.defaultState) + { + case ResourceState::ConstantBuffer: + { + // We'll just assume ConstantBuffers are dynamic for now + bufferDesc.Usage = D3D11_USAGE_DYNAMIC; + break; + } + default: break; + } + + if (bufferDesc.BindFlags & (D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE)) + { + //desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE; + if (srcDesc.elementSize != 0) + { + bufferDesc.StructureByteStride = (UINT)srcDesc.elementSize; + bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; + } + else + { + bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + } + } + + if (srcDesc.memoryType == MemoryType::Upload) + { + bufferDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE; + } + + D3D11_SUBRESOURCE_DATA subResourceData = { 0 }; + subResourceData.pSysMem = initData; + + RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(srcDesc)); + + SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufferDesc, initData ? &subResourceData : nullptr, buffer->m_buffer.writeRef())); + buffer->m_d3dUsage = bufferDesc.Usage; + + if (srcDesc.memoryType == MemoryType::ReadBack || bufferDesc.Usage != D3D11_USAGE_DYNAMIC) + { + D3D11_BUFFER_DESC bufDesc = {}; + bufDesc.BindFlags = 0; + bufDesc.ByteWidth = (UINT)alignedSizeInBytes; + bufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; + bufDesc.Usage = D3D11_USAGE_STAGING; + + SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufDesc, nullptr, buffer->m_staging.writeRef())); + } + returnComPtr(outResource, buffer); + return SLANG_OK; +} + +Result DeviceImpl::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) +{ + D3D11_FILTER_REDUCTION_TYPE dxReduction = translateFilterReduction(desc.reductionOp); + D3D11_FILTER dxFilter; + if (desc.maxAnisotropy > 1) + { + dxFilter = D3D11_ENCODE_ANISOTROPIC_FILTER(dxReduction); + } + else + { + D3D11_FILTER_TYPE dxMin = translateFilterMode(desc.minFilter); + D3D11_FILTER_TYPE dxMag = translateFilterMode(desc.magFilter); + D3D11_FILTER_TYPE dxMip = translateFilterMode(desc.mipFilter); + + dxFilter = D3D11_ENCODE_BASIC_FILTER(dxMin, dxMag, dxMip, dxReduction); + } + + D3D11_SAMPLER_DESC dxDesc = {}; + dxDesc.Filter = dxFilter; + dxDesc.AddressU = translateAddressingMode(desc.addressU); + dxDesc.AddressV = translateAddressingMode(desc.addressV); + dxDesc.AddressW = translateAddressingMode(desc.addressW); + dxDesc.MipLODBias = desc.mipLODBias; + dxDesc.MaxAnisotropy = desc.maxAnisotropy; + dxDesc.ComparisonFunc = translateComparisonFunc(desc.comparisonFunc); + for (int ii = 0; ii < 4; ++ii) + dxDesc.BorderColor[ii] = desc.borderColor[ii]; + dxDesc.MinLOD = desc.minLOD; + dxDesc.MaxLOD = desc.maxLOD; + + ComPtr<ID3D11SamplerState> sampler; + SLANG_RETURN_ON_FAIL(m_device->CreateSamplerState( + &dxDesc, + sampler.writeRef())); + + RefPtr<SamplerStateImpl> samplerImpl = new SamplerStateImpl(); + samplerImpl->m_sampler = sampler; + returnComPtr(outSampler, samplerImpl); + return SLANG_OK; +} + +Result DeviceImpl::createTextureView(ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) +{ + auto resourceImpl = (TextureResourceImpl*)texture; + + switch (desc.type) + { + default: + return SLANG_FAIL; + + case IResourceView::Type::RenderTarget: + { + ComPtr<ID3D11RenderTargetView> rtv; + SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(resourceImpl->m_resource, nullptr, rtv.writeRef())); + + RefPtr<RenderTargetViewImpl> viewImpl = new RenderTargetViewImpl(); + viewImpl->m_type = ResourceViewImpl::Type::RTV; + viewImpl->m_rtv = rtv; + viewImpl->m_desc = desc; + + memcpy( + viewImpl->m_clearValue, + &resourceImpl->getDesc()->optimalClearValue.color, + sizeof(float) * 4); + returnComPtr(outView, viewImpl); + return SLANG_OK; + } + break; + + case IResourceView::Type::DepthStencil: + { + ComPtr<ID3D11DepthStencilView> dsv; + SLANG_RETURN_ON_FAIL(m_device->CreateDepthStencilView(resourceImpl->m_resource, nullptr, dsv.writeRef())); + + RefPtr<DepthStencilViewImpl> viewImpl = new DepthStencilViewImpl(); + viewImpl->m_type = ResourceViewImpl::Type::DSV; + viewImpl->m_dsv = dsv; + viewImpl->m_clearValue = resourceImpl->getDesc()->optimalClearValue.depthStencil; + viewImpl->m_desc = desc; + + returnComPtr(outView, viewImpl); + return SLANG_OK; + } + break; + + case IResourceView::Type::UnorderedAccess: + { + ComPtr<ID3D11UnorderedAccessView> uav; + SLANG_RETURN_ON_FAIL(m_device->CreateUnorderedAccessView(resourceImpl->m_resource, nullptr, uav.writeRef())); + + RefPtr<UnorderedAccessViewImpl> viewImpl = new UnorderedAccessViewImpl(); + viewImpl->m_type = ResourceViewImpl::Type::UAV; + viewImpl->m_uav = uav; + viewImpl->m_desc = desc; + + returnComPtr(outView, viewImpl); + return SLANG_OK; + } + break; + + case IResourceView::Type::ShaderResource: + { + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; + initSrvDesc(resourceImpl->getType(), *resourceImpl->getDesc(), D3DUtil::getMapFormat(desc.format), srvDesc); + + ComPtr<ID3D11ShaderResourceView> srv; + SLANG_RETURN_ON_FAIL(m_device->CreateShaderResourceView(resourceImpl->m_resource, &srvDesc, srv.writeRef())); + + RefPtr<ShaderResourceViewImpl> viewImpl = new ShaderResourceViewImpl(); + viewImpl->m_type = ResourceViewImpl::Type::SRV; + viewImpl->m_srv = srv; + viewImpl->m_desc = desc; + + returnComPtr(outView, viewImpl); + return SLANG_OK; + } + break; + } +} + +Result DeviceImpl::createBufferView( + IBufferResource* buffer, + IBufferResource* counterBuffer, + IResourceView::Desc const& desc, + IResourceView** outView) +{ + auto resourceImpl = (BufferResourceImpl*)buffer; + auto resourceDesc = *resourceImpl->getDesc(); + + switch (desc.type) + { + default: + return SLANG_FAIL; + + case IResourceView::Type::UnorderedAccess: + { + D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc = {}; + uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; + uavDesc.Format = D3DUtil::getMapFormat(desc.format); + uavDesc.Buffer.FirstElement = 0; + + if (resourceDesc.elementSize) + { + uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize); + } + else if (desc.format == Format::Unknown) + { + uavDesc.Buffer.Flags |= D3D11_BUFFER_UAV_FLAG_RAW; + uavDesc.Format = DXGI_FORMAT_R32_TYPELESS; + uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / 4); + } + else + { + FormatInfo sizeInfo; + gfxGetFormatInfo(desc.format, &sizeInfo); + uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / (sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock)); + } + + ComPtr<ID3D11UnorderedAccessView> uav; + SLANG_RETURN_ON_FAIL(m_device->CreateUnorderedAccessView(resourceImpl->m_buffer, &uavDesc, uav.writeRef())); + + RefPtr<UnorderedAccessViewImpl> viewImpl = new UnorderedAccessViewImpl(); + viewImpl->m_type = ResourceViewImpl::Type::UAV; + viewImpl->m_uav = uav; + viewImpl->m_desc = desc; + + returnComPtr(outView, viewImpl); + return SLANG_OK; + } + break; + + case IResourceView::Type::ShaderResource: + { + D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + srvDesc.Format = D3DUtil::getMapFormat(desc.format); + srvDesc.Buffer.FirstElement = 0; + + if (resourceDesc.elementSize) + { + srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize); + } + else if (desc.format == Format::Unknown) + { + // We need to switch to a different member of the `union`, + // so that we can set the `BufferEx.Flags` member. + // + srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX; + + // Because we've switched, we need to re-set the `FirstElement` + // field to be valid, since we can't count on all compilers + // to respect that `Buffer.FirstElement` and `BufferEx.FirstElement` + // alias in memory. + // + srvDesc.BufferEx.FirstElement = 0; + + srvDesc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW; + srvDesc.Format = DXGI_FORMAT_R32_TYPELESS; + srvDesc.BufferEx.NumElements = UINT(resourceDesc.sizeInBytes / 4); + } + else + { + FormatInfo sizeInfo; + gfxGetFormatInfo(desc.format, &sizeInfo); + srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / (sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock)); + } + + ComPtr<ID3D11ShaderResourceView> srv; + SLANG_RETURN_ON_FAIL(m_device->CreateShaderResourceView(resourceImpl->m_buffer, &srvDesc, srv.writeRef())); + + RefPtr<ShaderResourceViewImpl> viewImpl = new ShaderResourceViewImpl(); + viewImpl->m_type = ResourceViewImpl::Type::SRV; + viewImpl->m_srv = srv; + viewImpl->m_desc = desc; + returnComPtr(outView, viewImpl); + return SLANG_OK; + } + break; + } +} + +Result DeviceImpl::createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout) +{ + D3D11_INPUT_ELEMENT_DESC inputElements[16] = {}; + + char hlslBuffer[1024]; + char* hlslCursor = &hlslBuffer[0]; + + hlslCursor += sprintf(hlslCursor, "float4 main(\n"); + + auto inputElementCount = desc.inputElementCount; + auto inputElementsIn = desc.inputElements; + for (Int ii = 0; ii < inputElementCount; ++ii) + { + auto vertexStreamIndex = inputElementsIn[ii].bufferSlotIndex; + auto& vertexStream = desc.vertexStreams[vertexStreamIndex]; + + inputElements[ii].SemanticName = inputElementsIn[ii].semanticName; + inputElements[ii].SemanticIndex = (UINT)inputElementsIn[ii].semanticIndex; + inputElements[ii].Format = D3DUtil::getMapFormat(inputElementsIn[ii].format); + inputElements[ii].InputSlot = (UINT)vertexStreamIndex; + inputElements[ii].AlignedByteOffset = (UINT)inputElementsIn[ii].offset; + inputElements[ii].InputSlotClass = + (vertexStream.slotClass == InputSlotClass::PerInstance) ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA; + inputElements[ii].InstanceDataStepRate = (UINT)vertexStream.instanceDataStepRate; + + if (ii != 0) + { + hlslCursor += sprintf(hlslCursor, ",\n"); + } + + char const* typeName = "Unknown"; + switch (inputElementsIn[ii].format) + { + case Format::R32G32B32A32_FLOAT: + case Format::R8G8B8A8_UNORM: + typeName = "float4"; + break; + case Format::R32G32B32_FLOAT: + typeName = "float3"; + break; + case Format::R32G32_FLOAT: + typeName = "float2"; + break; + case Format::R32_FLOAT: + typeName = "float"; + break; + default: + return SLANG_FAIL; + } + + hlslCursor += sprintf(hlslCursor, "%s a%d : %s%d", + typeName, + (int)ii, + inputElementsIn[ii].semanticName, + (int)inputElementsIn[ii].semanticIndex); + } + + hlslCursor += sprintf(hlslCursor, "\n) : SV_Position { return 0; }"); + + ComPtr<ID3DBlob> vertexShaderBlob; + SLANG_RETURN_ON_FAIL(D3DUtil::compileHLSLShader("inputLayout", hlslBuffer, "main", "vs_5_0", vertexShaderBlob)); + + ComPtr<ID3D11InputLayout> inputLayout; + SLANG_RETURN_ON_FAIL(m_device->CreateInputLayout(&inputElements[0], (UINT)inputElementCount, vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), + inputLayout.writeRef())); + + RefPtr<InputLayoutImpl> impl = new InputLayoutImpl; + impl->m_layout.swap(inputLayout); + + auto vertexStreamCount = desc.vertexStreamCount; + impl->m_vertexStreamStrides.setCount(vertexStreamCount); + for (Int i = 0; i < vertexStreamCount; ++i) + { + impl->m_vertexStreamStrides[i] = (UINT)desc.vertexStreams[i].stride; + } + + returnComPtr(outLayout, impl); + return SLANG_OK; +} + +Result DeviceImpl::createQueryPool(const IQueryPool::Desc& desc, IQueryPool** outPool) +{ + RefPtr<QueryPoolImpl> result = new QueryPoolImpl(); + SLANG_RETURN_ON_FAIL(result->init(desc, this)); + returnComPtr(outPool, result); + return SLANG_OK; +} + +void* DeviceImpl::map(IBufferResource* bufferIn, MapFlavor flavor) +{ + BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn); + + D3D11_MAP mapType; + ID3D11Buffer* buffer = bufferResource->m_buffer; + + switch (flavor) + { + case MapFlavor::WriteDiscard: + mapType = D3D11_MAP_WRITE_DISCARD; + break; + case MapFlavor::HostWrite: + mapType = D3D11_MAP_WRITE_NO_OVERWRITE; + break; + case MapFlavor::HostRead: + mapType = D3D11_MAP_READ; + break; + default: + return nullptr; + } + + bufferResource->m_mapFlavor = flavor; + + switch (flavor) + { + case MapFlavor::WriteDiscard: + case MapFlavor::HostWrite: + // If buffer is not dynamic, we need to use staging buffer. + if (bufferResource->m_d3dUsage != D3D11_USAGE_DYNAMIC) + { + bufferResource->m_uploadStagingBuffer.setCount(bufferResource->getDesc()->sizeInBytes); + return bufferResource->m_uploadStagingBuffer.getBuffer(); + } + break; + case MapFlavor::HostRead: + buffer = bufferResource->m_staging; + if (!buffer) + { + return nullptr; + } + + // Okay copy the data over + m_immediateContext->CopyResource(buffer, bufferResource->m_buffer); + + } + + // We update our constant buffer per-frame, just for the purposes + // of the example, but we don't actually load different data + // per-frame (we always use an identity projection). + D3D11_MAPPED_SUBRESOURCE mappedSub; + SLANG_RETURN_NULL_ON_FAIL(m_immediateContext->Map(buffer, 0, mapType, 0, &mappedSub)); + + return mappedSub.pData; +} + +void DeviceImpl::unmap(IBufferResource* bufferIn, size_t offsetWritten, size_t sizeWritten) +{ + BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn); + switch (bufferResource->m_mapFlavor) + { + case MapFlavor::WriteDiscard: + case MapFlavor::HostWrite: + // If buffer is not dynamic, the CPU has already written to the staging buffer, + // and we need to copy the content over to the GPU buffer. + if (bufferResource->m_d3dUsage != D3D11_USAGE_DYNAMIC && sizeWritten != 0) + { + D3D11_BOX dstBox = {}; + dstBox.left = (UINT)offsetWritten; + dstBox.right = (UINT)(offsetWritten + sizeWritten); + dstBox.back = 1; + dstBox.bottom = 1; + m_immediateContext->UpdateSubresource( + bufferResource->m_buffer, + 0, + &dstBox, + bufferResource->m_uploadStagingBuffer.getBuffer() + offsetWritten, + 0, + 0); + return; + } + } + m_immediateContext->Unmap(bufferResource->m_mapFlavor == MapFlavor::HostRead ? bufferResource->m_staging : bufferResource->m_buffer, 0); +} + +#if 0 +void D3D11Device::setInputLayout(InputLayout* inputLayoutIn) +{ + auto inputLayout = static_cast<InputLayoutImpl*>(inputLayoutIn); + m_immediateContext->IASetInputLayout(inputLayout->m_layout); +} +#endif + +void DeviceImpl::setPrimitiveTopology(PrimitiveTopology topology) +{ + m_immediateContext->IASetPrimitiveTopology(D3DUtil::getPrimitiveTopology(topology)); +} + +void DeviceImpl::setVertexBuffers( + GfxIndex startSlot, + GfxCount slotCount, + IBufferResource* const* buffersIn, + const Offset* offsetsIn) +{ + static const int kMaxVertexBuffers = 16; + assert(slotCount <= kMaxVertexBuffers); + assert(m_currentPipelineState); // The pipeline state should be created before setting vertex buffers. + + UINT vertexStrides[kMaxVertexBuffers]; + UINT vertexOffsets[kMaxVertexBuffers]; + ID3D11Buffer* dxBuffers[kMaxVertexBuffers]; + + auto buffers = (BufferResourceImpl* const*)buffersIn; + + for (GfxIndex ii = 0; ii < slotCount; ++ii) + { + auto inputLayout = (InputLayoutImpl*)m_currentPipelineState->inputLayout.Ptr(); + vertexStrides[ii] = inputLayout->m_vertexStreamStrides[startSlot + ii]; + vertexOffsets[ii] = (UINT)offsetsIn[ii]; + dxBuffers[ii] = buffers[ii]->m_buffer; + } + + m_immediateContext->IASetVertexBuffers((UINT)startSlot, (UINT)slotCount, dxBuffers, &vertexStrides[0], &vertexOffsets[0]); +} + +void DeviceImpl::setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset) +{ + DXGI_FORMAT dxFormat = D3DUtil::getMapFormat(indexFormat); + m_immediateContext->IASetIndexBuffer(((BufferResourceImpl*)buffer)->m_buffer, dxFormat, UINT(offset)); +} + +void DeviceImpl::setViewports(GfxCount count, Viewport const* viewports) +{ + static const int kMaxViewports = D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX + 1; + assert(count <= kMaxViewports); + + D3D11_VIEWPORT dxViewports[kMaxViewports]; + for (GfxIndex ii = 0; ii < count; ++ii) + { + auto& inViewport = viewports[ii]; + auto& dxViewport = dxViewports[ii]; + + dxViewport.TopLeftX = inViewport.originX; + dxViewport.TopLeftY = inViewport.originY; + dxViewport.Width = inViewport.extentX; + dxViewport.Height = inViewport.extentY; + dxViewport.MinDepth = inViewport.minZ; + dxViewport.MaxDepth = inViewport.maxZ; + } + + m_immediateContext->RSSetViewports(UINT(count), dxViewports); +} + +void DeviceImpl::setScissorRects(GfxCount count, ScissorRect const* rects) +{ + static const int kMaxScissorRects = D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX + 1; + assert(count <= kMaxScissorRects); + + D3D11_RECT dxRects[kMaxScissorRects]; + for (GfxIndex ii = 0; ii < count; ++ii) + { + auto& inRect = rects[ii]; + auto& dxRect = dxRects[ii]; + + dxRect.left = LONG(inRect.minX); + dxRect.top = LONG(inRect.minY); + dxRect.right = LONG(inRect.maxX); + dxRect.bottom = LONG(inRect.maxY); + } + + m_immediateContext->RSSetScissorRects(UINT(count), dxRects); +} + + +void DeviceImpl::setPipelineState(IPipelineState* state) +{ + auto pipelineType = static_cast<PipelineStateBase*>(state)->desc.type; + + switch (pipelineType) + { + default: + break; + + case PipelineType::Graphics: + { + auto stateImpl = (GraphicsPipelineStateImpl*)state; + auto programImpl = static_cast<ShaderProgramImpl*>(stateImpl->m_program.Ptr()); + + // TODO: We could conceivably do some lightweight state + // differencing here (e.g., check if `programImpl` is the + // same as the program that is currently bound). + // + // It isn't clear how much that would pay off given that + // the D3D11 runtime seems to do its own state diffing. + + // IA + + m_immediateContext->IASetInputLayout(stateImpl->m_inputLayout->m_layout); + + // VS + + // TODO(tfoley): Why the conditional here? If somebody is trying to disable the VS or PS, shouldn't we respect that? + if (programImpl->m_vertexShader) + m_immediateContext->VSSetShader(programImpl->m_vertexShader, nullptr, 0); + + // HS + + // DS + + // GS + + // RS + + m_immediateContext->RSSetState(stateImpl->m_rasterizerState); + + // PS + if (programImpl->m_pixelShader) + m_immediateContext->PSSetShader(programImpl->m_pixelShader, nullptr, 0); + + // OM + + m_immediateContext->OMSetBlendState(stateImpl->m_blendState, stateImpl->m_blendColor, stateImpl->m_sampleMask); + + m_currentPipelineState = stateImpl; + + m_depthStencilStateDirty = true; + } + break; + + case PipelineType::Compute: + { + auto stateImpl = (ComputePipelineStateImpl*)state; + auto programImpl = static_cast<ShaderProgramImpl*>(stateImpl->m_program.Ptr()); + + // CS + + m_immediateContext->CSSetShader(programImpl->m_computeShader, nullptr, 0); + m_currentPipelineState = stateImpl; + } + break; + } + + /// ... +} + +void DeviceImpl::draw(GfxCount vertexCount, GfxIndex startVertex) +{ + _flushGraphicsState(); + m_immediateContext->Draw(vertexCount, startVertex); +} + +void DeviceImpl::drawIndexed(GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) +{ + _flushGraphicsState(); + m_immediateContext->DrawIndexed(indexCount, startIndex, baseVertex); +} + +void DeviceImpl::drawInstanced( + GfxCount vertexCount, + GfxCount instanceCount, + GfxIndex startVertex, + GfxIndex startInstanceLocation) +{ + _flushGraphicsState(); + m_immediateContext->DrawInstanced( + vertexCount, + instanceCount, + startVertex, + startInstanceLocation); +} + +void DeviceImpl::drawIndexedInstanced( + GfxCount indexCount, + GfxCount instanceCount, + GfxIndex startIndexLocation, + GfxIndex baseVertexLocation, + GfxIndex startInstanceLocation) +{ + _flushGraphicsState(); + m_immediateContext->DrawIndexedInstanced( + indexCount, + instanceCount, + startIndexLocation, + baseVertexLocation, + startInstanceLocation); +} + +Result DeviceImpl::createProgram( + const IShaderProgram::Desc& desc, IShaderProgram** outProgram, ISlangBlob** outDiagnosticBlob) +{ + SLANG_ASSERT(desc.slangGlobalScope); + + if (desc.slangGlobalScope->getSpecializationParamCount() != 0) + { + // For a specializable program, we don't invoke any actual slang compilation yet. + RefPtr<ShaderProgramImpl> shaderProgram = new ShaderProgramImpl(); + shaderProgram->init(desc); + returnComPtr(outProgram, shaderProgram); + return SLANG_OK; + } + + // If the program is already specialized, compile and create shader kernels now. + SlangInt targetIndex = 0; + auto slangGlobalScope = desc.slangGlobalScope; + auto programLayout = slangGlobalScope->getLayout(targetIndex); + if (!programLayout) + return SLANG_FAIL; + SlangUInt entryPointCount = programLayout->getEntryPointCount(); + if (entryPointCount == 0) + return SLANG_FAIL; + + RefPtr<ShaderProgramImpl> shaderProgram = new ShaderProgramImpl(); + shaderProgram->slangGlobalScope = desc.slangGlobalScope; + + ScopeNVAPI scopeNVAPI; + SLANG_RETURN_ON_FAIL(scopeNVAPI.init(this, 0)); + for (SlangUInt i = 0; i < entryPointCount; i++) + { + ComPtr<ISlangBlob> kernelCode; + ComPtr<ISlangBlob> diagnostics; + + auto compileResult = slangGlobalScope->getEntryPointCode( + (SlangInt)i, 0, kernelCode.writeRef(), diagnostics.writeRef()); + + if (diagnostics) + { + getDebugCallback()->handleMessage( + compileResult == SLANG_OK ? DebugMessageType::Warning : DebugMessageType::Error, + DebugMessageSource::Slang, + (char*)diagnostics->getBufferPointer()); + if (outDiagnosticBlob) + returnComPtr(outDiagnosticBlob, diagnostics); + } + + SLANG_RETURN_ON_FAIL(compileResult); + + auto entryPoint = programLayout->getEntryPointByIndex(i); + switch (entryPoint->getStage()) + { + case SLANG_STAGE_COMPUTE: + SLANG_ASSERT(entryPointCount == 1); + SLANG_RETURN_ON_FAIL(m_device->CreateComputeShader( + kernelCode->getBufferPointer(), + kernelCode->getBufferSize(), + nullptr, + shaderProgram->m_computeShader.writeRef())); + break; + case SLANG_STAGE_VERTEX: + SLANG_RETURN_ON_FAIL(m_device->CreateVertexShader( + kernelCode->getBufferPointer(), + kernelCode->getBufferSize(), + nullptr, + shaderProgram->m_vertexShader.writeRef())); + break; + case SLANG_STAGE_FRAGMENT: + SLANG_RETURN_ON_FAIL(m_device->CreatePixelShader( + kernelCode->getBufferPointer(), + kernelCode->getBufferSize(), + nullptr, + shaderProgram->m_pixelShader.writeRef())); + break; + default: + SLANG_ASSERT(!"pipeline stage not implemented"); + } + } + returnComPtr(outProgram, shaderProgram); + return SLANG_OK; +} + +Result DeviceImpl::createShaderObjectLayout( + slang::TypeLayoutReflection* typeLayout, + ShaderObjectLayoutBase** outLayout) +{ + RefPtr<ShaderObjectLayoutImpl> layout; + SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( + this, typeLayout, layout.writeRef())); + returnRefPtrMove(outLayout, layout); + return SLANG_OK; +} + +Result DeviceImpl::createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) +{ + RefPtr<ShaderObjectImpl> shaderObject; + SLANG_RETURN_ON_FAIL(ShaderObjectImpl::create(this, + static_cast<ShaderObjectLayoutImpl*>(layout), shaderObject.writeRef())); + returnComPtr(outObject, shaderObject); + return SLANG_OK; +} + +Result DeviceImpl::createMutableShaderObject( + ShaderObjectLayoutBase* layout, + IShaderObject** outObject) +{ + auto layoutImpl = static_cast<ShaderObjectLayoutImpl*>(layout); + + RefPtr<MutableShaderObjectImpl> result = new MutableShaderObjectImpl(); + SLANG_RETURN_ON_FAIL(result->init(this, layoutImpl)); + returnComPtr(outObject, result); + + return SLANG_OK; +} + +Result DeviceImpl::createRootShaderObject(IShaderProgram* program, ShaderObjectBase** outObject) +{ + auto programImpl = static_cast<ShaderProgramImpl*>(program); + RefPtr<RootShaderObjectImpl> shaderObject; + RefPtr<RootShaderObjectLayoutImpl> rootLayout; + SLANG_RETURN_ON_FAIL(RootShaderObjectLayoutImpl::create( + this, programImpl->slangGlobalScope, programImpl->slangGlobalScope->getLayout(), rootLayout.writeRef())); + SLANG_RETURN_ON_FAIL(RootShaderObjectImpl::create( + this, rootLayout.Ptr(), shaderObject.writeRef())); + returnRefPtrMove(outObject, shaderObject); + return SLANG_OK; +} + +void DeviceImpl::bindRootShaderObject(IShaderObject* shaderObject) +{ + RootShaderObjectImpl* rootShaderObjectImpl = static_cast<RootShaderObjectImpl*>(shaderObject); + RefPtr<PipelineStateBase> specializedPipeline; + maybeSpecializePipeline(m_currentPipelineState, rootShaderObjectImpl, specializedPipeline); + PipelineStateImpl* specializedPipelineImpl = static_cast<PipelineStateImpl*>(specializedPipeline.Ptr()); + setPipelineState(specializedPipelineImpl); + + // In order to bind the root object we must compute its specialized layout. + // + // TODO: This is in most ways redundant with `maybeSpecializePipeline` above, + // and the two operations should really be one. + // + RefPtr<ShaderObjectLayoutImpl> specializedRootLayout; + rootShaderObjectImpl->_getSpecializedLayout(specializedRootLayout.writeRef()); + RootShaderObjectLayoutImpl* specializedRootLayoutImpl = static_cast<RootShaderObjectLayoutImpl*>(specializedRootLayout.Ptr()); + + // Depending on whether we are binding a compute or a graphics/rasterization + // pipeline, we will need to bind any SRVs/UAVs/CBs/samplers using different + // D3D11 calls. We deal with that distinction here by instantiating an + // appropriate subtype of `BindingContext` based on the pipeline type. + // + switch (m_currentPipelineState->desc.type) + { + case PipelineType::Compute: + { + ComputeBindingContext context(this, m_immediateContext); + rootShaderObjectImpl->bindAsRoot(&context, specializedRootLayoutImpl); + + // Because D3D11 requires all UAVs to be set at once, we did *not* issue + // actual binding calls during the `bindAsRoot` step, and instead we + // batch them up and set them here. + // + m_immediateContext->CSSetUnorderedAccessViews(0, context.uavCount, context.uavs, nullptr); + } + break; + default: + { + GraphicsBindingContext context(this, m_immediateContext); + rootShaderObjectImpl->bindAsRoot(&context, specializedRootLayoutImpl); + + // Similar to the compute case above, the rasteirzation case needs to + // set the UAVs after the call to `bindAsRoot()` completes, but we + // also have a few extra wrinkles here that are specific to the D3D 11.0 + // rasterization pipeline. + // + // In D3D 11.0, the RTV and UAV binding slots alias, so that a shader + // that binds an RTV for `SV_Target0` cannot also bind a UAV for `u0`. + // The Slang layout algorithm already accounts for this rule, and assigns + // all UAVs to slots taht won't alias the RTVs it knows about. + // + // In order to account for the aliasing, we need to consider how many + // RTVs are bound as part of the active framebuffer, and then adjust + // the UAVs that we bind accordingly. + // + auto rtvCount = (UINT)m_currentFramebuffer->renderTargetViews.getCount(); + // + // The `context` we are using will have computed the number of UAV registers + // that might need to be bound, as a range from 0 to `context.uavCount`. + // However we need to skip over the first `rtvCount` of those, so the + // actual number of UAVs we wnat to bind is smaller: + // + // Note: As a result we expect that either there were no UAVs bound, + // *or* the number of UAV slots bound is higher than the number of + // RTVs so that there is something left to actually bind. + // + SLANG_ASSERT((context.uavCount == 0) || (context.uavCount >= rtvCount)); + auto bindableUAVCount = context.uavCount - rtvCount; + // + // Similarly, the actual UAVs we intend to bind will come after the first + // `rtvCount` in the array. + // + auto bindableUAVs = context.uavs + rtvCount; + + // Once the offsetting is accounted for, we set all of the RTVs, DSV, + // and UAVs with one call. + // + // TODO: We may want to use the capability for `OMSetRenderTargetsAnd...` + // to only set the UAVs and leave the RTVs/UAVs alone, so that we don't + // needlessly re-bind RTVs during a pass. + // + m_immediateContext->OMSetRenderTargetsAndUnorderedAccessViews( + rtvCount, + m_currentFramebuffer->d3dRenderTargetViews.getArrayView().getBuffer(), + m_currentFramebuffer->d3dDepthStencilView, + rtvCount, + bindableUAVCount, + bindableUAVs, + nullptr); + } + break; + } +} + +Result DeviceImpl::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState) +{ + GraphicsPipelineStateDesc desc = inDesc; + + auto programImpl = (ShaderProgramImpl*)desc.program; + + ComPtr<ID3D11DepthStencilState> depthStencilState; + { + D3D11_DEPTH_STENCIL_DESC dsDesc; + dsDesc.DepthEnable = desc.depthStencil.depthTestEnable; + dsDesc.DepthWriteMask = desc.depthStencil.depthWriteEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; + dsDesc.DepthFunc = translateComparisonFunc(desc.depthStencil.depthFunc); + dsDesc.StencilEnable = desc.depthStencil.stencilEnable; + dsDesc.StencilReadMask = desc.depthStencil.stencilReadMask; + dsDesc.StencilWriteMask = desc.depthStencil.stencilWriteMask; + +#define FACE(DST, SRC) \ + dsDesc.DST.StencilFailOp = translateStencilOp( desc.depthStencil.SRC.stencilFailOp); \ + dsDesc.DST.StencilDepthFailOp = translateStencilOp( desc.depthStencil.SRC.stencilDepthFailOp); \ + dsDesc.DST.StencilPassOp = translateStencilOp( desc.depthStencil.SRC.stencilPassOp); \ + dsDesc.DST.StencilFunc = translateComparisonFunc(desc.depthStencil.SRC.stencilFunc); \ + /* end */ + + FACE(FrontFace, frontFace); + FACE(BackFace, backFace); + + SLANG_RETURN_ON_FAIL(m_device->CreateDepthStencilState( + &dsDesc, + depthStencilState.writeRef())); + } + + ComPtr<ID3D11RasterizerState> rasterizerState; + { + D3D11_RASTERIZER_DESC rsDesc; + rsDesc.FillMode = translateFillMode(desc.rasterizer.fillMode); + rsDesc.CullMode = translateCullMode(desc.rasterizer.cullMode); + rsDesc.FrontCounterClockwise = desc.rasterizer.frontFace == FrontFaceMode::Clockwise; + rsDesc.DepthBias = desc.rasterizer.depthBias; + rsDesc.DepthBiasClamp = desc.rasterizer.depthBiasClamp; + rsDesc.SlopeScaledDepthBias = desc.rasterizer.slopeScaledDepthBias; + rsDesc.DepthClipEnable = desc.rasterizer.depthClipEnable; + rsDesc.ScissorEnable = desc.rasterizer.scissorEnable; + rsDesc.MultisampleEnable = desc.rasterizer.multisampleEnable; + rsDesc.AntialiasedLineEnable = desc.rasterizer.antialiasedLineEnable; + + SLANG_RETURN_ON_FAIL(m_device->CreateRasterizerState( + &rsDesc, + rasterizerState.writeRef())); + + } + + ComPtr<ID3D11BlendState> blendState; + { + auto& srcDesc = desc.blend; + D3D11_BLEND_DESC dstDesc = {}; + + TargetBlendDesc defaultTargetBlendDesc; + + static const UInt kMaxTargets = D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; + if (srcDesc.targetCount > kMaxTargets) return SLANG_FAIL; + + for (GfxIndex ii = 0; ii < kMaxTargets; ++ii) + { + TargetBlendDesc const* srcTargetBlendDescPtr = nullptr; + if (ii < srcDesc.targetCount) + { + srcTargetBlendDescPtr = &srcDesc.targets[ii]; + } + else if (srcDesc.targetCount == 0) + { + srcTargetBlendDescPtr = &defaultTargetBlendDesc; + } + else + { + srcTargetBlendDescPtr = &srcDesc.targets[srcDesc.targetCount - 1]; + } + + auto& srcTargetBlendDesc = *srcTargetBlendDescPtr; + auto& dstTargetBlendDesc = dstDesc.RenderTarget[ii]; + + if (isBlendDisabled(srcTargetBlendDesc)) + { + dstTargetBlendDesc.BlendEnable = false; + dstTargetBlendDesc.BlendOp = D3D11_BLEND_OP_ADD; + dstTargetBlendDesc.BlendOpAlpha = D3D11_BLEND_OP_ADD; + dstTargetBlendDesc.SrcBlend = D3D11_BLEND_ONE; + dstTargetBlendDesc.SrcBlendAlpha = D3D11_BLEND_ONE; + dstTargetBlendDesc.DestBlend = D3D11_BLEND_ZERO; + dstTargetBlendDesc.DestBlendAlpha = D3D11_BLEND_ZERO; + } + else + { + dstTargetBlendDesc.BlendEnable = true; + dstTargetBlendDesc.BlendOp = translateBlendOp(srcTargetBlendDesc.color.op); + dstTargetBlendDesc.BlendOpAlpha = translateBlendOp(srcTargetBlendDesc.alpha.op); + dstTargetBlendDesc.SrcBlend = translateBlendFactor(srcTargetBlendDesc.color.srcFactor); + dstTargetBlendDesc.SrcBlendAlpha = translateBlendFactor(srcTargetBlendDesc.alpha.srcFactor); + dstTargetBlendDesc.DestBlend = translateBlendFactor(srcTargetBlendDesc.color.dstFactor); + dstTargetBlendDesc.DestBlendAlpha = translateBlendFactor(srcTargetBlendDesc.alpha.dstFactor); + } + + dstTargetBlendDesc.RenderTargetWriteMask = translateRenderTargetWriteMask(srcTargetBlendDesc.writeMask); + } + + dstDesc.IndependentBlendEnable = srcDesc.targetCount > 1; + dstDesc.AlphaToCoverageEnable = srcDesc.alphaToCoverageEnable; + + SLANG_RETURN_ON_FAIL(m_device->CreateBlendState( + &dstDesc, + blendState.writeRef())); + } + + RefPtr<GraphicsPipelineStateImpl> state = new GraphicsPipelineStateImpl(); + state->m_depthStencilState = depthStencilState; + state->m_rasterizerState = rasterizerState; + state->m_blendState = blendState; + state->m_inputLayout = static_cast<InputLayoutImpl*>(desc.inputLayout); + state->m_rtvCount = (UINT) static_cast<FramebufferLayoutImpl*>(desc.framebufferLayout) + ->m_renderTargets.getCount(); + state->m_blendColor[0] = 0; + state->m_blendColor[1] = 0; + state->m_blendColor[2] = 0; + state->m_blendColor[3] = 0; + state->m_sampleMask = 0xFFFFFFFF; + state->init(desc); + returnComPtr(outState, state); + return SLANG_OK; +} + +Result DeviceImpl::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState) +{ + ComputePipelineStateDesc desc = inDesc; + + RefPtr<ComputePipelineStateImpl> state = new ComputePipelineStateImpl(); + state->init(desc); + returnComPtr(outState, state); + return SLANG_OK; +} + +void DeviceImpl::copyBuffer( + IBufferResource* dst, + Offset dstOffset, + IBufferResource* src, + Offset srcOffset, + Size size) +{ + auto dstImpl = static_cast<BufferResourceImpl*>(dst); + auto srcImpl = static_cast<BufferResourceImpl*>(src); + D3D11_BOX srcBox = {}; + srcBox.left = (UINT)srcOffset; + srcBox.right = (UINT)(srcOffset + size); + srcBox.bottom = srcBox.back = 1; + m_immediateContext->CopySubresourceRegion( + dstImpl->m_buffer, 0, (UINT)dstOffset, 0, 0, srcImpl->m_buffer, 0, &srcBox); +} + +void DeviceImpl::dispatchCompute(int x, int y, int z) +{ + m_immediateContext->Dispatch(x, y, z); +} + +void DeviceImpl::_flushGraphicsState() +{ + if (m_depthStencilStateDirty) + { + m_depthStencilStateDirty = false; + auto pipelineState = static_cast<GraphicsPipelineStateImpl*>(m_currentPipelineState.Ptr()); + m_immediateContext->OMSetDepthStencilState( + pipelineState->m_depthStencilState, m_stencilRef); + } +} + +void DeviceImpl::beginCommandBuffer(const CommandBufferInfo& info) +{ + if (info.hasWriteTimestamps) + { + m_immediateContext->Begin(m_disjointQuery); + } +} + +void DeviceImpl::endCommandBuffer(const CommandBufferInfo& info) +{ + if (info.hasWriteTimestamps) + { + m_immediateContext->End(m_disjointQuery); + } +} + +void DeviceImpl::writeTimestamp(IQueryPool* pool, GfxIndex index) +{ + auto poolImpl = static_cast<QueryPoolImpl*>(pool); + m_immediateContext->End(poolImpl->getQuery(index)); +} +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-device.h b/tools/gfx/d3d11/d3d11-device.h new file mode 100644 index 000000000..608411912 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-device.h @@ -0,0 +1,161 @@ +// d3d11-device.h +#pragma once +#include "d3d11-framebuffer.h" +#include "d3d11-pipeline-state.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class DeviceImpl : public ImmediateRendererBase +{ +public: + + ~DeviceImpl() {} + + // Renderer implementation + virtual SLANG_NO_THROW Result SLANG_MCALL initialize(const Desc& desc) override; + virtual void clearFrame(uint32_t colorBufferMask, bool clearDepth, bool clearStencil) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createSwapchain( + const ISwapchain::Desc& desc, WindowHandle window, ISwapchain** outSwapchain) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createFramebufferLayout( + const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout) override; + virtual SLANG_NO_THROW Result SLANG_MCALL + createFramebuffer(const IFramebuffer::Desc& desc, IFramebuffer** outFramebuffer) override; + virtual void setFramebuffer(IFramebuffer* frameBuffer) override; + virtual void setStencilReference(uint32_t referenceValue) override; + + virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( + const ITextureResource::Desc& desc, + const ITextureResource::SubresourceData* initData, + ITextureResource** outResource) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( + const IBufferResource::Desc& desc, + const void* initData, + IBufferResource** outResource) override; + virtual SLANG_NO_THROW Result SLANG_MCALL + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override; + + virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( + ITextureResource* texture, + IResourceView::Desc const& desc, + IResourceView** outView) override; + + virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( + IBufferResource* buffer, + IBufferResource* counterBuffer, + IResourceView::Desc const& desc, + IResourceView** outView) override; + + virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( + IInputLayout::Desc const& desc, + IInputLayout** outLayout) override; + + virtual SLANG_NO_THROW Result SLANG_MCALL createQueryPool( + const IQueryPool::Desc& desc, IQueryPool** outPool) override; + + virtual Result createShaderObjectLayout( + slang::TypeLayoutReflection* typeLayout, + ShaderObjectLayoutBase** outLayout) override; + virtual Result createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) + override; + virtual Result createMutableShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) override; + virtual Result createRootShaderObject(IShaderProgram* program, ShaderObjectBase** outObject) + override; + virtual void bindRootShaderObject(IShaderObject* shaderObject) override; + + virtual SLANG_NO_THROW Result SLANG_MCALL createProgram( + const IShaderProgram::Desc& desc, + IShaderProgram** outProgram, + ISlangBlob** outDiagnosticBlob) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( + const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( + const ComputePipelineStateDesc& desc, IPipelineState** outState) override; + + virtual void* map(IBufferResource* buffer, MapFlavor flavor) override; + virtual void unmap(IBufferResource* buffer, size_t offsetWritten, size_t sizeWritten) override; + virtual void copyBuffer( + IBufferResource* dst, + size_t dstOffset, + IBufferResource* src, + size_t srcOffset, + size_t size) override; + virtual SLANG_NO_THROW SlangResult SLANG_MCALL readTextureResource( + ITextureResource* texture, ResourceState state, ISlangBlob** outBlob, size_t* outRowPitch, size_t* outPixelSize) override; + + virtual void setPrimitiveTopology(PrimitiveTopology topology) override; + + virtual void setVertexBuffers( + GfxIndex startSlot, + GfxCount slotCount, + IBufferResource* const* buffers, + const Offset* offsets) override; + virtual void setIndexBuffer( + IBufferResource* buffer, Format indexFormat, Offset offset) override; + virtual void setViewports(GfxCount count, Viewport const* viewports) override; + virtual void setScissorRects(GfxCount count, ScissorRect const* rects) override; + virtual void setPipelineState(IPipelineState* state) override; + virtual void draw(GfxCount vertexCount, GfxIndex startVertex) override; + virtual void drawIndexed( + GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) override; + virtual void drawInstanced( + GfxCount vertexCount, + GfxCount instanceCount, + GfxIndex startVertex, + GfxIndex startInstanceLocation) override; + virtual void drawIndexedInstanced( + GfxCount indexCount, + GfxCount instanceCount, + GfxIndex startIndexLocation, + GfxIndex baseVertexLocation, + GfxIndex startInstanceLocation) override; + virtual void dispatchCompute(int x, int y, int z) override; + virtual void submitGpuWork() override {} + virtual void waitForGpu() override + { + + } + virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const override + { + return m_info; + } + virtual void beginCommandBuffer(const CommandBufferInfo& info) override; + virtual void endCommandBuffer(const CommandBufferInfo& info) override; + virtual void writeTimestamp(IQueryPool* pool, GfxIndex index) override; + +public: + void _flushGraphicsState(); + + // D3D11Device members. + + DeviceInfo m_info; + String m_adapterName; + + ComPtr<IDXGISwapChain> m_swapChain; + ComPtr<ID3D11Device> m_device; + ComPtr<ID3D11DeviceContext> m_immediateContext; + ComPtr<ID3D11Texture2D> m_backBufferTexture; + ComPtr<IDXGIFactory> m_dxgiFactory; + RefPtr<FramebufferImpl> m_currentFramebuffer; + + RefPtr<PipelineStateImpl> m_currentPipelineState; + + ComPtr<ID3D11Query> m_disjointQuery; + + uint32_t m_stencilRef = 0; + bool m_depthStencilStateDirty = true; + + Desc m_desc; + + float m_clearColor[4] = { 0, 0, 0, 0 }; + + bool m_nvapi = false; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-framebuffer.h b/tools/gfx/d3d11/d3d11-framebuffer.h new file mode 100644 index 000000000..b0b55901a --- /dev/null +++ b/tools/gfx/d3d11/d3d11-framebuffer.h @@ -0,0 +1,38 @@ +// d3d11-framebuffer.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +enum +{ + kMaxUAVs = 64, + kMaxRTVs = 8, +}; + +class FramebufferLayoutImpl : public FramebufferLayoutBase +{ +public: + ShortList<IFramebufferLayout::TargetLayout> m_renderTargets; + bool m_hasDepthStencil = false; + IFramebufferLayout::TargetLayout m_depthStencil; +}; + +class FramebufferImpl : public FramebufferBase +{ +public: + ShortList<RefPtr<RenderTargetViewImpl>, kMaxRTVs> renderTargetViews; + ShortList<ID3D11RenderTargetView*, kMaxRTVs> d3dRenderTargetViews; + RefPtr<DepthStencilViewImpl> depthStencilView; + ID3D11DepthStencilView* d3dDepthStencilView; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-helper-functions.cpp b/tools/gfx/d3d11/d3d11-helper-functions.cpp new file mode 100644 index 000000000..c4caab59b --- /dev/null +++ b/tools/gfx/d3d11/d3d11-helper-functions.cpp @@ -0,0 +1,354 @@ +// d3d11-helper-functions.cpp +#include "d3d11-helper-functions.h" + +#include "d3d11-device.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + bool isSupportedNVAPIOp(IUnknown* dev, uint32_t op) + { +#ifdef GFX_NVAPI + { + bool isSupported; + NvAPI_Status status = NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(dev, NvU32(op), &isSupported); + return status == NVAPI_OK && isSupported; + } +#else + return false; +#endif + } + + D3D11_BIND_FLAG calcResourceFlag(ResourceState state) + { + switch (state) + { + case ResourceState::VertexBuffer: + return D3D11_BIND_VERTEX_BUFFER; + case ResourceState::IndexBuffer: + return D3D11_BIND_INDEX_BUFFER; + case ResourceState::ConstantBuffer: + return D3D11_BIND_CONSTANT_BUFFER; + case ResourceState::StreamOutput: + return D3D11_BIND_STREAM_OUTPUT; + case ResourceState::RenderTarget: + return D3D11_BIND_RENDER_TARGET; + case ResourceState::DepthRead: + case ResourceState::DepthWrite: + return D3D11_BIND_DEPTH_STENCIL; + case ResourceState::UnorderedAccess: + return D3D11_BIND_UNORDERED_ACCESS; + case ResourceState::ShaderResource: + return D3D11_BIND_SHADER_RESOURCE; + default: + return D3D11_BIND_FLAG(0); + } + } + + int _calcResourceBindFlags(ResourceStateSet allowedStates) + { + int dstFlags = 0; + for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++) + { + auto state = (ResourceState)i; + if (allowedStates.contains(state)) + dstFlags |= calcResourceFlag(state); + } + return dstFlags; + } + + int _calcResourceAccessFlags(MemoryType memType) + { + switch (memType) + { + case MemoryType::DeviceLocal: + return 0; + case MemoryType::ReadBack: + return D3D11_CPU_ACCESS_READ; + case MemoryType::Upload: + return D3D11_CPU_ACCESS_WRITE; + default: + assert(!"Invalid flags"); + return 0; + } + } + + D3D11_FILTER_TYPE translateFilterMode(TextureFilteringMode mode) + { + switch (mode) + { + default: + return D3D11_FILTER_TYPE(0); + +#define CASE(SRC, DST) \ + case TextureFilteringMode::SRC: return D3D11_FILTER_TYPE_##DST + + CASE(Point, POINT); + CASE(Linear, LINEAR); + +#undef CASE + } + } + + D3D11_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op) + { + switch (op) + { + default: + return D3D11_FILTER_REDUCTION_TYPE(0); + +#define CASE(SRC, DST) \ + case TextureReductionOp::SRC: return D3D11_FILTER_REDUCTION_TYPE_##DST + + CASE(Average, STANDARD); + CASE(Comparison, COMPARISON); + CASE(Minimum, MINIMUM); + CASE(Maximum, MAXIMUM); + +#undef CASE + } + } + + D3D11_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode) + { + switch (mode) + { + default: + return D3D11_TEXTURE_ADDRESS_MODE(0); + +#define CASE(SRC, DST) \ + case TextureAddressingMode::SRC: return D3D11_TEXTURE_ADDRESS_##DST + + CASE(Wrap, WRAP); + CASE(ClampToEdge, CLAMP); + CASE(ClampToBorder, BORDER); + CASE(MirrorRepeat, MIRROR); + CASE(MirrorOnce, MIRROR_ONCE); + +#undef CASE + } + } + + D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func) + { + switch (func) + { + default: + // TODO: need to report failures + return D3D11_COMPARISON_ALWAYS; + +#define CASE(FROM, TO) \ + case ComparisonFunc::FROM: return D3D11_COMPARISON_##TO + + CASE(Never, NEVER); + CASE(Less, LESS); + CASE(Equal, EQUAL); + CASE(LessEqual, LESS_EQUAL); + CASE(Greater, GREATER); + CASE(NotEqual, NOT_EQUAL); + CASE(GreaterEqual, GREATER_EQUAL); + CASE(Always, ALWAYS); +#undef CASE + } + } + + D3D11_STENCIL_OP translateStencilOp(StencilOp op) + { + switch (op) + { + default: + // TODO: need to report failures + return D3D11_STENCIL_OP_KEEP; + +#define CASE(FROM, TO) \ + case StencilOp::FROM: return D3D11_STENCIL_OP_##TO + + CASE(Keep, KEEP); + CASE(Zero, ZERO); + CASE(Replace, REPLACE); + CASE(IncrementSaturate, INCR_SAT); + CASE(DecrementSaturate, DECR_SAT); + CASE(Invert, INVERT); + CASE(IncrementWrap, INCR); + CASE(DecrementWrap, DECR); +#undef CASE + + } + } + + D3D11_FILL_MODE translateFillMode(FillMode mode) + { + switch (mode) + { + default: + // TODO: need to report failures + return D3D11_FILL_SOLID; + + case FillMode::Solid: return D3D11_FILL_SOLID; + case FillMode::Wireframe: return D3D11_FILL_WIREFRAME; + } + } + + D3D11_CULL_MODE translateCullMode(CullMode mode) + { + switch (mode) + { + default: + // TODO: need to report failures + return D3D11_CULL_NONE; + + case CullMode::None: return D3D11_CULL_NONE; + case CullMode::Back: return D3D11_CULL_BACK; + case CullMode::Front: return D3D11_CULL_FRONT; + } + } + + bool isBlendDisabled(AspectBlendDesc const& desc) + { + return desc.op == BlendOp::Add + && desc.srcFactor == BlendFactor::One + && desc.dstFactor == BlendFactor::Zero; + } + + + bool isBlendDisabled(TargetBlendDesc const& desc) + { + return isBlendDisabled(desc.color) + && isBlendDisabled(desc.alpha); + } + + D3D11_BLEND_OP translateBlendOp(BlendOp op) + { + switch (op) + { + default: + assert(!"unimplemented"); + return (D3D11_BLEND_OP)-1; + +#define CASE(FROM, TO) case BlendOp::FROM: return D3D11_BLEND_OP_##TO + CASE(Add, ADD); + CASE(Subtract, SUBTRACT); + CASE(ReverseSubtract, REV_SUBTRACT); + CASE(Min, MIN); + CASE(Max, MAX); +#undef CASE + } + } + + D3D11_BLEND translateBlendFactor(BlendFactor factor) + { + switch (factor) + { + default: + assert(!"unimplemented"); + return (D3D11_BLEND)-1; + +#define CASE(FROM, TO) case BlendFactor::FROM: return D3D11_BLEND_##TO + CASE(Zero, ZERO); + CASE(One, ONE); + CASE(SrcColor, SRC_COLOR); + CASE(InvSrcColor, INV_SRC_COLOR); + CASE(SrcAlpha, SRC_ALPHA); + CASE(InvSrcAlpha, INV_SRC_ALPHA); + CASE(DestAlpha, DEST_ALPHA); + CASE(InvDestAlpha, INV_DEST_ALPHA); + CASE(DestColor, DEST_COLOR); + CASE(InvDestColor, INV_DEST_ALPHA); + CASE(SrcAlphaSaturate, SRC_ALPHA_SAT); + CASE(BlendColor, BLEND_FACTOR); + CASE(InvBlendColor, INV_BLEND_FACTOR); + CASE(SecondarySrcColor, SRC1_COLOR); + CASE(InvSecondarySrcColor, INV_SRC1_COLOR); + CASE(SecondarySrcAlpha, SRC1_ALPHA); + CASE(InvSecondarySrcAlpha, INV_SRC1_ALPHA); +#undef CASE + } + } + + D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT mask) + { + UINT result = 0; +#define CASE(FROM, TO) if(mask & RenderTargetWriteMask::Enable##FROM) result |= D3D11_COLOR_WRITE_ENABLE_##TO + + CASE(Red, RED); + CASE(Green, GREEN); + CASE(Blue, BLUE); + CASE(Alpha, ALPHA); + +#undef CASE + return D3D11_COLOR_WRITE_ENABLE(result); + } + + void initSrvDesc(IResource::Type resourceType, const ITextureResource::Desc& textureDesc, DXGI_FORMAT pixelFormat, D3D11_SHADER_RESOURCE_VIEW_DESC& descOut) + { + // create SRV + descOut = D3D11_SHADER_RESOURCE_VIEW_DESC(); + + descOut.Format = (pixelFormat == DXGI_FORMAT_UNKNOWN) ? D3DUtil::calcFormat(D3DUtil::USAGE_SRV, D3DUtil::getMapFormat(textureDesc.format)) : pixelFormat; + const int arraySize = calcEffectiveArraySize(textureDesc); + if (arraySize <= 1) + { + switch (textureDesc.type) + { + case IResource::Type::Texture1D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D; break; + case IResource::Type::Texture2D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; break; + case IResource::Type::Texture3D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break; + default: assert(!"Unknown dimension"); + } + + descOut.Texture2D.MipLevels = textureDesc.numMipLevels; + descOut.Texture2D.MostDetailedMip = 0; + } + else if (resourceType == IResource::Type::TextureCube) + { + if (textureDesc.arraySize > 1) + { + descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; + + descOut.TextureCubeArray.NumCubes = textureDesc.arraySize; + descOut.TextureCubeArray.First2DArrayFace = 0; + descOut.TextureCubeArray.MipLevels = textureDesc.numMipLevels; + descOut.TextureCubeArray.MostDetailedMip = 0; + } + else + { + descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; + + descOut.TextureCube.MipLevels = textureDesc.numMipLevels; + descOut.TextureCube.MostDetailedMip = 0; + } + } + else + { + assert(textureDesc.size.depth > 1 || arraySize > 1); + + switch (textureDesc.type) + { + case IResource::Type::Texture1D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY; break; + case IResource::Type::Texture2D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; break; + case IResource::Type::Texture3D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break; + + default: assert(!"Unknown dimension"); + } + + descOut.Texture2DArray.ArraySize = max(textureDesc.size.depth, arraySize); + descOut.Texture2DArray.MostDetailedMip = 0; + descOut.Texture2DArray.MipLevels = textureDesc.numMipLevels; + descOut.Texture2DArray.FirstArraySlice = 0; + } + } +} // namespace d3d11 + +Result SLANG_MCALL createD3D11Device(const IDevice::Desc* desc, IDevice** outDevice) +{ + RefPtr<d3d11::DeviceImpl> result = new d3d11::DeviceImpl(); + SLANG_RETURN_ON_FAIL(result->initialize(*desc)); + returnComPtr(outDevice, result); + return SLANG_OK; +} + +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-helper-functions.h b/tools/gfx/d3d11/d3d11-helper-functions.h new file mode 100644 index 000000000..266ba0973 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-helper-functions.h @@ -0,0 +1,286 @@ +// d3d11-helper-functions.h +#pragma once + +#include "slang-gfx.h" +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + /// Contextual data and operations required when binding shader objects to the pipeline state + struct BindingContext + { + // One key service that the `BindingContext` provides is abstracting over + // the difference between the D3D11 compute and graphics/rasteriation pipelines. + // D3D11 has distinct operations for, e.g., `CSSetShaderResources` + // for compute vs. `VSSetShaderResources` and `PSSetShaderResources` + // for rasterization. + // + // The context type provides simple operations for setting each class + // of resource/sampler, which will be overridden in derived types. + // + // TODO: These operations should really support binding multiple resources/samplers + // in one call, so that we can eventually make more efficient use of the API. + // + // TODO: We could reasonably also just store the bound resources into + // lcoal arrays like we are doing for UAVs, and remove the pipeline-specific + // virtual functions. However, doing so would seemingly eliminate any + // chance of avoiding redundant binding work when binding changes are + // made for a root shader object. + // + virtual void setCBV(UINT index, ID3D11Buffer* buffer) = 0; + virtual void setSRV(UINT index, ID3D11ShaderResourceView* srv) = 0; + virtual void setSampler(UINT index, ID3D11SamplerState* sampler) = 0; + + // Unordered Access Views (UAVs) are a somewhat special case in that + // the D3D11 API requires them to all be set at once, rather than one + // at a time. To support this, we will keep a local array of the UAVs + // that have been bound (up to the maximum supported by D3D 11.0) + // + void setUAV(UINT index, ID3D11UnorderedAccessView* uav) + { + uavs[index] = uav; + + // We will also track the total number of UAV slots that will + // need to be bound (including any gaps that might occur due + // to either explicit bindings or RTV bindings that conflict + // with the `u` registers for fragment shaders). + // + if (uavCount <= index) + { + uavCount = index + 1; + } + } + + /// The values bound for any UAVs + ID3D11UnorderedAccessView* uavs[D3D11_PS_CS_UAV_REGISTER_COUNT]; + + /// The number of entries in `uavs` that need to be considered when binding to the pipeline + UINT uavCount = 0; + + /// The D3D11 device that we are using for binding + DeviceImpl* device = nullptr; + + /// The D3D11 device context that we are using for binding + ID3D11DeviceContext* context = nullptr; + + /// Initialize a binding context for binding to the given `device` and `context` + BindingContext( + DeviceImpl* device, + ID3D11DeviceContext* context) + : device(device) + , context(context) + { + memset(uavs, 0, sizeof(uavs)); + } + }; + + /// A `BindingContext` for binding to the compute pipeline + struct ComputeBindingContext : BindingContext + { + /// Initialize a binding context for binding to the given `device` and `context` + ComputeBindingContext( + DeviceImpl* device, + ID3D11DeviceContext* context) + : BindingContext(device, context) + {} + + void setCBV(UINT index, ID3D11Buffer* buffer) SLANG_OVERRIDE + { + context->CSSetConstantBuffers(index, 1, &buffer); + } + + void setSRV(UINT index, ID3D11ShaderResourceView* srv) SLANG_OVERRIDE + { + context->CSSetShaderResources(index, 1, &srv); + } + + void setSampler(UINT index, ID3D11SamplerState* sampler) SLANG_OVERRIDE + { + context->CSSetSamplers(index, 1, &sampler); + } + }; + + /// A `BindingContext` for binding to the graphics/rasterization pipeline + struct GraphicsBindingContext : BindingContext + { + /// Initialize a binding context for binding to the given `device` and `context` + GraphicsBindingContext( + DeviceImpl* device, + ID3D11DeviceContext* context) + : BindingContext(device, context) + {} + + // TODO: The operations here are only dealing with vertex and fragment + // shaders for now. We should eventually extend them to handle HS/DS/GS + // bindings. (We might want to skip those stages depending on whether + // the associated program uses them at all). + // + // TODO: If we support cases where different stages might use distinct + // entry-point parameters, we might need to support some modes where + // a "stage mask" is passed in that applies to the bindings. + // + void setCBV(UINT index, ID3D11Buffer* buffer) SLANG_OVERRIDE + { + context->VSSetConstantBuffers(index, 1, &buffer); + context->PSSetConstantBuffers(index, 1, &buffer); + } + + void setSRV(UINT index, ID3D11ShaderResourceView* srv) SLANG_OVERRIDE + { + context->VSSetShaderResources(index, 1, &srv); + context->PSSetShaderResources(index, 1, &srv); + } + + void setSampler(UINT index, ID3D11SamplerState* sampler) SLANG_OVERRIDE + { + context->VSSetSamplers(index, 1, &sampler); + context->PSSetSamplers(index, 1, &sampler); + } + }; + + // In order to bind shader parameters to the correct locations, we need to + // be able to describe those locations. Most shader parameters will + // only consume a single type of D3D11-visible regsiter (e.g., a `t` + // register for a txture, or an `s` register for a sampler), and scalar + // integers suffice for these cases. + // + // In more complex cases we might be binding an entire "sub-object" like + // a parameter block, an entry point, etc. For the general case, we need + // to be able to represent a composite offset that includes offsets for + // each of the register classes known to D3D11. + + /// A "simple" binding offset that records an offset in CBV/SRV/UAV/Sampler slots + struct SimpleBindingOffset + { + uint32_t cbv = 0; + uint32_t srv = 0; + uint32_t uav = 0; + uint32_t sampler = 0; + + /// Create a default (zero) offset + SimpleBindingOffset() + {} + + /// Create an offset based on offset information in the given Slang `varLayout` + SimpleBindingOffset(slang::VariableLayoutReflection* varLayout) + { + if (varLayout) + { + cbv = (uint32_t)varLayout->getOffset(SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER); + srv = (uint32_t)varLayout->getOffset(SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE); + uav = (uint32_t)varLayout->getOffset(SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS); + sampler = (uint32_t)varLayout->getOffset(SLANG_PARAMETER_CATEGORY_SAMPLER_STATE); + } + } + + /// Create an offset based on size/stride information in the given Slang `typeLayout` + SimpleBindingOffset(slang::TypeLayoutReflection* typeLayout) + { + if (typeLayout) + { + cbv = (uint32_t)typeLayout->getSize(SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER); + srv = (uint32_t)typeLayout->getSize(SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE); + uav = (uint32_t)typeLayout->getSize(SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS); + sampler = (uint32_t)typeLayout->getSize(SLANG_PARAMETER_CATEGORY_SAMPLER_STATE); + } + } + + /// Add any values in the given `offset` + void operator+=(SimpleBindingOffset const& offset) + { + cbv += offset.cbv; + srv += offset.srv; + uav += offset.uav; + sampler += offset.sampler; + } + }; + + // While a "simple" binding offset representation will work in many cases, + // once we need to deal with layout for programs with interface-type parameters + // that have been statically specialized, we also need to track the offset + // for where to bind any "pending" data that arises from the process of static + // specialization. + // + // In order to conveniently track both the "primary" and "pending" offset information, + // we will define a more complete `BindingOffset` type that combines simple + // binding offsets for the primary and pending parts. + + /// A representation of the offset at which to bind a shader parameter or sub-object + struct BindingOffset : SimpleBindingOffset + { + // Offsets for "primary" data are stored directly in the `BindingOffset` + // via the inheritance from `SimpleBindingOffset`. + + /// Offset for any "pending" data + SimpleBindingOffset pending; + + /// Create a default (zero) offset + BindingOffset() + {} + + /// Create an offset from a simple offset + explicit BindingOffset(SimpleBindingOffset const& offset) + : SimpleBindingOffset(offset) + {} + + /// Create an offset based on offset information in the given Slang `varLayout` + BindingOffset(slang::VariableLayoutReflection* varLayout) + : SimpleBindingOffset(varLayout) + , pending(varLayout->getPendingDataLayout()) + {} + + /// Create an offset based on size/stride information in the given Slang `typeLayout` + BindingOffset(slang::TypeLayoutReflection* typeLayout) + : SimpleBindingOffset(typeLayout) + , pending(typeLayout->getPendingDataTypeLayout()) + {} + + /// Add any values in the given `offset` + void operator+=(SimpleBindingOffset const& offset) + { + SimpleBindingOffset::operator+=(offset); + } + + /// Add any values in the given `offset` + void operator+=(BindingOffset const& offset) + { + SimpleBindingOffset::operator+=(offset); + pending += offset.pending; + } + }; + + bool isSupportedNVAPIOp(IUnknown* dev, uint32_t op); + + D3D11_BIND_FLAG calcResourceFlag(ResourceState state); + int _calcResourceBindFlags(ResourceStateSet allowedStates); + int _calcResourceAccessFlags(MemoryType memType); + + D3D11_FILTER_TYPE translateFilterMode(TextureFilteringMode mode); + D3D11_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op); + D3D11_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode); + D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func); + + D3D11_STENCIL_OP translateStencilOp(StencilOp op); + D3D11_FILL_MODE translateFillMode(FillMode mode); + D3D11_CULL_MODE translateCullMode(CullMode mode); + bool isBlendDisabled(AspectBlendDesc const& desc); + bool isBlendDisabled(TargetBlendDesc const& desc); + D3D11_BLEND_OP translateBlendOp(BlendOp op); + D3D11_BLEND translateBlendFactor(BlendFactor factor); + D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT mask); + + void initSrvDesc( + IResource::Type resourceType, + const ITextureResource::Desc& textureDesc, + DXGI_FORMAT pixelFormat, + D3D11_SHADER_RESOURCE_VIEW_DESC& descOut); +} // namespace d3d11 + +Result SLANG_MCALL createD3D11Device(const IDevice::Desc* desc, IDevice** outDevice); + +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-pipeline-state.cpp b/tools/gfx/d3d11/d3d11-pipeline-state.cpp new file mode 100644 index 000000000..f4a6d7dbd --- /dev/null +++ b/tools/gfx/d3d11/d3d11-pipeline-state.cpp @@ -0,0 +1,29 @@ +// d3d11-pipeline-state.cpp +#include "d3d11-pipeline-state.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +void GraphicsPipelineStateImpl::init(const GraphicsPipelineStateDesc& inDesc) +{ + PipelineStateBase::PipelineStateDesc pipelineDesc; + pipelineDesc.graphics = inDesc; + pipelineDesc.type = PipelineType::Graphics; + initializeBase(pipelineDesc); +} + +void ComputePipelineStateImpl::init(const ComputePipelineStateDesc& inDesc) +{ + PipelineStateBase::PipelineStateDesc pipelineDesc; + pipelineDesc.compute = inDesc; + pipelineDesc.type = PipelineType::Compute; + initializeBase(pipelineDesc); +} + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-pipeline-state.h b/tools/gfx/d3d11/d3d11-pipeline-state.h new file mode 100644 index 000000000..7ca812d1d --- /dev/null +++ b/tools/gfx/d3d11/d3d11-pipeline-state.h @@ -0,0 +1,42 @@ +// d3d11-pipeline-state.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class PipelineStateImpl : public PipelineStateBase +{ +public: +}; + +class GraphicsPipelineStateImpl : public PipelineStateImpl +{ +public: + UINT m_rtvCount; + + RefPtr<InputLayoutImpl> m_inputLayout; + ComPtr<ID3D11DepthStencilState> m_depthStencilState; + ComPtr<ID3D11RasterizerState> m_rasterizerState; + ComPtr<ID3D11BlendState> m_blendState; + + float m_blendColor[4]; + UINT m_sampleMask; + + void init(const GraphicsPipelineStateDesc& inDesc); +}; + +class ComputePipelineStateImpl : public PipelineStateImpl +{ +public: + void init(const ComputePipelineStateDesc& inDesc); +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-query.cpp b/tools/gfx/d3d11/d3d11-query.cpp new file mode 100644 index 000000000..37b8ddc25 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-query.cpp @@ -0,0 +1,55 @@ +// d3d11-query.cpp +#include "d3d11-query.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +Result QueryPoolImpl::init(const IQueryPool::Desc& desc, DeviceImpl* device) +{ + m_device = device; + m_queryDesc.MiscFlags = 0; + switch (desc.type) + { + case QueryType::Timestamp: + m_queryDesc.Query = D3D11_QUERY_TIMESTAMP; + break; + default: + return SLANG_E_INVALID_ARG; + } + m_queries.setCount(desc.count); + return SLANG_OK; +} + +ID3D11Query* QueryPoolImpl::getQuery(SlangInt index) +{ + if (!m_queries[index]) + m_device->m_device->CreateQuery(&m_queryDesc, m_queries[index].writeRef()); + return m_queries[index].get(); +} + +SLANG_NO_THROW Result SLANG_MCALL QueryPoolImpl::getResult( + GfxIndex queryIndex, GfxCount count, uint64_t* data) +{ + D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData; + while (S_OK != m_device->m_immediateContext->GetData( + m_device->m_disjointQuery, &disjointData, sizeof(D3D11_QUERY_DATA_TIMESTAMP_DISJOINT), 0)) + { + Sleep(1); + } + m_device->m_info.timestampFrequency = disjointData.Frequency; + + for (SlangInt i = 0; i < count; i++) + { + SLANG_RETURN_ON_FAIL(m_device->m_immediateContext->GetData( + m_queries[queryIndex + i], data + i, sizeof(uint64_t), 0)); + } + return SLANG_OK; +} + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-query.h b/tools/gfx/d3d11/d3d11-query.h new file mode 100644 index 000000000..393294c0a --- /dev/null +++ b/tools/gfx/d3d11/d3d11-query.h @@ -0,0 +1,29 @@ +// d3d11-query.h +#pragma once +#include "d3d11-base.h" + +#include "d3d11-device.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + + class QueryPoolImpl : public QueryPoolBase + { + public: + List<ComPtr<ID3D11Query>> m_queries; + RefPtr<DeviceImpl> m_device; + D3D11_QUERY_DESC m_queryDesc; + + Result init(const IQueryPool::Desc& desc, DeviceImpl* device); + ID3D11Query* getQuery(SlangInt index); + virtual SLANG_NO_THROW Result SLANG_MCALL getResult( + GfxIndex queryIndex, GfxCount count, uint64_t* data) override; + }; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-resource-views.h b/tools/gfx/d3d11/d3d11-resource-views.h new file mode 100644 index 000000000..f76acd98b --- /dev/null +++ b/tools/gfx/d3d11/d3d11-resource-views.h @@ -0,0 +1,54 @@ +// d3d11-resource-views.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class ResourceViewImpl : public ResourceViewBase +{ +public: + enum class Type + { + SRV, + UAV, + DSV, + RTV, + }; + Type m_type; +}; + +class ShaderResourceViewImpl : public ResourceViewImpl +{ +public: + ComPtr<ID3D11ShaderResourceView> m_srv; +}; + +class UnorderedAccessViewImpl : public ResourceViewImpl +{ +public: + ComPtr<ID3D11UnorderedAccessView> m_uav; +}; + +class DepthStencilViewImpl : public ResourceViewImpl +{ +public: + ComPtr<ID3D11DepthStencilView> m_dsv; + DepthStencilClearValue m_clearValue; +}; + +class RenderTargetViewImpl : public ResourceViewImpl +{ +public: + ComPtr<ID3D11RenderTargetView> m_rtv; + float m_clearValue[4]; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-sampler.h b/tools/gfx/d3d11/d3d11-sampler.h new file mode 100644 index 000000000..ae094d282 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-sampler.h @@ -0,0 +1,21 @@ +// d3d11-sampler.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class SamplerStateImpl : public SamplerStateBase +{ +public: + ComPtr<ID3D11SamplerState> m_sampler; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-scopeNVAPI.cpp b/tools/gfx/d3d11/d3d11-scopeNVAPI.cpp new file mode 100644 index 000000000..b230623fe --- /dev/null +++ b/tools/gfx/d3d11/d3d11-scopeNVAPI.cpp @@ -0,0 +1,49 @@ +// d3d11-scopeNVAPI.cpp +#include "d3d11-scopeNVAPI.h" + +#include "d3d11-device.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +SlangResult ScopeNVAPI::init(DeviceImpl* device, Index regIndex) +{ + if (!device->m_nvapi) + { + // There is nothing to set as nvapi is not set + return SLANG_OK; + } + +#ifdef GFX_NVAPI + NvAPI_Status nvapiStatus = NvAPI_D3D11_SetNvShaderExtnSlot(renderer->m_device, NvU32(regIndex)); + if (nvapiStatus != NVAPI_OK) + { + return SLANG_FAIL; + } +#endif + + // Record the renderer so it can be freed + m_renderer = device; + return SLANG_OK; +} + +ScopeNVAPI::~ScopeNVAPI() +{ + // If the m_renderer is not set, it must not have been set up + if (m_renderer) + { +#ifdef GFX_NVAPI + // Disable the slot used + NvAPI_Status nvapiStatus = NvAPI_D3D11_SetNvShaderExtnSlot(m_renderer->m_device, ~0); + SLANG_ASSERT(nvapiStatus == NVAPI_OK); +#endif + } +} + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-scopeNVAPI.h b/tools/gfx/d3d11/d3d11-scopeNVAPI.h new file mode 100644 index 000000000..0de611ee0 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-scopeNVAPI.h @@ -0,0 +1,26 @@ +// d3d11-scopeNVAPI.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class ScopeNVAPI +{ +public: + ScopeNVAPI() : m_renderer(nullptr) {} + SlangResult init(DeviceImpl* renderer, Index regIndex); + ~ScopeNVAPI(); + +protected: + DeviceImpl* m_renderer; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-shader-object-layout.cpp b/tools/gfx/d3d11/d3d11-shader-object-layout.cpp new file mode 100644 index 000000000..ff1c5d03c --- /dev/null +++ b/tools/gfx/d3d11/d3d11-shader-object-layout.cpp @@ -0,0 +1,329 @@ +// d3d11-shader-object-layout.cpp +#include "d3d11-shader-object-layout.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +ShaderObjectLayoutImpl::SubObjectRangeOffset::SubObjectRangeOffset( + slang::VariableLayoutReflection* varLayout) + : BindingOffset(varLayout) +{ + if (auto pendingLayout = varLayout->getPendingDataLayout()) + { + pendingOrdinaryData = (uint32_t)pendingLayout->getOffset(SLANG_PARAMETER_CATEGORY_UNIFORM); + } +} + +ShaderObjectLayoutImpl::SubObjectRangeStride::SubObjectRangeStride( + slang::TypeLayoutReflection* typeLayout) + : BindingOffset(typeLayout) +{ + if (auto pendingLayout = typeLayout->getPendingDataTypeLayout()) + { + pendingOrdinaryData = (uint32_t)typeLayout->getStride(); + } +} + +Result ShaderObjectLayoutImpl::Builder::setElementTypeLayout(slang::TypeLayoutReflection* typeLayout) +{ + typeLayout = _unwrapParameterGroups(typeLayout, m_containerType); + + m_elementTypeLayout = typeLayout; + + m_totalOrdinaryDataSize = (uint32_t)typeLayout->getSize(); + + // Compute the binding ranges that are used to store + // the logical contents of the object in memory. + + SlangInt bindingRangeCount = typeLayout->getBindingRangeCount(); + for (SlangInt r = 0; r < bindingRangeCount; ++r) + { + slang::BindingType slangBindingType = typeLayout->getBindingRangeType(r); + SlangInt count = typeLayout->getBindingRangeBindingCount(r); + slang::TypeLayoutReflection* slangLeafTypeLayout = + typeLayout->getBindingRangeLeafTypeLayout(r); + + BindingRangeInfo bindingRangeInfo; + bindingRangeInfo.bindingType = slangBindingType; + bindingRangeInfo.count = count; + + switch (slangBindingType) + { + case slang::BindingType::ConstantBuffer: + case slang::BindingType::ParameterBlock: + case slang::BindingType::ExistentialValue: + bindingRangeInfo.baseIndex = m_subObjectCount; + bindingRangeInfo.subObjectIndex = m_subObjectCount; + m_subObjectCount += count; + break; + case slang::BindingType::RawBuffer: + case slang::BindingType::MutableRawBuffer: + if (slangLeafTypeLayout->getType()->getElementType() != nullptr) + { + // A structured buffer occupies both a resource slot and + // a sub-object slot. + bindingRangeInfo.subObjectIndex = m_subObjectCount; + m_subObjectCount += count; + } + if (slangBindingType == slang::BindingType::RawBuffer) + { + bindingRangeInfo.baseIndex = m_srvCount; + m_srvCount += count; + m_srvRanges.add(r); + } + else + { + bindingRangeInfo.baseIndex = m_uavCount; + m_uavCount += count; + m_uavRanges.add(r); + } + break; + case slang::BindingType::Sampler: + bindingRangeInfo.baseIndex = m_samplerCount; + m_samplerCount += count; + m_samplerRanges.add(r); + break; + + case slang::BindingType::CombinedTextureSampler: + break; + case slang::BindingType::MutableTexture: + case slang::BindingType::MutableTypedBuffer: + bindingRangeInfo.baseIndex = m_uavCount; + m_uavCount += count; + m_uavRanges.add(r); + break; + + case slang::BindingType::VaryingInput: + break; + + case slang::BindingType::VaryingOutput: + break; + + default: + bindingRangeInfo.baseIndex = m_srvCount; + m_srvCount += count; + m_srvRanges.add(r); + break; + } + + // We'd like to extract the information on the D3D11 shader + // register that this range should bind into. + // + // A binding range represents a logical member of the shader + // object type, and it may encompass zero or more *descriptor + // ranges* that describe how it is physically bound to pipeline + // state. + // + // If the current bindign range is backed by at least one descriptor + // range then we can query the register offset of that descriptor + // range. We expect that in the common case there will be exactly + // one descriptor range, and we can extract the information easily. + // + // TODO: we might eventually need to special-case our handling + // of combined texture-sampler ranges since they will need to + // store two different offsets. + // + if (typeLayout->getBindingRangeDescriptorRangeCount(r) != 0) + { + // The Slang reflection information organizes the descriptor ranges + // into "descriptor sets" but D3D11 has no notion like that so we + // expect all ranges belong to a single set. + // + SlangInt descriptorSetIndex = typeLayout->getBindingRangeDescriptorSetIndex(r); + SLANG_ASSERT(descriptorSetIndex == 0); + + SlangInt descriptorRangeIndex = typeLayout->getBindingRangeFirstDescriptorRangeIndex(r); + auto registerOffset = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(descriptorSetIndex, descriptorRangeIndex); + + bindingRangeInfo.registerOffset = (uint32_t)registerOffset; + } + + m_bindingRanges.add(bindingRangeInfo); + } + + SlangInt subObjectRangeCount = typeLayout->getSubObjectRangeCount(); + for (SlangInt r = 0; r < subObjectRangeCount; ++r) + { + SlangInt bindingRangeIndex = typeLayout->getSubObjectRangeBindingRangeIndex(r); + auto& bindingRange = m_bindingRanges[bindingRangeIndex]; + + auto slangBindingType = typeLayout->getBindingRangeType(bindingRangeIndex); + slang::TypeLayoutReflection* slangLeafTypeLayout = + typeLayout->getBindingRangeLeafTypeLayout(bindingRangeIndex); + + SubObjectRangeInfo subObjectRange; + subObjectRange.bindingRangeIndex = bindingRangeIndex; + + // We will use Slang reflection information to extract the offset and stride + // information for each sub-object range. + // + subObjectRange.offset = SubObjectRangeOffset(typeLayout->getSubObjectRangeOffset(r)); + subObjectRange.stride = SubObjectRangeStride(slangLeafTypeLayout); + + // A sub-object range can either represent a sub-object of a known + // type, like a `ConstantBuffer<Foo>` or `ParameterBlock<Foo>` + // *or* it can represent a sub-object of some existential type (e.g., `IBar`). + // + RefPtr<ShaderObjectLayoutImpl> subObjectLayout; + switch (slangBindingType) + { + default: + { + // In the case of `ConstantBuffer<X>` or `ParameterBlock<X>` + // we can construct a layout from the element type directly. + // + auto elementTypeLayout = slangLeafTypeLayout->getElementTypeLayout(); + createForElementType( + m_renderer, + elementTypeLayout, + subObjectLayout.writeRef()); + } + break; + + case slang::BindingType::ExistentialValue: + // In the case of an interface-type sub-object range, we can only + // construct a layout if we have static specialization information + // that tells us what type we expect to find in that range. + // + // The static specialization information is expected to take the + // form of a "pending" type layotu attached to the interface type + // of the leaf type layout. + // + if (auto pendingTypeLayout = slangLeafTypeLayout->getPendingDataTypeLayout()) + { + createForElementType( + m_renderer, + pendingTypeLayout, + subObjectLayout.writeRef()); + + // An interface-type range that includes ordinary data can + // increase the size of the ordinary data buffer we need to + // allocate for the parent object. + // + uint32_t ordinaryDataEnd = subObjectRange.offset.pendingOrdinaryData + + (uint32_t)bindingRange.count * subObjectRange.stride.pendingOrdinaryData; + + if (ordinaryDataEnd > m_totalOrdinaryDataSize) + { + m_totalOrdinaryDataSize = ordinaryDataEnd; + } + } + } + subObjectRange.layout = subObjectLayout; + + m_subObjectRanges.add(subObjectRange); + } + return SLANG_OK; +} + +SlangResult ShaderObjectLayoutImpl::Builder::build(ShaderObjectLayoutImpl** outLayout) +{ + auto layout = + RefPtr<ShaderObjectLayoutImpl>(new ShaderObjectLayoutImpl()); + SLANG_RETURN_ON_FAIL(layout->_init(this)); + + returnRefPtrMove(outLayout, layout); + return SLANG_OK; +} + +Result ShaderObjectLayoutImpl::createForElementType( + RendererBase* renderer, + slang::TypeLayoutReflection* elementType, + ShaderObjectLayoutImpl** outLayout) +{ + Builder builder(renderer); + builder.setElementTypeLayout(elementType); + return builder.build(outLayout); +} + +Result ShaderObjectLayoutImpl::_init(Builder const* builder) +{ + auto renderer = builder->m_renderer; + + initBase(renderer, builder->m_elementTypeLayout); + + m_bindingRanges = builder->m_bindingRanges; + m_srvRanges = builder->m_srvRanges; + m_uavRanges = builder->m_uavRanges; + m_samplerRanges = builder->m_samplerRanges; + + m_srvCount = builder->m_srvCount; + m_samplerCount = builder->m_samplerCount; + m_uavCount = builder->m_uavCount; + m_subObjectCount = builder->m_subObjectCount; + m_subObjectRanges = builder->m_subObjectRanges; + + m_totalOrdinaryDataSize = builder->m_totalOrdinaryDataSize; + + m_containerType = builder->m_containerType; + return SLANG_OK; +} + +Result RootShaderObjectLayoutImpl::Builder::build(RootShaderObjectLayoutImpl** outLayout) +{ + RefPtr<RootShaderObjectLayoutImpl> layout = new RootShaderObjectLayoutImpl(); + SLANG_RETURN_ON_FAIL(layout->_init(this)); + + returnRefPtrMove(outLayout, layout); + return SLANG_OK; +} + +void RootShaderObjectLayoutImpl::Builder::addGlobalParams(slang::VariableLayoutReflection* globalsLayout) +{ + setElementTypeLayout(globalsLayout->getTypeLayout()); + m_pendingDataOffset = BindingOffset(globalsLayout).pending; +} + +void RootShaderObjectLayoutImpl::Builder::addEntryPoint( + SlangStage stage, ShaderObjectLayoutImpl* entryPointLayout, slang::EntryPointLayout* slangEntryPoint) +{ + EntryPointInfo info; + info.layout = entryPointLayout; + info.offset = BindingOffset(slangEntryPoint->getVarLayout()); + m_entryPoints.add(info); +} + +Result RootShaderObjectLayoutImpl::create( + RendererBase* renderer, + slang::IComponentType* program, + slang::ProgramLayout* programLayout, + RootShaderObjectLayoutImpl** outLayout) +{ + RootShaderObjectLayoutImpl::Builder builder(renderer, program, programLayout); + builder.addGlobalParams(programLayout->getGlobalParamsVarLayout()); + + SlangInt entryPointCount = programLayout->getEntryPointCount(); + for (SlangInt e = 0; e < entryPointCount; ++e) + { + auto slangEntryPoint = programLayout->getEntryPointByIndex(e); + RefPtr<ShaderObjectLayoutImpl> entryPointLayout; + SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( + renderer, slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); + builder.addEntryPoint(slangEntryPoint->getStage(), entryPointLayout, slangEntryPoint); + } + + SLANG_RETURN_ON_FAIL(builder.build(outLayout)); + + return SLANG_OK; +} + +Result RootShaderObjectLayoutImpl::_init(Builder const* builder) +{ + auto renderer = builder->m_renderer; + + SLANG_RETURN_ON_FAIL(Super::_init(builder)); + + m_program = builder->m_program; + m_programLayout = builder->m_programLayout; + m_entryPoints = builder->m_entryPoints; + m_pendingDataOffset = builder->m_pendingDataOffset; + return SLANG_OK; +} + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-shader-object-layout.h b/tools/gfx/d3d11/d3d11-shader-object-layout.h new file mode 100644 index 000000000..717f270bc --- /dev/null +++ b/tools/gfx/d3d11/d3d11-shader-object-layout.h @@ -0,0 +1,258 @@ +// d3d11-shader-object-layout.h +#pragma once + +#include "d3d11-base.h" +#include "d3d11-helper-functions.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class ShaderObjectLayoutImpl : public ShaderObjectLayoutBase +{ +public: + // A shader object comprises three main kinds of state: + // + // * Zero or more bytes of ordinary ("uniform") data + // * Zero or more *bindings* for textures, buffers, and samplers + // * Zero or more *sub-objects* representing nested parameter blocks, etc. + // + // A shader object *layout* stores information that can be used to + // organize these different kinds of state and optimize access to them. + // + // For example, both texture/buffer/sampler bindings and sub-objects + // are organized into logical *binding ranges* by the Slang reflection + // API, and a shader object layout will store information about those + // ranges in a form that is usable for the D3D11 API: + + /// Information about a logical binding range as reported by Slang reflection + struct BindingRangeInfo + { + /// The type of bindings in this range + slang::BindingType bindingType; + + /// The number of bindings in this range + Index count; + + /// The starting index for this range in the appropriate "flat" array in a shader object. + /// E.g., for a shader resource view range, this would be an index into the `m_srvs` array. + Index baseIndex; + + /// The offset of this binding range from the start of the sub-object + /// in terms of whatever D3D11 register class it consumes. E.g., for + /// a `Texture2D` binding range this will represent an offset in + /// `t` registers. + /// + uint32_t registerOffset; + + /// An index into the sub-object array if this binding range is treated + /// as a sub-object. + Index subObjectIndex; + }; + + // Sometimes we just want to iterate over the ranges that represent + // sub-objects while skipping over the others, because sub-object + // ranges often require extra handling or more state. + // + // For that reason we also store pre-computed information about each + // sub-object range. + + /// Offset information for a sub-object range + struct SubObjectRangeOffset : BindingOffset + { + SubObjectRangeOffset() + {} + + SubObjectRangeOffset(slang::VariableLayoutReflection* varLayout); + + /// The offset for "pending" ordinary data related to this range + uint32_t pendingOrdinaryData = 0; + }; + + /// Stride information for a sub-object range + struct SubObjectRangeStride : BindingOffset + { + SubObjectRangeStride() + {} + + SubObjectRangeStride(slang::TypeLayoutReflection* typeLayout); + + /// The strid for "pending" ordinary data related to this range + uint32_t pendingOrdinaryData = 0; + }; + + /// Information about a logical binding range as reported by Slang reflection + struct SubObjectRangeInfo + { + /// The index of the binding range that corresponds to this sub-object range + Index bindingRangeIndex; + + /// The layout expected for objects bound to this range (if known) + RefPtr<ShaderObjectLayoutImpl> layout; + + /// The offset to use when binding the first object in this range + SubObjectRangeOffset offset; + + /// Stride between consecutive objects in this range + SubObjectRangeStride stride; + }; + + struct Builder + { + public: + Builder(RendererBase* renderer) + : m_renderer(renderer) + {} + + RendererBase* m_renderer; + slang::TypeLayoutReflection* m_elementTypeLayout; + + List<BindingRangeInfo> m_bindingRanges; + List<SubObjectRangeInfo> m_subObjectRanges; + + /// The indices of the binding ranges that represent SRVs + List<Index> m_srvRanges; + + /// The indices of the binding ranges that represent UAVs + List<Index> m_uavRanges; + + /// The indices of the binding ranges that represent samplers + List<Index> m_samplerRanges; + + Index m_srvCount = 0; + Index m_samplerCount = 0; + Index m_uavCount = 0; + Index m_subObjectCount = 0; + + uint32_t m_totalOrdinaryDataSize = 0; + + /// The container type of this shader object. When `m_containerType` is + /// `StructuredBuffer` or `UnsizedArray`, this shader object represents a collection + /// instead of a single object. + ShaderObjectContainerType m_containerType = ShaderObjectContainerType::None; + + Result setElementTypeLayout(slang::TypeLayoutReflection* typeLayout); + SlangResult build(ShaderObjectLayoutImpl** outLayout); + }; + + static Result createForElementType( + RendererBase* renderer, + slang::TypeLayoutReflection* elementType, + ShaderObjectLayoutImpl** outLayout); + + List<BindingRangeInfo> const& getBindingRanges() { return m_bindingRanges; } + + Index getBindingRangeCount() { return m_bindingRanges.getCount(); } + + BindingRangeInfo const& getBindingRange(Index index) { return m_bindingRanges[index]; } + + Index getSRVCount() { return m_srvCount; } + Index getSamplerCount() { return m_samplerCount; } + Index getUAVCount() { return m_uavCount; } + Index getSubObjectCount() { return m_subObjectCount; } + Index getVaryingOutputCount() { return m_varyingOutputCount; } + + SubObjectRangeInfo const& getSubObjectRange(Index index) { return m_subObjectRanges[index]; } + List<SubObjectRangeInfo> const& getSubObjectRanges() { return m_subObjectRanges; } + + RendererBase* getRenderer() { return m_renderer; } + + slang::TypeReflection* getType() + { + return m_elementTypeLayout->getType(); + } + + /// Get the indices that represent all the SRV ranges in this type + List<Index> const& getSRVRanges() const { return m_srvRanges; } + + /// Get the indices that reprsent all the UAV ranges in this type + List<Index> const& getUAVRanges() const { return m_uavRanges; } + + /// Get the indices that represnet all the sampler ranges in this type + List<Index> const& getSamplerRanges() const { return m_samplerRanges; } + + uint32_t getTotalOrdinaryDataSize() const { return m_totalOrdinaryDataSize; } + +protected: + Result _init(Builder const* builder); + + List<BindingRangeInfo> m_bindingRanges; + List<Index> m_srvRanges; + List<Index> m_uavRanges; + List<Index> m_samplerRanges; + Index m_srvCount = 0; + Index m_samplerCount = 0; + Index m_uavCount = 0; + Index m_subObjectCount = 0; + Index m_varyingInputCount = 0; + Index m_varyingOutputCount = 0; + uint32_t m_totalOrdinaryDataSize = 0; + List<SubObjectRangeInfo> m_subObjectRanges; +}; + +class RootShaderObjectLayoutImpl : public ShaderObjectLayoutImpl +{ + typedef ShaderObjectLayoutImpl Super; + +public: + struct EntryPointInfo + { + RefPtr<ShaderObjectLayoutImpl> layout; + + /// The offset for this entry point's parameters, relative to the starting offset for the program + BindingOffset offset; + }; + + struct Builder : Super::Builder + { + Builder( + RendererBase* renderer, + slang::IComponentType* program, + slang::ProgramLayout* programLayout) + : Super::Builder(renderer) + , m_program(program) + , m_programLayout(programLayout) + {} + + Result build(RootShaderObjectLayoutImpl** outLayout); + void addGlobalParams(slang::VariableLayoutReflection* globalsLayout); + void addEntryPoint(SlangStage stage, ShaderObjectLayoutImpl* entryPointLayout, slang::EntryPointLayout* slangEntryPoint); + + slang::IComponentType* m_program; + slang::ProgramLayout* m_programLayout; + List<EntryPointInfo> m_entryPoints; + SimpleBindingOffset m_pendingDataOffset; + }; + + EntryPointInfo& getEntryPoint(Index index) { return m_entryPoints[index]; } + + List<EntryPointInfo>& getEntryPoints() { return m_entryPoints; } + + static Result create( + RendererBase* renderer, + slang::IComponentType* program, + slang::ProgramLayout* programLayout, + RootShaderObjectLayoutImpl** outLayout); + + slang::IComponentType* getSlangProgram() const { return m_program; } + slang::ProgramLayout* getSlangProgramLayout() const { return m_programLayout; } + + /// Get the offset at which "pending" shader parameters for this program start + SimpleBindingOffset const& getPendingDataOffset() const { return m_pendingDataOffset; } + +protected: + Result _init(Builder const* builder); + + ComPtr<slang::IComponentType> m_program; + slang::ProgramLayout* m_programLayout = nullptr; + + List<EntryPointInfo> m_entryPoints; + SimpleBindingOffset m_pendingDataOffset; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-shader-object.cpp b/tools/gfx/d3d11/d3d11-shader-object.cpp new file mode 100644 index 000000000..0354b3fdb --- /dev/null +++ b/tools/gfx/d3d11/d3d11-shader-object.cpp @@ -0,0 +1,680 @@ +// d3d11-shader-object.cpp +#include "d3d11-shader-object.h" + +#include "d3d11-device.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +Result ShaderObjectImpl::create( + IDevice* device, + ShaderObjectLayoutImpl* layout, + ShaderObjectImpl** outShaderObject) +{ + auto object = RefPtr<ShaderObjectImpl>(new ShaderObjectImpl()); + SLANG_RETURN_ON_FAIL(object->init(device, layout)); + + returnRefPtrMove(outShaderObject, object); + return SLANG_OK; +} + +SLANG_NO_THROW Result SLANG_MCALL + ShaderObjectImpl::setData(ShaderOffset const& inOffset, void const* data, size_t inSize) +{ + Index offset = inOffset.uniformOffset; + Index size = inSize; + + char* dest = m_data.getBuffer(); + Index availableSize = m_data.getCount(); + + // TODO: We really should bounds-check access rather than silently ignoring sets + // that are too large, but we have several test cases that set more data than + // an object actually stores on several targets... + // + if (offset < 0) + { + size += offset; + offset = 0; + } + if ((offset + size) >= availableSize) + { + size = availableSize - offset; + } + + memcpy(dest + offset, data, size); + + m_isConstantBufferDirty = true; + + return SLANG_OK; +} + +SLANG_NO_THROW Result SLANG_MCALL + ShaderObjectImpl::setResource(ShaderOffset const& offset, IResourceView* resourceView) +{ + if (offset.bindingRangeIndex < 0) + return SLANG_E_INVALID_ARG; + auto layout = getLayout(); + if (offset.bindingRangeIndex >= layout->getBindingRangeCount()) + return SLANG_E_INVALID_ARG; + auto& bindingRange = layout->getBindingRange(offset.bindingRangeIndex); + + auto resourceViewImpl = static_cast<ResourceViewImpl*>(resourceView); + if (D3DUtil::isUAVBinding(bindingRange.bindingType)) + { + SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::Type::UAV); + m_uavs[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<UnorderedAccessViewImpl*>(resourceView); + } + else + { + SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::Type::SRV); + m_srvs[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<ShaderResourceViewImpl*>(resourceView); + } + return SLANG_OK; +} + +SLANG_NO_THROW Result SLANG_MCALL ShaderObjectImpl::setSampler(ShaderOffset const& offset, ISamplerState* sampler) +{ + if (offset.bindingRangeIndex < 0) + return SLANG_E_INVALID_ARG; + auto layout = getLayout(); + if (offset.bindingRangeIndex >= layout->getBindingRangeCount()) + return SLANG_E_INVALID_ARG; + auto& bindingRange = layout->getBindingRange(offset.bindingRangeIndex); + + m_samplers[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<SamplerStateImpl*>(sampler); + return SLANG_OK; +} + +Result ShaderObjectImpl::init(IDevice* device, ShaderObjectLayoutImpl* layout) +{ + m_layout = layout; + + // If the layout tells us that there is any uniform data, + // then we will allocate a CPU memory buffer to hold that data + // while it is being set from the host. + // + // Once the user is done setting the parameters/fields of this + // shader object, we will produce a GPU-memory version of the + // uniform data (which includes values from this object and + // any existential-type sub-objects). + // + size_t uniformSize = layout->getElementTypeLayout()->getSize(); + if (uniformSize) + { + m_data.setCount(uniformSize); + memset(m_data.getBuffer(), 0, uniformSize); + } + + m_srvs.setCount(layout->getSRVCount()); + m_samplers.setCount(layout->getSamplerCount()); + m_uavs.setCount(layout->getUAVCount()); + + // If the layout specifies that we have any sub-objects, then + // we need to size the array to account for them. + // + Index subObjectCount = layout->getSubObjectCount(); + m_objects.setCount(subObjectCount); + + for (auto subObjectRangeInfo : layout->getSubObjectRanges()) + { + auto subObjectLayout = subObjectRangeInfo.layout; + + // In the case where the sub-object range represents an + // existential-type leaf field (e.g., an `IBar`), we + // cannot pre-allocate the object(s) to go into that + // range, since we can't possibly know what to allocate + // at this point. + // + if (!subObjectLayout) + continue; + // + // Otherwise, we will allocate a sub-object to fill + // in each entry in this range, based on the layout + // information we already have. + + auto& bindingRangeInfo = layout->getBindingRange(subObjectRangeInfo.bindingRangeIndex); + for (Index i = 0; i < bindingRangeInfo.count; ++i) + { + RefPtr<ShaderObjectImpl> subObject; + SLANG_RETURN_ON_FAIL( + ShaderObjectImpl::create(device, subObjectLayout, subObject.writeRef())); + m_objects[bindingRangeInfo.subObjectIndex + i] = subObject; + } + } + + return SLANG_OK; +} + +Result ShaderObjectImpl::_writeOrdinaryData( + void* dest, + size_t destSize, + ShaderObjectLayoutImpl* specializedLayout) +{ + // We start by simply writing in the ordinary data contained directly in this object. + // + auto src = m_data.getBuffer(); + auto srcSize = size_t(m_data.getCount()); + SLANG_ASSERT(srcSize <= destSize); + memcpy(dest, src, srcSize); + + // In the case where this object has any sub-objects of + // existential/interface type, we need to recurse on those objects + // that need to write their state into an appropriate "pending" allocation. + // + // Note: Any values that could fit into the "payload" included + // in the existential-type field itself will have already been + // written as part of `setObject()`. This loop only needs to handle + // those sub-objects that do not "fit." + // + // An implementers looking at this code might wonder if things could be changed + // so that *all* writes related to sub-objects for interface-type fields could + // be handled in this one location, rather than having some in `setObject()` and + // others handled here. + // + Index subObjectRangeCounter = 0; + for (auto const& subObjectRangeInfo : specializedLayout->getSubObjectRanges()) + { + Index subObjectRangeIndex = subObjectRangeCounter++; + auto const& bindingRangeInfo = specializedLayout->getBindingRange(subObjectRangeInfo.bindingRangeIndex); + + // We only need to handle sub-object ranges for interface/existential-type fields, + // because fields of constant-buffer or parameter-block type are responsible for + // the ordinary/uniform data of their own existential/interface-type sub-objects. + // + if (bindingRangeInfo.bindingType != slang::BindingType::ExistentialValue) + continue; + + // Each sub-object range represents a single "leaf" field, but might be nested + // under zero or more outer arrays, such that the number of existential values + // in the same range can be one or more. + // + auto count = bindingRangeInfo.count; + + // We are not concerned with the case where the existential value(s) in the range + // git into the payload part of the leaf field. + // + // In the case where the value didn't fit, the Slang layout strategy would have + // considered the requirements of the value as a "pending" allocation, and would + // allocate storage for the ordinary/uniform part of that pending allocation inside + // of the parent object's type layout. + // + // Here we assume that the Slang reflection API can provide us with a single byte + // offset and stride for the location of the pending data allocation in the specialized + // type layout, which will store the values for this sub-object range. + // + // TODO: The reflection API functions we are assuming here haven't been implemented + // yet, so the functions being called here are stubs. + // + // TODO: It might not be that a single sub-object range can reliably map to a single + // contiguous array with a single stride; we need to carefully consider what the layout + // logic does for complex cases with multiple layers of nested arrays and structures. + // + size_t subObjectRangePendingDataOffset = subObjectRangeInfo.offset.pendingOrdinaryData; + size_t subObjectRangePendingDataStride = subObjectRangeInfo.stride.pendingOrdinaryData; + + // If the range doesn't actually need/use the "pending" allocation at all, then + // we need to detect that case and skip such ranges. + // + // TODO: This should probably be handled on a per-object basis by caching a "does it fit?" + // bit as part of the information for bound sub-objects, given that we already + // compute the "does it fit?" status as part of `setObject()`. + // + if (subObjectRangePendingDataOffset == 0) + continue; + + for (Slang::Index i = 0; i < count; ++i) + { + auto subObject = m_objects[bindingRangeInfo.subObjectIndex + i]; + + RefPtr<ShaderObjectLayoutImpl> subObjectLayout; + SLANG_RETURN_ON_FAIL(subObject->_getSpecializedLayout(subObjectLayout.writeRef())); + + auto subObjectOffset = subObjectRangePendingDataOffset + i * subObjectRangePendingDataStride; + + auto subObjectDest = (char*)dest + subObjectOffset; + + subObject->_writeOrdinaryData(subObjectDest, destSize - subObjectOffset, subObjectLayout); + } + } + + return SLANG_OK; +} + +Result ShaderObjectImpl::_ensureOrdinaryDataBufferCreatedIfNeeded( + DeviceImpl* device, + ShaderObjectLayoutImpl* specializedLayout) +{ + auto specializedOrdinaryDataSize = specializedLayout->getTotalOrdinaryDataSize(); + if (specializedOrdinaryDataSize == 0) + return SLANG_OK; + + // If we have already created a buffer to hold ordinary data, then we should + // simply re-use that buffer rather than re-create it. + if (!m_ordinaryDataBuffer) + { + ComPtr<IBufferResource> bufferResourcePtr; + IBufferResource::Desc bufferDesc = {}; + bufferDesc.type = IResource::Type::Buffer; + bufferDesc.sizeInBytes = specializedOrdinaryDataSize; + bufferDesc.defaultState = ResourceState::ConstantBuffer; + bufferDesc.allowedStates = + ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination); + bufferDesc.memoryType = MemoryType::Upload; + SLANG_RETURN_ON_FAIL( + device->createBufferResource(bufferDesc, nullptr, bufferResourcePtr.writeRef())); + m_ordinaryDataBuffer = static_cast<BufferResourceImpl*>(bufferResourcePtr.get()); + } + + if (m_isConstantBufferDirty) + { + // Once the buffer is allocated, we can use `_writeOrdinaryData` to fill it in. + // + // Note that `_writeOrdinaryData` is potentially recursive in the case + // where this object contains interface/existential-type fields, so we + // don't need or want to inline it into this call site. + // + + auto ordinaryData = device->map(m_ordinaryDataBuffer, gfx::MapFlavor::WriteDiscard); + auto result = _writeOrdinaryData(ordinaryData, specializedOrdinaryDataSize, specializedLayout); + device->unmap(m_ordinaryDataBuffer, 0, specializedOrdinaryDataSize); + m_isConstantBufferDirty = false; + return result; + } + return SLANG_OK; +} + +Result ShaderObjectImpl::_bindOrdinaryDataBufferIfNeeded( + BindingContext* context, + BindingOffset& ioOffset, + ShaderObjectLayoutImpl* specializedLayout) +{ + // We start by ensuring that the buffer is created, if it is needed. + // + SLANG_RETURN_ON_FAIL(_ensureOrdinaryDataBufferCreatedIfNeeded(context->device, specializedLayout)); + + // If we did indeed need/create a buffer, then we must bind it + // into root binding state. + // + if (m_ordinaryDataBuffer) + { + context->setCBV(ioOffset.cbv, m_ordinaryDataBuffer->m_buffer); + ioOffset.cbv++; + } + + return SLANG_OK; +} + +Result ShaderObjectImpl::bindAsConstantBuffer( + BindingContext* context, + BindingOffset const& inOffset, + ShaderObjectLayoutImpl* specializedLayout) +{ + // When binding a `ConstantBuffer<X>` we need to first bind a constant + // buffer for any "ordinary" data in `X`, and then bind the remaining + // resources and sub-objects. + // + // The one important detail to keep track of its that *if* we bind + // a constant buffer for ordinary data we will need to account for + // it in the offset we use for binding the remaining data. That + // detail is dealt with here by the way that `_bindOrdinaryDataBufferIfNeeded` + // will modify the `offset` parameter if it binds anything. + // + BindingOffset offset = inOffset; + SLANG_RETURN_ON_FAIL(_bindOrdinaryDataBufferIfNeeded(context, /*inout*/ offset, specializedLayout)); + + // Once the ordinary data buffer is bound, we can move on to binding + // the rest of the state, which can use logic shared with the case + // for interface-type sub-object ranges. + // + // Note that this call will use the `offset` value that might have + // been modified during `_bindOrindaryDataBufferIfNeeded`. + // + SLANG_RETURN_ON_FAIL(bindAsValue(context, offset, specializedLayout)); + + return SLANG_OK; +} + +Result ShaderObjectImpl::bindAsValue( + BindingContext* context, + BindingOffset const& offset, + ShaderObjectLayoutImpl* specializedLayout) +{ + // We start by iterating over the binding ranges in this type, isolating + // just those ranges that represent SRVs, UAVs, and samplers. + // In each loop we will bind the values stored for those binding ranges + // to the correct D3D11 register (based on the `registerOffset` field + // stored in the bindinge range). + // + // TODO: These loops could be optimized if we stored parallel arrays + // for things like `m_srvs` so that we directly store an array of + // `ID3D11ShaderResourceView*` where each entry matches the `gfx`-level + // object that was bound (or holds null if nothing is bound). + // In that case, we could perform a single `setSRVs()` call for each + // binding range. + // + // TODO: More ambitiously, if the Slang layout algorithm could be modified + // so that non-sub-object binding ranges are guaranteed to be contiguous + // then a *single* `setSRVs()` call could set all of the SRVs for an object + // at once. + + for (auto bindingRangeIndex : specializedLayout->getSRVRanges()) + { + auto const& bindingRange = specializedLayout->getBindingRange(bindingRangeIndex); + auto count = (uint32_t)bindingRange.count; + auto baseIndex = (uint32_t)bindingRange.baseIndex; + auto registerOffset = bindingRange.registerOffset + offset.srv; + for (uint32_t i = 0; i < count; ++i) + { + auto srv = m_srvs[baseIndex + i]; + context->setSRV(registerOffset + i, srv ? srv->m_srv : nullptr); + } + } + + for (auto bindingRangeIndex : specializedLayout->getUAVRanges()) + { + auto const& bindingRange = specializedLayout->getBindingRange(bindingRangeIndex); + auto count = (uint32_t)bindingRange.count; + auto baseIndex = (uint32_t)bindingRange.baseIndex; + auto registerOffset = bindingRange.registerOffset + offset.uav; + for (uint32_t i = 0; i < count; ++i) + { + auto uav = m_uavs[baseIndex + i]; + context->setUAV(registerOffset + i, uav ? uav->m_uav : nullptr); + } + } + + for (auto bindingRangeIndex : specializedLayout->getSamplerRanges()) + { + auto const& bindingRange = specializedLayout->getBindingRange(bindingRangeIndex); + auto count = (uint32_t)bindingRange.count; + auto baseIndex = (uint32_t)bindingRange.baseIndex; + auto registerOffset = bindingRange.registerOffset + offset.sampler; + for (uint32_t i = 0; i < count; ++i) + { + auto sampler = m_samplers[baseIndex + i]; + context->setSampler(registerOffset + i, sampler ? sampler->m_sampler.get() : nullptr); + } + } + + // Once all the simple binding ranges are dealt with, we will bind + // all of the sub-objects in sub-object ranges. + // + for (auto const& subObjectRange : specializedLayout->getSubObjectRanges()) + { + auto subObjectLayout = subObjectRange.layout; + auto const& bindingRange = specializedLayout->getBindingRange(subObjectRange.bindingRangeIndex); + Index count = bindingRange.count; + Index subObjectIndex = bindingRange.subObjectIndex; + + // The starting offset for a sub-object range was computed + // from Slang reflection information, so we can apply it here. + // + BindingOffset rangeOffset = offset; + rangeOffset += subObjectRange.offset; + + // Similarly, the "stride" between consecutive objects in + // the range was also pre-computed. + // + BindingOffset rangeStride = subObjectRange.stride; + + switch (bindingRange.bindingType) + { + // For D3D11-compatible compilation targets, the Slang compiler + // treats the `ConstantBuffer<T>` and `ParameterBlock<T>` types the same. + // + case slang::BindingType::ConstantBuffer: + case slang::BindingType::ParameterBlock: + { + BindingOffset objOffset = rangeOffset; + for (Index i = 0; i < count; ++i) + { + auto subObject = m_objects[subObjectIndex + i]; + + // Unsurprisingly, we bind each object in the range as + // a constant buffer. + // + subObject->bindAsConstantBuffer(context, objOffset, subObjectLayout); + + objOffset += rangeStride; + } + } + break; + + case slang::BindingType::ExistentialValue: + // We can only bind information for existential-typed sub-object + // ranges if we have a static type that we are able to specialize to. + // + if (subObjectLayout) + { + // The data for objects in this range will always be bound into + // the "pending" allocation for the parent block/buffer/object. + // As a result, the offset for the first object in the range + // will come from the `pending` part of the range's offset. + // + SimpleBindingOffset objOffset = rangeOffset.pending; + SimpleBindingOffset objStride = rangeStride.pending; + + for (Index i = 0; i < count; ++i) + { + auto subObject = m_objects[subObjectIndex + i]; + subObject->bindAsValue(context, BindingOffset(objOffset), subObjectLayout); + + objOffset += objStride; + } + } + break; + + default: + break; + } + } + + return SLANG_OK; +} + +Result ShaderObjectImpl::_getSpecializedLayout(ShaderObjectLayoutImpl** outLayout) +{ + if (!m_specializedLayout) + { + SLANG_RETURN_ON_FAIL(_createSpecializedLayout(m_specializedLayout.writeRef())); + } + returnRefPtr(outLayout, m_specializedLayout); + return SLANG_OK; +} + +Result ShaderObjectImpl::_createSpecializedLayout(ShaderObjectLayoutImpl** outLayout) +{ + ExtendedShaderObjectType extendedType; + SLANG_RETURN_ON_FAIL(getSpecializedShaderObjectType(&extendedType)); + + auto renderer = getRenderer(); + RefPtr<ShaderObjectLayoutImpl> layout; + SLANG_RETURN_ON_FAIL(renderer->getShaderObjectLayout( + extendedType.slangType, + m_layout->getContainerType(), + (ShaderObjectLayoutBase**)layout.writeRef())); + + returnRefPtrMove(outLayout, layout); + return SLANG_OK; +} + +Result RootShaderObjectImpl::create( + IDevice* device, + RootShaderObjectLayoutImpl* layout, + RootShaderObjectImpl** outShaderObject) +{ + RefPtr<RootShaderObjectImpl> object = new RootShaderObjectImpl(); + SLANG_RETURN_ON_FAIL(object->init(device, layout)); + + returnRefPtrMove(outShaderObject, object); + return SLANG_OK; +} + +Result RootShaderObjectImpl::collectSpecializationArgs(ExtendedShaderObjectTypeList& args) +{ + SLANG_RETURN_ON_FAIL(ShaderObjectImpl::collectSpecializationArgs(args)); + for (auto& entryPoint : m_entryPoints) + { + SLANG_RETURN_ON_FAIL(entryPoint->collectSpecializationArgs(args)); + } + return SLANG_OK; +} + +Result RootShaderObjectImpl::bindAsRoot( + BindingContext* context, + RootShaderObjectLayoutImpl* specializedLayout) +{ + // When binding an entire root shader object, we need to deal with + // the way that specialization might have allocated space for "pending" + // parameter data after all the primary parameters. + // + // We start by initializing an offset that will store zeros for the + // primary data, an the computed offset from the specialized layout + // for pending data. + // + BindingOffset offset; + offset.pending = specializedLayout->getPendingDataOffset(); + + // Note: We could *almost* call `bindAsConstantBuffer()` here to bind + // the state of the root object itself, but there is an important + // detail that means we can't: + // + // The `_bindOrdinaryDataBufferIfNeeded` operation automatically + // increments the offset parameter if it binds a buffer, so that + // subsequently bindings will be adjusted. However, the reflection + // information computed for root shader parameters is absolute rather + // than relative to the default constant buffer (if any). + // + // TODO: Quite technically, the ordinary data buffer for the global + // scope is *not* guaranteed to be at offset zero, so this logic should + // really be querying an appropriate absolute offset from `specializedLayout`. + // + BindingOffset ordinaryDataBufferOffset = offset; + SLANG_RETURN_ON_FAIL(_bindOrdinaryDataBufferIfNeeded(context, /*inout*/ ordinaryDataBufferOffset, specializedLayout)); + SLANG_RETURN_ON_FAIL(bindAsValue(context, offset, specializedLayout)); + + // Once the state stored in the root shader object itself has been bound, + // we turn our attention to the entry points and their parameters. + // + auto entryPointCount = m_entryPoints.getCount(); + for (Index i = 0; i < entryPointCount; ++i) + { + auto entryPoint = m_entryPoints[i]; + auto const& entryPointInfo = specializedLayout->getEntryPoint(i); + + // Each entry point will be bound at some offset relative to where + // the root shader parameters start. + // + BindingOffset entryPointOffset = offset; + entryPointOffset += entryPointInfo.offset; + + // An entry point can simply be bound as a constant buffer, because + // the absolute offsets as are used for the global scope do not apply + // (because entry points don't need to deal with explicit bindings). + // + SLANG_RETURN_ON_FAIL(entryPoint->bindAsConstantBuffer(context, entryPointOffset, entryPointInfo.layout)); + } + + return SLANG_OK; +} + +Result RootShaderObjectImpl::init(IDevice* device, RootShaderObjectLayoutImpl* layout) +{ + SLANG_RETURN_ON_FAIL(Super::init(device, layout)); + + for (auto entryPointInfo : layout->getEntryPoints()) + { + RefPtr<ShaderObjectImpl> entryPoint; + SLANG_RETURN_ON_FAIL( + ShaderObjectImpl::create(device, entryPointInfo.layout, entryPoint.writeRef())); + m_entryPoints.add(entryPoint); + } + + return SLANG_OK; +} + +Result RootShaderObjectImpl::_createSpecializedLayout(ShaderObjectLayoutImpl** outLayout) +{ + ExtendedShaderObjectTypeList specializationArgs; + SLANG_RETURN_ON_FAIL(collectSpecializationArgs(specializationArgs)); + + // Note: There is an important policy decision being made here that we need + // to approach carefully. + // + // We are doing two different things that affect the layout of a program: + // + // 1. We are *composing* one or more pieces of code (notably the shared global/module + // stuff and the per-entry-point stuff). + // + // 2. We are *specializing* code that includes generic/existential parameters + // to concrete types/values. + // + // We need to decide the relative *order* of these two steps, because of how it impacts + // layout. The layout for `specialize(compose(A,B), X, Y)` is potentially different + // form that of `compose(specialize(A,X), specialize(B,Y))`, even when both are + // semantically equivalent programs. + // + // Right now we are using the first option: we are first generating a full composition + // of all the code we plan to use (global scope plus all entry points), and then + // specializing it to the concatenated specialization arguments for all of that. + // + // In some cases, though, this model isn't appropriate. For example, when dealing with + // ray-tracing shaders and local root signatures, we really want the parameters of each + // entry point (actually, each entry-point *group*) to be allocated distinct storage, + // which really means we want to compute something like: + // + // SpecializedGlobals = specialize(compose(ModuleA, ModuleB, ...), X, Y, ...) + // + // SpecializedEP1 = compose(SpecializedGlobals, specialize(EntryPoint1, T, U, ...)) + // SpecializedEP2 = compose(SpecializedGlobals, specialize(EntryPoint2, A, B, ...)) + // + // Note how in this case all entry points agree on the layout for the shared/common + // parameters, but their layouts are also independent of one another. + // + // Furthermore, in this example, loading another entry point into the system would not + // require re-computing the layouts (or generated kernel code) for any of the entry points + // that had already been loaded (in contrast to a compose-then-specialize approach). + // + ComPtr<slang::IComponentType> specializedComponentType; + ComPtr<slang::IBlob> diagnosticBlob; + auto result = getLayout()->getSlangProgram()->specialize( + specializationArgs.components.getArrayView().getBuffer(), + specializationArgs.getCount(), + specializedComponentType.writeRef(), + diagnosticBlob.writeRef()); + + // TODO: print diagnostic message via debug output interface. + + if (result != SLANG_OK) + return result; + + auto slangSpecializedLayout = specializedComponentType->getLayout(); + RefPtr<RootShaderObjectLayoutImpl> specializedLayout; + RootShaderObjectLayoutImpl::create(getRenderer(), specializedComponentType, slangSpecializedLayout, specializedLayout.writeRef()); + + // Note: Computing the layout for the specialized program will have also computed + // the layouts for the entry points, and we really need to attach that information + // to them so that they don't go and try to compute their own specializations. + // + // TODO: Well, if we move to the specialization model described above then maybe + // we *will* want entry points to do their own specialization work... + // + auto entryPointCount = m_entryPoints.getCount(); + for (Index i = 0; i < entryPointCount; ++i) + { + auto entryPointInfo = specializedLayout->getEntryPoint(i); + auto entryPointVars = m_entryPoints[i]; + + entryPointVars->m_specializedLayout = entryPointInfo.layout; + } + + returnRefPtrMove(outLayout, specializedLayout); + return SLANG_OK; +} +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-shader-object.h b/tools/gfx/d3d11/d3d11-shader-object.h new file mode 100644 index 000000000..b4e43c3ee --- /dev/null +++ b/tools/gfx/d3d11/d3d11-shader-object.h @@ -0,0 +1,199 @@ +// d3d11-shader-object.h +#pragma once +#include "d3d11-base.h" + +#include "d3d11-buffer.h" +#include "d3d11-resource-views.h" +#include "d3d11-sampler.h" +#include "d3d11-shader-object-layout.h" + +#include "d3d11-helper-functions.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class ShaderObjectImpl + : public ShaderObjectBaseImpl< + ShaderObjectImpl, + ShaderObjectLayoutImpl, + SimpleShaderObjectData> +{ +public: + static Result create( + IDevice* device, + ShaderObjectLayoutImpl* layout, + ShaderObjectImpl** outShaderObject); + + RendererBase* getDevice() { return m_layout->getDevice(); } + + SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; } + + SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) + SLANG_OVERRIDE + { + *outEntryPoint = nullptr; + return SLANG_OK; + } + + virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() override + { + return m_data.getBuffer(); + } + + virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override + { + return (size_t)m_data.getCount(); + } + + SLANG_NO_THROW Result SLANG_MCALL + setData(ShaderOffset const& inOffset, void const* data, size_t inSize) SLANG_OVERRIDE; + + SLANG_NO_THROW Result SLANG_MCALL + setResource(ShaderOffset const& offset, IResourceView* resourceView) SLANG_OVERRIDE; + + SLANG_NO_THROW Result SLANG_MCALL setSampler(ShaderOffset const& offset, ISamplerState* sampler) + SLANG_OVERRIDE; + + SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler( + ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) SLANG_OVERRIDE + { + return SLANG_E_NOT_IMPLEMENTED; + } + +public: + + +protected: + friend class ProgramVars; + + Result init(IDevice* device, ShaderObjectLayoutImpl* layout); + + /// Write the uniform/ordinary data of this object into the given `dest` buffer at the given `offset` + Result _writeOrdinaryData( + void* dest, + size_t destSize, + ShaderObjectLayoutImpl* specializedLayout); + + /// Ensure that the `m_ordinaryDataBuffer` has been created, if it is needed + /// + /// The `specializedLayout` type must represent a specialized layout for this + /// type that includes any "pending" data. + /// + Result _ensureOrdinaryDataBufferCreatedIfNeeded( + DeviceImpl* device, + ShaderObjectLayoutImpl* specializedLayout); + + /// Bind the buffer for ordinary/uniform data, if needed + /// + /// The `ioOffset` parameter will be updated to reflect the constant buffer + /// register consumed by the ordinary data buffer, if one was bound. + /// + Result _bindOrdinaryDataBufferIfNeeded( + BindingContext* context, + BindingOffset& ioOffset, + ShaderObjectLayoutImpl* specializedLayout); + +public: + /// Bind this object as if it was declared as a `ConstantBuffer<T>` in Slang + Result bindAsConstantBuffer( + BindingContext* context, + BindingOffset const& inOffset, + ShaderObjectLayoutImpl* specializedLayout); + + /// Bind this object as a value that appears in the body of another object. + /// + /// This case is directly used when binding an object for an interface-type + /// sub-object range when static specialization is used. It is also used + /// indirectly when binding sub-objects to constant buffer or parameter + /// block ranges. + /// + Result bindAsValue( + BindingContext* context, + BindingOffset const& offset, + ShaderObjectLayoutImpl* specializedLayout); + + // Because the binding ranges have already been reflected + // and organized as part of each shader object layout, + // the object itself can store its data in a small number + // of simple arrays. + /// The shader resource views (SRVs) that are part of the state of this object + List<RefPtr<ShaderResourceViewImpl>> m_srvs; + + /// The unordered access views (UAVs) that are part of the state of this object + List<RefPtr<UnorderedAccessViewImpl>> m_uavs; + + /// The samplers that are part of the state of this object + List<RefPtr<SamplerStateImpl>> m_samplers; + + /// A constant buffer used to stored ordinary data for this object + /// and existential-type sub-objects. + /// + /// Created on demand with `_createOrdinaryDataBufferIfNeeded()` + RefPtr<BufferResourceImpl> m_ordinaryDataBuffer; + + bool m_isConstantBufferDirty = true; + + /// Get the layout of this shader object with specialization arguments considered + /// + /// This operation should only be called after the shader object has been + /// fully filled in and finalized. + /// + Result _getSpecializedLayout(ShaderObjectLayoutImpl** outLayout); + + /// Create the layout for this shader object with specialization arguments considered + /// + /// This operation is virtual so that it can be customized by `ProgramVars`. + /// + virtual Result _createSpecializedLayout(ShaderObjectLayoutImpl** outLayout); + + RefPtr<ShaderObjectLayoutImpl> m_specializedLayout; +}; + +class MutableShaderObjectImpl + : public MutableShaderObject< + MutableShaderObjectImpl, + ShaderObjectLayoutImpl> +{}; + +class RootShaderObjectImpl : public ShaderObjectImpl +{ + typedef ShaderObjectImpl Super; + +public: + virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() override { return 1; } + virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() override { return 1; } + + static Result create(IDevice* device, RootShaderObjectLayoutImpl* layout, RootShaderObjectImpl** outShaderObject); + + RootShaderObjectLayoutImpl* getLayout() { return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr()); } + + GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (GfxCount)m_entryPoints.getCount(); } + SlangResult SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) SLANG_OVERRIDE + { + returnComPtr(outEntryPoint, m_entryPoints[index]); + return SLANG_OK; + } + + virtual Result collectSpecializationArgs(ExtendedShaderObjectTypeList& args) override; + + /// Bind this object as a root shader object + Result bindAsRoot( + BindingContext* context, + RootShaderObjectLayoutImpl* specializedLayout); + + +protected: + Result init(IDevice* device, RootShaderObjectLayoutImpl* layout); + + Result _createSpecializedLayout(ShaderObjectLayoutImpl** outLayout) SLANG_OVERRIDE; + + List<RefPtr<ShaderObjectImpl>> m_entryPoints; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-shader-program.cpp b/tools/gfx/d3d11/d3d11-shader-program.cpp new file mode 100644 index 000000000..f957f6353 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-shader-program.cpp @@ -0,0 +1,17 @@ +// d3d11-shader-program.cpp +#include "d3d11-shader-program.h" + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + + + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-shader-program.h b/tools/gfx/d3d11/d3d11-shader-program.h new file mode 100644 index 000000000..14549a4b5 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-shader-program.h @@ -0,0 +1,23 @@ +// d3d11-shader-program.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class ShaderProgramImpl : public ShaderProgramBase +{ +public: + ComPtr<ID3D11VertexShader> m_vertexShader; + ComPtr<ID3D11PixelShader> m_pixelShader; + ComPtr<ID3D11ComputeShader> m_computeShader; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-swap-chain.cpp b/tools/gfx/d3d11/d3d11-swap-chain.cpp new file mode 100644 index 000000000..177fb89dd --- /dev/null +++ b/tools/gfx/d3d11/d3d11-swap-chain.cpp @@ -0,0 +1,69 @@ +// d3d11-swap-chain.cpp +#include "d3d11-swap-chain.h" + +#include "d3d11-device.h" +#include "d3d11-texture.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +Result SwapchainImpl::init(DeviceImpl* renderer, const ISwapchain::Desc& swapchainDesc, WindowHandle window) +{ + m_renderer = renderer; + m_device = renderer->m_device; + m_dxgiFactory = renderer->m_dxgiFactory; + return D3DSwapchainBase::init(swapchainDesc, window, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL); +} + +void SwapchainImpl::createSwapchainBufferImages() +{ + m_images.clear(); + // D3D11 implements automatic back buffer rotation, so the application + // always render to buffer 0. + ComPtr<ID3D11Resource> d3dResource; + m_swapChain->GetBuffer(0, IID_PPV_ARGS(d3dResource.writeRef())); + ITextureResource::Desc imageDesc = {}; + imageDesc.type = IResource::Type::Texture2D; + imageDesc.arraySize = 0; + imageDesc.numMipLevels = 1; + imageDesc.size.width = m_desc.width; + imageDesc.size.height = m_desc.height; + imageDesc.size.depth = 1; + imageDesc.format = m_desc.format; + imageDesc.defaultState = ResourceState::Present; + imageDesc.allowedStates = ResourceStateSet( + ResourceState::Present, + ResourceState::CopyDestination, + ResourceState::RenderTarget); + RefPtr<TextureResourceImpl> image = new TextureResourceImpl(imageDesc); + image->m_resource = d3dResource; + for (GfxIndex i = 0; i < m_desc.imageCount; i++) + { + m_images.add(image); + } +} + +SLANG_NO_THROW Result SLANG_MCALL SwapchainImpl::resize(GfxCount width, GfxCount height) +{ + m_renderer->m_currentFramebuffer = nullptr; + m_renderer->m_immediateContext->ClearState(); + return D3DSwapchainBase::resize(width, height); +} + +SLANG_NO_THROW bool SLANG_MCALL SwapchainImpl::isOccluded() +{ + return false; +} + +SLANG_NO_THROW Result SLANG_MCALL SwapchainImpl::setFullScreenMode(bool mode) +{ + return SLANG_FAIL; +} + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-swap-chain.h b/tools/gfx/d3d11/d3d11-swap-chain.h new file mode 100644 index 000000000..a8b8fe033 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-swap-chain.h @@ -0,0 +1,31 @@ +// d3d11-swap-chain.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class SwapchainImpl : public D3DSwapchainBase +{ +public: + ComPtr<ID3D11Device> m_device; + ComPtr<IDXGIFactory> m_dxgiFactory; + RefPtr<DeviceImpl> m_renderer; + Result init(DeviceImpl* renderer, const ISwapchain::Desc& swapchainDesc, WindowHandle window); + + virtual void createSwapchainBufferImages() override; + virtual IDXGIFactory* getDXGIFactory() override { return m_dxgiFactory; } + virtual IUnknown* getOwningDevice() override { return m_device; } + virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override; + virtual SLANG_NO_THROW bool SLANG_MCALL isOccluded() override; + virtual SLANG_NO_THROW Result SLANG_MCALL setFullScreenMode(bool mode) override; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-texture.h b/tools/gfx/d3d11/d3d11-texture.h new file mode 100644 index 000000000..fb88d2b76 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-texture.h @@ -0,0 +1,28 @@ +// d3d11-texture.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class TextureResourceImpl : public TextureResource +{ +public: + typedef TextureResource Parent; + + TextureResourceImpl(const Desc& desc) + : Parent(desc) + { + } + ComPtr<ID3D11Resource> m_resource; + +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/d3d11-vertex-layout.h b/tools/gfx/d3d11/d3d11-vertex-layout.h new file mode 100644 index 000000000..9c3f1cd46 --- /dev/null +++ b/tools/gfx/d3d11/d3d11-vertex-layout.h @@ -0,0 +1,22 @@ +// d3d11-vertex-layout.h +#pragma once + +#include "d3d11-base.h" + +namespace gfx +{ + +using namespace Slang; + +namespace d3d11 +{ + +class InputLayoutImpl: public InputLayoutBase +{ +public: + ComPtr<ID3D11InputLayout> m_layout; + List<UINT> m_vertexStreamStrides; +}; + +} // namespace d3d11 +} // namespace gfx diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp deleted file mode 100644 index ee95d269f..000000000 --- a/tools/gfx/d3d11/render-d3d11.cpp +++ /dev/null @@ -1,4017 +0,0 @@ -// render-d3d11.cpp -#define _CRT_SECURE_NO_WARNINGS - -#include "render-d3d11.h" -#include "core/slang-basic.h" -#include "core/slang-blob.h" - -//WORKING: #include "options.h" -#include "../immediate-renderer-base.h" -#include "../d3d/d3d-util.h" -#include "../d3d/d3d-swapchain.h" -#include "../nvapi/nvapi-util.h" -#include "../mutable-shader-object.h" - -// In order to use the Slang API, we need to include its header - -//#include <slang.h> - -#include "slang-com-ptr.h" -#include "../flag-combiner.h" - -// We will be rendering with Direct3D 11, so we need to include -// the Windows and D3D11 headers - -#define WIN32_LEAN_AND_MEAN -#define NOMINMAX -#include <Windows.h> -#undef WIN32_LEAN_AND_MEAN -#undef NOMINMAX - -#include <d3d11_2.h> -#include <d3dcompiler.h> - -#ifdef GFX_NVAPI -// NVAPI integration is desribed here -// https://developer.nvidia.com/unlocking-gpu-intrinsics-hlsl - -# include "../nvapi/nvapi-include.h" -#endif - -// We will use the C standard library just for printing error messages. -#include <stdio.h> - -#ifdef _MSC_VER -#include <stddef.h> -#if (_MSC_VER < 1900) -#define snprintf sprintf_s -#endif -#endif -// -using namespace Slang; - -namespace gfx { - -class D3D11Device : public ImmediateRendererBase -{ -public: - enum - { - kMaxUAVs = 64, - kMaxRTVs = 8, - }; - - ~D3D11Device() {} - - // Renderer implementation - virtual SLANG_NO_THROW Result SLANG_MCALL initialize(const Desc& desc) override; - virtual void clearFrame(uint32_t colorBufferMask, bool clearDepth, bool clearStencil) override; - virtual SLANG_NO_THROW Result SLANG_MCALL createSwapchain( - const ISwapchain::Desc& desc, WindowHandle window, ISwapchain** outSwapchain) override; - virtual SLANG_NO_THROW Result SLANG_MCALL createFramebufferLayout( - const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout) override; - virtual SLANG_NO_THROW Result SLANG_MCALL - createFramebuffer(const IFramebuffer::Desc& desc, IFramebuffer** outFramebuffer) override; - virtual void setFramebuffer(IFramebuffer* frameBuffer) override; - virtual void setStencilReference(uint32_t referenceValue) override; - - virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - const ITextureResource::Desc& desc, - const ITextureResource::SubresourceData* initData, - ITextureResource** outResource) override; - virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - const IBufferResource::Desc& desc, - const void* initData, - IBufferResource** outResource) override; - virtual SLANG_NO_THROW Result SLANG_MCALL - createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override; - - virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - ITextureResource* texture, - IResourceView::Desc const& desc, - IResourceView** outView) override; - - virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - IBufferResource* buffer, - IBufferResource* counterBuffer, - IResourceView::Desc const& desc, - IResourceView** outView) override; - - virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( - IInputLayout::Desc const& desc, - IInputLayout** outLayout) override; - - virtual SLANG_NO_THROW Result SLANG_MCALL createQueryPool( - const IQueryPool::Desc& desc, IQueryPool** outPool) override; - - virtual Result createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, - ShaderObjectLayoutBase** outLayout) override; - virtual Result createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) - override; - virtual Result createMutableShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) override; - virtual Result createRootShaderObject(IShaderProgram* program, ShaderObjectBase** outObject) - override; - virtual void bindRootShaderObject(IShaderObject* shaderObject) override; - - virtual SLANG_NO_THROW Result SLANG_MCALL createProgram( - const IShaderProgram::Desc& desc, - IShaderProgram** outProgram, - ISlangBlob** outDiagnosticBlob) override; - virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( - const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override; - virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( - const ComputePipelineStateDesc& desc, IPipelineState** outState) override; - - virtual void* map(IBufferResource* buffer, MapFlavor flavor) override; - virtual void unmap(IBufferResource* buffer, size_t offsetWritten, size_t sizeWritten) override; - virtual void copyBuffer( - IBufferResource* dst, - size_t dstOffset, - IBufferResource* src, - size_t srcOffset, - size_t size) override; - virtual SLANG_NO_THROW SlangResult SLANG_MCALL readTextureResource( - ITextureResource* texture, ResourceState state, ISlangBlob** outBlob, size_t* outRowPitch, size_t* outPixelSize) override; - - virtual void setPrimitiveTopology(PrimitiveTopology topology) override; - - virtual void setVertexBuffers( - GfxIndex startSlot, - GfxCount slotCount, - IBufferResource* const* buffers, - const Offset* offsets) override; - virtual void setIndexBuffer( - IBufferResource* buffer, Format indexFormat, Offset offset) override; - virtual void setViewports(GfxCount count, Viewport const* viewports) override; - virtual void setScissorRects(GfxCount count, ScissorRect const* rects) override; - virtual void setPipelineState(IPipelineState* state) override; - virtual void draw(GfxCount vertexCount, GfxIndex startVertex) override; - virtual void drawIndexed( - GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) override; - virtual void drawInstanced( - GfxCount vertexCount, - GfxCount instanceCount, - GfxIndex startVertex, - GfxIndex startInstanceLocation) override; - virtual void drawIndexedInstanced( - GfxCount indexCount, - GfxCount instanceCount, - GfxIndex startIndexLocation, - GfxIndex baseVertexLocation, - GfxIndex startInstanceLocation) override; - virtual void dispatchCompute(int x, int y, int z) override; - virtual void submitGpuWork() override {} - virtual void waitForGpu() override - { - - } - virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const override - { - return m_info; - } - virtual void beginCommandBuffer(const CommandBufferInfo& info) override - { - if (info.hasWriteTimestamps) - { - m_immediateContext->Begin(m_disjointQuery); - } - } - virtual void endCommandBuffer(const CommandBufferInfo& info) override - { - if (info.hasWriteTimestamps) - { - m_immediateContext->End(m_disjointQuery); - } - } - virtual void writeTimestamp(IQueryPool* pool, GfxIndex index) override - { - auto poolImpl = static_cast<QueryPoolImpl*>(pool); - m_immediateContext->End(poolImpl->getQuery(index)); - } - -protected: - - class ScopeNVAPI - { - public: - ScopeNVAPI() : m_renderer(nullptr) {} - SlangResult init(D3D11Device* renderer, Index regIndex); - ~ScopeNVAPI(); - - protected: - D3D11Device* m_renderer; - }; - - class ShaderProgramImpl : public ShaderProgramBase - { - public: - ComPtr<ID3D11VertexShader> m_vertexShader; - ComPtr<ID3D11PixelShader> m_pixelShader; - ComPtr<ID3D11ComputeShader> m_computeShader; - }; - - class BufferResourceImpl: public BufferResource - { - public: - typedef BufferResource Parent; - - BufferResourceImpl(const IBufferResource::Desc& desc): - Parent(desc) - { - } - - MapFlavor m_mapFlavor; - D3D11_USAGE m_d3dUsage; - ComPtr<ID3D11Buffer> m_buffer; - ComPtr<ID3D11Buffer> m_staging; - List<uint8_t> m_uploadStagingBuffer; - - virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() override - { - return 0; - } - - virtual SLANG_NO_THROW Result SLANG_MCALL - map(MemoryRange* rangeToRead, void** outPointer) override - { - SLANG_UNUSED(rangeToRead); - SLANG_UNUSED(outPointer); - return SLANG_FAIL; - } - - virtual SLANG_NO_THROW Result SLANG_MCALL unmap(MemoryRange* writtenRange) override - { - SLANG_UNUSED(writtenRange); - return SLANG_FAIL; - } - }; - class TextureResourceImpl : public TextureResource - { - public: - typedef TextureResource Parent; - - TextureResourceImpl(const Desc& desc) - : Parent(desc) - { - } - ComPtr<ID3D11Resource> m_resource; - - }; - - class SamplerStateImpl : public SamplerStateBase - { - public: - ComPtr<ID3D11SamplerState> m_sampler; - }; - - - class ResourceViewImpl : public ResourceViewBase - { - public: - enum class Type - { - SRV, - UAV, - DSV, - RTV, - }; - Type m_type; - }; - - class ShaderResourceViewImpl : public ResourceViewImpl - { - public: - ComPtr<ID3D11ShaderResourceView> m_srv; - }; - - class UnorderedAccessViewImpl : public ResourceViewImpl - { - public: - ComPtr<ID3D11UnorderedAccessView> m_uav; - }; - - class DepthStencilViewImpl : public ResourceViewImpl - { - public: - ComPtr<ID3D11DepthStencilView> m_dsv; - DepthStencilClearValue m_clearValue; - }; - - class RenderTargetViewImpl : public ResourceViewImpl - { - public: - ComPtr<ID3D11RenderTargetView> m_rtv; - float m_clearValue[4]; - }; - - class FramebufferLayoutImpl : public FramebufferLayoutBase - { - public: - ShortList<IFramebufferLayout::TargetLayout> m_renderTargets; - bool m_hasDepthStencil = false; - IFramebufferLayout::TargetLayout m_depthStencil; - }; - - class FramebufferImpl : public FramebufferBase - { - public: - ShortList<RefPtr<RenderTargetViewImpl>, kMaxRTVs> renderTargetViews; - ShortList<ID3D11RenderTargetView*, kMaxRTVs> d3dRenderTargetViews; - RefPtr<DepthStencilViewImpl> depthStencilView; - ID3D11DepthStencilView* d3dDepthStencilView; - }; - - class SwapchainImpl : public D3DSwapchainBase - { - public: - ComPtr<ID3D11Device> m_device; - ComPtr<IDXGIFactory> m_dxgiFactory; - RefPtr<D3D11Device> m_renderer; - Result init(D3D11Device* renderer, const ISwapchain::Desc& swapchainDesc, WindowHandle window) - { - m_renderer = renderer; - m_device = renderer->m_device; - m_dxgiFactory = renderer->m_dxgiFactory; - return D3DSwapchainBase::init(swapchainDesc, window, DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL); - } - virtual void createSwapchainBufferImages() override - { - m_images.clear(); - // D3D11 implements automatic back buffer rotation, so the application - // always render to buffer 0. - ComPtr<ID3D11Resource> d3dResource; - m_swapChain->GetBuffer(0, IID_PPV_ARGS(d3dResource.writeRef())); - ITextureResource::Desc imageDesc = {}; - imageDesc.type = IResource::Type::Texture2D; - imageDesc.arraySize = 0; - imageDesc.numMipLevels = 1; - imageDesc.size.width = m_desc.width; - imageDesc.size.height = m_desc.height; - imageDesc.size.depth = 1; - imageDesc.format = m_desc.format; - imageDesc.defaultState = ResourceState::Present; - imageDesc.allowedStates = ResourceStateSet( - ResourceState::Present, - ResourceState::CopyDestination, - ResourceState::RenderTarget); - RefPtr<TextureResourceImpl> image = new TextureResourceImpl(imageDesc); - image->m_resource = d3dResource; - for (GfxIndex i = 0; i < m_desc.imageCount; i++) - { - m_images.add(image); - } - } - virtual IDXGIFactory* getDXGIFactory() override { return m_dxgiFactory; } - virtual IUnknown* getOwningDevice() override { return m_device; } - virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override - { - m_renderer->m_currentFramebuffer = nullptr; - m_renderer->m_immediateContext->ClearState(); - return D3DSwapchainBase::resize(width, height); - } - virtual SLANG_NO_THROW bool SLANG_MCALL isOccluded() override - { - return false; - } - virtual SLANG_NO_THROW Result SLANG_MCALL setFullScreenMode(bool mode) override - { - return SLANG_FAIL; - } - }; - - class InputLayoutImpl: public InputLayoutBase - { - public: - ComPtr<ID3D11InputLayout> m_layout; - List<UINT> m_vertexStreamStrides; - }; - - class QueryPoolImpl : public QueryPoolBase - { - public: - List<ComPtr<ID3D11Query>> m_queries; - RefPtr<D3D11Device> m_device; - D3D11_QUERY_DESC m_queryDesc; - Result init(const IQueryPool::Desc& desc, D3D11Device* device) - { - m_device = device; - m_queryDesc.MiscFlags = 0; - switch (desc.type) - { - case QueryType::Timestamp: - m_queryDesc.Query = D3D11_QUERY_TIMESTAMP; - break; - default: - return SLANG_E_INVALID_ARG; - } - m_queries.setCount(desc.count); - return SLANG_OK; - } - ID3D11Query* getQuery(SlangInt index) - { - if (!m_queries[index]) - m_device->m_device->CreateQuery(&m_queryDesc, m_queries[index].writeRef()); - return m_queries[index].get(); - } - - virtual SLANG_NO_THROW Result SLANG_MCALL getResult( - GfxIndex queryIndex, GfxCount count, uint64_t* data) override - { - D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData; - while (S_OK != m_device->m_immediateContext->GetData( - m_device->m_disjointQuery, &disjointData, sizeof(D3D11_QUERY_DATA_TIMESTAMP_DISJOINT), 0)) - { - Sleep(1); - } - m_device->m_info.timestampFrequency = disjointData.Frequency; - - for (SlangInt i = 0; i < count; i++) - { - SLANG_RETURN_ON_FAIL(m_device->m_immediateContext->GetData( - m_queries[queryIndex + i], data + i, sizeof(uint64_t), 0)); - } - return SLANG_OK; - } - }; - - class PipelineStateImpl : public PipelineStateBase - { - public: - }; - - - class GraphicsPipelineStateImpl : public PipelineStateImpl - { - public: - UINT m_rtvCount; - - RefPtr<InputLayoutImpl> m_inputLayout; - ComPtr<ID3D11DepthStencilState> m_depthStencilState; - ComPtr<ID3D11RasterizerState> m_rasterizerState; - ComPtr<ID3D11BlendState> m_blendState; - - float m_blendColor[4]; - UINT m_sampleMask; - - void init(const GraphicsPipelineStateDesc& inDesc) - { - PipelineStateBase::PipelineStateDesc pipelineDesc; - pipelineDesc.graphics = inDesc; - pipelineDesc.type = PipelineType::Graphics; - initializeBase(pipelineDesc); - } - }; - - class ComputePipelineStateImpl : public PipelineStateImpl - { - public: - void init(const ComputePipelineStateDesc& inDesc) - { - PipelineStateBase::PipelineStateDesc pipelineDesc; - pipelineDesc.compute = inDesc; - pipelineDesc.type = PipelineType::Compute; - initializeBase(pipelineDesc); - } - }; - - /// Contextual data and operations required when binding shader objects to the pipeline state - struct BindingContext - { - // One key service that the `BindingContext` provides is abstracting over - // the difference between the D3D11 compute and graphics/rasteriation pipelines. - // D3D11 has distinct operations for, e.g., `CSSetShaderResources` - // for compute vs. `VSSetShaderResources` and `PSSetShaderResources` - // for rasterization. - // - // The context type provides simple operations for setting each class - // of resource/sampler, which will be overridden in derived types. - // - // TODO: These operations should really support binding multiple resources/samplers - // in one call, so that we can eventually make more efficient use of the API. - // - // TODO: We could reasonably also just store the bound resources into - // lcoal arrays like we are doing for UAVs, and remove the pipeline-specific - // virtual functions. However, doing so would seemingly eliminate any - // chance of avoiding redundant binding work when binding changes are - // made for a root shader object. - // - virtual void setCBV(UINT index, ID3D11Buffer* buffer) = 0; - virtual void setSRV(UINT index, ID3D11ShaderResourceView* srv) = 0; - virtual void setSampler(UINT index, ID3D11SamplerState* sampler) = 0; - - // Unordered Access Views (UAVs) are a somewhat special case in that - // the D3D11 API requires them to all be set at once, rather than one - // at a time. To support this, we will keep a local array of the UAVs - // that have been bound (up to the maximum supported by D3D 11.0) - // - void setUAV(UINT index, ID3D11UnorderedAccessView* uav) - { - uavs[index] = uav; - - // We will also track the total number of UAV slots that will - // need to be bound (including any gaps that might occur due - // to either explicit bindings or RTV bindings that conflict - // with the `u` registers for fragment shaders). - // - if(uavCount <= index) - { - uavCount = index+1; - } - } - - /// The values bound for any UAVs - ID3D11UnorderedAccessView* uavs[D3D11_PS_CS_UAV_REGISTER_COUNT]; - - /// The number of entries in `uavs` that need to be considered when binding to the pipeline - UINT uavCount = 0; - - /// The D3D11 device that we are using for binding - D3D11Device* device = nullptr; - - /// The D3D11 device context that we are using for binding - ID3D11DeviceContext* context = nullptr; - - /// Initialize a binding context for binding to the given `device` and `context` - BindingContext( - D3D11Device* device, - ID3D11DeviceContext* context) - : device(device) - , context(context) - { - memset(uavs, 0, sizeof(uavs)); - } - }; - - /// A `BindingContext` for binding to the compute pipeline - struct ComputeBindingContext : BindingContext - { - /// Initialize a binding context for binding to the given `device` and `context` - ComputeBindingContext( - D3D11Device* device, - ID3D11DeviceContext* context) - : BindingContext(device, context) - {} - - void setCBV(UINT index, ID3D11Buffer* buffer) SLANG_OVERRIDE - { - context->CSSetConstantBuffers(index, 1, &buffer); - } - - void setSRV(UINT index, ID3D11ShaderResourceView* srv) SLANG_OVERRIDE - { - context->CSSetShaderResources(index, 1, &srv); - } - - void setSampler(UINT index, ID3D11SamplerState* sampler) SLANG_OVERRIDE - { - context->CSSetSamplers(index, 1, &sampler); - } - }; - - /// A `BindingContext` for binding to the graphics/rasterization pipeline - struct GraphicsBindingContext : BindingContext - { - /// Initialize a binding context for binding to the given `device` and `context` - GraphicsBindingContext( - D3D11Device* device, - ID3D11DeviceContext* context) - : BindingContext(device, context) - {} - - // TODO: The operations here are only dealing with vertex and fragment - // shaders for now. We should eventually extend them to handle HS/DS/GS - // bindings. (We might want to skip those stages depending on whether - // the associated program uses them at all). - // - // TODO: If we support cases where different stages might use distinct - // entry-point parameters, we might need to support some modes where - // a "stage mask" is passed in that applies to the bindings. - // - void setCBV(UINT index, ID3D11Buffer* buffer) SLANG_OVERRIDE - { - context->VSSetConstantBuffers(index, 1, &buffer); - context->PSSetConstantBuffers(index, 1, &buffer); - } - - void setSRV(UINT index, ID3D11ShaderResourceView* srv) SLANG_OVERRIDE - { - context->VSSetShaderResources(index, 1, &srv); - context->PSSetShaderResources(index, 1, &srv); - } - - void setSampler(UINT index, ID3D11SamplerState* sampler) SLANG_OVERRIDE - { - context->VSSetSamplers(index, 1, &sampler); - context->PSSetSamplers(index, 1, &sampler); - } - }; - - // In order to bind shader parameters to the correct locations, we need to - // be able to describe those locations. Most shader parameters will - // only consume a single type of D3D11-visible regsiter (e.g., a `t` - // register for a txture, or an `s` register for a sampler), and scalar - // integers suffice for these cases. - // - // In more complex cases we might be binding an entire "sub-object" like - // a parameter block, an entry point, etc. For the general case, we need - // to be able to represent a composite offset that includes offsets for - // each of the register classes known to D3D11. - - /// A "simple" binding offset that records an offset in CBV/SRV/UAV/Sampler slots - struct SimpleBindingOffset - { - uint32_t cbv = 0; - uint32_t srv = 0; - uint32_t uav = 0; - uint32_t sampler = 0; - - /// Create a default (zero) offset - SimpleBindingOffset() - {} - - /// Create an offset based on offset information in the given Slang `varLayout` - SimpleBindingOffset(slang::VariableLayoutReflection* varLayout) - { - if(varLayout) - { - cbv = (uint32_t) varLayout->getOffset(SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER); - srv = (uint32_t) varLayout->getOffset(SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE); - uav = (uint32_t) varLayout->getOffset(SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS); - sampler = (uint32_t) varLayout->getOffset(SLANG_PARAMETER_CATEGORY_SAMPLER_STATE); - } - } - - /// Create an offset based on size/stride information in the given Slang `typeLayout` - SimpleBindingOffset(slang::TypeLayoutReflection* typeLayout) - { - if(typeLayout) - { - cbv = (uint32_t) typeLayout->getSize(SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER); - srv = (uint32_t) typeLayout->getSize(SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE); - uav = (uint32_t) typeLayout->getSize(SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS); - sampler = (uint32_t) typeLayout->getSize(SLANG_PARAMETER_CATEGORY_SAMPLER_STATE); - } - } - - /// Add any values in the given `offset` - void operator+=(SimpleBindingOffset const& offset) - { - cbv += offset.cbv; - srv += offset.srv; - uav += offset.uav; - sampler += offset.sampler; - } - }; - - // While a "simple" binding offset representation will work in many cases, - // once we need to deal with layout for programs with interface-type parameters - // that have been statically specialized, we also need to track the offset - // for where to bind any "pending" data that arises from the process of static - // specialization. - // - // In order to conveniently track both the "primary" and "pending" offset information, - // we will define a more complete `BindingOffset` type that combines simple - // binding offsets for the primary and pending parts. - - /// A representation of the offset at which to bind a shader parameter or sub-object - struct BindingOffset : SimpleBindingOffset - { - // Offsets for "primary" data are stored directly in the `BindingOffset` - // via the inheritance from `SimpleBindingOffset`. - - /// Offset for any "pending" data - SimpleBindingOffset pending; - - /// Create a default (zero) offset - BindingOffset() - {} - - /// Create an offset from a simple offset - explicit BindingOffset(SimpleBindingOffset const& offset) - : SimpleBindingOffset(offset) - {} - - /// Create an offset based on offset information in the given Slang `varLayout` - BindingOffset(slang::VariableLayoutReflection* varLayout) - : SimpleBindingOffset(varLayout) - , pending(varLayout->getPendingDataLayout()) - {} - - /// Create an offset based on size/stride information in the given Slang `typeLayout` - BindingOffset(slang::TypeLayoutReflection* typeLayout) - : SimpleBindingOffset(typeLayout) - , pending(typeLayout->getPendingDataTypeLayout()) - {} - - /// Add any values in the given `offset` - void operator+=(SimpleBindingOffset const& offset) - { - SimpleBindingOffset::operator+=(offset); - } - - /// Add any values in the given `offset` - void operator+=(BindingOffset const& offset) - { - SimpleBindingOffset::operator+=(offset); - pending += offset.pending; - } - }; - - class ShaderObjectLayoutImpl : public ShaderObjectLayoutBase - { - public: - // A shader object comprises three main kinds of state: - // - // * Zero or more bytes of ordinary ("uniform") data - // * Zero or more *bindings* for textures, buffers, and samplers - // * Zero or more *sub-objects* representing nested parameter blocks, etc. - // - // A shader object *layout* stores information that can be used to - // organize these different kinds of state and optimize access to them. - // - // For example, both texture/buffer/sampler bindings and sub-objects - // are organized into logical *binding ranges* by the Slang reflection - // API, and a shader object layout will store information about those - // ranges in a form that is usable for the D3D11 API: - - /// Information about a logical binding range as reported by Slang reflection - struct BindingRangeInfo - { - /// The type of bindings in this range - slang::BindingType bindingType; - - /// The number of bindings in this range - Index count; - - /// The starting index for this range in the appropriate "flat" array in a shader object. - /// E.g., for a shader resourve view range, this would be an index into the `m_srvs` array. - Index baseIndex; - - /// The offset of this binding range from the start of the sub-object - /// in terms of whatever D3D11 register class it consumes. E.g., for - /// a `Texture2D` binding range this will represent an offset in - /// `t` registers. - /// - uint32_t registerOffset; - - /// An index into the sub-object array if this binding range is treated - /// as a sub-object. - Index subObjectIndex; - }; - - // Sometimes we just want to iterate over the ranges that represnet - // sub-objects while skipping over the others, because sub-object - // ranges often require extra handling or more state. - // - // For that reason we also store pre-computed information about each - // sub-object range. - - /// Offset information for a sub-object range - struct SubObjectRangeOffset : BindingOffset - { - SubObjectRangeOffset() - {} - - SubObjectRangeOffset(slang::VariableLayoutReflection* varLayout) - : BindingOffset(varLayout) - { - if(auto pendingLayout = varLayout->getPendingDataLayout()) - { - pendingOrdinaryData = (uint32_t) pendingLayout->getOffset(SLANG_PARAMETER_CATEGORY_UNIFORM); - } - } - - /// The offset for "pending" ordinary data related to this range - uint32_t pendingOrdinaryData = 0; - }; - - /// Stride information for a sub-object range - struct SubObjectRangeStride : BindingOffset - { - SubObjectRangeStride() - {} - - SubObjectRangeStride(slang::TypeLayoutReflection* typeLayout) - : BindingOffset(typeLayout) - { - if(auto pendingLayout = typeLayout->getPendingDataTypeLayout()) - { - pendingOrdinaryData = (uint32_t) typeLayout->getStride(); - } - } - - /// The strid for "pending" ordinary data related to this range - uint32_t pendingOrdinaryData = 0; - }; - - /// Information about a logical binding range as reported by Slang reflection - struct SubObjectRangeInfo - { - /// The index of the binding range that corresponds to this sub-object range - Index bindingRangeIndex; - - /// The layout expected for objects bound to this range (if known) - RefPtr<ShaderObjectLayoutImpl> layout; - - /// The offset to use when binding the first object in this range - SubObjectRangeOffset offset; - - /// Stride between consecutive objects in this range - SubObjectRangeStride stride; - }; - - struct Builder - { - public: - Builder(RendererBase* renderer) - : m_renderer(renderer) - {} - - RendererBase* m_renderer; - slang::TypeLayoutReflection* m_elementTypeLayout; - - List<BindingRangeInfo> m_bindingRanges; - List<SubObjectRangeInfo> m_subObjectRanges; - - /// The indices of the binding ranges that represent SRVs - List<Index> m_srvRanges; - - /// The indices of the binding ranges that represent UAVs - List<Index> m_uavRanges; - - /// The indices of the binding ranges that represent samplers - List<Index> m_samplerRanges; - - Index m_srvCount = 0; - Index m_samplerCount = 0; - Index m_uavCount = 0; - Index m_subObjectCount = 0; - - uint32_t m_totalOrdinaryDataSize = 0; - - /// The container type of this shader object. When `m_containerType` is - /// `StructuredBuffer` or `UnsizedArray`, this shader object represents a collection - /// instead of a single object. - ShaderObjectContainerType m_containerType = ShaderObjectContainerType::None; - - Result setElementTypeLayout(slang::TypeLayoutReflection* typeLayout) - { - typeLayout = _unwrapParameterGroups(typeLayout, m_containerType); - - m_elementTypeLayout = typeLayout; - - m_totalOrdinaryDataSize = (uint32_t) typeLayout->getSize(); - - // Compute the binding ranges that are used to store - // the logical contents of the object in memory. - - SlangInt bindingRangeCount = typeLayout->getBindingRangeCount(); - for (SlangInt r = 0; r < bindingRangeCount; ++r) - { - slang::BindingType slangBindingType = typeLayout->getBindingRangeType(r); - SlangInt count = typeLayout->getBindingRangeBindingCount(r); - slang::TypeLayoutReflection* slangLeafTypeLayout = - typeLayout->getBindingRangeLeafTypeLayout(r); - - BindingRangeInfo bindingRangeInfo; - bindingRangeInfo.bindingType = slangBindingType; - bindingRangeInfo.count = count; - - switch (slangBindingType) - { - case slang::BindingType::ConstantBuffer: - case slang::BindingType::ParameterBlock: - case slang::BindingType::ExistentialValue: - bindingRangeInfo.baseIndex = m_subObjectCount; - bindingRangeInfo.subObjectIndex = m_subObjectCount; - m_subObjectCount += count; - break; - case slang::BindingType::RawBuffer: - case slang::BindingType::MutableRawBuffer: - if (slangLeafTypeLayout->getType()->getElementType() != nullptr) - { - // A structured buffer occupies both a resource slot and - // a sub-object slot. - bindingRangeInfo.subObjectIndex = m_subObjectCount; - m_subObjectCount += count; - } - if (slangBindingType == slang::BindingType::RawBuffer) - { - bindingRangeInfo.baseIndex = m_srvCount; - m_srvCount += count; - m_srvRanges.add(r); - } - else - { - bindingRangeInfo.baseIndex = m_uavCount; - m_uavCount += count; - m_uavRanges.add(r); - } - break; - case slang::BindingType::Sampler: - bindingRangeInfo.baseIndex = m_samplerCount; - m_samplerCount += count; - m_samplerRanges.add(r); - break; - - case slang::BindingType::CombinedTextureSampler: - break; - case slang::BindingType::MutableTexture: - case slang::BindingType::MutableTypedBuffer: - bindingRangeInfo.baseIndex = m_uavCount; - m_uavCount += count; - m_uavRanges.add(r); - break; - - case slang::BindingType::VaryingInput: - break; - - case slang::BindingType::VaryingOutput: - break; - - default: - bindingRangeInfo.baseIndex = m_srvCount; - m_srvCount += count; - m_srvRanges.add(r); - break; - } - - // We'd like to extract the information on the D3D11 shader - // register that this range should bind into. - // - // A binding range represents a logical member of the shader - // object type, and it may encompass zero or more *descriptor - // ranges* that describe how it is physically bound to pipeline - // state. - // - // If the current bindign range is backed by at least one descriptor - // range then we can query the register offset of that descriptor - // range. We expect that in the common case there will be exactly - // one descriptor range, and we can extract the information easily. - // - // TODO: we might eventually need to special-case our handling - // of combined texture-sampler ranges since they will need to - // store two different offsets. - // - if(typeLayout->getBindingRangeDescriptorRangeCount(r) != 0) - { - // The Slang reflection information organizes the descriptor ranges - // into "descriptor sets" but D3D11 has no notion like that so we - // expect all ranges belong to a single set. - // - SlangInt descriptorSetIndex = typeLayout->getBindingRangeDescriptorSetIndex(r); - SLANG_ASSERT(descriptorSetIndex == 0); - - SlangInt descriptorRangeIndex = typeLayout->getBindingRangeFirstDescriptorRangeIndex(r); - auto registerOffset = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(descriptorSetIndex, descriptorRangeIndex); - - bindingRangeInfo.registerOffset = (uint32_t) registerOffset; - } - - m_bindingRanges.add(bindingRangeInfo); - } - - SlangInt subObjectRangeCount = typeLayout->getSubObjectRangeCount(); - for (SlangInt r = 0; r < subObjectRangeCount; ++r) - { - SlangInt bindingRangeIndex = typeLayout->getSubObjectRangeBindingRangeIndex(r); - auto& bindingRange = m_bindingRanges[bindingRangeIndex]; - - auto slangBindingType = typeLayout->getBindingRangeType(bindingRangeIndex); - slang::TypeLayoutReflection* slangLeafTypeLayout = - typeLayout->getBindingRangeLeafTypeLayout(bindingRangeIndex); - - SubObjectRangeInfo subObjectRange; - subObjectRange.bindingRangeIndex = bindingRangeIndex; - - // We will use Slang reflection information to extract the offset and stride - // information for each sub-object range. - // - subObjectRange.offset = SubObjectRangeOffset(typeLayout->getSubObjectRangeOffset(r)); - subObjectRange.stride = SubObjectRangeStride(slangLeafTypeLayout); - - // A sub-object range can either represent a sub-object of a known - // type, like a `ConstantBuffer<Foo>` or `ParameterBlock<Foo>` - // *or* it can represent a sub-object of some existential type (e.g., `IBar`). - // - RefPtr<ShaderObjectLayoutImpl> subObjectLayout; - switch(slangBindingType) - { - default: - { - // In the case of `ConstantBuffer<X>` or `ParameterBlock<X>` - // we can construct a layout from the element type directly. - // - auto elementTypeLayout = slangLeafTypeLayout->getElementTypeLayout(); - createForElementType( - m_renderer, - elementTypeLayout, - subObjectLayout.writeRef()); - } - break; - - case slang::BindingType::ExistentialValue: - // In the case of an interface-type sub-object range, we can only - // construct a layout if we have static specialization information - // that tells us what type we expect to find in that range. - // - // The static specialization information is expected to take the - // form of a "pending" type layotu attached to the interface type - // of the leaf type layout. - // - if(auto pendingTypeLayout = slangLeafTypeLayout->getPendingDataTypeLayout()) - { - createForElementType( - m_renderer, - pendingTypeLayout, - subObjectLayout.writeRef()); - - // An interface-type range that includes ordinary data can - // increase the size of the ordinary data buffer we need to - // allocate for the parent object. - // - uint32_t ordinaryDataEnd = subObjectRange.offset.pendingOrdinaryData - + (uint32_t) bindingRange.count * subObjectRange.stride.pendingOrdinaryData; - - if(ordinaryDataEnd > m_totalOrdinaryDataSize) - { - m_totalOrdinaryDataSize = ordinaryDataEnd; - } - } - } - subObjectRange.layout = subObjectLayout; - - m_subObjectRanges.add(subObjectRange); - } - return SLANG_OK; - } - - SlangResult build(ShaderObjectLayoutImpl** outLayout) - { - auto layout = - RefPtr<ShaderObjectLayoutImpl>(new ShaderObjectLayoutImpl()); - SLANG_RETURN_ON_FAIL(layout->_init(this)); - - returnRefPtrMove(outLayout, layout); - return SLANG_OK; - } - }; - - static Result createForElementType( - RendererBase* renderer, - slang::TypeLayoutReflection* elementType, - ShaderObjectLayoutImpl** outLayout) - { - Builder builder(renderer); - builder.setElementTypeLayout(elementType); - return builder.build(outLayout); - } - - List<BindingRangeInfo> const& getBindingRanges() { return m_bindingRanges; } - - Index getBindingRangeCount() { return m_bindingRanges.getCount(); } - - BindingRangeInfo const& getBindingRange(Index index) { return m_bindingRanges[index]; } - - Index getSRVCount() { return m_srvCount; } - Index getSamplerCount() { return m_samplerCount; } - Index getUAVCount() { return m_uavCount; } - Index getSubObjectCount() { return m_subObjectCount; } - Index getVaryingOutputCount() { return m_varyingOutputCount; } - - SubObjectRangeInfo const& getSubObjectRange(Index index) { return m_subObjectRanges[index]; } - List<SubObjectRangeInfo> const& getSubObjectRanges() { return m_subObjectRanges; } - - RendererBase* getRenderer() { return m_renderer; } - - slang::TypeReflection* getType() - { - return m_elementTypeLayout->getType(); - } - - /// Get the indices that represent all the SRV ranges in this type - List<Index> const& getSRVRanges() const { return m_srvRanges; } - - /// Get the indices that reprsent all the UAV ranges in this type - List<Index> const& getUAVRanges() const { return m_uavRanges; } - - /// Get the indices that represnet all the sampler ranges in this type - List<Index> const& getSamplerRanges() const { return m_samplerRanges; } - - uint32_t getTotalOrdinaryDataSize() const { return m_totalOrdinaryDataSize; } - - protected: - Result _init(Builder const* builder) - { - auto renderer = builder->m_renderer; - - initBase(renderer, builder->m_elementTypeLayout); - - m_bindingRanges = builder->m_bindingRanges; - m_srvRanges = builder->m_srvRanges; - m_uavRanges = builder->m_uavRanges; - m_samplerRanges = builder->m_samplerRanges; - - m_srvCount = builder->m_srvCount; - m_samplerCount = builder->m_samplerCount; - m_uavCount = builder->m_uavCount; - m_subObjectCount = builder->m_subObjectCount; - m_subObjectRanges = builder->m_subObjectRanges; - - m_totalOrdinaryDataSize = builder->m_totalOrdinaryDataSize; - - m_containerType = builder->m_containerType; - return SLANG_OK; - } - - List<BindingRangeInfo> m_bindingRanges; - List<Index> m_srvRanges; - List<Index> m_uavRanges; - List<Index> m_samplerRanges; - Index m_srvCount = 0; - Index m_samplerCount = 0; - Index m_uavCount = 0; - Index m_subObjectCount = 0; - Index m_varyingInputCount = 0; - Index m_varyingOutputCount = 0; - uint32_t m_totalOrdinaryDataSize = 0; - List<SubObjectRangeInfo> m_subObjectRanges; - }; - - class RootShaderObjectLayoutImpl : public ShaderObjectLayoutImpl - { - typedef ShaderObjectLayoutImpl Super; - - public: - struct EntryPointInfo - { - RefPtr<ShaderObjectLayoutImpl> layout; - - /// The offset for this entry point's parameters, relative to the starting offset for the program - BindingOffset offset; - }; - - struct Builder : Super::Builder - { - Builder( - RendererBase* renderer, - slang::IComponentType* program, - slang::ProgramLayout* programLayout) - : Super::Builder(renderer) - , m_program(program) - , m_programLayout(programLayout) - {} - - Result build(RootShaderObjectLayoutImpl** outLayout) - { - RefPtr<RootShaderObjectLayoutImpl> layout = new RootShaderObjectLayoutImpl(); - SLANG_RETURN_ON_FAIL(layout->_init(this)); - - returnRefPtrMove(outLayout, layout); - return SLANG_OK; - } - - void addGlobalParams(slang::VariableLayoutReflection* globalsLayout) - { - setElementTypeLayout(globalsLayout->getTypeLayout()); - m_pendingDataOffset = BindingOffset(globalsLayout).pending; - } - - void addEntryPoint(SlangStage stage, ShaderObjectLayoutImpl* entryPointLayout, slang::EntryPointLayout* slangEntryPoint) - { - EntryPointInfo info; - info.layout = entryPointLayout; - info.offset = BindingOffset(slangEntryPoint->getVarLayout()); - m_entryPoints.add(info); - } - - slang::IComponentType* m_program; - slang::ProgramLayout* m_programLayout; - List<EntryPointInfo> m_entryPoints; - SimpleBindingOffset m_pendingDataOffset; - }; - - EntryPointInfo& getEntryPoint(Index index) { return m_entryPoints[index]; } - - List<EntryPointInfo>& getEntryPoints() { return m_entryPoints; } - - static Result create( - RendererBase* renderer, - slang::IComponentType* program, - slang::ProgramLayout* programLayout, - RootShaderObjectLayoutImpl** outLayout) - { - RootShaderObjectLayoutImpl::Builder builder(renderer, program, programLayout); - builder.addGlobalParams(programLayout->getGlobalParamsVarLayout()); - - SlangInt entryPointCount = programLayout->getEntryPointCount(); - for (SlangInt e = 0; e < entryPointCount; ++e) - { - auto slangEntryPoint = programLayout->getEntryPointByIndex(e); - RefPtr<ShaderObjectLayoutImpl> entryPointLayout; - SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - renderer, slangEntryPoint->getTypeLayout(), entryPointLayout.writeRef())); - builder.addEntryPoint(slangEntryPoint->getStage(), entryPointLayout, slangEntryPoint); - } - - SLANG_RETURN_ON_FAIL(builder.build(outLayout)); - - return SLANG_OK; - } - - slang::IComponentType* getSlangProgram() const { return m_program; } - slang::ProgramLayout* getSlangProgramLayout() const { return m_programLayout; } - - /// Get the offset at which "pending" shader parameters for this program start - SimpleBindingOffset const& getPendingDataOffset() const { return m_pendingDataOffset; } - - protected: - Result _init(Builder const* builder) - { - auto renderer = builder->m_renderer; - - SLANG_RETURN_ON_FAIL(Super::_init(builder)); - - m_program = builder->m_program; - m_programLayout = builder->m_programLayout; - m_entryPoints = builder->m_entryPoints; - m_pendingDataOffset = builder->m_pendingDataOffset; - return SLANG_OK; - } - - ComPtr<slang::IComponentType> m_program; - slang::ProgramLayout* m_programLayout = nullptr; - - List<EntryPointInfo> m_entryPoints; - SimpleBindingOffset m_pendingDataOffset; - }; - - class ShaderObjectImpl - : public ShaderObjectBaseImpl< - ShaderObjectImpl, - ShaderObjectLayoutImpl, - SimpleShaderObjectData> - { - public: - static Result create( - IDevice* device, - ShaderObjectLayoutImpl* layout, - ShaderObjectImpl** outShaderObject) - { - auto object = RefPtr<ShaderObjectImpl>(new ShaderObjectImpl()); - SLANG_RETURN_ON_FAIL(object->init(device, layout)); - - returnRefPtrMove(outShaderObject, object); - return SLANG_OK; - } - - RendererBase* getDevice() { return m_layout->getDevice(); } - - SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; } - - SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) - SLANG_OVERRIDE - { - *outEntryPoint = nullptr; - return SLANG_OK; - } - - virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() override - { - return m_data.getBuffer(); - } - - virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override - { - return (size_t)m_data.getCount(); - } - - SLANG_NO_THROW Result SLANG_MCALL - setData(ShaderOffset const& inOffset, void const* data, size_t inSize) SLANG_OVERRIDE - { - Index offset = inOffset.uniformOffset; - Index size = inSize; - - char* dest = m_data.getBuffer(); - Index availableSize = m_data.getCount(); - - // TODO: We really should bounds-check access rather than silently ignoring sets - // that are too large, but we have several test cases that set more data than - // an object actually stores on several targets... - // - if (offset < 0) - { - size += offset; - offset = 0; - } - if ((offset + size) >= availableSize) - { - size = availableSize - offset; - } - - memcpy(dest + offset, data, size); - - m_isConstantBufferDirty = true; - - return SLANG_OK; - } - - - - SLANG_NO_THROW Result SLANG_MCALL - setResource(ShaderOffset const& offset, IResourceView* resourceView) SLANG_OVERRIDE - { - if (offset.bindingRangeIndex < 0) - return SLANG_E_INVALID_ARG; - auto layout = getLayout(); - if (offset.bindingRangeIndex >= layout->getBindingRangeCount()) - return SLANG_E_INVALID_ARG; - auto& bindingRange = layout->getBindingRange(offset.bindingRangeIndex); - - auto resourceViewImpl = static_cast<ResourceViewImpl*>(resourceView); - if (D3DUtil::isUAVBinding(bindingRange.bindingType)) - { - SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::Type::UAV); - m_uavs[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<UnorderedAccessViewImpl*>(resourceView); - } - else - { - SLANG_ASSERT(resourceViewImpl->m_type == ResourceViewImpl::Type::SRV); - m_srvs[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<ShaderResourceViewImpl*>(resourceView); - } - return SLANG_OK; - } - - SLANG_NO_THROW Result SLANG_MCALL setSampler(ShaderOffset const& offset, ISamplerState* sampler) - SLANG_OVERRIDE - { - if (offset.bindingRangeIndex < 0) - return SLANG_E_INVALID_ARG; - auto layout = getLayout(); - if (offset.bindingRangeIndex >= layout->getBindingRangeCount()) - return SLANG_E_INVALID_ARG; - auto& bindingRange = layout->getBindingRange(offset.bindingRangeIndex); - - m_samplers[bindingRange.baseIndex + offset.bindingArrayIndex] = static_cast<SamplerStateImpl*>(sampler); - return SLANG_OK; - } - - SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler( - ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) SLANG_OVERRIDE - { - return SLANG_E_NOT_IMPLEMENTED; - } - - public: - - - protected: - friend class ProgramVars; - - Result init(IDevice* device, ShaderObjectLayoutImpl* layout) - { - m_layout = layout; - - // If the layout tells us that there is any uniform data, - // then we will allocate a CPU memory buffer to hold that data - // while it is being set from the host. - // - // Once the user is done setting the parameters/fields of this - // shader object, we will produce a GPU-memory version of the - // uniform data (which includes values from this object and - // any existential-type sub-objects). - // - size_t uniformSize = layout->getElementTypeLayout()->getSize(); - if (uniformSize) - { - m_data.setCount(uniformSize); - memset(m_data.getBuffer(), 0, uniformSize); - } - - m_srvs.setCount(layout->getSRVCount()); - m_samplers.setCount(layout->getSamplerCount()); - m_uavs.setCount(layout->getUAVCount()); - - // If the layout specifies that we have any sub-objects, then - // we need to size the array to account for them. - // - Index subObjectCount = layout->getSubObjectCount(); - m_objects.setCount(subObjectCount); - - for (auto subObjectRangeInfo : layout->getSubObjectRanges()) - { - auto subObjectLayout = subObjectRangeInfo.layout; - - // In the case where the sub-object range represents an - // existential-type leaf field (e.g., an `IBar`), we - // cannot pre-allocate the object(s) to go into that - // range, since we can't possibly know what to allocate - // at this point. - // - if (!subObjectLayout) - continue; - // - // Otherwise, we will allocate a sub-object to fill - // in each entry in this range, based on the layout - // information we already have. - - auto& bindingRangeInfo = layout->getBindingRange(subObjectRangeInfo.bindingRangeIndex); - for (Index i = 0; i < bindingRangeInfo.count; ++i) - { - RefPtr<ShaderObjectImpl> subObject; - SLANG_RETURN_ON_FAIL( - ShaderObjectImpl::create(device, subObjectLayout, subObject.writeRef())); - m_objects[bindingRangeInfo.subObjectIndex + i] = subObject; - } - } - - return SLANG_OK; - } - - /// Write the uniform/ordinary data of this object into the given `dest` buffer at the given `offset` - Result _writeOrdinaryData( - void* dest, - size_t destSize, - ShaderObjectLayoutImpl* specializedLayout) - { - // We start by simply writing in the ordinary data contained directly in this object. - // - auto src = m_data.getBuffer(); - auto srcSize = size_t(m_data.getCount()); - SLANG_ASSERT(srcSize <= destSize); - memcpy(dest, src, srcSize); - - // In the case where this object has any sub-objects of - // existential/interface type, we need to recurse on those objects - // that need to write their state into an appropriate "pending" allocation. - // - // Note: Any values that could fit into the "payload" included - // in the existential-type field itself will have already been - // written as part of `setObject()`. This loop only needs to handle - // those sub-objects that do not "fit." - // - // An implementers looking at this code might wonder if things could be changed - // so that *all* writes related to sub-objects for interface-type fields could - // be handled in this one location, rather than having some in `setObject()` and - // others handled here. - // - Index subObjectRangeCounter = 0; - for (auto const& subObjectRangeInfo : specializedLayout->getSubObjectRanges()) - { - Index subObjectRangeIndex = subObjectRangeCounter++; - auto const& bindingRangeInfo = specializedLayout->getBindingRange(subObjectRangeInfo.bindingRangeIndex); - - // We only need to handle sub-object ranges for interface/existential-type fields, - // because fields of constant-buffer or parameter-block type are responsible for - // the ordinary/uniform data of their own existential/interface-type sub-objects. - // - if (bindingRangeInfo.bindingType != slang::BindingType::ExistentialValue) - continue; - - // Each sub-object range represents a single "leaf" field, but might be nested - // under zero or more outer arrays, such that the number of existential values - // in the same range can be one or more. - // - auto count = bindingRangeInfo.count; - - // We are not concerned with the case where the existential value(s) in the range - // git into the payload part of the leaf field. - // - // In the case where the value didn't fit, the Slang layout strategy would have - // considered the requirements of the value as a "pending" allocation, and would - // allocate storage for the ordinary/uniform part of that pending allocation inside - // of the parent object's type layout. - // - // Here we assume that the Slang reflection API can provide us with a single byte - // offset and stride for the location of the pending data allocation in the specialized - // type layout, which will store the values for this sub-object range. - // - // TODO: The reflection API functions we are assuming here haven't been implemented - // yet, so the functions being called here are stubs. - // - // TODO: It might not be that a single sub-object range can reliably map to a single - // contiguous array with a single stride; we need to carefully consider what the layout - // logic does for complex cases with multiple layers of nested arrays and structures. - // - size_t subObjectRangePendingDataOffset = subObjectRangeInfo.offset.pendingOrdinaryData; - size_t subObjectRangePendingDataStride = subObjectRangeInfo.stride.pendingOrdinaryData; - - // If the range doesn't actually need/use the "pending" allocation at all, then - // we need to detect that case and skip such ranges. - // - // TODO: This should probably be handled on a per-object basis by caching a "does it fit?" - // bit as part of the information for bound sub-objects, given that we already - // compute the "does it fit?" status as part of `setObject()`. - // - if (subObjectRangePendingDataOffset == 0) - continue; - - for (Slang::Index i = 0; i < count; ++i) - { - auto subObject = m_objects[bindingRangeInfo.subObjectIndex + i]; - - RefPtr<ShaderObjectLayoutImpl> subObjectLayout; - SLANG_RETURN_ON_FAIL(subObject->_getSpecializedLayout(subObjectLayout.writeRef())); - - auto subObjectOffset = subObjectRangePendingDataOffset + i * subObjectRangePendingDataStride; - - auto subObjectDest = (char*)dest + subObjectOffset; - - subObject->_writeOrdinaryData(subObjectDest, destSize - subObjectOffset, subObjectLayout); - } - } - - return SLANG_OK; - } - - /// Ensure that the `m_ordinaryDataBuffer` has been created, if it is needed - /// - /// The `specializedLayout` type must represent a specialized layout for this - /// type that includes any "pending" data. - /// - Result _ensureOrdinaryDataBufferCreatedIfNeeded( - D3D11Device* device, - ShaderObjectLayoutImpl* specializedLayout) - { - auto specializedOrdinaryDataSize = specializedLayout->getTotalOrdinaryDataSize(); - if (specializedOrdinaryDataSize == 0) - return SLANG_OK; - - // If we have already created a buffer to hold ordinary data, then we should - // simply re-use that buffer rather than re-create it. - if (!m_ordinaryDataBuffer) - { - ComPtr<IBufferResource> bufferResourcePtr; - IBufferResource::Desc bufferDesc = {}; - bufferDesc.type = IResource::Type::Buffer; - bufferDesc.sizeInBytes = specializedOrdinaryDataSize; - bufferDesc.defaultState = ResourceState::ConstantBuffer; - bufferDesc.allowedStates = - ResourceStateSet(ResourceState::ConstantBuffer, ResourceState::CopyDestination); - bufferDesc.memoryType = MemoryType::Upload; - SLANG_RETURN_ON_FAIL( - device->createBufferResource(bufferDesc, nullptr, bufferResourcePtr.writeRef())); - m_ordinaryDataBuffer = static_cast<BufferResourceImpl*>(bufferResourcePtr.get()); - } - - if (m_isConstantBufferDirty) - { - // Once the buffer is allocated, we can use `_writeOrdinaryData` to fill it in. - // - // Note that `_writeOrdinaryData` is potentially recursive in the case - // where this object contains interface/existential-type fields, so we - // don't need or want to inline it into this call site. - // - - auto ordinaryData = device->map(m_ordinaryDataBuffer, gfx::MapFlavor::WriteDiscard); - auto result = _writeOrdinaryData(ordinaryData, specializedOrdinaryDataSize, specializedLayout); - device->unmap(m_ordinaryDataBuffer, 0, specializedOrdinaryDataSize); - m_isConstantBufferDirty = false; - return result; - } - return SLANG_OK; - } - - /// Bind the buffer for ordinary/uniform data, if needed - /// - /// The `ioOffset` parameter will be updated to reflect the constant buffer - /// register consumed by the ordinary data buffer, if one was bound. - /// - Result _bindOrdinaryDataBufferIfNeeded( - BindingContext* context, - BindingOffset& ioOffset, - ShaderObjectLayoutImpl* specializedLayout) - { - // We start by ensuring that the buffer is created, if it is needed. - // - SLANG_RETURN_ON_FAIL(_ensureOrdinaryDataBufferCreatedIfNeeded(context->device, specializedLayout)); - - // If we did indeed need/create a buffer, then we must bind it - // into root binding state. - // - if (m_ordinaryDataBuffer) - { - context->setCBV(ioOffset.cbv, m_ordinaryDataBuffer->m_buffer); - ioOffset.cbv++; - } - - return SLANG_OK; - } - public: - /// Bind this object as if it was declared as a `ConstantBuffer<T>` in Slang - Result bindAsConstantBuffer( - BindingContext* context, - BindingOffset const& inOffset, - ShaderObjectLayoutImpl* specializedLayout) - { - // When binding a `ConstantBuffer<X>` we need to first bind a constant - // buffer for any "ordinary" data in `X`, and then bind the remaining - // resources and sub-objets. - // - // The one important detail to keep track of its that *if* we bind - // a constant buffer for ordinary data we will need to account for - // it in the offset we use for binding the remaining data. That - // detail is dealt with here by the way that `_bindOrdinaryDataBufferIfNeeded` - // will modify the `offset` parameter if it binds anything. - // - BindingOffset offset = inOffset; - SLANG_RETURN_ON_FAIL(_bindOrdinaryDataBufferIfNeeded(context, /*inout*/ offset, specializedLayout)); - - // Once the ordinary data buffer is bound, we can move on to binding - // the rest of the state, which can use logic shared with the case - // for interface-type sub-object ranges. - // - // Note that this call will use the `offset` value that might have - // been modified during `_bindOrindaryDataBufferIfNeeded`. - // - SLANG_RETURN_ON_FAIL(bindAsValue(context, offset, specializedLayout)); - - return SLANG_OK; - } - - /// Bind this object as a value that appears in the body of another object. - /// - /// This case is directly used when binding an object for an interface-type - /// sub-object range when static specialization is used. It is also used - /// indirectly when binding sub-objects to constant buffer or parameter - /// block ranges. - /// - Result bindAsValue( - BindingContext* context, - BindingOffset const& offset, - ShaderObjectLayoutImpl* specializedLayout) - { - // We start by iterating over the binding ranges in this type, isolating - // just those ranges that represent SRVs, UAVs, and samplers. - // In each loop we will bind the values stored for those binding ranges - // to the correct D3D11 register (based on the `registerOffset` field - // stored in the bindinge range). - // - // TODO: These loops could be optimized if we stored parallel arrays - // for things like `m_srvs` so that we directly store an array of - // `ID3D11ShaderResourceView*` where each entry matches the `gfx`-level - // object that was bound (or holds null if nothing is bound). - // In that case, we could perform a single `setSRVs()` call for each - // binding range. - // - // TODO: More ambitiously, if the Slang layout algorithm could be modified - // so that non-sub-object binding ranges are guaranteed to be contiguous - // then a *single* `setSRVs()` call could set all of the SRVs for an object - // at once. - - for(auto bindingRangeIndex : specializedLayout->getSRVRanges()) - { - auto const& bindingRange = specializedLayout->getBindingRange(bindingRangeIndex); - auto count = (uint32_t) bindingRange.count; - auto baseIndex = (uint32_t) bindingRange.baseIndex; - auto registerOffset = bindingRange.registerOffset + offset.srv; - for(uint32_t i = 0; i < count; ++i) - { - auto srv = m_srvs[baseIndex + i]; - context->setSRV(registerOffset + i, srv ? srv->m_srv : nullptr); - } - } - - for(auto bindingRangeIndex : specializedLayout->getUAVRanges()) - { - auto const& bindingRange = specializedLayout->getBindingRange(bindingRangeIndex); - auto count = (uint32_t) bindingRange.count; - auto baseIndex = (uint32_t) bindingRange.baseIndex; - auto registerOffset = bindingRange.registerOffset + offset.uav; - for(uint32_t i = 0; i < count; ++i) - { - auto uav = m_uavs[baseIndex + i]; - context->setUAV(registerOffset + i, uav ? uav->m_uav : nullptr); - } - } - - for(auto bindingRangeIndex : specializedLayout->getSamplerRanges()) - { - auto const& bindingRange = specializedLayout->getBindingRange(bindingRangeIndex); - auto count = (uint32_t) bindingRange.count; - auto baseIndex = (uint32_t) bindingRange.baseIndex; - auto registerOffset = bindingRange.registerOffset + offset.sampler; - for(uint32_t i = 0; i < count; ++i) - { - auto sampler = m_samplers[baseIndex + i]; - context->setSampler(registerOffset + i, sampler ? sampler->m_sampler.get() : nullptr); - } - } - - // Once all the simple binding ranges are dealt with, we will bind - // all of the sub-objects in sub-object ranges. - // - for(auto const& subObjectRange : specializedLayout->getSubObjectRanges()) - { - auto subObjectLayout = subObjectRange.layout; - auto const& bindingRange = specializedLayout->getBindingRange(subObjectRange.bindingRangeIndex); - Index count = bindingRange.count; - Index subObjectIndex = bindingRange.subObjectIndex; - - // The starting offset for a sub-object range was computed - // from Slang reflection information, so we can apply it here. - // - BindingOffset rangeOffset = offset; - rangeOffset += subObjectRange.offset; - - // Similarly, the "stride" between consecutive objects in - // the range was also pre-computed. - // - BindingOffset rangeStride = subObjectRange.stride; - - switch(bindingRange.bindingType) - { - // For D3D11-compatible compilation targets, the Slang compiler - // treats the `ConstantBuffer<T>` and `ParameterBlock<T>` types the same. - // - case slang::BindingType::ConstantBuffer: - case slang::BindingType::ParameterBlock: - { - BindingOffset objOffset = rangeOffset; - for(Index i = 0; i < count; ++i) - { - auto subObject = m_objects[subObjectIndex + i]; - - // Unsurprisingly, we bind each object in the range as - // a constant buffer. - // - subObject->bindAsConstantBuffer(context, objOffset, subObjectLayout); - - objOffset += rangeStride; - } - } - break; - - case slang::BindingType::ExistentialValue: - // We can only bind information for existential-typed sub-object - // ranges if we have a static type that we are able to specialize to. - // - if(subObjectLayout) - { - // The data for objects in this range will always be bound into - // the "pending" allocation for the parent block/buffer/object. - // As a result, the offset for the first object in the range - // will come from the `pending` part of the range's offset. - // - SimpleBindingOffset objOffset = rangeOffset.pending; - SimpleBindingOffset objStride = rangeStride.pending; - - for(Index i = 0; i < count; ++i) - { - auto subObject = m_objects[subObjectIndex + i]; - subObject->bindAsValue(context, BindingOffset(objOffset), subObjectLayout); - - objOffset += objStride; - } - } - break; - - default: - break; - } - } - - return SLANG_OK; - } - - // Because the binding ranges have already been reflected - // and organized as part of each shader object layout, - // the object itself can store its data in a small number - // of simple arrays. - /// The shader resource views (SRVs) that are part of the state of this object - List<RefPtr<ShaderResourceViewImpl>> m_srvs; - - /// The unordered access views (UAVs) that are part of the state of this object - List<RefPtr<UnorderedAccessViewImpl>> m_uavs; - - /// The samplers that are part of the state of this object - List<RefPtr<SamplerStateImpl>> m_samplers; - - /// A constant buffer used to stored ordinary data for this object - /// and existential-type sub-objects. - /// - /// Created on demand with `_createOrdinaryDataBufferIfNeeded()` - RefPtr<BufferResourceImpl> m_ordinaryDataBuffer; - - bool m_isConstantBufferDirty = true; - - /// Get the layout of this shader object with specialization arguments considered - /// - /// This operation should only be called after the shader object has been - /// fully filled in and finalized. - /// - Result _getSpecializedLayout(ShaderObjectLayoutImpl** outLayout) - { - if (!m_specializedLayout) - { - SLANG_RETURN_ON_FAIL(_createSpecializedLayout(m_specializedLayout.writeRef())); - } - returnRefPtr(outLayout, m_specializedLayout); - return SLANG_OK; - } - - /// Create the layout for this shader object with specialization arguments considered - /// - /// This operation is virtual so that it can be customized by `ProgramVars`. - /// - virtual Result _createSpecializedLayout(ShaderObjectLayoutImpl** outLayout) - { - ExtendedShaderObjectType extendedType; - SLANG_RETURN_ON_FAIL(getSpecializedShaderObjectType(&extendedType)); - - auto renderer = getRenderer(); - RefPtr<ShaderObjectLayoutImpl> layout; - SLANG_RETURN_ON_FAIL(renderer->getShaderObjectLayout( - extendedType.slangType, - m_layout->getContainerType(), - (ShaderObjectLayoutBase**)layout.writeRef())); - - returnRefPtrMove(outLayout, layout); - return SLANG_OK; - } - - RefPtr<ShaderObjectLayoutImpl> m_specializedLayout; - }; - - class MutableShaderObjectImpl - : public MutableShaderObject< - MutableShaderObjectImpl, - ShaderObjectLayoutImpl> - {}; - - class RootShaderObjectImpl : public ShaderObjectImpl - { - typedef ShaderObjectImpl Super; - - public: - virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() override { return 1; } - virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() override { return 1; } - - static Result create(IDevice* device, RootShaderObjectLayoutImpl* layout, RootShaderObjectImpl** outShaderObject) - { - RefPtr<RootShaderObjectImpl> object = new RootShaderObjectImpl(); - SLANG_RETURN_ON_FAIL(object->init(device, layout)); - - returnRefPtrMove(outShaderObject, object); - return SLANG_OK; - } - - RootShaderObjectLayoutImpl* getLayout() { return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr()); } - - GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (GfxCount)m_entryPoints.getCount(); } - SlangResult SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) SLANG_OVERRIDE - { - returnComPtr(outEntryPoint, m_entryPoints[index]); - return SLANG_OK; - } - - virtual Result collectSpecializationArgs(ExtendedShaderObjectTypeList& args) override - { - SLANG_RETURN_ON_FAIL(ShaderObjectImpl::collectSpecializationArgs(args)); - for (auto& entryPoint : m_entryPoints) - { - SLANG_RETURN_ON_FAIL(entryPoint->collectSpecializationArgs(args)); - } - return SLANG_OK; - } - - /// Bind this object as a root shader object - Result bindAsRoot( - BindingContext* context, - RootShaderObjectLayoutImpl* specializedLayout) - { - // When binding an entire root shader object, we need to deal with - // the way that specialization might have allocated space for "pending" - // parameter data after all the primary parameters. - // - // We start by initializing an offset that will store zeros for the - // primary data, an the computed offset from the specialized layout - // for pending data. - // - BindingOffset offset; - offset.pending = specializedLayout->getPendingDataOffset(); - - // Note: We could *almost* call `bindAsConstantBuffer()` here to bind - // the state of the root object itself, but there is an important - // detail that means we can't: - // - // The `_bindOrdinaryDataBufferIfNeeded` operation automatically - // increments the offset parameter if it binds a buffer, so that - // subsequently bindings will be adjusted. However, the reflection - // information computed for root shader parameters is absolute rather - // than relative to the default constant buffer (if any). - // - // TODO: Quite technically, the ordinary data buffer for the global - // scope is *not* guaranteed to be at offset zero, so this logic should - // really be querying an appropriate absolute offset from `specializedLayout`. - // - BindingOffset ordinaryDataBufferOffset = offset; - SLANG_RETURN_ON_FAIL(_bindOrdinaryDataBufferIfNeeded(context, /*inout*/ ordinaryDataBufferOffset, specializedLayout)); - SLANG_RETURN_ON_FAIL(bindAsValue(context, offset, specializedLayout)); - - // Once the state stored in the root shader object itself has been bound, - // we turn our attention to the entry points and their parameters. - // - auto entryPointCount = m_entryPoints.getCount(); - for (Index i = 0; i < entryPointCount; ++i) - { - auto entryPoint = m_entryPoints[i]; - auto const& entryPointInfo = specializedLayout->getEntryPoint(i); - - // Each entry point will be bound at some offset relative to where - // the root shader parameters start. - // - BindingOffset entryPointOffset = offset; - entryPointOffset += entryPointInfo.offset; - - // An entry point can simply be bound as a constant buffer, because - // the absolute offsets as are used for the global scope do not apply - // (because entry points don't need to deal with explicit bindings). - // - SLANG_RETURN_ON_FAIL(entryPoint->bindAsConstantBuffer(context, entryPointOffset, entryPointInfo.layout)); - } - - return SLANG_OK; - } - - - protected: - Result init(IDevice* device, RootShaderObjectLayoutImpl* layout) - { - SLANG_RETURN_ON_FAIL(Super::init(device, layout)); - - for (auto entryPointInfo : layout->getEntryPoints()) - { - RefPtr<ShaderObjectImpl> entryPoint; - SLANG_RETURN_ON_FAIL( - ShaderObjectImpl::create(device, entryPointInfo.layout, entryPoint.writeRef())); - m_entryPoints.add(entryPoint); - } - - return SLANG_OK; - } - - Result _createSpecializedLayout(ShaderObjectLayoutImpl** outLayout) SLANG_OVERRIDE - { - ExtendedShaderObjectTypeList specializationArgs; - SLANG_RETURN_ON_FAIL(collectSpecializationArgs(specializationArgs)); - - // Note: There is an important policy decision being made here that we need - // to approach carefully. - // - // We are doing two different things that affect the layout of a program: - // - // 1. We are *composing* one or more pieces of code (notably the shared global/module - // stuff and the per-entry-point stuff). - // - // 2. We are *specializing* code that includes generic/existential parameters - // to concrete types/values. - // - // We need to decide the relative *order* of these two steps, because of how it impacts - // layout. The layout for `specialize(compose(A,B), X, Y)` is potentially different - // form that of `compose(specialize(A,X), speciealize(B,Y))`, even when both are - // semantically equivalent programs. - // - // Right now we are using the first option: we are first generating a full composition - // of all the code we plan to use (global scope plus all entry points), and then - // specializing it to the concatenated specialization argumenst for all of that. - // - // In some cases, though, this model isn't appropriate. For example, when dealing with - // ray-tracing shaders and local root signatures, we really want the parameters of each - // entry point (actually, each entry-point *group*) to be allocated distinct storage, - // which really means we want to compute something like: - // - // SpecializedGlobals = specialize(compose(ModuleA, ModuleB, ...), X, Y, ...) - // - // SpecializedEP1 = compose(SpecializedGlobals, specialize(EntryPoint1, T, U, ...)) - // SpecializedEP2 = compose(SpecializedGlobals, specialize(EntryPoint2, A, B, ...)) - // - // Note how in this case all entry points agree on the layout for the shared/common - // parmaeters, but their layouts are also independent of one another. - // - // Furthermore, in this example, loading another entry point into the system would not - // rquire re-computing the layouts (or generated kernel code) for any of the entry points - // that had already been loaded (in contrast to a compose-then-specialize approach). - // - ComPtr<slang::IComponentType> specializedComponentType; - ComPtr<slang::IBlob> diagnosticBlob; - auto result = getLayout()->getSlangProgram()->specialize( - specializationArgs.components.getArrayView().getBuffer(), - specializationArgs.getCount(), - specializedComponentType.writeRef(), - diagnosticBlob.writeRef()); - - // TODO: print diagnostic message via debug output interface. - - if (result != SLANG_OK) - return result; - - auto slangSpecializedLayout = specializedComponentType->getLayout(); - RefPtr<RootShaderObjectLayoutImpl> specializedLayout; - RootShaderObjectLayoutImpl::create(getRenderer(), specializedComponentType, slangSpecializedLayout, specializedLayout.writeRef()); - - // Note: Computing the layout for the specialized program will have also computed - // the layouts for the entry points, and we really need to attach that information - // to them so that they don't go and try to compute their own specializations. - // - // TODO: Well, if we move to the specialization model described above then maybe - // we *will* want entry points to do their own specialization work... - // - auto entryPointCount = m_entryPoints.getCount(); - for (Index i = 0; i < entryPointCount; ++i) - { - auto entryPointInfo = specializedLayout->getEntryPoint(i); - auto entryPointVars = m_entryPoints[i]; - - entryPointVars->m_specializedLayout = entryPointInfo.layout; - } - - returnRefPtrMove(outLayout, specializedLayout); - return SLANG_OK; - } - - - List<RefPtr<ShaderObjectImpl>> m_entryPoints; - }; - - void _flushGraphicsState(); - - // D3D11Device members. - - DeviceInfo m_info; - String m_adapterName; - - ComPtr<IDXGISwapChain> m_swapChain; - ComPtr<ID3D11Device> m_device; - ComPtr<ID3D11DeviceContext> m_immediateContext; - ComPtr<ID3D11Texture2D> m_backBufferTexture; - ComPtr<IDXGIFactory> m_dxgiFactory; - RefPtr<FramebufferImpl> m_currentFramebuffer; - - RefPtr<PipelineStateImpl> m_currentPipelineState; - - ComPtr<ID3D11Query> m_disjointQuery; - - uint32_t m_stencilRef = 0; - bool m_depthStencilStateDirty = true; - - Desc m_desc; - - float m_clearColor[4] = { 0, 0, 0, 0 }; - - bool m_nvapi = false; -}; - -SlangResult SLANG_MCALL createD3D11Device(const IDevice::Desc* desc, IDevice** outDevice) -{ - RefPtr<D3D11Device> result = new D3D11Device(); - SLANG_RETURN_ON_FAIL(result->initialize(*desc)); - returnComPtr(outDevice, result); - return SLANG_OK; -} - -static void initSrvDesc(IResource::Type resourceType, const ITextureResource::Desc& textureDesc, DXGI_FORMAT pixelFormat, D3D11_SHADER_RESOURCE_VIEW_DESC& descOut) -{ - // create SRV - descOut = D3D11_SHADER_RESOURCE_VIEW_DESC(); - - descOut.Format = (pixelFormat == DXGI_FORMAT_UNKNOWN) ? D3DUtil::calcFormat(D3DUtil::USAGE_SRV, D3DUtil::getMapFormat(textureDesc.format)) : pixelFormat; - const int arraySize = calcEffectiveArraySize(textureDesc); - if (arraySize <= 1) - { - switch (textureDesc.type) - { - case IResource::Type::Texture1D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D; break; - case IResource::Type::Texture2D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; break; - case IResource::Type::Texture3D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break; - default: assert(!"Unknown dimension"); - } - - descOut.Texture2D.MipLevels = textureDesc.numMipLevels; - descOut.Texture2D.MostDetailedMip = 0; - } - else if (resourceType == IResource::Type::TextureCube) - { - if (textureDesc.arraySize > 1) - { - descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; - - descOut.TextureCubeArray.NumCubes = textureDesc.arraySize; - descOut.TextureCubeArray.First2DArrayFace = 0; - descOut.TextureCubeArray.MipLevels = textureDesc.numMipLevels; - descOut.TextureCubeArray.MostDetailedMip = 0; - } - else - { - descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; - - descOut.TextureCube.MipLevels = textureDesc.numMipLevels; - descOut.TextureCube.MostDetailedMip = 0; - } - } - else - { - assert(textureDesc.size.depth > 1 || arraySize > 1); - - switch (textureDesc.type) - { - case IResource::Type::Texture1D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY; break; - case IResource::Type::Texture2D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; break; - case IResource::Type::Texture3D: descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; break; - - default: assert(!"Unknown dimension"); - } - - descOut.Texture2DArray.ArraySize = max(textureDesc.size.depth, arraySize); - descOut.Texture2DArray.MostDetailedMip = 0; - descOut.Texture2DArray.MipLevels = textureDesc.numMipLevels; - descOut.Texture2DArray.FirstArraySlice = 0; - } -} - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!ScopeNVAPI !!!!!!!!!!!!!!!!!!!!!!!!!!!!! - -SlangResult D3D11Device::ScopeNVAPI::init(D3D11Device* device, Index regIndex) -{ - if (!device->m_nvapi) - { - // There is nothing to set as nvapi is not set - return SLANG_OK; - } - -#ifdef GFX_NVAPI - NvAPI_Status nvapiStatus = NvAPI_D3D11_SetNvShaderExtnSlot(renderer->m_device, NvU32(regIndex)); - if (nvapiStatus != NVAPI_OK) - { - return SLANG_FAIL; - } -#endif - - // Record the renderer so it can be freed - m_renderer = device; - return SLANG_OK; -} - -D3D11Device::ScopeNVAPI::~ScopeNVAPI() -{ - // If the m_renderer is not set, it must not have been set up - if (m_renderer) - { -#ifdef GFX_NVAPI - // Disable the slot used - NvAPI_Status nvapiStatus = NvAPI_D3D11_SetNvShaderExtnSlot(m_renderer->m_device, ~0); - SLANG_ASSERT(nvapiStatus == NVAPI_OK); -#endif - } -} - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!D3D11Device !!!!!!!!!!!!!!!!!!!!!!!!!!!!! - -// !!!!!!!!!!!!!!!!!!!!!!!!!!!! Renderer interface !!!!!!!!!!!!!!!!!!!!!!!!!! - -static bool isSupportedNVAPIOp(IUnknown* dev, uint32_t op) -{ -#ifdef GFX_NVAPI - { - bool isSupported; - NvAPI_Status status = NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(dev, NvU32(op), &isSupported); - return status == NVAPI_OK && isSupported; - } -#else - return false; -#endif -} - -SlangResult D3D11Device::initialize(const Desc& desc) -{ - SLANG_RETURN_ON_FAIL(slangContext.initialize( - desc.slang, - SLANG_DXBC, - "sm_5_0", - makeArray(slang::PreprocessorMacroDesc{ "__D3D11__", "1" }).getView())); - - SLANG_RETURN_ON_FAIL(RendererBase::initialize(desc)); - - // Initialize DeviceInfo - { - m_info.deviceType = DeviceType::DirectX11; - m_info.bindingStyle = BindingStyle::DirectX; - m_info.projectionStyle = ProjectionStyle::DirectX; - m_info.apiName = "Direct3D 11"; - static const float kIdentity[] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}; - ::memcpy(m_info.identityProjectionMatrix, kIdentity, sizeof(kIdentity)); - } - - m_desc = desc; - - // Rather than statically link against D3D, we load it dynamically. - HMODULE d3dModule = LoadLibraryA("d3d11.dll"); - if (!d3dModule) - { - fprintf(stderr, "error: failed load 'd3d11.dll'\n"); - return SLANG_FAIL; - } - - PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN D3D11CreateDeviceAndSwapChain_ = - (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)GetProcAddress(d3dModule, "D3D11CreateDeviceAndSwapChain"); - if (!D3D11CreateDeviceAndSwapChain_) - { - fprintf(stderr, - "error: failed load symbol 'D3D11CreateDeviceAndSwapChain'\n"); - return SLANG_FAIL; - } - - PFN_D3D11_CREATE_DEVICE D3D11CreateDevice_ = - (PFN_D3D11_CREATE_DEVICE)GetProcAddress(d3dModule, "D3D11CreateDevice"); - if (!D3D11CreateDevice_) - { - fprintf(stderr, - "error: failed load symbol 'D3D11CreateDevice'\n"); - return SLANG_FAIL; - } - - // We will ask for the highest feature level that can be supported. - const D3D_FEATURE_LEVEL featureLevels[] = { - D3D_FEATURE_LEVEL_11_1, - D3D_FEATURE_LEVEL_11_0, - D3D_FEATURE_LEVEL_10_1, - D3D_FEATURE_LEVEL_10_0, - D3D_FEATURE_LEVEL_9_3, - D3D_FEATURE_LEVEL_9_2, - D3D_FEATURE_LEVEL_9_1, - }; - D3D_FEATURE_LEVEL featureLevel = D3D_FEATURE_LEVEL_9_1; - const int totalNumFeatureLevels = SLANG_COUNT_OF(featureLevels); - - { - // On a machine that does not have an up-to-date version of D3D installed, - // the `D3D11CreateDeviceAndSwapChain` call will fail with `E_INVALIDARG` - // if you ask for feature level 11_1 (DeviceCheckFlag::UseFullFeatureLevel). - // The workaround is to call `D3D11CreateDeviceAndSwapChain` the first time - // with 11_1 and then back off to 11_0 if that fails. - - FlagCombiner combiner; - // TODO: we should probably provide a command-line option - // to override UseDebug of default rather than leave it - // up to each back-end to specify. - -#if _DEBUG - combiner.add(DeviceCheckFlag::UseDebug, ChangeType::OnOff); ///< First try debug then non debug -#else - combiner.add(DeviceCheckFlag::UseDebug, ChangeType::Off); ///< Don't bother with debug -#endif - combiner.add(DeviceCheckFlag::UseHardwareDevice, ChangeType::OnOff); ///< First try hardware, then reference - combiner.add(DeviceCheckFlag::UseFullFeatureLevel, ChangeType::OnOff); ///< First try fully featured, then degrade features - - - const int numCombinations = combiner.getNumCombinations(); - Result res = SLANG_FAIL; - for (int i = 0; i < numCombinations; ++i) - { - const auto deviceCheckFlags = combiner.getCombination(i); - D3DUtil::createFactory(deviceCheckFlags, m_dxgiFactory); - - // If we have an adapter set on the desc, look it up. We only need to do so for hardware - ComPtr<IDXGIAdapter> adapter; - if (desc.adapter && (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice)) - { - List<ComPtr<IDXGIAdapter>> dxgiAdapters; - D3DUtil::findAdapters(deviceCheckFlags, Slang::UnownedStringSlice(desc.adapter), dxgiAdapters); - if (dxgiAdapters.getCount() == 0) - { - continue; - } - adapter = dxgiAdapters[0]; - } - - // The adapter can be nullptr - that just means 'default', but when so we need to select the driver type - D3D_DRIVER_TYPE driverType = D3D_DRIVER_TYPE_UNKNOWN; - if (adapter == nullptr) - { - // If we don't have an adapter, select directly - driverType = (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice) ? D3D_DRIVER_TYPE_HARDWARE : D3D_DRIVER_TYPE_REFERENCE; - } - - const int startFeatureIndex = (deviceCheckFlags & DeviceCheckFlag::UseFullFeatureLevel) ? 0 : 1; - const UINT deviceFlags = (deviceCheckFlags & DeviceCheckFlag::UseDebug) ? D3D11_CREATE_DEVICE_DEBUG : 0; - - res = D3D11CreateDevice_( - adapter, - driverType, - nullptr, - deviceFlags, - &featureLevels[startFeatureIndex], - totalNumFeatureLevels - startFeatureIndex, - D3D11_SDK_VERSION, - m_device.writeRef(), - &featureLevel, - m_immediateContext.writeRef()); - // Check if successfully constructed - if so we are done. - if (SLANG_SUCCEEDED(res)) - { - break; - } - } - // If res is failure, means all styles have have failed, and so initialization fails. - if (SLANG_FAILED(res)) - { - return res; - } - // Check we have a swap chain, context and device - SLANG_ASSERT(m_immediateContext && m_device); - - ComPtr<IDXGIDevice> dxgiDevice; - if (m_device->QueryInterface(dxgiDevice.writeRef()) == 0) - { - ComPtr<IDXGIAdapter> dxgiAdapter; - dxgiDevice->GetAdapter(dxgiAdapter.writeRef()); - DXGI_ADAPTER_DESC adapterDesc; - dxgiAdapter->GetDesc(&adapterDesc); - m_adapterName = String::fromWString(adapterDesc.Description); - m_info.adapterName = m_adapterName.begin(); - } - } - - // NVAPI - if (desc.nvapiExtnSlot >= 0) - { - if (SLANG_FAILED(NVAPIUtil::initialize())) - { - return SLANG_E_NOT_AVAILABLE; - } - -#ifdef GFX_NVAPI - if (NvAPI_D3D11_SetNvShaderExtnSlot(m_device, NvU32(desc.nvapiExtnSlot)) != NVAPI_OK) - { - return SLANG_E_NOT_AVAILABLE; - } - - if (isSupportedNVAPIOp(m_device, NV_EXTN_OP_UINT64_ATOMIC )) - { - m_features.add("atomic-int64"); - } - if (isSupportedNVAPIOp(m_device, NV_EXTN_OP_FP32_ATOMIC)) - { - m_features.add("atomic-float"); - } - - m_nvapi = true; -#endif - } - - { - // Create a TIMESTAMP_DISJOINT query object to query/update frequency info. - D3D11_QUERY_DESC disjointQueryDesc = {}; - disjointQueryDesc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT; - SLANG_RETURN_ON_FAIL(m_device->CreateQuery( - &disjointQueryDesc, m_disjointQuery.writeRef())); - m_immediateContext->Begin(m_disjointQuery); - m_immediateContext->End(m_disjointQuery); - D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData = {}; - m_immediateContext->GetData(m_disjointQuery, &disjointData, sizeof(disjointData), 0); - m_info.timestampFrequency = disjointData.Frequency; - } - return SLANG_OK; -} - -void D3D11Device::clearFrame(uint32_t colorBufferMask, bool clearDepth, bool clearStencil) -{ - uint32_t mask = 1; - for (auto rtv : m_currentFramebuffer->renderTargetViews) - { - if (colorBufferMask & mask) - m_immediateContext->ClearRenderTargetView(rtv->m_rtv, rtv->m_clearValue); - mask <<= 1; - } - - if (m_currentFramebuffer->depthStencilView) - { - UINT clearFlags = 0; - if (clearDepth) - clearFlags = D3D11_CLEAR_DEPTH; - if (clearStencil) - clearFlags |= D3D11_CLEAR_STENCIL; - if (clearFlags) - { - m_immediateContext->ClearDepthStencilView( - m_currentFramebuffer->depthStencilView->m_dsv, - clearFlags, - m_currentFramebuffer->depthStencilView->m_clearValue.depth, - m_currentFramebuffer->depthStencilView->m_clearValue.stencil); - } - } -} - -Result D3D11Device::createSwapchain( - const ISwapchain::Desc& desc, WindowHandle window, ISwapchain** outSwapchain) -{ - RefPtr<SwapchainImpl> swapchain = new SwapchainImpl(); - SLANG_RETURN_ON_FAIL(swapchain->init(this, desc, window)); - returnComPtr(outSwapchain, swapchain); - return SLANG_OK; -} - -Result D3D11Device::createFramebufferLayout( - const IFramebufferLayout::Desc& desc, IFramebufferLayout** outLayout) -{ - RefPtr<FramebufferLayoutImpl> layout = new FramebufferLayoutImpl(); - layout->m_renderTargets.setCount(desc.renderTargetCount); - for (GfxIndex i = 0; i < desc.renderTargetCount; i++) - { - layout->m_renderTargets[i] = desc.renderTargets[i]; - } - - if (desc.depthStencil) - { - layout->m_hasDepthStencil = true; - layout->m_depthStencil = *desc.depthStencil; - } - else - { - layout->m_hasDepthStencil = false; - } - returnComPtr(outLayout, layout); - return SLANG_OK; -} - -Result D3D11Device::createFramebuffer( - const IFramebuffer::Desc& desc, IFramebuffer** outFramebuffer) -{ - RefPtr<FramebufferImpl> framebuffer = new FramebufferImpl(); - framebuffer->renderTargetViews.setCount(desc.renderTargetCount); - framebuffer->d3dRenderTargetViews.setCount(desc.renderTargetCount); - for (GfxIndex i = 0; i < desc.renderTargetCount; i++) - { - framebuffer->renderTargetViews[i] = static_cast<RenderTargetViewImpl*>(desc.renderTargetViews[i]); - framebuffer->d3dRenderTargetViews[i] = framebuffer->renderTargetViews[i]->m_rtv; - } - framebuffer->depthStencilView = static_cast<DepthStencilViewImpl*>(desc.depthStencilView); - framebuffer->d3dDepthStencilView = framebuffer->depthStencilView ? framebuffer->depthStencilView->m_dsv : nullptr; - returnComPtr(outFramebuffer, framebuffer); - return SLANG_OK; -} - -void D3D11Device::setFramebuffer(IFramebuffer* frameBuffer) -{ - // Note: the framebuffer state will be flushed to the pipeline as part - // of binding the root shader object. - // - // TODO: alternatively we could call `OMSetRenderTargets` here and then - // call `OMSetRenderTargetsAndUnorderedAccessViews` later with the option - // that preserves the existing RTV/DSV bindings. - // - m_currentFramebuffer = static_cast<FramebufferImpl*>(frameBuffer); -} - -void D3D11Device::setStencilReference(uint32_t referenceValue) -{ - m_stencilRef = referenceValue; - m_depthStencilStateDirty = true; -} - -SlangResult D3D11Device::readTextureResource( - ITextureResource* resource, - ResourceState state, - ISlangBlob** outBlob, - size_t* outRowPitch, - size_t* outPixelSize) -{ - SLANG_UNUSED(state); - - auto texture = static_cast<TextureResourceImpl*>(resource); - // Don't bother supporting MSAA for right now - if (texture->getDesc()->sampleDesc.numSamples > 1) - { - fprintf(stderr, "ERROR: cannot capture multi-sample texture\n"); - return E_INVALIDARG; - } - - FormatInfo sizeInfo; - gfxGetFormatInfo(texture->getDesc()->format, &sizeInfo); - size_t bytesPerPixel = sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock; - size_t rowPitch = int(texture->getDesc()->size.width) * bytesPerPixel; - size_t bufferSize = rowPitch * int(texture->getDesc()->size.height); - if (outRowPitch) - *outRowPitch = rowPitch; - if (outPixelSize) - *outPixelSize = bytesPerPixel; - - D3D11_TEXTURE2D_DESC textureDesc; - auto d3d11Texture = ((ID3D11Texture2D*)texture->m_resource.get()); - d3d11Texture->GetDesc(&textureDesc); - - HRESULT hr = S_OK; - ComPtr<ID3D11Texture2D> stagingTexture; - - if (textureDesc.Usage == D3D11_USAGE_STAGING && - (textureDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ)) - { - stagingTexture = d3d11Texture; - } - else - { - // Modify the descriptor to give us a staging texture - textureDesc.BindFlags = 0; - textureDesc.MiscFlags &= ~D3D11_RESOURCE_MISC_TEXTURECUBE; - textureDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; - textureDesc.Usage = D3D11_USAGE_STAGING; - - hr = m_device->CreateTexture2D(&textureDesc, 0, stagingTexture.writeRef()); - if (FAILED(hr)) - { - fprintf(stderr, "ERROR: failed to create staging texture\n"); - return hr; - } - - m_immediateContext->CopyResource(stagingTexture, d3d11Texture); - } - - // Now just read back texels from the staging textures - { - D3D11_MAPPED_SUBRESOURCE mappedResource; - SLANG_RETURN_ON_FAIL(m_immediateContext->Map(stagingTexture, 0, D3D11_MAP_READ, 0, &mappedResource)); - RefPtr<ListBlob> blob = new ListBlob(); - blob->m_data.setCount(bufferSize); - char* buffer = (char*)blob->m_data.begin(); - for (size_t y = 0; y < textureDesc.Height; y++) - { - memcpy( - (char*)buffer + y * (*outRowPitch), - (char*)mappedResource.pData + y * mappedResource.RowPitch, - *outRowPitch); - } - // Make sure to unmap - m_immediateContext->Unmap(stagingTexture, 0); - returnComPtr(outBlob, blob); - return SLANG_OK; - } -} - -static D3D11_BIND_FLAG calcResourceFlag(ResourceState state) -{ - switch (state) - { - case ResourceState::VertexBuffer: - return D3D11_BIND_VERTEX_BUFFER; - case ResourceState::IndexBuffer: - return D3D11_BIND_INDEX_BUFFER; - case ResourceState::ConstantBuffer: - return D3D11_BIND_CONSTANT_BUFFER; - case ResourceState::StreamOutput: - return D3D11_BIND_STREAM_OUTPUT; - case ResourceState::RenderTarget: - return D3D11_BIND_RENDER_TARGET; - case ResourceState::DepthRead: - case ResourceState::DepthWrite: - return D3D11_BIND_DEPTH_STENCIL; - case ResourceState::UnorderedAccess: - return D3D11_BIND_UNORDERED_ACCESS; - case ResourceState::ShaderResource: - return D3D11_BIND_SHADER_RESOURCE; - default: - return D3D11_BIND_FLAG(0); - } -} - -static int _calcResourceBindFlags(ResourceStateSet allowedStates) -{ - int dstFlags = 0; - for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++) - { - auto state = (ResourceState)i; - if (allowedStates.contains(state)) - dstFlags |= calcResourceFlag(state); - } - return dstFlags; -} - -static int _calcResourceAccessFlags(MemoryType memType) -{ - switch (memType) - { - case MemoryType::DeviceLocal: - return 0; - case MemoryType::ReadBack: - return D3D11_CPU_ACCESS_READ; - case MemoryType::Upload: - return D3D11_CPU_ACCESS_WRITE; - default: - assert(!"Invalid flags"); - return 0; - } -} - -Result D3D11Device::createTextureResource(const ITextureResource::Desc& descIn, const ITextureResource::SubresourceData* initData, ITextureResource** outResource) -{ - TextureResource::Desc srcDesc = fixupTextureDesc(descIn); - - const int effectiveArraySize = calcEffectiveArraySize(srcDesc); - - const DXGI_FORMAT format = D3DUtil::getMapFormat(srcDesc.format); - if (format == DXGI_FORMAT_UNKNOWN) - { - return SLANG_FAIL; - } - - const int bindFlags = _calcResourceBindFlags(srcDesc.allowedStates); - - // Set up the initialize data - List<D3D11_SUBRESOURCE_DATA> subRes; - D3D11_SUBRESOURCE_DATA* subResourcesPtr = nullptr; - if(initData) - { - subRes.setCount(srcDesc.numMipLevels * effectiveArraySize); - { - int subResourceIndex = 0; - for (int i = 0; i < effectiveArraySize; i++) - { - for (int j = 0; j < srcDesc.numMipLevels; j++) - { - const int mipHeight = calcMipSize(srcDesc.size.height, j); - - D3D11_SUBRESOURCE_DATA& data = subRes[subResourceIndex]; - auto& srcData = initData[subResourceIndex]; - - data.pSysMem = srcData.data; - data.SysMemPitch = UINT(srcData.strideY); - data.SysMemSlicePitch = UINT(srcData.strideZ); - - subResourceIndex++; - } - } - } - subResourcesPtr = subRes.getBuffer(); - } - - const int accessFlags = _calcResourceAccessFlags(srcDesc.memoryType); - - RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc)); - - switch (srcDesc.type) - { - case IResource::Type::Texture1D: - { - D3D11_TEXTURE1D_DESC desc = { 0 }; - desc.BindFlags = bindFlags; - desc.CPUAccessFlags = accessFlags; - desc.Format = format; - desc.MiscFlags = 0; - desc.MipLevels = srcDesc.numMipLevels; - desc.ArraySize = effectiveArraySize; - desc.Width = srcDesc.size.width; - desc.Usage = D3D11_USAGE_DEFAULT; - - ComPtr<ID3D11Texture1D> texture1D; - SLANG_RETURN_ON_FAIL(m_device->CreateTexture1D(&desc, subResourcesPtr, texture1D.writeRef())); - - texture->m_resource = texture1D; - break; - } - case IResource::Type::TextureCube: - case IResource::Type::Texture2D: - { - D3D11_TEXTURE2D_DESC desc = { 0 }; - desc.BindFlags = bindFlags; - desc.CPUAccessFlags = accessFlags; - desc.Format = format; - desc.MiscFlags = 0; - desc.MipLevels = srcDesc.numMipLevels; - desc.ArraySize = effectiveArraySize; - - desc.Width = srcDesc.size.width; - desc.Height = srcDesc.size.height; - desc.Usage = D3D11_USAGE_DEFAULT; - desc.SampleDesc.Count = srcDesc.sampleDesc.numSamples; - desc.SampleDesc.Quality = srcDesc.sampleDesc.quality; - - if (srcDesc.type == IResource::Type::TextureCube) - { - desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE; - } - - ComPtr<ID3D11Texture2D> texture2D; - SLANG_RETURN_ON_FAIL(m_device->CreateTexture2D(&desc, subResourcesPtr, texture2D.writeRef())); - - texture->m_resource = texture2D; - break; - } - case IResource::Type::Texture3D: - { - D3D11_TEXTURE3D_DESC desc = { 0 }; - desc.BindFlags = bindFlags; - desc.CPUAccessFlags = accessFlags; - desc.Format = format; - desc.MiscFlags = 0; - desc.MipLevels = srcDesc.numMipLevels; - desc.Width = srcDesc.size.width; - desc.Height = srcDesc.size.height; - desc.Depth = srcDesc.size.depth; - desc.Usage = D3D11_USAGE_DEFAULT; - - ComPtr<ID3D11Texture3D> texture3D; - SLANG_RETURN_ON_FAIL(m_device->CreateTexture3D(&desc, subResourcesPtr, texture3D.writeRef())); - - texture->m_resource = texture3D; - break; - } - default: - return SLANG_FAIL; - } - - returnComPtr(outResource, texture); - return SLANG_OK; -} - -Result D3D11Device::createBufferResource(const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) -{ - IBufferResource::Desc srcDesc = fixupBufferDesc(descIn); - - auto d3dBindFlags = _calcResourceBindFlags(srcDesc.allowedStates); - - size_t alignedSizeInBytes = srcDesc.sizeInBytes; - - if(d3dBindFlags & D3D11_BIND_CONSTANT_BUFFER) - { - // Make aligned to 256 bytes... not sure why, but if you remove this the tests do fail. - alignedSizeInBytes = D3DUtil::calcAligned(alignedSizeInBytes, 256); - } - - // Hack to make the initialization never read from out of bounds memory, by copying into a buffer - List<uint8_t> initDataBuffer; - if (initData && alignedSizeInBytes > srcDesc.sizeInBytes) - { - initDataBuffer.setCount(alignedSizeInBytes); - ::memcpy(initDataBuffer.getBuffer(), initData, srcDesc.sizeInBytes); - initData = initDataBuffer.getBuffer(); - } - - D3D11_BUFFER_DESC bufferDesc = { 0 }; - bufferDesc.ByteWidth = UINT(alignedSizeInBytes); - bufferDesc.BindFlags = d3dBindFlags; - // For read we'll need to do some staging - bufferDesc.CPUAccessFlags = _calcResourceAccessFlags(descIn.memoryType); - bufferDesc.Usage = D3D11_USAGE_DEFAULT; - - // If written by CPU, make it dynamic - if (descIn.memoryType == MemoryType::Upload && - !descIn.allowedStates.contains(ResourceState::UnorderedAccess)) - { - bufferDesc.Usage = D3D11_USAGE_DYNAMIC; - } - - if (srcDesc.memoryType == MemoryType::ReadBack) - { - bufferDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_READ; - bufferDesc.Usage = D3D11_USAGE_STAGING; - } - - switch (descIn.defaultState) - { - case ResourceState::ConstantBuffer: - { - // We'll just assume ConstantBuffers are dynamic for now - bufferDesc.Usage = D3D11_USAGE_DYNAMIC; - break; - } - default: break; - } - - if (bufferDesc.BindFlags & (D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE)) - { - //desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE; - if (srcDesc.elementSize != 0) - { - bufferDesc.StructureByteStride = (UINT)srcDesc.elementSize; - bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; - } - else - { - bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - } - } - - if (srcDesc.memoryType == MemoryType::Upload) - { - bufferDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE; - } - - D3D11_SUBRESOURCE_DATA subResourceData = { 0 }; - subResourceData.pSysMem = initData; - - RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(srcDesc)); - - SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufferDesc, initData ? &subResourceData : nullptr, buffer->m_buffer.writeRef())); - buffer->m_d3dUsage = bufferDesc.Usage; - - if (srcDesc.memoryType == MemoryType::ReadBack || bufferDesc.Usage != D3D11_USAGE_DYNAMIC) - { - D3D11_BUFFER_DESC bufDesc = {}; - bufDesc.BindFlags = 0; - bufDesc.ByteWidth = (UINT)alignedSizeInBytes; - bufDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; - bufDesc.Usage = D3D11_USAGE_STAGING; - - SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufDesc, nullptr, buffer->m_staging.writeRef())); - } - returnComPtr(outResource, buffer); - return SLANG_OK; -} - -D3D11_FILTER_TYPE translateFilterMode(TextureFilteringMode mode) -{ - switch (mode) - { - default: - return D3D11_FILTER_TYPE(0); - -#define CASE(SRC, DST) \ - case TextureFilteringMode::SRC: return D3D11_FILTER_TYPE_##DST - - CASE(Point, POINT); - CASE(Linear, LINEAR); - -#undef CASE - } -} - -D3D11_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op) -{ - switch (op) - { - default: - return D3D11_FILTER_REDUCTION_TYPE(0); - -#define CASE(SRC, DST) \ - case TextureReductionOp::SRC: return D3D11_FILTER_REDUCTION_TYPE_##DST - - CASE(Average, STANDARD); - CASE(Comparison, COMPARISON); - CASE(Minimum, MINIMUM); - CASE(Maximum, MAXIMUM); - -#undef CASE - } -} - -D3D11_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode) -{ - switch (mode) - { - default: - return D3D11_TEXTURE_ADDRESS_MODE(0); - -#define CASE(SRC, DST) \ - case TextureAddressingMode::SRC: return D3D11_TEXTURE_ADDRESS_##DST - - CASE(Wrap, WRAP); - CASE(ClampToEdge, CLAMP); - CASE(ClampToBorder, BORDER); - CASE(MirrorRepeat, MIRROR); - CASE(MirrorOnce, MIRROR_ONCE); - -#undef CASE - } -} - -static D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func) -{ - switch (func) - { - default: - // TODO: need to report failures - return D3D11_COMPARISON_ALWAYS; - -#define CASE(FROM, TO) \ - case ComparisonFunc::FROM: return D3D11_COMPARISON_##TO - - CASE(Never, NEVER); - CASE(Less, LESS); - CASE(Equal, EQUAL); - CASE(LessEqual, LESS_EQUAL); - CASE(Greater, GREATER); - CASE(NotEqual, NOT_EQUAL); - CASE(GreaterEqual, GREATER_EQUAL); - CASE(Always, ALWAYS); -#undef CASE - } -} - -Result D3D11Device::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) -{ - D3D11_FILTER_REDUCTION_TYPE dxReduction = translateFilterReduction(desc.reductionOp); - D3D11_FILTER dxFilter; - if (desc.maxAnisotropy > 1) - { - dxFilter = D3D11_ENCODE_ANISOTROPIC_FILTER(dxReduction); - } - else - { - D3D11_FILTER_TYPE dxMin = translateFilterMode(desc.minFilter); - D3D11_FILTER_TYPE dxMag = translateFilterMode(desc.magFilter); - D3D11_FILTER_TYPE dxMip = translateFilterMode(desc.mipFilter); - - dxFilter = D3D11_ENCODE_BASIC_FILTER(dxMin, dxMag, dxMip, dxReduction); - } - - D3D11_SAMPLER_DESC dxDesc = {}; - dxDesc.Filter = dxFilter; - dxDesc.AddressU = translateAddressingMode(desc.addressU); - dxDesc.AddressV = translateAddressingMode(desc.addressV); - dxDesc.AddressW = translateAddressingMode(desc.addressW); - dxDesc.MipLODBias = desc.mipLODBias; - dxDesc.MaxAnisotropy = desc.maxAnisotropy; - dxDesc.ComparisonFunc = translateComparisonFunc(desc.comparisonFunc); - for (int ii = 0; ii < 4; ++ii) - dxDesc.BorderColor[ii] = desc.borderColor[ii]; - dxDesc.MinLOD = desc.minLOD; - dxDesc.MaxLOD = desc.maxLOD; - - ComPtr<ID3D11SamplerState> sampler; - SLANG_RETURN_ON_FAIL(m_device->CreateSamplerState( - &dxDesc, - sampler.writeRef())); - - RefPtr<SamplerStateImpl> samplerImpl = new SamplerStateImpl(); - samplerImpl->m_sampler = sampler; - returnComPtr(outSampler, samplerImpl); - return SLANG_OK; -} - -Result D3D11Device::createTextureView(ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) -{ - auto resourceImpl = (TextureResourceImpl*) texture; - - switch (desc.type) - { - default: - return SLANG_FAIL; - - case IResourceView::Type::RenderTarget: - { - ComPtr<ID3D11RenderTargetView> rtv; - SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(resourceImpl->m_resource, nullptr, rtv.writeRef())); - - RefPtr<RenderTargetViewImpl> viewImpl = new RenderTargetViewImpl(); - viewImpl->m_type = ResourceViewImpl::Type::RTV; - viewImpl->m_rtv = rtv; - viewImpl->m_desc = desc; - - memcpy( - viewImpl->m_clearValue, - &resourceImpl->getDesc()->optimalClearValue.color, - sizeof(float) * 4); - returnComPtr(outView, viewImpl); - return SLANG_OK; - } - break; - - case IResourceView::Type::DepthStencil: - { - ComPtr<ID3D11DepthStencilView> dsv; - SLANG_RETURN_ON_FAIL(m_device->CreateDepthStencilView(resourceImpl->m_resource, nullptr, dsv.writeRef())); - - RefPtr<DepthStencilViewImpl> viewImpl = new DepthStencilViewImpl(); - viewImpl->m_type = ResourceViewImpl::Type::DSV; - viewImpl->m_dsv = dsv; - viewImpl->m_clearValue = resourceImpl->getDesc()->optimalClearValue.depthStencil; - viewImpl->m_desc = desc; - - returnComPtr(outView, viewImpl); - return SLANG_OK; - } - break; - - case IResourceView::Type::UnorderedAccess: - { - ComPtr<ID3D11UnorderedAccessView> uav; - SLANG_RETURN_ON_FAIL(m_device->CreateUnorderedAccessView(resourceImpl->m_resource, nullptr, uav.writeRef())); - - RefPtr<UnorderedAccessViewImpl> viewImpl = new UnorderedAccessViewImpl(); - viewImpl->m_type = ResourceViewImpl::Type::UAV; - viewImpl->m_uav = uav; - viewImpl->m_desc = desc; - - returnComPtr(outView, viewImpl); - return SLANG_OK; - } - break; - - case IResourceView::Type::ShaderResource: - { - D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; - initSrvDesc(resourceImpl->getType(), *resourceImpl->getDesc(), D3DUtil::getMapFormat(desc.format), srvDesc); - - ComPtr<ID3D11ShaderResourceView> srv; - SLANG_RETURN_ON_FAIL(m_device->CreateShaderResourceView(resourceImpl->m_resource, &srvDesc, srv.writeRef())); - - RefPtr<ShaderResourceViewImpl> viewImpl = new ShaderResourceViewImpl(); - viewImpl->m_type = ResourceViewImpl::Type::SRV; - viewImpl->m_srv = srv; - viewImpl->m_desc = desc; - - returnComPtr(outView, viewImpl); - return SLANG_OK; - } - break; - } -} - -Result D3D11Device::createBufferView( - IBufferResource* buffer, - IBufferResource* counterBuffer, - IResourceView::Desc const& desc, - IResourceView** outView) -{ - auto resourceImpl = (BufferResourceImpl*) buffer; - auto resourceDesc = *resourceImpl->getDesc(); - - switch (desc.type) - { - default: - return SLANG_FAIL; - - case IResourceView::Type::UnorderedAccess: - { - D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc = {}; - uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; - uavDesc.Format = D3DUtil::getMapFormat(desc.format); - uavDesc.Buffer.FirstElement = 0; - - if(resourceDesc.elementSize) - { - uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize); - } - else if(desc.format == Format::Unknown) - { - uavDesc.Buffer.Flags |= D3D11_BUFFER_UAV_FLAG_RAW; - uavDesc.Format = DXGI_FORMAT_R32_TYPELESS; - uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / 4); - } - else - { - FormatInfo sizeInfo; - gfxGetFormatInfo(desc.format, &sizeInfo); - uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / (sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock)); - } - - ComPtr<ID3D11UnorderedAccessView> uav; - SLANG_RETURN_ON_FAIL(m_device->CreateUnorderedAccessView(resourceImpl->m_buffer, &uavDesc, uav.writeRef())); - - RefPtr<UnorderedAccessViewImpl> viewImpl = new UnorderedAccessViewImpl(); - viewImpl->m_type = ResourceViewImpl::Type::UAV; - viewImpl->m_uav = uav; - viewImpl->m_desc = desc; - - returnComPtr(outView, viewImpl); - return SLANG_OK; - } - break; - - case IResourceView::Type::ShaderResource: - { - D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; - srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; - srvDesc.Format = D3DUtil::getMapFormat(desc.format); - srvDesc.Buffer.FirstElement = 0; - - if(resourceDesc.elementSize) - { - srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / resourceDesc.elementSize); - } - else if(desc.format == Format::Unknown) - { - // We need to switch to a different member of the `union`, - // so that we can set the `BufferEx.Flags` member. - // - srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX; - - // Because we've switched, we need to re-set the `FirstElement` - // field to be valid, since we can't count on all compilers - // to respect that `Buffer.FirstElement` and `BufferEx.FirstElement` - // alias in memory. - // - srvDesc.BufferEx.FirstElement = 0; - - srvDesc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW; - srvDesc.Format = DXGI_FORMAT_R32_TYPELESS; - srvDesc.BufferEx.NumElements = UINT(resourceDesc.sizeInBytes / 4); - } - else - { - FormatInfo sizeInfo; - gfxGetFormatInfo(desc.format, &sizeInfo); - srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / (sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock)); - } - - ComPtr<ID3D11ShaderResourceView> srv; - SLANG_RETURN_ON_FAIL(m_device->CreateShaderResourceView(resourceImpl->m_buffer, &srvDesc, srv.writeRef())); - - RefPtr<ShaderResourceViewImpl> viewImpl = new ShaderResourceViewImpl(); - viewImpl->m_type = ResourceViewImpl::Type::SRV; - viewImpl->m_srv = srv; - viewImpl->m_desc = desc; - returnComPtr(outView, viewImpl); - return SLANG_OK; - } - break; - } -} - -Result D3D11Device::createInputLayout(IInputLayout::Desc const& desc, IInputLayout** outLayout) -{ - D3D11_INPUT_ELEMENT_DESC inputElements[16] = {}; - - char hlslBuffer[1024]; - char* hlslCursor = &hlslBuffer[0]; - - hlslCursor += sprintf(hlslCursor, "float4 main(\n"); - - auto inputElementCount = desc.inputElementCount; - auto inputElementsIn = desc.inputElements; - for (Int ii = 0; ii < inputElementCount; ++ii) - { - auto vertexStreamIndex = inputElementsIn[ii].bufferSlotIndex; - auto& vertexStream = desc.vertexStreams[vertexStreamIndex]; - - inputElements[ii].SemanticName = inputElementsIn[ii].semanticName; - inputElements[ii].SemanticIndex = (UINT)inputElementsIn[ii].semanticIndex; - inputElements[ii].Format = D3DUtil::getMapFormat(inputElementsIn[ii].format); - inputElements[ii].InputSlot = (UINT)vertexStreamIndex; - inputElements[ii].AlignedByteOffset = (UINT)inputElementsIn[ii].offset; - inputElements[ii].InputSlotClass = - (vertexStream.slotClass == InputSlotClass::PerInstance) ? D3D11_INPUT_PER_INSTANCE_DATA : D3D11_INPUT_PER_VERTEX_DATA; - inputElements[ii].InstanceDataStepRate = (UINT)vertexStream.instanceDataStepRate; - - if (ii != 0) - { - hlslCursor += sprintf(hlslCursor, ",\n"); - } - - char const* typeName = "Unknown"; - switch (inputElementsIn[ii].format) - { - case Format::R32G32B32A32_FLOAT: - case Format::R8G8B8A8_UNORM: - typeName = "float4"; - break; - case Format::R32G32B32_FLOAT: - typeName = "float3"; - break; - case Format::R32G32_FLOAT: - typeName = "float2"; - break; - case Format::R32_FLOAT: - typeName = "float"; - break; - default: - return SLANG_FAIL; - } - - hlslCursor += sprintf(hlslCursor, "%s a%d : %s%d", - typeName, - (int)ii, - inputElementsIn[ii].semanticName, - (int)inputElementsIn[ii].semanticIndex); - } - - hlslCursor += sprintf(hlslCursor, "\n) : SV_Position { return 0; }"); - - ComPtr<ID3DBlob> vertexShaderBlob; - SLANG_RETURN_ON_FAIL(D3DUtil::compileHLSLShader("inputLayout", hlslBuffer, "main", "vs_5_0", vertexShaderBlob)); - - ComPtr<ID3D11InputLayout> inputLayout; - SLANG_RETURN_ON_FAIL(m_device->CreateInputLayout(&inputElements[0], (UINT)inputElementCount, vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), - inputLayout.writeRef())); - - RefPtr<InputLayoutImpl> impl = new InputLayoutImpl; - impl->m_layout.swap(inputLayout); - - auto vertexStreamCount = desc.vertexStreamCount; - impl->m_vertexStreamStrides.setCount(vertexStreamCount); - for (Int i = 0; i < vertexStreamCount; ++i) - { - impl->m_vertexStreamStrides[i] = (UINT)desc.vertexStreams[i].stride; - } - - returnComPtr(outLayout, impl); - return SLANG_OK; -} - -Result D3D11Device::createQueryPool(const IQueryPool::Desc& desc, IQueryPool** outPool) -{ - RefPtr<QueryPoolImpl> result = new QueryPoolImpl(); - SLANG_RETURN_ON_FAIL(result->init(desc, this)); - returnComPtr(outPool, result); - return SLANG_OK; -} - -void* D3D11Device::map(IBufferResource* bufferIn, MapFlavor flavor) -{ - BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn); - - D3D11_MAP mapType; - ID3D11Buffer* buffer = bufferResource->m_buffer; - - switch (flavor) - { - case MapFlavor::WriteDiscard: - mapType = D3D11_MAP_WRITE_DISCARD; - break; - case MapFlavor::HostWrite: - mapType = D3D11_MAP_WRITE_NO_OVERWRITE; - break; - case MapFlavor::HostRead: - mapType = D3D11_MAP_READ; - break; - default: - return nullptr; - } - - bufferResource->m_mapFlavor = flavor; - - switch (flavor) - { - case MapFlavor::WriteDiscard: - case MapFlavor::HostWrite: - // If buffer is not dynamic, we need to use staging buffer. - if (bufferResource->m_d3dUsage != D3D11_USAGE_DYNAMIC) - { - bufferResource->m_uploadStagingBuffer.setCount(bufferResource->getDesc()->sizeInBytes); - return bufferResource->m_uploadStagingBuffer.getBuffer(); - } - break; - case MapFlavor::HostRead: - buffer = bufferResource->m_staging; - if (!buffer) - { - return nullptr; - } - - // Okay copy the data over - m_immediateContext->CopyResource(buffer, bufferResource->m_buffer); - - } - - // We update our constant buffer per-frame, just for the purposes - // of the example, but we don't actually load different data - // per-frame (we always use an identity projection). - D3D11_MAPPED_SUBRESOURCE mappedSub; - SLANG_RETURN_NULL_ON_FAIL(m_immediateContext->Map(buffer, 0, mapType, 0, &mappedSub)); - - return mappedSub.pData; -} - -void D3D11Device::unmap(IBufferResource* bufferIn, size_t offsetWritten, size_t sizeWritten) -{ - BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn); - switch (bufferResource->m_mapFlavor) - { - case MapFlavor::WriteDiscard: - case MapFlavor::HostWrite: - // If buffer is not dynamic, the CPU has already written to the staging buffer, - // and we need to copy the content over to the GPU buffer. - if (bufferResource->m_d3dUsage != D3D11_USAGE_DYNAMIC && sizeWritten != 0) - { - D3D11_BOX dstBox = {}; - dstBox.left = (UINT)offsetWritten; - dstBox.right = (UINT)(offsetWritten + sizeWritten); - dstBox.back = 1; - dstBox.bottom = 1; - m_immediateContext->UpdateSubresource( - bufferResource->m_buffer, - 0, - &dstBox, - bufferResource->m_uploadStagingBuffer.getBuffer() + offsetWritten, - 0, - 0); - return; - } - } - m_immediateContext->Unmap(bufferResource->m_mapFlavor == MapFlavor::HostRead ? bufferResource->m_staging : bufferResource->m_buffer, 0); -} - -#if 0 -void D3D11Device::setInputLayout(InputLayout* inputLayoutIn) -{ - auto inputLayout = static_cast<InputLayoutImpl*>(inputLayoutIn); - m_immediateContext->IASetInputLayout(inputLayout->m_layout); -} -#endif - -void D3D11Device::setPrimitiveTopology(PrimitiveTopology topology) -{ - m_immediateContext->IASetPrimitiveTopology(D3DUtil::getPrimitiveTopology(topology)); -} - -void D3D11Device::setVertexBuffers( - GfxIndex startSlot, - GfxCount slotCount, - IBufferResource* const* buffersIn, - const Offset* offsetsIn) -{ - static const int kMaxVertexBuffers = 16; - assert(slotCount <= kMaxVertexBuffers); - assert(m_currentPipelineState); // The pipeline state should be created before setting vertex buffers. - - UINT vertexStrides[kMaxVertexBuffers]; - UINT vertexOffsets[kMaxVertexBuffers]; - ID3D11Buffer* dxBuffers[kMaxVertexBuffers]; - - auto buffers = (BufferResourceImpl*const*)buffersIn; - - for (GfxIndex ii = 0; ii < slotCount; ++ii) - { - auto inputLayout = (InputLayoutImpl*)m_currentPipelineState->inputLayout.Ptr(); - vertexStrides[ii] = inputLayout->m_vertexStreamStrides[startSlot + ii]; - vertexOffsets[ii] = (UINT)offsetsIn[ii]; - dxBuffers[ii] = buffers[ii]->m_buffer; - } - - m_immediateContext->IASetVertexBuffers((UINT)startSlot, (UINT)slotCount, dxBuffers, &vertexStrides[0], &vertexOffsets[0]); -} - -void D3D11Device::setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset) -{ - DXGI_FORMAT dxFormat = D3DUtil::getMapFormat(indexFormat); - m_immediateContext->IASetIndexBuffer(((BufferResourceImpl*)buffer)->m_buffer, dxFormat, UINT(offset)); -} - -void D3D11Device::setViewports(GfxCount count, Viewport const* viewports) -{ - static const int kMaxViewports = D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX + 1; - assert(count <= kMaxViewports); - - D3D11_VIEWPORT dxViewports[kMaxViewports]; - for(GfxIndex ii = 0; ii < count; ++ii) - { - auto& inViewport = viewports[ii]; - auto& dxViewport = dxViewports[ii]; - - dxViewport.TopLeftX = inViewport.originX; - dxViewport.TopLeftY = inViewport.originY; - dxViewport.Width = inViewport.extentX; - dxViewport.Height = inViewport.extentY; - dxViewport.MinDepth = inViewport.minZ; - dxViewport.MaxDepth = inViewport.maxZ; - } - - m_immediateContext->RSSetViewports(UINT(count), dxViewports); -} - -void D3D11Device::setScissorRects(GfxCount count, ScissorRect const* rects) -{ - static const int kMaxScissorRects = D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX + 1; - assert(count <= kMaxScissorRects); - - D3D11_RECT dxRects[kMaxScissorRects]; - for(GfxIndex ii = 0; ii < count; ++ii) - { - auto& inRect = rects[ii]; - auto& dxRect = dxRects[ii]; - - dxRect.left = LONG(inRect.minX); - dxRect.top = LONG(inRect.minY); - dxRect.right = LONG(inRect.maxX); - dxRect.bottom = LONG(inRect.maxY); - } - - m_immediateContext->RSSetScissorRects(UINT(count), dxRects); -} - - -void D3D11Device::setPipelineState(IPipelineState* state) -{ - auto pipelineType = static_cast<PipelineStateBase*>(state)->desc.type; - - switch(pipelineType) - { - default: - break; - - case PipelineType::Graphics: - { - auto stateImpl = (GraphicsPipelineStateImpl*) state; - auto programImpl = static_cast<ShaderProgramImpl*>(stateImpl->m_program.Ptr()); - - // TODO: We could conceivably do some lightweight state - // differencing here (e.g., check if `programImpl` is the - // same as the program that is currently bound). - // - // It isn't clear how much that would pay off given that - // the D3D11 runtime seems to do its own state diffing. - - // IA - - m_immediateContext->IASetInputLayout(stateImpl->m_inputLayout->m_layout); - - // VS - - // TODO(tfoley): Why the conditional here? If somebody is trying to disable the VS or PS, shouldn't we respect that? - if (programImpl->m_vertexShader) - m_immediateContext->VSSetShader(programImpl->m_vertexShader, nullptr, 0); - - // HS - - // DS - - // GS - - // RS - - m_immediateContext->RSSetState(stateImpl->m_rasterizerState); - - // PS - if (programImpl->m_pixelShader) - m_immediateContext->PSSetShader(programImpl->m_pixelShader, nullptr, 0); - - // OM - - m_immediateContext->OMSetBlendState(stateImpl->m_blendState, stateImpl->m_blendColor, stateImpl->m_sampleMask); - - m_currentPipelineState = stateImpl; - - m_depthStencilStateDirty = true; - } - break; - - case PipelineType::Compute: - { - auto stateImpl = (ComputePipelineStateImpl*) state; - auto programImpl = static_cast<ShaderProgramImpl*>(stateImpl->m_program.Ptr()); - - // CS - - m_immediateContext->CSSetShader(programImpl->m_computeShader, nullptr, 0); - m_currentPipelineState = stateImpl; - } - break; - } - - /// ... -} - -void D3D11Device::draw(GfxCount vertexCount, GfxIndex startVertex) -{ - _flushGraphicsState(); - m_immediateContext->Draw(vertexCount, startVertex); -} - -void D3D11Device::drawIndexed(GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) -{ - _flushGraphicsState(); - m_immediateContext->DrawIndexed(indexCount, startIndex, baseVertex); -} - -void D3D11Device::drawInstanced( - GfxCount vertexCount, - GfxCount instanceCount, - GfxIndex startVertex, - GfxIndex startInstanceLocation) -{ - _flushGraphicsState(); - m_immediateContext->DrawInstanced( - vertexCount, - instanceCount, - startVertex, - startInstanceLocation); -} - -void D3D11Device::drawIndexedInstanced( - GfxCount indexCount, - GfxCount instanceCount, - GfxIndex startIndexLocation, - GfxIndex baseVertexLocation, - GfxIndex startInstanceLocation) -{ - _flushGraphicsState(); - m_immediateContext->DrawIndexedInstanced( - indexCount, - instanceCount, - startIndexLocation, - baseVertexLocation, - startInstanceLocation); -} - -Result D3D11Device::createProgram( - const IShaderProgram::Desc& desc, IShaderProgram** outProgram, ISlangBlob** outDiagnosticBlob) -{ - SLANG_ASSERT(desc.slangGlobalScope); - - if (desc.slangGlobalScope->getSpecializationParamCount() != 0) - { - // For a specializable program, we don't invoke any actual slang compilation yet. - RefPtr<ShaderProgramImpl> shaderProgram = new ShaderProgramImpl(); - shaderProgram->init(desc); - returnComPtr(outProgram, shaderProgram); - return SLANG_OK; - } - - // If the program is already specialized, compile and create shader kernels now. - SlangInt targetIndex = 0; - auto slangGlobalScope = desc.slangGlobalScope; - auto programLayout = slangGlobalScope->getLayout(targetIndex); - if (!programLayout) - return SLANG_FAIL; - SlangUInt entryPointCount = programLayout->getEntryPointCount(); - if (entryPointCount == 0) - return SLANG_FAIL; - - RefPtr<ShaderProgramImpl> shaderProgram = new ShaderProgramImpl(); - shaderProgram->slangGlobalScope = desc.slangGlobalScope; - - ScopeNVAPI scopeNVAPI; - SLANG_RETURN_ON_FAIL(scopeNVAPI.init(this, 0)); - for (SlangUInt i = 0; i < entryPointCount; i++) - { - ComPtr<ISlangBlob> kernelCode; - ComPtr<ISlangBlob> diagnostics; - - auto compileResult = slangGlobalScope->getEntryPointCode( - (SlangInt)i, 0, kernelCode.writeRef(), diagnostics.writeRef()); - - if (diagnostics) - { - getDebugCallback()->handleMessage( - compileResult == SLANG_OK ? DebugMessageType::Warning : DebugMessageType::Error, - DebugMessageSource::Slang, - (char*)diagnostics->getBufferPointer()); - if (outDiagnosticBlob) - returnComPtr(outDiagnosticBlob, diagnostics); - } - - SLANG_RETURN_ON_FAIL(compileResult); - - auto entryPoint = programLayout->getEntryPointByIndex(i); - switch (entryPoint->getStage()) - { - case SLANG_STAGE_COMPUTE: - SLANG_ASSERT(entryPointCount == 1); - SLANG_RETURN_ON_FAIL(m_device->CreateComputeShader( - kernelCode->getBufferPointer(), - kernelCode->getBufferSize(), - nullptr, - shaderProgram->m_computeShader.writeRef())); - break; - case SLANG_STAGE_VERTEX: - SLANG_RETURN_ON_FAIL(m_device->CreateVertexShader( - kernelCode->getBufferPointer(), - kernelCode->getBufferSize(), - nullptr, - shaderProgram->m_vertexShader.writeRef())); - break; - case SLANG_STAGE_FRAGMENT: - SLANG_RETURN_ON_FAIL(m_device->CreatePixelShader( - kernelCode->getBufferPointer(), - kernelCode->getBufferSize(), - nullptr, - shaderProgram->m_pixelShader.writeRef())); - break; - default: - SLANG_ASSERT(!"pipeline stage not implemented"); - } - } - returnComPtr(outProgram, shaderProgram); - return SLANG_OK; -} - -static D3D11_STENCIL_OP translateStencilOp(StencilOp op) -{ - switch(op) - { - default: - // TODO: need to report failures - return D3D11_STENCIL_OP_KEEP; - -#define CASE(FROM, TO) \ - case StencilOp::FROM: return D3D11_STENCIL_OP_##TO - - CASE(Keep, KEEP); - CASE(Zero, ZERO); - CASE(Replace, REPLACE); - CASE(IncrementSaturate, INCR_SAT); - CASE(DecrementSaturate, DECR_SAT); - CASE(Invert, INVERT); - CASE(IncrementWrap, INCR); - CASE(DecrementWrap, DECR); -#undef CASE - - } -} - -static D3D11_FILL_MODE translateFillMode(FillMode mode) -{ - switch(mode) - { - default: - // TODO: need to report failures - return D3D11_FILL_SOLID; - - case FillMode::Solid: return D3D11_FILL_SOLID; - case FillMode::Wireframe: return D3D11_FILL_WIREFRAME; - } -} - -static D3D11_CULL_MODE translateCullMode(CullMode mode) -{ - switch(mode) - { - default: - // TODO: need to report failures - return D3D11_CULL_NONE; - - case CullMode::None: return D3D11_CULL_NONE; - case CullMode::Back: return D3D11_CULL_BACK; - case CullMode::Front: return D3D11_CULL_FRONT; - } -} - -bool isBlendDisabled(AspectBlendDesc const& desc) -{ - return desc.op == BlendOp::Add - && desc.srcFactor == BlendFactor::One - && desc.dstFactor == BlendFactor::Zero; -} - - -bool isBlendDisabled(TargetBlendDesc const& desc) -{ - return isBlendDisabled(desc.color) - && isBlendDisabled(desc.alpha); -} - -D3D11_BLEND_OP translateBlendOp(BlendOp op) -{ - switch(op) - { - default: - assert(!"unimplemented"); - return (D3D11_BLEND_OP) -1; - -#define CASE(FROM, TO) case BlendOp::FROM: return D3D11_BLEND_OP_##TO - CASE(Add, ADD); - CASE(Subtract, SUBTRACT); - CASE(ReverseSubtract, REV_SUBTRACT); - CASE(Min, MIN); - CASE(Max, MAX); -#undef CASE - } -} - -D3D11_BLEND translateBlendFactor(BlendFactor factor) -{ - switch(factor) - { - default: - assert(!"unimplemented"); - return (D3D11_BLEND) -1; - -#define CASE(FROM, TO) case BlendFactor::FROM: return D3D11_BLEND_##TO - CASE(Zero, ZERO); - CASE(One, ONE); - CASE(SrcColor, SRC_COLOR); - CASE(InvSrcColor, INV_SRC_COLOR); - CASE(SrcAlpha, SRC_ALPHA); - CASE(InvSrcAlpha, INV_SRC_ALPHA); - CASE(DestAlpha, DEST_ALPHA); - CASE(InvDestAlpha, INV_DEST_ALPHA); - CASE(DestColor, DEST_COLOR); - CASE(InvDestColor, INV_DEST_ALPHA); - CASE(SrcAlphaSaturate, SRC_ALPHA_SAT); - CASE(BlendColor, BLEND_FACTOR); - CASE(InvBlendColor, INV_BLEND_FACTOR); - CASE(SecondarySrcColor, SRC1_COLOR); - CASE(InvSecondarySrcColor, INV_SRC1_COLOR); - CASE(SecondarySrcAlpha, SRC1_ALPHA); - CASE(InvSecondarySrcAlpha, INV_SRC1_ALPHA); -#undef CASE - } -} - -D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT mask) -{ - UINT result = 0; -#define CASE(FROM, TO) if(mask & RenderTargetWriteMask::Enable##FROM) result |= D3D11_COLOR_WRITE_ENABLE_##TO - - CASE(Red, RED); - CASE(Green, GREEN); - CASE(Blue, BLUE); - CASE(Alpha, ALPHA); - -#undef CASE - return D3D11_COLOR_WRITE_ENABLE(result); -} - -Result D3D11Device::createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, - ShaderObjectLayoutBase** outLayout) -{ - RefPtr<ShaderObjectLayoutImpl> layout; - SLANG_RETURN_ON_FAIL(ShaderObjectLayoutImpl::createForElementType( - this, typeLayout, layout.writeRef())); - returnRefPtrMove(outLayout, layout); - return SLANG_OK; -} - -Result D3D11Device::createShaderObject(ShaderObjectLayoutBase* layout, IShaderObject** outObject) -{ - RefPtr<ShaderObjectImpl> shaderObject; - SLANG_RETURN_ON_FAIL(ShaderObjectImpl::create(this, - static_cast<ShaderObjectLayoutImpl*>(layout), shaderObject.writeRef())); - returnComPtr(outObject, shaderObject); - return SLANG_OK; -} - -Result D3D11Device::createMutableShaderObject( - ShaderObjectLayoutBase* layout, - IShaderObject** outObject) -{ - auto layoutImpl = static_cast<ShaderObjectLayoutImpl*>(layout); - - RefPtr<MutableShaderObjectImpl> result = new MutableShaderObjectImpl(); - SLANG_RETURN_ON_FAIL(result->init(this, layoutImpl)); - returnComPtr(outObject, result); - - return SLANG_OK; -} - -Result D3D11Device::createRootShaderObject(IShaderProgram* program, ShaderObjectBase** outObject) -{ - auto programImpl = static_cast<ShaderProgramImpl*>(program); - RefPtr<RootShaderObjectImpl> shaderObject; - RefPtr<RootShaderObjectLayoutImpl> rootLayout; - SLANG_RETURN_ON_FAIL(RootShaderObjectLayoutImpl::create( - this, programImpl->slangGlobalScope, programImpl->slangGlobalScope->getLayout(), rootLayout.writeRef())); - SLANG_RETURN_ON_FAIL(RootShaderObjectImpl::create( - this, rootLayout.Ptr(), shaderObject.writeRef())); - returnRefPtrMove(outObject, shaderObject); - return SLANG_OK; -} - -void D3D11Device::bindRootShaderObject(IShaderObject* shaderObject) -{ - RootShaderObjectImpl* rootShaderObjectImpl = static_cast<RootShaderObjectImpl*>(shaderObject); - RefPtr<PipelineStateBase> specializedPipeline; - maybeSpecializePipeline(m_currentPipelineState, rootShaderObjectImpl, specializedPipeline); - PipelineStateImpl* specializedPipelineImpl = static_cast<PipelineStateImpl*>(specializedPipeline.Ptr()); - setPipelineState(specializedPipelineImpl); - - // In order to bind the root object we must compute its specialized layout. - // - // TODO: This is in most ways redundant with `maybeSpecializePipeline` above, - // and the two operations should really be one. - // - RefPtr<ShaderObjectLayoutImpl> specializedRootLayout; - rootShaderObjectImpl->_getSpecializedLayout(specializedRootLayout.writeRef()); - RootShaderObjectLayoutImpl* specializedRootLayoutImpl = static_cast<RootShaderObjectLayoutImpl*>(specializedRootLayout.Ptr()); - - // Depending on whether we are binding a compute or a graphics/rasterization - // pipeline, we will need to bind any SRVs/UAVs/CBs/samplers using different - // D3D11 calls. We deal with that distinction here by instantiating an - // appropriate subtype of `BindingContext` based on the pipeline type. - // - switch (m_currentPipelineState->desc.type) - { - case PipelineType::Compute: - { - ComputeBindingContext context(this, m_immediateContext); - rootShaderObjectImpl->bindAsRoot(&context, specializedRootLayoutImpl); - - // Because D3D11 requires all UAVs to be set at once, we did *not* issue - // actual binding calls during the `bindAsRoot` step, and instead we - // batch them up and set them here. - // - m_immediateContext->CSSetUnorderedAccessViews(0, context.uavCount, context.uavs, nullptr); - } - break; - default: - { - GraphicsBindingContext context(this, m_immediateContext); - rootShaderObjectImpl->bindAsRoot(&context, specializedRootLayoutImpl); - - // Similar to the compute case above, the rasteirzation case needs to - // set the UAVs after the call to `bindAsRoot()` completes, but we - // also have a few extra wrinkles here that are specific to the D3D 11.0 - // rasterization pipeline. - // - // In D3D 11.0, the RTV and UAV binding slots alias, so that a shader - // that binds an RTV for `SV_Target0` cannot also bind a UAV for `u0`. - // The Slang layout algorithm already accounts for this rule, and assigns - // all UAVs to slots taht won't alias the RTVs it knows about. - // - // In order to account for the aliasing, we need to consider how many - // RTVs are bound as part of the active framebuffer, and then adjust - // the UAVs that we bind accordingly. - // - auto rtvCount = (UINT)m_currentFramebuffer->renderTargetViews.getCount(); - // - // The `context` we are using will have computed the number of UAV registers - // that might need to be bound, as a range from 0 to `context.uavCount`. - // However we need to skip over the first `rtvCount` of those, so the - // actual number of UAVs we wnat to bind is smaller: - // - // Note: As a result we expect that either there were no UAVs bound, - // *or* the number of UAV slots bound is higher than the number of - // RTVs so that there is something left to actually bind. - // - SLANG_ASSERT((context.uavCount == 0) || (context.uavCount >= rtvCount)); - auto bindableUAVCount = context.uavCount - rtvCount; - // - // Similarly, the actual UAVs we intend to bind will come after the first - // `rtvCount` in the array. - // - auto bindableUAVs = context.uavs + rtvCount; - - // Once the offsetting is accounted for, we set all of the RTVs, DSV, - // and UAVs with one call. - // - // TODO: We may want to use the capability for `OMSetRenderTargetsAnd...` - // to only set the UAVs and leave the RTVs/UAVs alone, so that we don't - // needlessly re-bind RTVs during a pass. - // - m_immediateContext->OMSetRenderTargetsAndUnorderedAccessViews( - rtvCount, - m_currentFramebuffer->d3dRenderTargetViews.getArrayView().getBuffer(), - m_currentFramebuffer->d3dDepthStencilView, - rtvCount, - bindableUAVCount, - bindableUAVs, - nullptr); - } - break; - } -} - -Result D3D11Device::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState) -{ - GraphicsPipelineStateDesc desc = inDesc; - - auto programImpl = (ShaderProgramImpl*) desc.program; - - ComPtr<ID3D11DepthStencilState> depthStencilState; - { - D3D11_DEPTH_STENCIL_DESC dsDesc; - dsDesc.DepthEnable = desc.depthStencil.depthTestEnable; - dsDesc.DepthWriteMask = desc.depthStencil.depthWriteEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO; - dsDesc.DepthFunc = translateComparisonFunc(desc.depthStencil.depthFunc); - dsDesc.StencilEnable = desc.depthStencil.stencilEnable; - dsDesc.StencilReadMask = desc.depthStencil.stencilReadMask; - dsDesc.StencilWriteMask = desc.depthStencil.stencilWriteMask; - - #define FACE(DST, SRC) \ - dsDesc.DST.StencilFailOp = translateStencilOp( desc.depthStencil.SRC.stencilFailOp); \ - dsDesc.DST.StencilDepthFailOp = translateStencilOp( desc.depthStencil.SRC.stencilDepthFailOp); \ - dsDesc.DST.StencilPassOp = translateStencilOp( desc.depthStencil.SRC.stencilPassOp); \ - dsDesc.DST.StencilFunc = translateComparisonFunc(desc.depthStencil.SRC.stencilFunc); \ - /* end */ - - FACE(FrontFace, frontFace); - FACE(BackFace, backFace); - - SLANG_RETURN_ON_FAIL(m_device->CreateDepthStencilState( - &dsDesc, - depthStencilState.writeRef())); - } - - ComPtr<ID3D11RasterizerState> rasterizerState; - { - D3D11_RASTERIZER_DESC rsDesc; - rsDesc.FillMode = translateFillMode(desc.rasterizer.fillMode); - rsDesc.CullMode = translateCullMode(desc.rasterizer.cullMode); - rsDesc.FrontCounterClockwise = desc.rasterizer.frontFace == FrontFaceMode::Clockwise; - rsDesc.DepthBias = desc.rasterizer.depthBias; - rsDesc.DepthBiasClamp = desc.rasterizer.depthBiasClamp; - rsDesc.SlopeScaledDepthBias = desc.rasterizer.slopeScaledDepthBias; - rsDesc.DepthClipEnable = desc.rasterizer.depthClipEnable; - rsDesc.ScissorEnable = desc.rasterizer.scissorEnable; - rsDesc.MultisampleEnable = desc.rasterizer.multisampleEnable; - rsDesc.AntialiasedLineEnable = desc.rasterizer.antialiasedLineEnable; - - SLANG_RETURN_ON_FAIL(m_device->CreateRasterizerState( - &rsDesc, - rasterizerState.writeRef())); - - } - - ComPtr<ID3D11BlendState> blendState; - { - auto& srcDesc = desc.blend; - D3D11_BLEND_DESC dstDesc = {}; - - TargetBlendDesc defaultTargetBlendDesc; - - static const UInt kMaxTargets = D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; - if(srcDesc.targetCount > kMaxTargets) return SLANG_FAIL; - - for(GfxIndex ii = 0; ii < kMaxTargets; ++ii) - { - TargetBlendDesc const* srcTargetBlendDescPtr = nullptr; - if(ii < srcDesc.targetCount) - { - srcTargetBlendDescPtr = &srcDesc.targets[ii]; - } - else if(srcDesc.targetCount == 0) - { - srcTargetBlendDescPtr = &defaultTargetBlendDesc; - } - else - { - srcTargetBlendDescPtr = &srcDesc.targets[srcDesc.targetCount-1]; - } - - auto& srcTargetBlendDesc = *srcTargetBlendDescPtr; - auto& dstTargetBlendDesc = dstDesc.RenderTarget[ii]; - - if(isBlendDisabled(srcTargetBlendDesc)) - { - dstTargetBlendDesc.BlendEnable = false; - dstTargetBlendDesc.BlendOp = D3D11_BLEND_OP_ADD; - dstTargetBlendDesc.BlendOpAlpha = D3D11_BLEND_OP_ADD; - dstTargetBlendDesc.SrcBlend = D3D11_BLEND_ONE; - dstTargetBlendDesc.SrcBlendAlpha = D3D11_BLEND_ONE; - dstTargetBlendDesc.DestBlend = D3D11_BLEND_ZERO; - dstTargetBlendDesc.DestBlendAlpha = D3D11_BLEND_ZERO; - } - else - { - dstTargetBlendDesc.BlendEnable = true; - dstTargetBlendDesc.BlendOp = translateBlendOp(srcTargetBlendDesc.color.op); - dstTargetBlendDesc.BlendOpAlpha = translateBlendOp(srcTargetBlendDesc.alpha.op); - dstTargetBlendDesc.SrcBlend = translateBlendFactor(srcTargetBlendDesc.color.srcFactor); - dstTargetBlendDesc.SrcBlendAlpha = translateBlendFactor(srcTargetBlendDesc.alpha.srcFactor); - dstTargetBlendDesc.DestBlend = translateBlendFactor(srcTargetBlendDesc.color.dstFactor); - dstTargetBlendDesc.DestBlendAlpha = translateBlendFactor(srcTargetBlendDesc.alpha.dstFactor); - } - - dstTargetBlendDesc.RenderTargetWriteMask = translateRenderTargetWriteMask(srcTargetBlendDesc.writeMask); - } - - dstDesc.IndependentBlendEnable = srcDesc.targetCount > 1; - dstDesc.AlphaToCoverageEnable = srcDesc.alphaToCoverageEnable; - - SLANG_RETURN_ON_FAIL(m_device->CreateBlendState( - &dstDesc, - blendState.writeRef())); - } - - RefPtr<GraphicsPipelineStateImpl> state = new GraphicsPipelineStateImpl(); - state->m_depthStencilState = depthStencilState; - state->m_rasterizerState = rasterizerState; - state->m_blendState = blendState; - state->m_inputLayout = static_cast<InputLayoutImpl*>(desc.inputLayout); - state->m_rtvCount = (UINT) static_cast<FramebufferLayoutImpl*>(desc.framebufferLayout) - ->m_renderTargets.getCount(); - state->m_blendColor[0] = 0; - state->m_blendColor[1] = 0; - state->m_blendColor[2] = 0; - state->m_blendColor[3] = 0; - state->m_sampleMask = 0xFFFFFFFF; - state->init(desc); - returnComPtr(outState, state); - return SLANG_OK; -} - -Result D3D11Device::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState) -{ - ComputePipelineStateDesc desc = inDesc; - - RefPtr<ComputePipelineStateImpl> state = new ComputePipelineStateImpl(); - state->init(desc); - returnComPtr(outState, state); - return SLANG_OK; -} - -void D3D11Device::copyBuffer( - IBufferResource* dst, - Offset dstOffset, - IBufferResource* src, - Offset srcOffset, - Size size) -{ - auto dstImpl = static_cast<BufferResourceImpl*>(dst); - auto srcImpl = static_cast<BufferResourceImpl*>(src); - D3D11_BOX srcBox = {}; - srcBox.left = (UINT)srcOffset; - srcBox.right = (UINT)(srcOffset + size); - srcBox.bottom = srcBox.back = 1; - m_immediateContext->CopySubresourceRegion( - dstImpl->m_buffer, 0, (UINT)dstOffset, 0, 0, srcImpl->m_buffer, 0, &srcBox); -} - -void D3D11Device::dispatchCompute(int x, int y, int z) -{ - m_immediateContext->Dispatch(x, y, z); -} - -void D3D11Device::_flushGraphicsState() -{ - if (m_depthStencilStateDirty) - { - m_depthStencilStateDirty = false; - auto pipelineState = static_cast<GraphicsPipelineStateImpl*>(m_currentPipelineState.Ptr()); - m_immediateContext->OMSetDepthStencilState( - pipelineState->m_depthStencilState, m_stencilRef); - } -} - -} diff --git a/tools/gfx/d3d11/render-d3d11.h b/tools/gfx/d3d11/render-d3d11.h deleted file mode 100644 index f593ea424..000000000 --- a/tools/gfx/d3d11/render-d3d11.h +++ /dev/null @@ -1,11 +0,0 @@ -// render-d3d11.h -#pragma once - -#include "../renderer-shared.h" - -namespace gfx -{ - -SlangResult SLANG_MCALL createD3D11Device(const IDevice::Desc* desc, IDevice** outDevice); - -} // gfx diff --git a/tools/gfx/render.cpp b/tools/gfx/render.cpp index 4d6e1bb85..ef4edb341 100644 --- a/tools/gfx/render.cpp +++ b/tools/gfx/render.cpp @@ -1,7 +1,6 @@ // render.cpp #include "renderer-shared.h" #include "../../source/core/slang-math.h" -#include "d3d11/render-d3d11.h" #include "open-gl/render-gl.h" #include "cuda/render-cuda.h" #include "cpu/render-cpu.h" @@ -12,6 +11,7 @@ namespace gfx { using namespace Slang; +Result SLANG_MCALL createD3D11Device(const IDevice::Desc* desc, IDevice** outDevice); Result SLANG_MCALL createD3D12Device(const IDevice::Desc* desc, IDevice** outDevice); Result SLANG_MCALL createVKDevice(const IDevice::Desc* desc, IDevice** outDevice); |