CUDA texture sampler support (#625)

skallweitNV · web-flow · commit ea84f7be475b · 2026-01-20T17:06:07.000+01:00
* Add support for specifying sampler settings for CUDA textures and texture views

* Enable sampler tests for CUDA

* Add validation
diff --git a/include/slang-rhi.h b/include/slang-rhi.h
@@ -974,6 +974,8 @@ struct SubresourceLayout
     Size rowCount;
 };
 
+class ISampler;
+
 static const uint32_t kAllLayers = 0xffffffff;
 static const uint32_t kAllMips = 0xffffffff;
 static const SubresourceRange kAllSubresources = {0, kAllLayers, 0, kAllMips};
@@ -1008,6 +1010,10 @@ struct TextureDesc
 
     const ClearValue* optimalClearValue = nullptr;
 
+    /// Default sampler settings to use for the texture (CUDA only).
+    /// If not specified, tri-linear filtering and wrap addressing mode will be used.
+    ISampler* sampler = nullptr;
+
     /// The name of the texture for debugging purposes.
     const char* label = nullptr;
 
@@ -1027,6 +1033,11 @@ struct TextureViewDesc
     Format format = Format::Undefined;
     TextureAspect aspect = TextureAspect::All;
     SubresourceRange subresourceRange = kEntireTexture;
+
+    /// Sampler settings to use for the texture view (CUDA only).
+    /// If not specified, the default sampler settings from the texture will be used.
+    ISampler* sampler = nullptr;
+
     const char* label = nullptr;
 };
 
diff --git a/src/cuda/cuda-device.cpp b/src/cuda/cuda-device.cpp
@@ -345,6 +345,7 @@ Result DeviceImpl::initialize(const DeviceDesc& desc)
     // Supports surface/swapchain (implemented in Vulkan).
     addFeature(Feature::Surface);
 #endif
+    addFeature(Feature::CustomBorderColor);
     addFeature(Feature::CombinedTextureSampler);
     addFeature(Feature::TimestampQuery);
     addFeature(Feature::RealtimeClock);
diff --git a/src/cuda/cuda-texture.cpp b/src/cuda/cuda-texture.cpp
@@ -270,12 +270,19 @@ Result DeviceImpl::createTexture(const TextureDesc& desc_, const SubresourceData
 
     auto& samplerSettings = tex->m_defaultSamplerSettings;
     samplerSettings = {};
-    samplerSettings.addressMode[0] = CU_TR_ADDRESS_MODE_WRAP;
-    samplerSettings.addressMode[1] = CU_TR_ADDRESS_MODE_WRAP;
-    samplerSettings.addressMode[2] = CU_TR_ADDRESS_MODE_WRAP;
-    samplerSettings.filterMode = CU_TR_FILTER_MODE_LINEAR;
-    samplerSettings.maxAnisotropy = 1;
-    samplerSettings.mipmapFilterMode = CU_TR_FILTER_MODE_LINEAR;
+    if (desc.sampler)
+    {
+        samplerSettings = checked_cast<SamplerImpl*>(desc.sampler)->m_samplerSettings;
+    }
+    else
+    {
+        samplerSettings.addressMode[0] = CU_TR_ADDRESS_MODE_WRAP;
+        samplerSettings.addressMode[1] = CU_TR_ADDRESS_MODE_WRAP;
+        samplerSettings.addressMode[2] = CU_TR_ADDRESS_MODE_WRAP;
+        samplerSettings.filterMode = CU_TR_FILTER_MODE_LINEAR;
+        samplerSettings.maxAnisotropy = 1;
+        samplerSettings.mipmapFilterMode = CU_TR_FILTER_MODE_LINEAR;
+    }
 
     // The size of the element/texel in bytes
     const FormatInfo& formatInfo = getFormatInfo(desc.format);
@@ -647,6 +654,8 @@ Result DeviceImpl::createTextureView(ITexture* texture, const TextureViewDesc& d
     if (view->m_desc.format == Format::Undefined)
         view->m_desc.format = view->m_texture->m_desc.format;
     view->m_desc.subresourceRange = view->m_texture->resolveSubresourceRange(desc.subresourceRange);
+    view->m_samplerSettings = desc.sampler ? checked_cast<SamplerImpl*>(desc.sampler)->m_samplerSettings
+                                           : view->m_texture->m_defaultSamplerSettings;
     returnComPtr(outView, view);
     return SLANG_OK;
 }
diff --git a/src/cuda/cuda-texture.h b/src/cuda/cuda-texture.h
@@ -104,8 +104,7 @@ class TextureViewImpl : public TextureView
     CUtexObject getTexObject()
     {
         if (!m_cudaTexObj)
-            m_cudaTexObj =
-                m_texture->getTexObject(m_desc.format, m_texture->m_defaultSamplerSettings, m_desc.subresourceRange);
+            m_cudaTexObj = m_texture->getTexObject(m_desc.format, m_samplerSettings, m_desc.subresourceRange);
         return m_cudaTexObj;
     }
 
@@ -122,6 +121,7 @@ class TextureViewImpl : public TextureView
     }
 
     BreakableReference<TextureImpl> m_texture;
