Split render-d3d11.cpp into smaller files (#2307)

* render-d3d11 split, does not compile

* Compiles but unit tests failing

* ran premake.bat

* Readded constructor code that was accidentally removed

1 files changed, 354 insertions, 0 deletions

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