CUDA/CPU support for 1D, 2D, CubeArray (shader-slang#1232)

* CUDA support for array of resources.

* * Add support for Texture2DArray on CPU
* Expand texture-simple.slang to test Texture2DArray

* Reorganise CUDAComputeUtil to split out createTextureResource.

* Add TextureCubeArray support for CPU/CUDA targets.

Author: jsmall-zzz

prelude/slang-cpp-types.h

@@ -311,6 +311,38 @@ struct Texture1DArray
     ITexture1DArray* texture;              
 };
 
+struct ITexture2DArray
+{
+    virtual void Load(const int4& v, void* out) = 0;
+    virtual void Sample(SamplerState samplerState, const float3& loc, void* out) = 0;
+    virtual void SampleLevel(SamplerState samplerState, const float3& loc, float level, void* out) = 0;
+};
+
+template <typename T>
+struct Texture2DArray
+{
+    T Load(const int4& v) const { T out; texture->Load(v, &out); return out; }
+    T Sample(SamplerState samplerState, const float3& v) const { T out; texture->Sample(samplerState, v, &out); return out; }
+    T SampleLevel(SamplerState samplerState, const float3& v, float level) { T out; texture->SampleLevel(samplerState, v, level, &out); return out; }
+    
+    ITexture2DArray* texture;              
+};
+
+struct ITextureCubeArray
+{
+    virtual void Sample(SamplerState samplerState, const float4& loc, void* out) = 0;
+    virtual void SampleLevel(SamplerState samplerState, const float4& loc, float level, void* out) = 0;
+};
+
+template <typename T>
+struct TextureCubeArray
+{
+    T Sample(SamplerState samplerState, const float4& v) const { T out; texture->Sample(samplerState, v, &out); return out; }
+    T SampleLevel(SamplerState samplerState, const float4& v, float level) { T out; texture->SampleLevel(samplerState, v, level, &out); return out; }
+    
+    ITextureCubeArray* texture;              
+};
+
 /* Varying input for Compute */
 
 /* Used when running a single thread */

tests/compute/texture-simple.slang

@@ -17,6 +17,10 @@ TextureCube<float> tCube;
 
 //TEST_INPUT: Texture1D(size=4, content = one, arrayLength=2):name t1DArray
 Texture1DArray<float> t1DArray;
+//TEST_INPUT: Texture2D(size=4, content = one, arrayLength=2):name t2DArray
+Texture2DArray<float> t2DArray;
+//TEST_INPUT: TextureCube(size=4, content = one, arrayLength=2):name tCubeArray
+TextureCubeArray<float> tCubeArray;
 
 //TEST_INPUT: Sampler:name samplerState
 SamplerState samplerState;
@@ -37,6 +41,8 @@ void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
     val += tCube.SampleLevel(samplerState, normalize(float3(u, 1 - u, u)), 0);
 
     val += t1DArray.SampleLevel(samplerState, float2(u, 0), 0);
+    val += t2DArray.SampleLevel(samplerState, float3(u, u, 0), 0);
+    val += tCubeArray.SampleLevel(samplerState, float4(u, u, u, 0), 0);
 
     outputBuffer[idx] = val;
 }

tests/compute/texture-simple.slang.expected.txt

@@ -1,4 +1,4 @@
-40A00000
-40A00000
-40A00000
-40A00000
+40E00000
+40E00000
+40E00000
+40E00000

tools/render-test/cpu-compute-util.cpp

@@ -182,6 +182,71 @@ struct ValueTexture1DArray : public CPUComputeUtil::Resource, public CPPPrelude:
     float m_value;
 };
 
+template <int COUNT>
+struct ValueTexture2DArray : public CPUComputeUtil::Resource, public CPPPrelude::ITexture2DArray
+{
+    void set(void* out)
+    {
+        float* dst = (float*)out;
+        for (int i = 0; i < COUNT; ++i)
+        {
+            dst[i] = m_value;
+        }
+    }
+
+    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);
+    }
+
+    ValueTexture2DArray(float value) :
+        m_value(value)
+    {
+        m_interface = static_cast<CPPPrelude::ITexture2DArray*>(this);
+    }
+
+    float m_value;
+};
+
+
+template <int COUNT>
+struct ValueTextureCubeArray : public CPUComputeUtil::Resource, public CPPPrelude::ITextureCubeArray
+{
+    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::float4& loc, void* out) SLANG_OVERRIDE
+    {
+        set(out);
+    }
+    virtual void SampleLevel(CPPPrelude::SamplerState samplerState, const CPPPrelude::float4& loc, float level, void* out) SLANG_OVERRIDE
+    {
+        set(out);
+    }
+
+    ValueTextureCubeArray(float value) :
+        m_value(value)
+    {
+        m_interface = static_cast<CPPPrelude::ITextureCubeArray*>(this);
+    }
+
+    float m_value;
+};
+
 static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape shape, int elemCount, float value)
 {
     switch (shape)
@@ -243,6 +308,31 @@ static CPUComputeUtil::Resource* _newValueTexture(SlangResourceShape shape, int
             }
             break;
         }
+        case SLANG_TEXTURE_2D_ARRAY:
+        {
+            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;
+            }
+            break;
+        }
+        case SLANG_TEXTURE_CUBE_ARRAY:
+        {
+            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;
+            }
+            break;
+        }
+
 
         default: break;
     }