+    SamplerSettings m_samplerSettings;
     CUtexObject m_cudaTexObj = 0;
     CUsurfObject m_cudaSurfObj = 0;
 };
diff --git a/src/debug-layer/debug-device.cpp b/src/debug-layer/debug-device.cpp
@@ -99,8 +99,6 @@ Result DebugDevice::createTexture(const TextureDesc& desc, const SubresourceData
 {
     SLANG_RHI_API_FUNC;
 
-    DeviceType deviceType = getDeviceType();
-
     if (uint32_t(desc.type) > uint32_t(TextureType::TextureCubeArray))
     {
         RHI_VALIDATION_ERROR("Invalid texture type");
@@ -165,12 +163,12 @@ Result DebugDevice::createTexture(const TextureDesc& desc, const SubresourceData
             RHI_VALIDATION_ERROR("Texture with multisample type cannot have mip levels");
             return SLANG_E_INVALID_ARG;
         }
-        if (deviceType == DeviceType::WGPU && desc.sampleCount != 4)
+        if (ctx->deviceType == DeviceType::WGPU && desc.sampleCount != 4)
         {
             RHI_VALIDATION_ERROR("WebGPU only supports sample count of 4");
             return SLANG_E_INVALID_ARG;
         }
-        if (deviceType == DeviceType::WGPU && desc.arrayLength != 1)
+        if (ctx->deviceType == DeviceType::WGPU && desc.arrayLength != 1)
         {
             RHI_VALIDATION_ERROR("WebGPU doesn't support multisampled texture arrays");
             return SLANG_E_INVALID_ARG;
@@ -220,6 +218,12 @@ Result DebugDevice::createTexture(const TextureDesc& desc, const SubresourceData
         break;
     }
 
+    if (desc.sampler != nullptr && ctx->deviceType != DeviceType::CUDA)
+    {
+        RHI_VALIDATION_ERROR("Setting default sampler for texture is only supported on CUDA device");
+        return SLANG_E_INVALID_ARG;
+    }
+
     TextureDesc patchedDesc = desc;
     std::string label;
     if (!patchedDesc.label)
@@ -421,6 +425,12 @@ Result DebugDevice::createTextureView(ITexture* texture, const TextureViewDesc&
 {
     SLANG_RHI_API_FUNC;
 
+    if (desc.sampler != nullptr && ctx->deviceType != DeviceType::CUDA)
+    {
+        RHI_VALIDATION_ERROR("Setting default sampler for texture is only supported on CUDA device");
+        return SLANG_E_INVALID_ARG;
+    }
+
     TextureViewDesc patchedDesc = desc;
     std::string label;
     if (!patchedDesc.label)
diff --git a/tests/test-sampler.cpp b/tests/test-sampler.cpp
@@ -4,7 +4,7 @@
 using namespace rhi;
 using namespace rhi::testing;
 
-static Result createTestTexture(IDevice* device, ITexture** outTexture)
+static Result createTestTexture(IDevice* device, ISampler* sampler, ITexture** outTexture)
 {
     ComPtr<ITexture> texture;
     TextureDesc desc = {};
@@ -14,6 +14,7 @@ static Result createTestTexture(IDevice* device, ITexture** outTexture)
     desc.mipCount = 2;
     desc.memoryType = MemoryType::DeviceLocal;
     desc.usage = TextureUsage::ShaderResource | TextureUsage::CopyDestination | TextureUsage::CopySource;
+    desc.sampler = sampler;
 
     // mip 0
     // ---------------------
@@ -62,95 +63,77 @@ struct TestRecord
     float expectedColor[4];
 };
 
-struct SamplerTest
+static void testSampler(IDevice* device, const SamplerDesc& samplerDesc, span<TestRecord> testRecords)
 {
-    static constexpr size_t kMaxRecords = 32;
+    ComPtr<ISampler> sampler;
+    REQUIRE_CALL(device->createSampler(samplerDesc, sampler.writeRef()));
 
-    ComPtr<IDevice> device;
     ComPtr<ITexture> texture;
+    // On CUDA, we need to have a sampler associated with the texture for sampling to work.
+    REQUIRE_CALL(
+        createTestTexture(device, device->getDeviceType() == DeviceType::CUDA ? sampler : nullptr, texture.writeRef())
+    );
+
+    ComPtr<IShaderProgram> shaderProgram;
+    REQUIRE_CALL(loadProgram(device, "test-sampler", "sampleTexture", shaderProgram.writeRef()));
+
+    ComputePipelineDesc pipelineDesc = {};
+    pipelineDesc.program = shaderProgram.get();
+    ComPtr<IComputePipeline> pipeline;
+    REQUIRE_CALL(device->createComputePipeline(pipelineDesc, pipeline.writeRef()));
+
+    BufferDesc bufferDesc = {};
+    bufferDesc.size = testRecords.size() * sizeof(TestInput);
+    bufferDesc.elementSize = sizeof(TestInput);
+    bufferDesc.usage = BufferUsage::ShaderResource | BufferUsage::CopyDestination;
     ComPtr<IBuffer> inputBuffer;
+    REQUIRE_CALL(device->createBuffer(bufferDesc, nullptr, inputBuffer.writeRef()));
+
+    bufferDesc.size = testRecords.size() * sizeof(TestOutput);
+    bufferDesc.elementSize = sizeof(TestOutput);
+    bufferDesc.usage = BufferUsage::UnorderedAccess | BufferUsage::CopySource;
     ComPtr<IBuffer> resultBuffer;
-    ComPtr<IComputePipeline> pipeline;
+    REQUIRE_CALL(device->createBuffer(bufferDesc, nullptr, resultBuffer.writeRef()));
 
-    void init(IDevice* device_)
+    std::vector<TestInput> inputData;
+    for (const auto& record : testRecords)
     {
-        this->device = device_;
-        REQUIRE_CALL(createTestTexture(device, texture.writeRef()));
-
-        ComPtr<IShaderProgram> shaderProgram;
-        REQUIRE_CALL(loadProgram(device, "test-sampler", "sampleTexture", shaderProgram.writeRef()));
-
-        ComputePipelineDesc pipelineDesc = {};
-        pipelineDesc.program = shaderProgram.get();
-        REQUIRE_CALL(device->createComputePipeline(pipelineDesc, pipeline.writeRef()));
-
-        BufferDesc bufferDesc = {};
-        bufferDesc.size = kMaxRecords * sizeof(TestInput);
-        bufferDesc.elementSize = sizeof(TestInput);
-        bufferDesc.usage = BufferUsage::ShaderResource | BufferUsage::CopyDestination;
-        REQUIRE_CALL(device->createBuffer(bufferDesc, nullptr, inputBuffer.writeRef()));
-
-        bufferDesc.size = kMaxRecords * sizeof(TestOutput);
-        bufferDesc.elementSize = sizeof(TestOutput);
-        bufferDesc.usage = BufferUsage::UnorderedAccess | BufferUsage::CopySource;
-        REQUIRE_CALL(device->createBuffer(bufferDesc, nullptr, resultBuffer.writeRef()));
+        inputData.push_back({record.u, record.v, record.level, 0.f});
     }
-
-    void check(ISampler* sampler, span<TestRecord> testRecords)
+    ComPtr<ICommandQueue> queue = device->getQueue(QueueType::Graphics);
+    ComPtr<ICommandEncoder> encoder = queue->createCommandEncoder();
+    encoder->uploadBufferData(inputBuffer, 0, inputData.size() * sizeof(TestInput), inputData.data());
+    IComputePassEncoder* passEncoder = encoder->beginComputePass();
+    IShaderObject* rootObject = passEncoder->bindPipeline(pipeline);
+    ShaderCursor cursor(rootObject);
+    cursor["texture"].setBinding(texture);
+    cursor["sampler"].setBinding(sampler);
+    cursor["inputs"].setBinding(inputBuffer);
+    cursor["results"].setBinding(resultBuffer);
+    cursor["count"].setData((uint32_t)testRecords.size());
+    passEncoder->dispatchCompute((uint32_t)testRecords.size(), 1, 1);
+    passEncoder->end();
+    queue->submit(encoder->finish());
+    queue->waitOnHost();
+
+    ComPtr<ISlangBlob> resultData;
+    REQUIRE_CALL(device->readBuffer(resultBuffer, 0, testRecords.size() * sizeof(TestOutput), resultData.writeRef()));
+    const TestOutput* output = (const TestOutput*)resultData->getBufferPointer();
+    for (size_t i = 0; i < testRecords.size(); i++)
     {
-        REQUIRE(testRecords.size() <= kMaxRecords);
-        std::vector<TestInput> inputData;
-        for (const auto& record : testRecords)
+        const TestRecord& record = testRecords[i];
+        CAPTURE(record.u);
+        CAPTURE(record.v);
+        CAPTURE(record.level);
+        for (size_t j = 0; j < 4; j++)
         {
-            inputData.push_back({record.u, record.v, record.level, 0.f});
-        }
-        ComPtr<ICommandQueue> queue = device->getQueue(QueueType::Graphics);
-        ComPtr<ICommandEncoder> encoder = queue->createCommandEncoder();
-        encoder->uploadBufferData(inputBuffer, 0, inputData.size() * sizeof(TestInput), inputData.data());
-        IComputePassEncoder* passEncoder = encoder->beginComputePass();
-        IShaderObject* rootObject = passEncoder->bindPipeline(pipeline);
-        ShaderCursor cursor(rootObject);
-        cursor["texture"].setBinding(texture);
-        cursor["sampler"].setBinding(sampler);
-        cursor["inputs"].setBinding(inputBuffer);
-        cursor["results"].setBinding(resultBuffer);
-        cursor["count"].setData((uint32_t)testRecords.size());
-        passEncoder->dispatchCompute((uint32_t)testRecords.size(), 1, 1);
-        passEncoder->end();
-        queue->submit(encoder->finish());
-        queue->waitOnHost();
-
-        ComPtr<ISlangBlob> resultData;
-        REQUIRE_CALL(
-            device->readBuffer(resultBuffer, 0, testRecords.size() * sizeof(TestOutput), resultData.writeRef())
-        );
-        const TestOutput* output = (const TestOutput*)resultData->getBufferPointer();
-        for (size_t i = 0; i < testRecords.size(); i++)
-        {
-            const TestRecord& record = testRecords[i];
-            CAPTURE(record.u);
-            CAPTURE(record.v);
-            CAPTURE(record.level);
-            for (size_t j = 0; j < 4; j++)
-            {
-                CAPTURE(j);
-                REQUIRE_EQ(output[i].color[j], testRecords[i].expectedColor[j]);
-            }
+            CAPTURE(j);
+            REQUIRE_EQ(output[i].color[j], testRecords[i].expectedColor[j]);
         }
     }
-};
-
-static void testSampler(IDevice* device, const SamplerDesc& samplerDesc, span<TestRecord> testRecords)
-{
-    ComPtr<ISampler> sampler;
-    REQUIRE_CALL(device->createSampler(samplerDesc, sampler.writeRef()));
-
-    SamplerTest test;
-    test.init(device);
-    test.check(sampler, testRecords);
 }
 
-GPU_TEST_CASE("sampler-filter-point", D3D11 | D3D12 | Vulkan | Metal | WGPU)
+GPU_TEST_CASE("sampler-filter-point", D3D11 | D3D12 | Vulkan | Metal | WGPU | CUDA)
 {
     SamplerDesc desc = {};
     desc.minFilter = TextureFilteringMode::Point;
@@ -178,7 +161,7 @@ GPU_TEST_CASE("sampler-filter-point", D3D11 | D3D12 | Vulkan | Metal | WGPU)
     testSampler(device, desc, testRecords);
 }
 
-GPU_TEST_CASE("sampler-filter-linear", D3D11 | D3D12 | Vulkan | Metal | WGPU)
+GPU_TEST_CASE("sampler-filter-linear", D3D11 | D3D12 | Vulkan | Metal | WGPU | CUDA)
 {
     SamplerDesc desc = {};
     desc.minFilter = TextureFilteringMode::Linear;
@@ -208,7 +191,7 @@ GPU_TEST_CASE("sampler-filter-linear", D3D11 | D3D12 | Vulkan | Metal | WGPU)
     testSampler(device, desc, testRecords);
 }
 
-GPU_TEST_CASE("sampler-border-black-transparent", D3D11 | D3D12 | Vulkan | Metal)
+GPU_TEST_CASE("sampler-border-black-transparent", D3D11 | D3D12 | Vulkan | Metal | CUDA)
 {
     SamplerDesc desc = {};
     desc.addressU = TextureAddressingMode::ClampToBorder;
@@ -223,7 +206,7 @@ GPU_TEST_CASE("sampler-border-black-transparent", D3D11 | D3D12 | Vulkan | Metal
     testSampler(device, desc, testRecords);
 }
 
-GPU_TEST_CASE("sampler-border-black-opaque", D3D11 | D3D12 | Vulkan | Metal)
+GPU_TEST_CASE("sampler-border-black-opaque", D3D11 | D3D12 | Vulkan | Metal | CUDA)
 {
     SamplerDesc desc = {};
     desc.addressU = TextureAddressingMode::ClampToBorder;
@@ -243,7 +226,7 @@ GPU_TEST_CASE("sampler-border-black-opaque", D3D11 | D3D12 | Vulkan | Metal)
     testSampler(device, desc, testRecords);
 }
 
-GPU_TEST_CASE("sampler-border-white-opaque", D3D11 | D3D12 | Vulkan | Metal)
+GPU_TEST_CASE("sampler-border-white-opaque", D3D11 | D3D12 | Vulkan | Metal | CUDA)
 {
     SamplerDesc desc = {};
     desc.addressU = TextureAddressingMode::ClampToBorder;
@@ -262,7 +245,7 @@ GPU_TEST_CASE("sampler-border-white-opaque", D3D11 | D3D12 | Vulkan | Metal)
     testSampler(device, desc, testRecords);
 }
 
-GPU_TEST_CASE("sampler-border-custom-color", D3D11 | D3D12 | Vulkan | Metal)
+GPU_TEST_CASE("sampler-border-custom-color", D3D11 | D3D12 | Vulkan | Metal | CUDA)
 {
     if (!device->hasFeature(Feature::CustomBorderColor))
         SKIP("Custom border color not supported");

Original file line number	Diff line number	Diff line change
`@@ -104,8 +104,7 @@ class TextureViewImpl : public TextureView`
`104`	`104`	`CUtexObject getTexObject()`
`105`	`105`	`{`
`106`	`106`	`if (!m_cudaTexObj)`
`107`		`- m_cudaTexObj =`
`108`		`- m_texture->getTexObject(m_desc.format, m_texture->m_defaultSamplerSettings, m_desc.subresourceRange);`
	`107`	`+ m_cudaTexObj = m_texture->getTexObject(m_desc.format, m_samplerSettings, m_desc.subresourceRange);`
`109`	`108`	`return m_cudaTexObj;`
`110`	`109`	`}`
`111`	`110`
`@@ -122,6 +121,7 @@ class TextureViewImpl : public TextureView`
`122`	`121`	`}`
`123`	`122`
`124`	`123`	`BreakableReference<TextureImpl> m_texture;`
	`124`	`+ SamplerSettings m_samplerSettings;`
`125`	`125`	`CUtexObject m_cudaTexObj = 0;`
`126`	`126`	`CUsurfObject m_cudaSurfObj = 0;`
`127`	`127`	`};`
Original file line number	Diff line number	Diff line change
`@@ -99,8 +99,6 @@ Result DebugDevice::createTexture(const TextureDesc& desc, const SubresourceData`
`99`	`99`	`{`
`100`	`100`	`SLANG_RHI_API_FUNC;`
`101`	`101`
`102`		`- DeviceType deviceType = getDeviceType();`
`103`		`-`
`104`	`102`	`if (uint32_t(desc.type) > uint32_t(TextureType::TextureCubeArray))`
`105`	`103`	`{`
`106`	`104`	`RHI_VALIDATION_ERROR("Invalid texture type");`
`@@ -165,12 +163,12 @@ Result DebugDevice::createTexture(const TextureDesc& desc, const SubresourceData`
`165`	`163`	`RHI_VALIDATION_ERROR("Texture with multisample type cannot have mip levels");`
`166`	`164`	`return SLANG_E_INVALID_ARG;`
`167`	`165`	`}`
`168`		`- if (deviceType == DeviceType::WGPU && desc.sampleCount != 4)`
	`166`	`+ if (ctx->deviceType == DeviceType::WGPU && desc.sampleCount != 4)`
`169`	`167`	`{`
`170`	`168`	`RHI_VALIDATION_ERROR("WebGPU only supports sample count of 4");`
`171`	`169`	`return SLANG_E_INVALID_ARG;`
`172`	`170`	`}`
`173`		`- if (deviceType == DeviceType::WGPU && desc.arrayLength != 1)`
	`171`	`+ if (ctx->deviceType == DeviceType::WGPU && desc.arrayLength != 1)`
`174`	`172`	`{`
`175`	`173`	`RHI_VALIDATION_ERROR("WebGPU doesn't support multisampled texture arrays");`
`176`	`174`	`return SLANG_E_INVALID_ARG;`
`@@ -220,6 +218,12 @@ Result DebugDevice::createTexture(const TextureDesc& desc, const SubresourceData`
`220`	`218`	`break;`
`221`	`219`	`}`
`222`	`220`
	`221`	`+ if (desc.sampler != nullptr && ctx->deviceType != DeviceType::CUDA)`
	`222`	`+ {`
	`223`	`+ RHI_VALIDATION_ERROR("Setting default sampler for texture is only supported on CUDA device");`
	`224`	`+ return SLANG_E_INVALID_ARG;`
	`225`	`+ }`
	`226`	`+`
`223`	`227`	`TextureDesc patchedDesc = desc;`
`224`	`228`	`std::string label;`
`225`	`229`	`if (!patchedDesc.label)`
`@@ -421,6 +425,12 @@ Result DebugDevice::createTextureView(ITexture* texture, const TextureViewDesc&`
`421`	`425`	`{`
`422`	`426`	`SLANG_RHI_API_FUNC;`
`423`	`427`
	`428`	`+ if (desc.sampler != nullptr && ctx->deviceType != DeviceType::CUDA)`
	`429`	`+ {`
	`430`	`+ RHI_VALIDATION_ERROR("Setting default sampler for texture is only supported on CUDA device");`
	`431`	`+ return SLANG_E_INVALID_ARG;`
	`432`	`+ }`
	`433`	`+`
`424`	`434`	`TextureViewDesc patchedDesc = desc;`
`425`	`435`	`std::string label;`
`426`	`436`	`if (!patchedDesc.label)`