From 8ee39e08c48a315163fe1850dbb12ca292020d4d Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Tue, 18 Feb 2020 14:14:16 -0500 Subject: First pass Texture Array support on CUDA/CPU (#1225) * Add cubemap support. * Add CUDA fence instrinsics. * Added Gather for CUDA. * Use the CUDA driver API as much as possible. * * Support 1D texture on CPU * WIP on 1D texture on CUDA * Added simplified texture test * Fix test. * Improve texture-simple tests. * * Add CPU support for 3d textures * Add support for mip maps to CUDA * Disable warnings in nvrtc * Update CUDA docs * WIP on 3d texture support. * Add support for 3d textures for CPU and CUDA. * CPU and CUDA support for cube maps. * Add CPU support for Texture1DArray. * Support CUDA Layered/Array type in meta library. --- tools/render-test/cpu-compute-util.cpp | 107 ++++++++++++++++++++++++++++++--- 1 file changed, 97 insertions(+), 10 deletions(-) (limited to 'tools/render-test/cpu-compute-util.cpp') diff --git a/tools/render-test/cpu-compute-util.cpp b/tools/render-test/cpu-compute-util.cpp index d69521e66..7be1a6c88 100644 --- a/tools/render-test/cpu-compute-util.cpp +++ b/tools/render-test/cpu-compute-util.cpp @@ -15,6 +15,36 @@ namespace renderer_test { using namespace Slang; +template +struct ValueTextureCube : public CPUComputeUtil::Resource, public CPPPrelude::ITextureCube +{ + void set(void* out) + { + float* dst = (float*)out; + for (int i = 0; i < COUNT; ++i) + { + dst[i] = m_value; + } + } + + virtual void Sample(CPPPrelude::SamplerState samplerState, const CPPPrelude::float3& loc, void* out) SLANG_OVERRIDE + { + set(out); + } + virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float3& loc, float level, void* out) SLANG_OVERRIDE + { + set(out); + } + + ValueTextureCube(float value) : + m_value(value) + { + m_interface = static_cast(this); + } + + float m_value; +}; + template struct ValueTexture3D : public CPUComputeUtil::Resource, public CPPPrelude::ITexture3D { @@ -118,10 +148,43 @@ struct ValueTexture1D : public CPUComputeUtil::Resource, public CPPPrelude::ITex }; +template +struct ValueTexture1DArray : public CPUComputeUtil::Resource, public CPPPrelude::ITexture1DArray +{ + void set(void* out) + { + float* dst = (float*)out; + for (int i = 0; i < COUNT; ++i) + { + dst[i] = m_value; + } + } -static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape baseShape, int elemCount, float value) + virtual void Load(const CPPPrelude::int3& v, void* out) SLANG_OVERRIDE + { + set(out); + } + virtual void Sample(CPPPrelude::SamplerState samplerState, const CPPPrelude::float2& loc, void* out) SLANG_OVERRIDE + { + set(out); + } + virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float2& loc, float level, void* out) SLANG_OVERRIDE + { + set(out); + } + + ValueTexture1DArray(float value) : + m_value(value) + { + m_interface = static_cast(this); + } + + float m_value; +}; + +static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape shape, int elemCount, float value) { - switch (baseShape) + switch (shape) { case SLANG_TEXTURE_1D: { @@ -157,6 +220,30 @@ static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape baseShape, default: break; } } + case SLANG_TEXTURE_CUBE: + { + switch (elemCount) + { + case 1: return new ValueTextureCube<1>(value); + case 2: return new ValueTextureCube<2>(value); + case 3: return new ValueTextureCube<3>(value); + case 4: return new ValueTextureCube<4>(value); + default: break; + } + } + case SLANG_TEXTURE_1D_ARRAY: + { + switch (elemCount) + { + case 1: return new ValueTexture1DArray<1>(value); + case 2: return new ValueTexture1DArray<2>(value); + case 3: return new ValueTexture1DArray<3>(value); + case 4: return new ValueTexture1DArray<4>(value); + default: break; + } + break; + } + default: break; } return nullptr; @@ -224,10 +311,9 @@ static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape baseShape, SLANG_ASSERT(value->m_userIndex >= 0); auto& srcEntry = layout.entries[value->m_userIndex]; - - // TODO(JS): - // We should use the srcEntry to determine what data to store in the texture, - // it's dimensions etc. For now we just support it being 1. + // TODO(JS): Currently we support only textures who's content is either + // 0 or 1. This is because this is easy to implement. + // Will need to do something better in the future.. slang::TypeReflection* typeReflection = typeLayout->getResourceResultType(); @@ -241,12 +327,12 @@ static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape baseShape, { case InputTextureContent::One: { - value->m_target = _newValueTexture(baseShape, count, 1.0f); + value->m_target = _newValueTexture(shape, count, 1.0f); break; } case InputTextureContent::Zero: { - value->m_target = _newValueTexture(baseShape, count, 0.0f); + value->m_target = _newValueTexture(shape, count, 0.0f); break; } default: break; @@ -335,13 +421,14 @@ static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape baseShape, assert(!"unhandled case"); break; case SLANG_TEXTURE_1D: + case SLANG_TEXTURE_2D: case SLANG_TEXTURE_3D: case SLANG_TEXTURE_CUBE: case SLANG_TEXTURE_BUFFER: - case SLANG_TEXTURE_2D: { Resource* targetResource = value ? static_cast(value->m_target.Ptr()) : nullptr; - *location.getUniform() = targetResource ? targetResource->getInterface() : nullptr; + void* intf = targetResource ? targetResource->getInterface() : nullptr; + *location.getUniform() = intf; break; } case SLANG_STRUCTURED_BUFFER: -- cgit v1.2.3