CPU Texture GetDimensions support (#1283)

* Added CPU support for GetDimensions on C++/CPU target.
Added texture-get-dimension.slang test

* Fix some typos.

* Update CUDA docs.

* Fix output of GetDimensions on glsl when has an array.
Disabled VK - because VK renderer doesn't support createTextureView

* Fix typo.

* Fix typo.

* Fix bad-operator-call diagnostics output.

3 files changed, 152 insertions, 38 deletions

diff --git a/tests/compute/texture-get-dimensions.slang b/tests/compute/texture-get-dimensions.slang
new file mode 100644
index 000000000..67c1fddc8
--- /dev/null
+++ b/tests/compute/texture-get-dimensions.slang
@@ -0,0 +1,106 @@
+//TEST(compute):COMPARE_COMPUTE_EX:-cpu -compute 
+//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute
+//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -dx12 
+//TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -dx12 -profile cs_6_0 -use-dxil
+// TODO(JS): Doesn't work on vk currently, because createTextureView not implemented on vk renderer
+//DISABLE_TEST(compute, vulkan):COMPARE_COMPUTE_EX:-vk -compute
+// TODO(JS): Doesn't work on CUDA as there aren't any CUDA functions to get dimensions.
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-cuda -compute 
+
+//TEST_INPUT: Texture1D(size=4, content = one):name t1D
+Texture1D<float> t1D;
+//TEST_INPUT: Texture2D(size=8, content = one):name t2D
+Texture2D<float> t2D;
+//TEST_INPUT: Texture3D(size=2, content = one):name t3D
+Texture3D<float> t3D;
+//TEST_INPUT: TextureCube(size=16, content = one):name tCube
+TextureCube<float> tCube;
+
+//TEST_INPUT: Texture1D(size=2, content = one, arrayLength=2):name t1DArray
+Texture1DArray<float> t1DArray;
+//TEST_INPUT: Texture2D(size=4, content = one, arrayLength=3):name t2DArray
+Texture2DArray<float> t2DArray;
+//TEST_INPUT: TextureCube(size=16, content = one, arrayLength=1):name tCubeArray
+TextureCubeArray<float> tCubeArray;
+
+//TEST_INPUT: Sampler:name samplerState
+SamplerState samplerState;
+
+//TEST_INPUT: ubuffer(data=[0 0 0 0 0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+[numthreads(8, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int idx = dispatchThreadID.x;
+    
+    uint mipWidth = 0;
+    uint mipHeight = 0;
+    uint mipDepth = 0;
+    uint mipCount = 1;
+    uint elementCount = 0;
+    
+    uint width = 0;
+    uint height = 0;
+    uint depth = 0;
+    
+    switch (idx)
+    {
+        case 0:
+        {
+            t1D.GetDimensions(width);
+            t1D.GetDimensions(0, mipWidth, mipCount);
+            break;
+        }
+        case 1:
+        {
+            t2D.GetDimensions(width, height);
+            t2D.GetDimensions(0, mipWidth, mipHeight, mipCount);
+            break;
+        }
+        case 2:
+        {
+            t3D.GetDimensions(width, height, depth);
+            t3D.GetDimensions(0, mipWidth, mipHeight, mipDepth, mipCount);
+            break;
+        }
+        case 3:
+        {
+            tCube.GetDimensions(width, height);
+            tCube.GetDimensions(0, mipWidth, mipHeight, mipCount);
+            break;
+        }
+        case 4:
+        {
+           t1DArray.GetDimensions(width, elementCount);
+           t1DArray.GetDimensions(0, mipWidth, elementCount, mipCount);
+           break;
+        }
+        case 5:
+        {
+           t2DArray.GetDimensions(width, height, elementCount);
+           t2DArray.GetDimensions(0, mipWidth, mipHeight, elementCount, mipCount);
+           break;
+        }
+        case 6:
+        {
+           tCubeArray.GetDimensions(width, height, elementCount);
+           tCubeArray.GetDimensions(0, mipWidth, mipHeight, elementCount, mipCount);
+           break;
+        }
+    }
+   
+    width = (mipWidth != width) ? ~0 : width;
+    height = (mipHeight != height) ? ~0 : height;
+    depth = (mipDepth != depth) ? ~0 : depth;
+   
+    // Only depth or element count can be set
+    if (depth == 0 && elementCount > 0)
+    {
+        depth = elementCount;
+    }
+   
+    uint val = ((0xff & width) << 24) | ((0xff & height) << 16) | ((0xff & depth) << 8) | (mipCount);
+   
+    outputBuffer[idx] = val;
+}
diff --git a/tests/compute/texture-get-dimensions.slang.expected.txt b/tests/compute/texture-get-dimensions.slang.expected.txt
new file mode 100644
index 000000000..3b060b4ae
--- /dev/null
+++ b/tests/compute/texture-get-dimensions.slang.expected.txt
@@ -0,0 +1,8 @@
+4C800000
+4D008000
+4C008080
+4D808000
+4C000080
+4C808060
+4D808008
+3F800000
diff --git a/tests/diagnostics/bad-operator-call.slang.expected b/tests/diagnostics/bad-operator-call.slang.expected
index f41fdf7c0..fd85fdbfc 100644
--- a/tests/diagnostics/bad-operator-call.slang.expected
+++ b/tests/diagnostics/bad-operator-call.slang.expected
@@ -1,51 +1,51 @@
 result code = -1
 standard error = {
 tests/diagnostics/bad-operator-call.slang(17): error 39999: no overload for '+=' applicable to arguments of type (int, S)
-core.meta.slang(1756): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, T) -> matrix<T,R,C>
-core.meta.slang(1748): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
-core.meta.slang(1740): note 39999: candidate: func +=<T, N:int>(vector<T,N>, T) -> vector<T,N>
-core.meta.slang(1732): note 39999: candidate: func +=<T, N:int>(vector<T,N>, vector<T,N>) -> vector<T,N>
-core.meta.slang(1724): note 39999: candidate: func +=<T>(T, T) -> T
+core.meta.slang(1745): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, T) -> matrix<T,R,C>
+core.meta.slang(1737): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
+core.meta.slang(1729): note 39999: candidate: func +=<T, N:int>(vector<T,N>, T) -> vector<T,N>
+core.meta.slang(1721): note 39999: candidate: func +=<T, N:int>(vector<T,N>, vector<T,N>) -> vector<T,N>
+core.meta.slang(1713): note 39999: candidate: func +=<T>(T, T) -> T
 tests/diagnostics/bad-operator-call.slang(19): error 39999: no overload for '+' applicable to arguments of type (int, S)
