summaryrefslogtreecommitdiffstats
path: root/tools/render-test
diff options
context:
space:
mode:
Diffstat (limited to 'tools/render-test')
-rw-r--r--tools/render-test/cpu-compute-util.cpp496
-rw-r--r--tools/render-test/cuda/cuda-compute-util.cpp4
2 files changed, 195 insertions, 305 deletions
diff --git a/tools/render-test/cpu-compute-util.cpp b/tools/render-test/cpu-compute-util.cpp
index 3826ccec1..ea3927621 100644
--- a/tools/render-test/cpu-compute-util.cpp
+++ b/tools/render-test/cpu-compute-util.cpp
@@ -16,39 +16,29 @@ namespace renderer_test {
using namespace Slang;
template <int COUNT>
-struct ValueTextureCube : public CPUComputeUtil::Resource, public CPPPrelude::ITextureCube
+struct ValueTexture : public CPUComputeUtil::Resource, public CPPPrelude::ITexture
{
- void set(void* out)
+ // ITexture interface
+ virtual void Load(const int32_t* loc, void* out) SLANG_OVERRIDE
{
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
- {
- dst[i] = m_value;
- }
+ _set(out);
}
-
- virtual void Sample(CPPPrelude::SamplerState samplerState, const CPPPrelude::float3& loc, void* out) SLANG_OVERRIDE
+ virtual void Sample(CPPPrelude::SamplerState samplerState, const float* loc, void* out) SLANG_OVERRIDE
{
- set(out);
+ _set(out);
}
- virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float3& loc, float level, void* out) SLANG_OVERRIDE
+ virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const float* loc, float level, void* out) SLANG_OVERRIDE
{
- set(out);
+ _set(out);
}
- ValueTextureCube(float value) :
+ ValueTexture(float value) :
m_value(value)
{
- m_interface = static_cast<CPPPrelude::ITextureCube*>(this);
+ m_interface = static_cast<CPPPrelude::ITexture*>(this);
}
- float m_value;
-};
-
-template <int COUNT>
-struct ValueTexture3D : public CPUComputeUtil::Resource, public CPPPrelude::ITexture3D
-{
- void set(void* out)
+ void _set(void* out)
{
float* dst = (float*)out;
for (int i = 0; i < COUNT; ++i)
@@ -57,330 +47,258 @@ struct ValueTexture3D : public CPUComputeUtil::Resource, public CPPPrelude::ITex
}
}
- virtual void Load(const CPPPrelude::int4& v, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
- 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);
- }
-
- ValueTexture3D(float value) :
- m_value(value)
- {
- m_interface = static_cast<CPPPrelude::ITexture3D*>(this);
- }
-
float m_value;
};
-template <int COUNT>
-struct ValueTexture2D : public CPUComputeUtil::Resource, public CPPPrelude::ITexture2D
+class FloatTextureData
{
- void set(void* out)
+public:
+ FloatTextureData() {}
+ FloatTextureData(int elementCount, int dimCount, const uint32_t* dims)
{
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
- {
- dst[i] = m_value;
- }
+ init(elementCount, dimCount, dims);
}
- 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
+ void init(int elementCount, int dimCount, const uint32_t* dims)
{
- set(out);
- }
- virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float2& loc, float level, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
+ SLANG_ASSERT(elementCount >= 1 && elementCount <= 4);
+ SLANG_ASSERT(dimCount >= 1 && dimCount < 4);
- ValueTexture2D(float value):
- m_value(value)
- {
- m_interface = static_cast<CPPPrelude::ITexture2D*>(this);
- }
-
- float m_value;
-};
+ Index totalSize = 1;
-template <int COUNT>
-struct ValueTexture1D : public CPUComputeUtil::Resource, public CPPPrelude::ITexture1D
-{
- void set(void* out)
- {
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
+ for (Index i = 0; i < Index(dimCount); ++i)
{
- dst[i] = m_value;
+ m_dims[i] = (dims[i] <= 0) ? 1 : dims[i];
+ totalSize *= m_dims[i];
}
- }
- virtual void Load(const CPPPrelude::int2& v, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
- virtual void Sample(CPPPrelude::SamplerState samplerState, float loc, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
- virtual void SampleLevel(CPPPrelude::SamplerState samplerState, float loc, float level, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
+ m_dimCount = uint8_t(dimCount);
+ m_elementCount = uint8_t(elementCount);
- ValueTexture1D(float value) :
- m_value(value)
- {
- m_interface = static_cast<CPPPrelude::ITexture1D*>(this);
+ // Set the array to hold the total capacity needed
+ m_values.setCount(totalSize);
}
- float m_value;
-};
-
-
-template <int COUNT>
-struct ValueTexture1DArray : public CPUComputeUtil::Resource, public CPPPrelude::ITexture1DArray
-{
- void set(void* out)
+ void setValue(float value)
{
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
+ const Index count = m_values.getCount();
+ float* dst = m_values.getBuffer();
+
+ for (Index i = 0; i < count; ++i)
{
- dst[i] = m_value;
+ dst[i] = value;
}
}
- virtual void Load(const CPPPrelude::int3& v, void* out) SLANG_OVERRIDE
+ void setAt(const uint32_t* location, const float* value)
{
- 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);
+ const Index index = _getIndex(location);
+ float* dst = &m_values[index];
+ switch (m_elementCount)
+ {
+ case 1: dst[0] = value[0]; break;
+ case 2: dst[0] = value[0]; dst[1] = value[1]; break;
+ case 3: dst[0] = value[0]; dst[1] = value[1]; dst[2] = value[2]; break;
+ case 4: dst[0] = value[0]; dst[1] = value[1]; dst[2] = value[2]; dst[3] = value[3]; break;
+ }
}
- ValueTexture1DArray(float value) :
- m_value(value)
+ float* getAt(const uint32_t* location)
{
- m_interface = static_cast<CPPPrelude::ITexture1DArray*>(this);
+ const Index index = _getIndex(location);
+ return &m_values[index];
}
- float m_value;
-};
-
-template <int COUNT>
-struct ValueTexture2DArray : public CPUComputeUtil::Resource, public CPPPrelude::ITexture2DArray
-{
- void set(void* out)
+ void getAt(const uint32_t* location, float* dst)
{
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
+ const Index index = _getIndex(location);
+ float* value = &m_values[index];
+ switch (m_elementCount)
{
- dst[i] = m_value;
+ case 1: dst[0] = value[0]; break;
+ case 2: dst[0] = value[0]; dst[1] = value[1]; break;
+ case 3: dst[0] = value[0]; dst[1] = value[1]; dst[2] = value[2]; break;
+ case 4: dst[0] = value[0]; dst[1] = value[1]; dst[2] = value[2]; dst[3] = value[3]; break;
}
}
- virtual void Load(const CPPPrelude::int4& v, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
- virtual void Sample(CPPPrelude::SamplerState samplerState, const CPPPrelude::float3& loc, void* out) SLANG_OVERRIDE
+ bool isLocationValid(const uint32_t* location) const
{
- set(out);
- }
- virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float3& loc, float level, void* out) SLANG_OVERRIDE
- {
- set(out);
+ for (Index i = 0; i < m_dimCount; ++i)
+ {
+ const auto v = location[i];
+ if (v >= m_dims[i])
+ {
+ return false;
+ }
+ }
+ return true;
}
- ValueTexture2DArray(float value) :
- m_value(value)
+ Index _getIndex(const uint32_t* location)
{
- m_interface = static_cast<CPPPrelude::ITexture2DArray*>(this);
+ const auto style = (m_dimCount << 2) | m_elementCount;
+ SLANG_ASSERT(isLocationValid(location));
+ switch (m_dimCount)
+ {
+ default: return 0;
+ case 1: return (location[0] )* m_elementCount;
+ case 2: return (location[0] + location[1] * m_dims[0]) * m_elementCount;
+ case 3: return (location[0] + (location[1] + location[2] * m_dims[1]) * m_dims[0]) * m_elementCount;
+ case 4: return (location[0] + (location[1] + (location[2] + location[3] * m_dims[2]) * m_dims[1]) * m_dims[0]) * m_elementCount;
+ }
}
- float m_value;
-};
+ uint8_t m_style;
+ uint8_t m_elementCount; ///< Number of elements in each value
+ uint8_t m_dimCount;
+ uint32_t m_dims[4]; ///< Sizes in each dimension
+
+ List<float> m_values; ///< Holds the contained data
+};
-template <int COUNT>
-struct ValueTextureCubeArray : public CPUComputeUtil::Resource, public CPPPrelude::ITextureCubeArray
+// For a RWTexture we will define it to have memory, and that it can only be accessed via
+struct FloatRWTexture : public CPUComputeUtil::Resource, public CPPPrelude::IRWTexture
{
- void set(void* out)
- {
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
- {
- dst[i] = m_value;
- }
- }
+ // IRWTexture
+ virtual void Load(const int32_t* loc, void* out) SLANG_OVERRIDE { m_data.getAt((const uint32_t*)loc, (float*)out); }
+ virtual void* refAt(const uint32_t* loc) SLANG_OVERRIDE { return m_data.getAt(loc); }
- virtual void Sample(CPPPrelude::SamplerState samplerState, const CPPPrelude::float4& loc, void* out) SLANG_OVERRIDE
+ FloatRWTexture(int elementCount, int dimsCount, const uint32_t* dims, float initialValue)
{
- set(out);
- }
- virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float4& loc, float level, void* out) SLANG_OVERRIDE
- {
- set(out);
+ m_data.init(elementCount, dimsCount, dims);
+ m_data.setValue(initialValue);
+ m_interface = static_cast<CPPPrelude::IRWTexture*>(this);
}
- ValueTextureCubeArray(float value) :
- m_value(value)
- {
- m_interface = static_cast<CPPPrelude::ITextureCubeArray*>(this);
- }
-
- float m_value;
+ FloatTextureData m_data;
};
-
-template <int COUNT>
-struct ValueRWTexture1D : public CPUComputeUtil::Resource, public CPPPrelude::IRWTexture1D
+static int _calcDims(const InputTextureDesc& desc, slang::TypeLayoutReflection* typeLayout, uint32_t outDims[4])
{
- void set(void* out)
- {
- float* dst = (float*)out;
- for (int i = 0; i < COUNT; ++i)
- {
- dst[i] = m_value;
- }
- }
+ const auto kind = typeLayout->getKind();
+ SLANG_ASSERT(kind == slang::TypeReflection::Kind::Resource);
- virtual void Load(int32_t loc, void* out) SLANG_OVERRIDE
- {
- set(out);
- }
+ auto type = typeLayout->getType();
+ auto shape = type->getResourceShape();
- ValueRWTexture1D(float value) :
- m_value(value)
- {
- m_interface = static_cast<CPPPrelude::IRWTexture1D*>(this);
- }
-
- float m_value;
-};
+ const uint32_t size = uint32_t(desc.size);
+ const auto baseShape = (shape & SLANG_RESOURCE_BASE_SHAPE_MASK);
+ int dimsCount = 0;
-static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape shape, SlangResourceAccess access, Index elemCount, float value)
-{
- switch (shape)
+ switch (baseShape)
{
case SLANG_TEXTURE_1D:
{
- if (access == SLANG_RESOURCE_ACCESS_READ_WRITE)
- {
- switch (elemCount)
- {
- case 1: return new ValueRWTexture1D<1>(value);
- case 2: return new ValueRWTexture1D<2>(value);
- case 3: return new ValueRWTexture1D<3>(value);
- case 4: return new ValueRWTexture1D<4>(value);
- default: break;
- }
- }
- else
- {
- switch (elemCount)
- {
- case 1: return new ValueTexture1D<1>(value);
- case 2: return new ValueTexture1D<2>(value);
- case 3: return new ValueTexture1D<3>(value);
- case 4: return new ValueTexture1D<4>(value);
- default: break;
- }
- }
+ outDims[dimsCount++] = size;
break;
}
case SLANG_TEXTURE_2D:
{
- switch (elemCount)
- {
- case 1: return new ValueTexture2D<1>(value);
- case 2: return new ValueTexture2D<2>(value);
- case 3: return new ValueTexture2D<3>(value);
- case 4: return new ValueTexture2D<4>(value);
- default: break;
- }
- }
- case SLANG_TEXTURE_3D:
- {
- switch (elemCount)
- {
- case 1: return new ValueTexture3D<1>(value);
- case 2: return new ValueTexture3D<2>(value);
- case 3: return new ValueTexture3D<3>(value);
- case 4: return new ValueTexture3D<4>(value);
- 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;
- }
+ outDims[dimsCount++] = size;
+ outDims[dimsCount++] = size;
break;
}
- case SLANG_TEXTURE_2D_ARRAY:
+ case SLANG_TEXTURE_3D:
{
- switch (elemCount)
- {
- case 1: return new ValueTexture2DArray<1>(value);
- case 2: return new ValueTexture2DArray<2>(value);
- case 3: return new ValueTexture2DArray<3>(value);
- case 4: return new ValueTexture2DArray<4>(value);
- default: break;
- }
+ outDims[dimsCount++] = size;
+ outDims[dimsCount++] = size;
+ outDims[dimsCount++] = size;
break;
}
- case SLANG_TEXTURE_CUBE_ARRAY:
+ case SLANG_TEXTURE_CUBE:
{
- switch (elemCount)
- {
- case 1: return new ValueTextureCubeArray<1>(value);
- case 2: return new ValueTextureCubeArray<2>(value);
- case 3: return new ValueTextureCubeArray<3>(value);
- case 4: return new ValueTextureCubeArray<4>(value);
- default: break;
- }
+ outDims[dimsCount++] = size;
+ outDims[dimsCount++] = size;
+ outDims[dimsCount++] = 6;
break;
}
+ }
+ if (shape & SLANG_TEXTURE_ARRAY_FLAG)
+ {
+ uint32_t arrayLength = uint32_t(desc.arrayLength);
+ outDims[dimsCount++] = arrayLength;
+ }
+
+ return dimsCount;
+}
+static CPUComputeUtil::Resource* _newReadTexture(int elemCount, SlangResourceShape shape, float initialValue)
+{
+ switch (elemCount)
+ {
+ case 1: return new ValueTexture<1>(initialValue);
+ case 2: return new ValueTexture<2>(initialValue);
+ case 3: return new ValueTexture<3>(initialValue);
+ case 4: return new ValueTexture<4>(initialValue);
default: break;
}
return nullptr;
}
+static SlangResult _newTexture(const InputTextureDesc& desc, slang::TypeLayoutReflection* typeLayout, RefPtr<CPUComputeUtil::Resource>& outResource)
+{
+ const auto kind = typeLayout->getKind();
+ SLANG_ASSERT(kind == slang::TypeReflection::Kind::Resource);
+
+ auto type = typeLayout->getType();
+ auto shape = type->getResourceShape();
+
+ auto access = type->getResourceAccess();
+
+ // 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();
+
+ int elemCount = 1;
+ if (typeReflection->getKind() == slang::TypeReflection::Kind::Vector)
+ {
+ elemCount = int(typeReflection->getElementCount());
+ }
+
+ float initialValue = 0.0f;
+
+ switch (desc.content)
+ {
+ case InputTextureContent::One: initialValue = 1.0f; break;
+ case InputTextureContent::Zero: initialValue = 0.0f; break;
+ default: break;
+ }
+
+ // These need a different style of texture if can be written to
+ if (access == SLANG_RESOURCE_ACCESS_READ_WRITE)
+ {
+ uint32_t dims[4];
+ const int dimsCount = _calcDims(desc, typeLayout, dims);
+
+ switch (shape)
+ {
+ case SLANG_TEXTURE_1D:
+ case SLANG_TEXTURE_2D:
+ case SLANG_TEXTURE_3D:
+ case SLANG_TEXTURE_CUBE:
+ case SLANG_TEXTURE_1D_ARRAY:
+ case SLANG_TEXTURE_2D_ARRAY:
+ {
+ outResource = new FloatRWTexture(elemCount, dimsCount, dims, initialValue);
+ return SLANG_OK;
+ }
+ }
+ }
+ else
+ {
+ outResource = _newReadTexture(elemCount, shape, initialValue);
+ return outResource ? SLANG_OK : SLANG_FAIL;
+ }
+
+ return SLANG_FAIL;
+}
+
/* static */SlangResult CPUComputeUtil::calcBindings(const ShaderCompilerUtil::OutputAndLayout& compilationAndLayout, Context& outContext)
{
auto request = compilationAndLayout.output.request;
@@ -443,39 +361,9 @@ static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape shape, Slan
SLANG_ASSERT(value->m_userIndex >= 0);
auto& srcEntry = layout.entries[value->m_userIndex];
- // 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();
-
- Index count = 1;
- if (typeReflection->getKind() == slang::TypeReflection::Kind::Vector)
- {
- count = Index(typeReflection->getElementCount());
- }
-
- switch (srcEntry.textureDesc.content)
- {
- case InputTextureContent::One:
- {
- value->m_target = _newValueTexture(shape, access, count, 1.0f);
- break;
- }
- case InputTextureContent::Zero:
- {
- value->m_target = _newValueTexture(shape, access, count, 0.0f);
- break;
- }
- default: break;
- }
-
- if (value->m_target == nullptr)
- {
- SLANG_ASSERT(!"Couldn't construct resource type");
- return SLANG_FAIL;
- }
-
+ RefPtr<CPUComputeUtil::Resource> resource;
+ SLANG_RETURN_ON_FAIL(_newTexture(srcEntry.textureDesc, typeLayout, resource));
+ value->m_target = resource;
break;
}
case SLANG_TEXTURE_BUFFER:
diff --git a/tools/render-test/cuda/cuda-compute-util.cpp b/tools/render-test/cuda/cuda-compute-util.cpp
index b21b22b30..96b4e3b3e 100644
--- a/tools/render-test/cuda/cuda-compute-util.cpp
+++ b/tools/render-test/cuda/cuda-compute-util.cpp
@@ -928,7 +928,9 @@ static SlangResult _compute(CUcontext context, CUmodule module, const ShaderComp
auto access = type->getResourceAccess();
- switch (shape & SLANG_RESOURCE_BASE_SHAPE_MASK)
+ const auto baseShape = shape & SLANG_RESOURCE_BASE_SHAPE_MASK;
+
+ switch (baseShape)
{
case SLANG_STRUCTURED_BUFFER:
{
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 15:23:02 +0000