-core.meta.slang(1646): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
-core.meta.slang(1639): note 39999: candidate: func +(uint, uint) -> uint
-core.meta.slang(1632): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
-core.meta.slang(1625): note 39999: candidate: func +(uint8_t, uint8_t) -> uint8_t
-core.meta.slang(1618): note 39999: candidate: func +(double, double) -> double
-core.meta.slang(1611): note 39999: candidate: func +(float, float) -> float
-core.meta.slang(1604): note 39999: candidate: func +(half, half) -> half
-core.meta.slang(1597): note 39999: candidate: func +(int64_t, int64_t) -> int64_t
-core.meta.slang(1590): note 39999: candidate: func +(int, int) -> int
-core.meta.slang(1583): note 39999: candidate: func +(int16_t, int16_t) -> int16_t
+core.meta.slang(1635): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
+core.meta.slang(1628): note 39999: candidate: func +(uint, uint) -> uint
+core.meta.slang(1621): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
+core.meta.slang(1614): note 39999: candidate: func +(uint8_t, uint8_t) -> uint8_t
+core.meta.slang(1607): note 39999: candidate: func +(double, double) -> double
+core.meta.slang(1600): note 39999: candidate: func +(float, float) -> float
+core.meta.slang(1593): note 39999: candidate: func +(half, half) -> half
+core.meta.slang(1586): note 39999: candidate: func +(int64_t, int64_t) -> int64_t
+core.meta.slang(1579): note 39999: candidate: func +(int, int) -> int
+core.meta.slang(1572): note 39999: candidate: func +(int16_t, int16_t) -> int16_t
 tests/diagnostics/bad-operator-call.slang(19): note 39999: 1 more overload candidates
 tests/diagnostics/bad-operator-call.slang(21): error 39999: no overload for '~' applicable to arguments of type (S)
-slang-stdlib.cpp(1638): note 39999: candidate: func ~(uint64_t) -> uint64_t
-slang-stdlib.cpp(1635): note 39999: candidate: func ~(uint) -> uint
-slang-stdlib.cpp(1632): note 39999: candidate: func ~(uint16_t) -> uint16_t
-slang-stdlib.cpp(1629): note 39999: candidate: func ~(uint8_t) -> uint8_t
-slang-stdlib.cpp(1626): note 39999: candidate: func ~(int64_t) -> int64_t
-slang-stdlib.cpp(1623): note 39999: candidate: func ~(int) -> int
-slang-stdlib.cpp(1620): note 39999: candidate: func ~(int16_t) -> int16_t
-slang-stdlib.cpp(1617): note 39999: candidate: func ~(int8_t) -> int8_t
+slang-stdlib.cpp(1646): note 39999: candidate: func ~(uint64_t) -> uint64_t
+slang-stdlib.cpp(1643): note 39999: candidate: func ~(uint) -> uint
+slang-stdlib.cpp(1640): note 39999: candidate: func ~(uint16_t) -> uint16_t
+slang-stdlib.cpp(1637): note 39999: candidate: func ~(uint8_t) -> uint8_t
+slang-stdlib.cpp(1634): note 39999: candidate: func ~(int64_t) -> int64_t
+slang-stdlib.cpp(1631): note 39999: candidate: func ~(int) -> int
+slang-stdlib.cpp(1628): note 39999: candidate: func ~(int16_t) -> int16_t
+slang-stdlib.cpp(1625): note 39999: candidate: func ~(int8_t) -> int8_t
 tests/diagnostics/bad-operator-call.slang(26): error 30047: argument passed to parameter '0' must be l-value.
 tests/diagnostics/bad-operator-call.slang(26): note 30048: argument was implicitly cast from 'int' to 'vector<int,4>', and Slang does not support using an implicit cast as an l-value
 tests/diagnostics/bad-operator-call.slang(30): error 39999: no overload for '+=' applicable to arguments of type (vector<float,3>, vector<int,4>)
-core.meta.slang(1756): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, T) -> matrix<T,R,C>
-core.meta.slang(1748): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
-core.meta.slang(1740): note 39999: candidate: func +=<T, N:int>(vector<T,N>, T) -> vector<T,N>
-core.meta.slang(1732): note 39999: candidate: func +=<T, N:int>(vector<T,N>, vector<T,N>) -> vector<T,N>
-core.meta.slang(1724): note 39999: candidate: func +=<T>(T, T) -> T
+core.meta.slang(1745): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, T) -> matrix<T,R,C>
+core.meta.slang(1737): note 39999: candidate: func +=<T, R:int, C:int>(matrix<T,R,C>, matrix<T,R,C>) -> matrix<T,R,C>
+core.meta.slang(1729): note 39999: candidate: func +=<T, N:int>(vector<T,N>, T) -> vector<T,N>
+core.meta.slang(1721): note 39999: candidate: func +=<T, N:int>(vector<T,N>, vector<T,N>) -> vector<T,N>
+core.meta.slang(1713): note 39999: candidate: func +=<T>(T, T) -> T
 tests/diagnostics/bad-operator-call.slang(32): error 39999: no overload for '+' applicable to arguments of type (vector<int,4>, vector<float,3>)
-core.meta.slang(1651): note 39999: candidate: func +<4>(vector<uint64_t,4>, uint64_t) -> vector<uint64_t,4>
-core.meta.slang(1649): note 39999: candidate: func +<3>(uint64_t, vector<uint64_t,3>) -> vector<uint64_t,3>
-core.meta.slang(1646): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
-core.meta.slang(1644): note 39999: candidate: func +<4>(vector<uint,4>, uint) -> vector<uint,4>
-core.meta.slang(1642): note 39999: candidate: func +<3>(uint, vector<uint,3>) -> vector<uint,3>
-core.meta.slang(1639): note 39999: candidate: func +(uint, uint) -> uint
-core.meta.slang(1637): note 39999: candidate: func +<4>(vector<uint16_t,4>, uint16_t) -> vector<uint16_t,4>
-core.meta.slang(1635): note 39999: candidate: func +<3>(uint16_t, vector<uint16_t,3>) -> vector<uint16_t,3>
-core.meta.slang(1632): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
-core.meta.slang(1630): note 39999: candidate: func +<4>(vector<uint8_t,4>, uint8_t) -> vector<uint8_t,4>
+core.meta.slang(1640): note 39999: candidate: func +<4>(vector<uint64_t,4>, uint64_t) -> vector<uint64_t,4>
+core.meta.slang(1638): note 39999: candidate: func +<3>(uint64_t, vector<uint64_t,3>) -> vector<uint64_t,3>
+core.meta.slang(1635): note 39999: candidate: func +(uint64_t, uint64_t) -> uint64_t
+core.meta.slang(1633): note 39999: candidate: func +<4>(vector<uint,4>, uint) -> vector<uint,4>
+core.meta.slang(1631): note 39999: candidate: func +<3>(uint, vector<uint,3>) -> vector<uint,3>
+core.meta.slang(1628): note 39999: candidate: func +(uint, uint) -> uint
+core.meta.slang(1626): note 39999: candidate: func +<4>(vector<uint16_t,4>, uint16_t) -> vector<uint16_t,4>
+core.meta.slang(1624): note 39999: candidate: func +<3>(uint16_t, vector<uint16_t,3>) -> vector<uint16_t,3>
+core.meta.slang(1621): note 39999: candidate: func +(uint16_t, uint16_t) -> uint16_t
+core.meta.slang(1619): note 39999: candidate: func +<4>(vector<uint8_t,4>, uint8_t) -> vector<uint8_t,4>
 tests/diagnostics/bad-operator-call.slang(32): note 39999: 23 more overload candidates
 }
 standard output = {