Attachment 372378 Details for Bug 198704 – WIP

[patch] WIP

bug-198704-20190618135622.patch (text/plain), 1.42 MB, created by Myles C. Maxfield on 2019-06-18 13:56:24 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2019-06-18 13:56:24 PDT

Size: 1.42 MB

patch

obsolete

>Subversion Revision: 246531
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 61548b320a7c9508f93d4bae785b46e4ae698e61..aa2c713f7a9c8ec40da43a8b25b6f21e65bde188 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,66 @@
>+2019-06-18  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [WHLSL] Hook up common texture functions
>+        https://bugs.webkit.org/show_bug.cgi?id=198704
>+
>+        This patch adds the Metal implementation of the Sample(), Load(), Store(), and GetDimensions()
>+        texture functions. The implementation simply performs string concatenation to produce the 
>+        correct results, and adds many new native functions to the standard library.
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Tests: webgpu/whlsl-textures-getdimensions.html
>+               webgpu/whlsl-textures-load.html
>+               webgpu/whlsl-textures-sample.html
>+               webgpu/whlsl-textures-store.html
>+
>+        * Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h: Add some more introspection functions
>+        so we can generate the necessary Metal functions for the appropriate texture types.
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::isTextureArray const):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::isDepthTexture const):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::isWritableTexture const):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::textureDimension const):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::setIsTextureArray):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::setIsDepthTexture):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::setIsWritableTexture):
>+        (WebCore::WHLSL::AST::NativeTypeDeclaration::setTextureDimension):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp: Native types can be passed into 
>+        entry points, too.
>+        (WebCore::WHLSL::Metal::EntryPointScaffolding::resourceHelperTypes):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp: Entry points that return void don't need a
>+        semantic.
>+        (WebCore::WHLSL::Metal::FunctionDefinitionWriter::visit):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp: Implement the functions.
>+        (WebCore::WHLSL::Metal::vectorLength):
>+        (WebCore::WHLSL::Metal::vectorInnerType):
>+        (WebCore::WHLSL::Metal::vectorSuffix):
>+        (WebCore::WHLSL::Metal::writeNativeFunction):
>+        * Modules/webgpu/WHLSL/Metal/WHLSLNativeTypeWriter.cpp: Textures come in two flavors: sample-able
>+        and read/write-able. Make sure we produce the correct Metal types for them.
>+        (WebCore::WHLSL::Metal::writeNativeType):
>+        * Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp: Implement the introspection functions.
>+        (WebCore::WHLSL::Intrinsics::addFullTexture):
>+        (WebCore::WHLSL::Intrinsics::addDepthTexture):
>+        * Modules/webgpu/WHLSL/WHLSLIntrinsics.h: Nested NameResolvers need to propagate their error. Also,
>+        native functions with named arguments shouldn't be adding their arguments to the global scope.
>+        (WebCore::WHLSL::Intrinsics::WTF_ARRAY_LENGTH):
>+        * Modules/webgpu/WHLSL/WHLSLNameResolver.cpp:
>+        (WebCore::WHLSL::NameResolver::visit):
>+        * Modules/webgpu/WHLSL/WHLSLNameResolver.h:
>+        * Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt: Metal doesn't have writable depth textures.
>+        * platform/graphics/gpu/GPUTexture.h:
>+        (WebCore::GPUTexture::isSampled const):
>+        (WebCore::GPUTexture::isStorage const):
>+        * platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm:
>+        (WebCore::GPUBindGroup::tryCreate):
>+        * platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm:
>+        (WebCore::trySetFunctions):
>+        * platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm: Make sure we hook up the usage
>+        flags correctly. This is important because textures don't work correctly if they have the wrong usages.
>+        (WebCore::GPUProgrammablePassEncoder::setBindGroup):
>+        * platform/graphics/gpu/cocoa/GPUTextureMetal.mm: Ditto.
>+        (WebCore::mtlTextureUsageForGPUTextureUsageFlags):
>+
> 2019-06-17  Sihui Liu  <sihui_liu@apple.com>
> 
>         -[WKWebsiteDataStore removeDataOfTypes:modifiedSince:completionHandler:] doesn't delete _WKWebsiteDataTypeCredentials
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h
>index fbd4ffbc6817a37393f66f9f6188d7c79e1ec69d..b6b62f85eb2ba879c0d8370dfbd858876e2ecbac 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLNativeTypeDeclaration.h
>@@ -59,10 +59,14 @@ public:
>     bool isInt() const { return m_isInt; }
>     bool isNumber() const { return m_isNumber; }
>     bool isFloating() const { return m_isFloating; }
>-    bool isAtom() const { return m_isAtomic; }
>+    bool isAtomic() const { return m_isAtomic; }
>     bool isVector() const { return m_isVector; }
>     bool isMatrix() const { return m_isMatrix; }
>     bool isTexture() const { return m_isTexture; }
>+    bool isTextureArray() const { return m_isTextureArray; }
>+    bool isDepthTexture() const { return m_isDepthTexture; }
>+    bool isWritableTexture() const { return m_isWritableTexture; }
>+    uint textureDimension() const { return m_textureDimension; }
>     bool isSigned() const { return m_isSigned; }
>     const std::function<bool(int)>& canRepresentInteger() const { return m_canRepresentInteger; }
>     const std::function<bool(unsigned)>& canRepresentUnsignedInteger() const { return m_canRepresentUnsignedInteger; }
>@@ -79,6 +83,10 @@ public:
>     void setIsVector() { m_isVector = true; }
>     void setIsMatrix() { m_isMatrix = true; }
>     void setIsTexture() { m_isTexture = true; }
>+    void setIsTextureArray() { m_isTextureArray = true; }
>+    void setIsDepthTexture() { m_isDepthTexture = true; }
>+    void setIsWritableTexture() { m_isWritableTexture = true; }
>+    void setTextureDimension(uint textureDimension) { m_textureDimension = textureDimension; }
>     void setIsSigned() { m_isSigned = true; }
>     void setCanRepresentInteger(std::function<bool(int)>&& canRepresent) { m_canRepresentInteger = WTFMove(canRepresent); }
>     void setCanRepresentUnsignedInteger(std::function<bool(unsigned)>&& canRepresent) { m_canRepresentUnsignedInteger = WTFMove(canRepresent); }
>@@ -97,6 +105,7 @@ private:
>     std::function<int64_t(int)> m_formatValueFromInteger;
>     std::function<int64_t(unsigned)> m_formatValueFromUnsignedInteger;
>     std::function<void(const std::function<bool(int64_t)>&)> m_iterateAllValues;
>+    uint m_textureDimension { 0 };
>     bool m_isInt { false };
>     bool m_isNumber { false };
>     bool m_isFloating { false };
>@@ -104,6 +113,9 @@ private:
>     bool m_isVector { false };
>     bool m_isMatrix { false };
>     bool m_isTexture { false };
>+    bool m_isTextureArray { false };
>+    bool m_isDepthTexture { false };
>+    bool m_isWritableTexture { false };
>     bool m_isSigned { false };
> };
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
>index ec45da13f86e34248eade0cdd0de50556737b14f..e81de4afc5afa258f4d12059d05990603dbb7e90 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
>@@ -147,15 +147,23 @@ String EntryPointScaffolding::resourceHelperTypes()
>             auto iterator = m_resourceMap.find(&m_layout[i].bindings[j]);
>             if (iterator == m_resourceMap.end())
>                 continue;
>-            auto& unnamedType = *m_entryPointItems.inputs[iterator->value].unnamedType;
>-            auto& referenceType = downcast<AST::ReferenceType>(unnamedType);
>-            auto mangledTypeName = m_typeNamer.mangledNameForType(referenceType.elementType());
>-            auto addressSpace = toString(referenceType.addressSpace());
>-            auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
>-            auto index = m_namedBindGroups[i].namedBindings[j].index;
>-            stringBuilder.append(makeString("    ", addressSpace, " ", mangledTypeName, "* ", elementName, " [[id(", index, ")]];\n"));
>-            if (auto lengthInformation = m_namedBindGroups[i].namedBindings[j].lengthInformation)
>-                stringBuilder.append(makeString("    uint2 ", lengthInformation->elementName, " [[id(", lengthInformation->index, ")]];\n"));
>+            auto& type = m_entryPointItems.inputs[iterator->value].unnamedType->unifyNode();
>+            if (is<AST::UnnamedType>(type) && is<AST::ReferenceType>(downcast<AST::UnnamedType>(type))) {
>+                auto& referenceType = downcast<AST::ReferenceType>(downcast<AST::UnnamedType>(type));
>+                auto mangledTypeName = m_typeNamer.mangledNameForType(referenceType.elementType());
>+                auto addressSpace = toString(referenceType.addressSpace());
>+                auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
>+                auto index = m_namedBindGroups[i].namedBindings[j].index;
>+                stringBuilder.append(makeString("    ", addressSpace, " ", mangledTypeName, "* ", elementName, " [[id(", index, ")]];\n"));
>+                if (auto lengthInformation = m_namedBindGroups[i].namedBindings[j].lengthInformation)
>+                    stringBuilder.append(makeString("    uint2 ", lengthInformation->elementName, " [[id(", lengthInformation->index, ")]];\n"));
>+            } else if (is<AST::NamedType>(type) && is<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(type))) {
>+                auto& namedType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(type));
>+                auto mangledTypeName = m_typeNamer.mangledNameForType(namedType);
>+                auto elementName = m_namedBindGroups[i].namedBindings[j].elementName;
>+                auto index = m_namedBindGroups[i].namedBindings[j].index;
>+                stringBuilder.append(makeString("    ", mangledTypeName, ' ', elementName, " [[id(", index, ")]];\n"));
>+            }
>         }
>         stringBuilder.append("};\n\n");
>     }
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
>index a416001298d5b9b9743931577c4b53dbe7fb800e..e5bc3666cb9518b588c1679a6031e42c54da2484 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
>@@ -542,7 +542,9 @@ void FunctionDefinitionWriter::visit(AST::CallExpression& callExpression)
>     auto iterator = m_functionMapping.find(callExpression.function());
>     ASSERT(iterator != m_functionMapping.end());
>     auto variableName = generateNextVariableName();
>-    m_stringBuilder.append(makeString(m_typeNamer.mangledNameForType(callExpression.resolvedType()), ' ', variableName, " = ", iterator->value, '('));
>+    if (!matches(callExpression.resolvedType(), m_intrinsics.voidType()))
>+        m_stringBuilder.append(makeString(m_typeNamer.mangledNameForType(callExpression.resolvedType()), ' ', variableName, " = "));
>+    m_stringBuilder.append(makeString(iterator->value, '('));
>     for (size_t i = 0; i < argumentNames.size(); ++i) {
>         if (i)
>             m_stringBuilder.append(", ");
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
>index 0ed12d2fbbc8950f6709bb46020c157648af4f95..88e4b6a94b007f70a096cd5599ea3d0d894ae77a 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
>@@ -81,6 +81,42 @@ static String atomicName(String input)
>         return "fetch_xor"_str;
> }
> 
>+static int vectorLength(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    int vectorLength = 1;
>+    if (!nativeTypeDeclaration.typeArguments().isEmpty()) {
>+        ASSERT(nativeTypeDeclaration.typeArguments().size() == 2);
>+        ASSERT(WTF::holds_alternative<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[1]));
>+        vectorLength = WTF::get<AST::ConstantExpression>(nativeTypeDeclaration.typeArguments()[1]).integerLiteral().value();
>+    }
>+    return vectorLength;
>+}
>+
>+static AST::NamedType& vectorInnerType(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (nativeTypeDeclaration.typeArguments().isEmpty())
>+        return nativeTypeDeclaration;
>+
>+    ASSERT(nativeTypeDeclaration.typeArguments().size() == 2);
>+    ASSERT(WTF::holds_alternative<UniqueRef<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0]));
>+    return WTF::get<UniqueRef<AST::TypeReference>>(nativeTypeDeclaration.typeArguments()[0])->resolvedType();
>+}
>+
>+static const char* vectorSuffix(int vectorLength)
>+{
>+    switch (vectorLength) {
>+    case 1:
>+        return "";
>+    case 2:
>+        return "2";
>+    case 3:
>+        return "3";
>+    default:
>+        ASSERT(vectorLength == 4);
>+        return "4";
>+    }
>+}
>+
> String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclaration, String& outputFunctionName, Intrinsics& intrinsics, TypeNamer& typeNamer, const char* memsetZeroFunctionName)
> {
>     StringBuilder stringBuilder;
>@@ -102,7 +138,7 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>             auto& parameterNamedType = downcast<AST::NamedType>(parameterType);
>             if (is<AST::NativeTypeDeclaration>(parameterNamedType)) {
>                 auto& parameterNativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(parameterNamedType);
>-                if (parameterNativeTypeDeclaration.isAtom()) {
>+                if (parameterNativeTypeDeclaration.isAtomic()) {
>                     stringBuilder.append(makeString(metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " x) {\n"));
>                     stringBuilder.append("    return atomic_load_explicit(&x, memory_order_relaxed);\n");
>                     stringBuilder.append("}\n");
>@@ -356,18 +392,151 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>     }
> 
>     if (nativeFunctionDeclaration.name() == "Sample") {
>-        // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195813 Implement this
>-        notImplemented();
>+        ASSERT(nativeFunctionDeclaration.parameters().size() == 3 || nativeFunctionDeclaration.parameters().size() == 4);
>+        
>+        auto& textureType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[0]->type()->unifyNode()));
>+        auto& locationType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[2]->type()->unifyNode()));
>+        auto locationVectorLength = vectorLength(locationType);
>+        auto& returnType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.type().unifyNode()));
>+        auto returnVectorLength = vectorLength(returnType);
>+
>+        auto metalParameter1Name = typeNamer.mangledNameForType(textureType);
>+        auto metalParameter2Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[1]->type());
>+        auto metalParameter3Name = typeNamer.mangledNameForType(locationType);
>+        String metalParameter4Name;
>+        if (nativeFunctionDeclaration.parameters().size() == 4)
>+            metalParameter4Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[3]->type());
>+        auto metalReturnName = typeNamer.mangledNameForType(returnType);
>+        stringBuilder.append(makeString(metalReturnName, ' ', outputFunctionName, '(', metalParameter1Name, " theTexture, ", metalParameter2Name, " theSampler, ", metalParameter3Name, " location"));
>+        if (!metalParameter4Name.isNull())
>+            stringBuilder.append(makeString(", ", metalParameter4Name, " offset"));
>+        stringBuilder.append(") {\n");
>+        stringBuilder.append("    return theTexture.sample(theSampler, ");
>+        if (textureType.isTextureArray()) {
>+            ASSERT(locationVectorLength > 1);
>+            stringBuilder.append(makeString("location.", "xyzw"_str.substring(0, locationVectorLength - 1), ", location.", "xyzw"_str.substring(locationVectorLength - 1, 1)));
>+        } else
>+            stringBuilder.append("location");
>+        if (!metalParameter4Name.isNull())
>+            stringBuilder.append(", offset");
>+        stringBuilder.append(")");
>+        if (!textureType.isDepthTexture())
>+            stringBuilder.append(makeString(".", "xyzw"_str.substring(0, returnVectorLength)));
>+        stringBuilder.append(";\n");
>+        stringBuilder.append("}\n");
>+        return stringBuilder.toString();
>     }
> 
>     if (nativeFunctionDeclaration.name() == "Load") {
>-        // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195813 Implement this
>-        notImplemented();
>+        ASSERT(nativeFunctionDeclaration.parameters().size() == 2);
>+        
>+        auto& textureType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[0]->type()->unifyNode()));
>+        auto& locationType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[1]->type()->unifyNode()));
>+        auto locationVectorLength = vectorLength(locationType);
>+        auto& returnType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.type().unifyNode()));
>+        auto returnVectorLength = vectorLength(returnType);
>+
>+        auto metalParameter1Name = typeNamer.mangledNameForType(textureType);
>+        auto metalParameter2Name = typeNamer.mangledNameForType(locationType);
>+        auto metalReturnName = typeNamer.mangledNameForType(returnType);
>+        stringBuilder.append(makeString(metalReturnName, ' ', outputFunctionName, '(', metalParameter1Name, " theTexture, ", metalParameter2Name, " location) {\n"));
>+        if (textureType.isTextureArray()) {
>+            ASSERT(locationVectorLength > 1);
>+            String dimensions[] = { "width"_str, "height"_str, "depth"_str };
>+            for (int i = 0; i < locationVectorLength - 1; ++i) {
>+                auto suffix = "xyzw"_str.substring(i, 1);
>+                stringBuilder.append(makeString("    if (location.", suffix, " < 0 || static_cast<uint32_t>(location.", suffix, ") >= theTexture.get_", dimensions[i], "()) return ", metalReturnName, "(0);\n"));
>+            }
>+            auto suffix = "xyzw"_str.substring(locationVectorLength - 1, 1);
>+            stringBuilder.append(makeString("    if (location.", suffix, " < 0 || static_cast<uint32_t>(location.", suffix, ") >= theTexture.get_array_size()) return ", metalReturnName, "(0);\n"));
>+        } else {
>+            if (locationVectorLength == 1)
>+                stringBuilder.append(makeString("    if (location < 0 || static_cast<uint32_t>(location) >= theTexture.get_width()) return ", metalReturnName, "(0);\n"));
>+            else {
>+                stringBuilder.append(makeString("    if (location.x < 0 || static_cast<uint32_t>(location.x) >= theTexture.get_width()) return ", metalReturnName, "(0);\n"));
>+                stringBuilder.append(makeString("    if (location.y < 0 || static_cast<uint32_t>(location.y) >= theTexture.get_height()) return ", metalReturnName, "(0);\n"));
>+                if (locationVectorLength >= 3)
>+                    stringBuilder.append(makeString("    if (location.z < 0 || static_cast<uint32_t>(location.z) >= theTexture.get_depth()) return ", metalReturnName, "(0);\n"));
>+            }
>+        }
>+        stringBuilder.append("    return theTexture.read(");
>+        if (textureType.isTextureArray()) {
>+            ASSERT(locationVectorLength > 1);
>+            stringBuilder.append(makeString("uint", vectorSuffix(locationVectorLength - 1), "(location.", "xyzw"_str.substring(0, locationVectorLength - 1), "), uint(location.", "xyzw"_str.substring(locationVectorLength - 1, 1), ")"));
>+        } else
>+            stringBuilder.append(makeString("uint", vectorSuffix(locationVectorLength), "(location)"));
>+        stringBuilder.append(")");
>+        if (!textureType.isDepthTexture())
>+            stringBuilder.append(makeString(".", "xyzw"_str.substring(0, returnVectorLength)));
>+        stringBuilder.append(";\n");
>+        stringBuilder.append("}\n");
>+        return stringBuilder.toString();
>     }
> 
>     if (nativeFunctionDeclaration.name() == "GetDimensions") {
>-        // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195813 Implement this
>-        notImplemented();
>+        auto& textureType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[0]->type()->unifyNode()));
>+
>+        size_t index = 1;
>+        if (!textureType.isWritableTexture())
>+            ++index;
>+        auto widthTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
>+        ++index;
>+        String heightTypeName;
>+        if (textureType.textureDimension() >= 2) {
>+            heightTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
>+            ++index;
>+        }
>+        String depthTypeName;
>+        if (textureType.textureDimension() >= 3) {
>+            depthTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
>+            ++index;
>+        }
>+        String elementsTypeName;
>+        if (textureType.isTextureArray()) {
>+            elementsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
>+            ++index;
>+        }
>+        String numberOfLevelsTypeName;
>+        if (!textureType.isWritableTexture()) {
>+            numberOfLevelsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
>+            ++index;
>+        }
>+        ASSERT(index == nativeFunctionDeclaration.parameters().size());
>+
>+        auto metalParameter1Name = typeNamer.mangledNameForType(textureType);
>+        stringBuilder.append(makeString("void ", outputFunctionName, '(', metalParameter1Name, " theTexture"));
>+        if (!textureType.isWritableTexture())
>+            stringBuilder.append(", uint mipLevel");
>+        stringBuilder.append(makeString(", ", widthTypeName, " width"));
>+        if (!heightTypeName.isNull())
>+            stringBuilder.append(makeString(", ", heightTypeName, " height"));
>+        if (!depthTypeName.isNull())
>+            stringBuilder.append(makeString(", ", depthTypeName, " depth"));
>+        if (!elementsTypeName.isNull())
>+            stringBuilder.append(makeString(", ", elementsTypeName, " elements"));
>+        if (!numberOfLevelsTypeName.isNull())
>+            stringBuilder.append(makeString(", ", numberOfLevelsTypeName, " numberOfLevels"));
>+        stringBuilder.append(") {\n");
>+        stringBuilder.append("    if (width)\n");
>+        stringBuilder.append("        *width = theTexture.get_width();\n");
>+        if (!heightTypeName.isNull()) {
>+            stringBuilder.append("    if (height)\n");
>+            stringBuilder.append("        *height = theTexture.get_height();\n");
>+        }
>+        if (!depthTypeName.isNull()) {
>+            stringBuilder.append("    if (depth)\n");
>+            stringBuilder.append("        *depth = theTexture.get_depth();\n");
>+        }
>+        if (!elementsTypeName.isNull()) {
>+            stringBuilder.append("    if (elements)\n");
>+            stringBuilder.append("        *elements = theTexture.get_array_size();\n");
>+        }
>+        if (!numberOfLevelsTypeName.isNull()) {
>+            stringBuilder.append("    if (numberOfLevels)\n");
>+            stringBuilder.append("        *numberOfLevels = theTexture.get_num_mip_levels();\n");
>+        }
>+        stringBuilder.append("}\n");
>+        return stringBuilder.toString();
>     }
> 
>     if (nativeFunctionDeclaration.name() == "SampleBias") {
>@@ -406,8 +575,51 @@ String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclara
>     }
> 
>     if (nativeFunctionDeclaration.name() == "Store") {
>-        // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195813 Implement this
>-        notImplemented();
>+        ASSERT(nativeFunctionDeclaration.parameters().size() == 3);
>+        
>+        auto& textureType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[0]->type()->unifyNode()));
>+        auto& itemType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[1]->type()->unifyNode()));
>+        auto& itemVectorInnerType = vectorInnerType(itemType);
>+        auto itemVectorLength = vectorLength(itemType);
>+        auto& locationType = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(nativeFunctionDeclaration.parameters()[2]->type()->unifyNode()));
>+        auto locationVectorLength = vectorLength(locationType);
>+
>+        auto metalParameter1Name = typeNamer.mangledNameForType(textureType);
>+        auto metalParameter2Name = typeNamer.mangledNameForType(itemType);
>+        auto metalParameter3Name = typeNamer.mangledNameForType(locationType);
>+        auto metalInnerTypeName = typeNamer.mangledNameForType(itemVectorInnerType);
>+        stringBuilder.append(makeString("void ", outputFunctionName, '(', metalParameter1Name, " theTexture, ", metalParameter2Name, " item, ", metalParameter3Name, " location) {\n"));
>+        if (textureType.isTextureArray()) {
>+            ASSERT(locationVectorLength > 1);
>+            String dimensions[] = { "width"_str, "height"_str, "depth"_str };
>+            for (int i = 0; i < locationVectorLength - 1; ++i) {
>+                auto suffix = "xyzw"_str.substring(i, 1);
>+                stringBuilder.append(makeString("    if (location.", suffix, " >= theTexture.get_", dimensions[i], "()) return;\n"));
>+            }
>+            auto suffix = "xyzw"_str.substring(locationVectorLength - 1, 1);
>+            stringBuilder.append(makeString("    if (location.", suffix, " >= theTexture.get_array_size()) return;\n"));
>+        } else {
>+            if (locationVectorLength == 1)
>+                stringBuilder.append(makeString("    if (location >= theTexture.get_width()) return;\n"));
>+            else {
>+                stringBuilder.append(makeString("    if (location.x >= theTexture.get_width()) return;\n"));
>+                stringBuilder.append(makeString("    if (location.y >= theTexture.get_height()) return;\n"));
>+                if (locationVectorLength >= 3)
>+                    stringBuilder.append(makeString("    if (location.z >= theTexture.get_depth()) return;\n"));
>+            }
>+        }
>+        stringBuilder.append(makeString("    theTexture.write(vec<", metalInnerTypeName, ", 4>(item"));
>+        for (int i = 0; i < 4 - itemVectorLength; ++i)
>+            stringBuilder.append(", 0");
>+        stringBuilder.append("), ");
>+        if (textureType.isTextureArray()) {
>+            ASSERT(locationVectorLength > 1);
>+            stringBuilder.append(makeString("uint", vectorSuffix(locationVectorLength - 1), "(location.", "xyzw"_str.substring(0, locationVectorLength - 1), "), uint(location.", "xyzw"_str.substring(locationVectorLength - 1, 1), ")"));
>+        } else
>+            stringBuilder.append(makeString("uint", vectorSuffix(locationVectorLength), "(location)"));
>+        stringBuilder.append(");\n");
>+        stringBuilder.append("}\n");
>+        return stringBuilder.toString();
>     }
> 
>     if (nativeFunctionDeclaration.name() == "GatherAlpha") {
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeTypeWriter.cpp b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeTypeWriter.cpp
>index f57d5c077cc4d2fd99ad1204c147c1a8d41945d3..ebfe61d5d8c3b2364deb6c7fcedd4ce919d32bdb 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeTypeWriter.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeTypeWriter.cpp
>@@ -180,12 +180,8 @@ String writeNativeType(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>             return "texturecube"_str;
>         if (nativeTypeDeclaration.name() == "TextureDepth2D")
>             return "depth2d"_str;
>-        if (nativeTypeDeclaration.name() == "RWTextureDepth2D")
>-            return "depth2d"_str;
>         if (nativeTypeDeclaration.name() == "TextureDepth2DArray")
>             return "depth2d_array"_str;
>-        if (nativeTypeDeclaration.name() == "RWTextureDepth2DArray")
>-            return "depth2d_array"_str;
>         ASSERT(nativeTypeDeclaration.name() == "TextureDepthCube");
>         return "depthcube"_str;
>     })();
>@@ -239,8 +235,12 @@ String writeNativeType(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>         ASSERT(typeReference->name() == "float4");
>         return "float"_str;
>     })();
>-    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195813 Specify the second template argument to Metal texture types.
>-    return makeString(prefix, '<', innerType, '>');
>+    auto isReadWrite = nativeTypeDeclaration.name() == "RWTexture1D"
>+        || nativeTypeDeclaration.name() == "RWTexture1DArray"
>+        || nativeTypeDeclaration.name() == "RWTexture2D"
>+        || nativeTypeDeclaration.name() == "RWTexture2DArray"
>+        || nativeTypeDeclaration.name() == "RWTexture3D";
>+    return makeString(prefix, '<', innerType, ", ", isReadWrite ? "access::read_write" : "access::sample", '>');
> }
> 
> } // namespace Metal
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.cpp
>index b22957a1be833fb298378cf90f2adc23eddc4ecf..eab71b3f26192b7634fa6b2f6f4ac400f1c22cc8 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.cpp
>@@ -75,7 +75,10 @@ private:
>         callExpression->setOverloads(m_castFunctions);
>         Vector<std::reference_wrapper<ResolvingType>> argumentTypes;
>         auto* function = resolveFunctionOverload(*callExpression->overloads(), argumentTypes, type);
>-        RELEASE_ASSERT(function);
>+        if (!function) {
>+            setError();
>+            return;
>+        }
>         callExpression->setFunction(*function);
> 
>         variableDeclaration.setInitializer(WTFMove(callExpression));
>@@ -85,10 +88,11 @@ private:
>     Vector<std::reference_wrapper<AST::FunctionDeclaration>, 1>& m_castFunctions;
> };
> 
>-void autoInitializeVariables(Program& program)
>+bool autoInitializeVariables(Program& program)
> {
>     AutoInitialize autoInitialize(program.nameContext());
>     autoInitialize.Visitor::visit(program);
>+    return !autoInitialize.error();
> }
> 
> } // namespace WHLSL
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.h
>index f2eac338207ebcc006bfbf679daac5bc34e03e86..29aabb078d5d5124f420e9985bb71626f5ed0dc8 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.h
>@@ -33,7 +33,7 @@ namespace WHLSL {
> 
> class Program;
> 
>-void autoInitializeVariables(Program&);
>+bool autoInitializeVariables(Program&);
> 
> }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.cpp
>index eda00baab09fda8ee73a473634508cd17d79934d..1240af58cf3ac3a3a7f28fa70465445774292712 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.cpp
>@@ -141,6 +141,14 @@ bool checkDuplicateFunctions(const Program& program)
>             && is<AST::ReferenceType>(static_cast<const AST::UnnamedType&>(*function.parameters()[1]->type()))
>             && matches(*function.parameters()[0]->type(), *function.parameters()[1]->type()))
>             return false;
>+        else if (function.isCast() && function.parameters().isEmpty()) {
>+            auto& unifyNode = function.type().unifyNode();
>+            if (is<AST::NamedType>(unifyNode) && is<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(unifyNode))) {
>+                auto& nativeTypeDeclaration = downcast<AST::NativeTypeDeclaration>(downcast<AST::NamedType>(unifyNode));
>+                if (nativeTypeDeclaration.isTexture())
>+                    return false;
>+            }
>+        }
> 
>         return true;
>     };
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..dccf22ca35cea1c73365b78d824ecb0aec3bb6a8
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.cpp
>@@ -0,0 +1,115 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "WHLSLCheckTextureReferences.h"
>+
>+#if ENABLE(WEBGPU)
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class TextureReferencesChecker : public Visitor {
>+public:
>+    TextureReferencesChecker() = default;
>+
>+    virtual ~TextureReferencesChecker() = default;
>+
>+private:
>+    void visit(AST::PointerType&) override;
>+    void visit(AST::ArrayReferenceType&) override;
>+    void visit(AST::ArrayType&) override;
>+    void visit(AST::Expression&) override;
>+
>+    bool containsTexture(AST::UnnamedType&);
>+};
>+
>+class TextureSearcher : public Visitor {
>+public:
>+    TextureSearcher() = default;
>+
>+    virtual ~TextureSearcher() = default;
>+
>+    bool foundTexture() const { return m_foundTexture; }
>+
>+private:
>+    void visit(AST::NativeTypeDeclaration&);
>+
>+    bool m_foundTexture { false };
>+};
>+
>+void TextureSearcher::visit(AST::NativeTypeDeclaration& nativeTypeDeclaration)
>+{
>+    if (nativeTypeDeclaration.isTexture())
>+        m_foundTexture = true;
>+}
>+
>+bool TextureReferencesChecker::containsTexture(AST::UnnamedType& unnamedType)
>+{
>+    TextureSearcher textureSearcher;
>+    textureSearcher.checkErrorAndVisit(unnamedType);
>+    return textureSearcher.foundTexture();
>+}
>+
>+void TextureReferencesChecker::visit(AST::PointerType& pointerType)
>+{
>+    Visitor::visit(pointerType);
>+    if (containsTexture(pointerType.elementType()))
>+        setError();
>+}
>+
>+void TextureReferencesChecker::visit(AST::ArrayReferenceType& arrayReferenceType)
>+{
>+    Visitor::visit(arrayReferenceType);
>+    if (containsTexture(arrayReferenceType.elementType()))
>+        setError();
>+}
>+
>+void TextureReferencesChecker::visit(AST::ArrayType& arrayType)
>+{
>+    Visitor::visit(arrayType);
>+    if (containsTexture(arrayType.type()))
>+        setError();
>+}
>+
>+void TextureReferencesChecker::visit(AST::Expression& expression)
>+{
>+    Visitor::visit(expression);
>+    Visitor::visit(expression.resolvedType());
>+}
>+
>+bool checkTextureReferences(Program& program)
>+{
>+    TextureReferencesChecker textureReferencesChecker;
>+    textureReferencesChecker.checkErrorAndVisit(program);
>+    return !textureReferencesChecker.error();
>+}
>+
>+} // namespace WHLSL
>+
>+} // namespace WebCore
>+
>+#endif // ENABLE(WEBGPU)
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..5327fabbaff915f0e1887af462046219bf52b4ad
>--- /dev/null
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.h
>@@ -0,0 +1,42 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(WEBGPU)
>+
>+namespace WebCore {
>+
>+namespace WHLSL {
>+
>+class Program;
>+
>+bool checkTextureReferences(Program&);
>+
>+}
>+
>+}
>+
>+#endif
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>index 2847295ac47996848f1b07a416a885434fe43f1d..652bd852779a7cfab6e4ef970c8239b139328428 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp
>@@ -452,7 +452,7 @@ public:
>     {
>     }
> 
>-    ~Checker() = default;
>+    virtual ~Checker() = default;
> 
>     void visit(Program&) override;
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp
>index c8bffb82caecfe98fb252f98ff28ffb8a35e6a7a..ba57ea4425c7b7a0dba8c8997c8be0c46f955d27 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.cpp
>@@ -369,6 +369,16 @@ bool Intrinsics::addFullTexture(AST::NativeTypeDeclaration& nativeTypeDeclaratio
>     }
>     ASSERT(innerTypeIndex != WTF_ARRAY_LENGTH(m_textureInnerTypeNames));
>     nativeTypeDeclaration.setIsTexture();
>+    if (textureTypeIndex >= indexOfFirstArrayType)
>+        nativeTypeDeclaration.setIsTextureArray();
>+    if (nativeTypeDeclaration.name() == "RWTexture1D" || nativeTypeDeclaration.name() == "RWTexture2D" || nativeTypeDeclaration.name() == "RWTexture3D" || nativeTypeDeclaration.name() == "RWTexture1DArray" || nativeTypeDeclaration.name() == "RWTexture2DArray")
>+        nativeTypeDeclaration.setIsWritableTexture();
>+    if (nativeTypeDeclaration.name() == "Texture1D" || nativeTypeDeclaration.name() == "RWTexture1D" || nativeTypeDeclaration.name() == "Texture1DArray" || nativeTypeDeclaration.name() == "RWTexture1DArray")
>+        nativeTypeDeclaration.setTextureDimension(1);
>+    if (nativeTypeDeclaration.name() == "Texture2D" || nativeTypeDeclaration.name() == "RWTexture2D" || nativeTypeDeclaration.name() == "TextureCube" || nativeTypeDeclaration.name() == "Texture2DArray" || nativeTypeDeclaration.name() == "RWTexture2DArray")
>+        nativeTypeDeclaration.setTextureDimension(2);
>+    if (nativeTypeDeclaration.name() == "Texture3D" || nativeTypeDeclaration.name() == "RWTexture3D")
>+        nativeTypeDeclaration.setTextureDimension(3);
>     m_fullTextures[textureTypeIndex][innerTypeIndex][vectorLength - 1] = &nativeTypeDeclaration;
>     return true;
> }
>@@ -378,12 +388,8 @@ void Intrinsics::addDepthTexture(AST::NativeTypeDeclaration& nativeTypeDeclarati
>     AST::NativeTypeDeclaration** texture = nullptr;
>     if (nativeTypeDeclaration.name() == "TextureDepth2D")
>         texture = m_textureDepth2D;
>-    else if (nativeTypeDeclaration.name() == "RWTextureDepth2D")
>-        texture = m_rwTextureDepth2D;
>     else if (nativeTypeDeclaration.name() == "TextureDepth2DArray")
>         texture = m_textureDepth2DArray;
>-    else if (nativeTypeDeclaration.name() == "RWTextureDepth2DArray")
>-        texture = m_rwTextureDepth2DArray;
>     else {
>         ASSERT(nativeTypeDeclaration.name() == "TextureDepthCube");
>         texture = m_textureDepthCube;
>@@ -391,6 +397,10 @@ void Intrinsics::addDepthTexture(AST::NativeTypeDeclaration& nativeTypeDeclarati
>     auto innerTypeIndex = std::find(m_depthTextureInnerTypes, m_depthTextureInnerTypes + WTF_ARRAY_LENGTH(m_depthTextureInnerTypes), innerType.name()) - m_depthTextureInnerTypes;
>     ASSERT(innerTypeIndex != WTF_ARRAY_LENGTH(m_depthTextureInnerTypes));
>     nativeTypeDeclaration.setIsTexture();
>+    if (texture == m_textureDepth2DArray)
>+        nativeTypeDeclaration.setIsTextureArray();
>+    nativeTypeDeclaration.setTextureDimension(2);
>+    nativeTypeDeclaration.setIsDepthTexture();
>     texture[innerTypeIndex] = &nativeTypeDeclaration;
> }
> 
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h
>index ad857c5f94eaf1352a31537154347d062ed0bba2..b4c7ef53dabbbedf46bd1fc661303c8031329b21 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLIntrinsics.h
>@@ -263,7 +263,10 @@ private:
>     AST::NativeTypeDeclaration* m_matrixHalf[3][3] {{ 0 }};
>     AST::NativeTypeDeclaration* m_matrixFloat[3][3] {{ 0 }};
> 
>-    static constexpr const char* m_textureTypeNames[] = { "Texture1D", "RWTexture1D", "Texture1DArray", "RWTexture1DArray", "Texture2D", "RWTexture2D", "Texture2DArray", "RWTexture2DArray", "Texture3D", "RWTexture3D", "TextureCube" };
>+    // Keep the array types partitioned from the non-array types.
>+    // This is how we retain what's an array and what isn't.
>+    static constexpr const char* m_textureTypeNames[] = { "Texture1D", "RWTexture1D", "Texture2D", "RWTexture2D", "Texture3D", "RWTexture3D", "TextureCube", "Texture1DArray", "RWTexture1DArray", "Texture2DArray", "RWTexture2DArray" };
>+    static constexpr unsigned indexOfFirstArrayType = 7;
> 
>     static constexpr const char* m_textureInnerTypeNames[] = { "uchar", "ushort",  "uint", "char", "short", "int", "half", "float" };
> 
>@@ -272,9 +275,7 @@ private:
>     static constexpr const char* m_depthTextureInnerTypes[] =  { "half", "float" };
> 
>     AST::NativeTypeDeclaration* m_textureDepth2D[WTF_ARRAY_LENGTH(m_depthTextureInnerTypes)] { 0 };
>-    AST::NativeTypeDeclaration* m_rwTextureDepth2D[WTF_ARRAY_LENGTH(m_depthTextureInnerTypes)] { 0 };
>     AST::NativeTypeDeclaration* m_textureDepth2DArray[WTF_ARRAY_LENGTH(m_depthTextureInnerTypes)] { 0 };
>-    AST::NativeTypeDeclaration* m_rwTextureDepth2DArray[WTF_ARRAY_LENGTH(m_depthTextureInnerTypes)] { 0 };
>     AST::NativeTypeDeclaration* m_textureDepthCube[WTF_ARRAY_LENGTH(m_depthTextureInnerTypes)] { 0 };
> 
>     AST::NativeFunctionDeclaration* m_ddx { nullptr };
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
>index c8004290ded41edc05f2dc1d90b4b76a1ee5693a..d48134e62c3d265a067d9301df7ee464f061f7c9 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLNameResolver.cpp
>@@ -92,6 +92,8 @@ void NameResolver::visit(AST::FunctionDefinition& functionDefinition)
>     for (auto& parameter : functionDefinition.parameters())
>         newNameResolver.checkErrorAndVisit(parameter);
>     newNameResolver.checkErrorAndVisit(functionDefinition.block());
>+    if (newNameResolver.error())
>+        setError();
> }
> 
> void NameResolver::visit(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
>@@ -110,6 +112,8 @@ void NameResolver::visit(AST::Block& block)
>     NameResolver newNameResolver(nameContext);
>     newNameResolver.setCurrentFunctionDefinition(m_currentFunction);
>     newNameResolver.Visitor::visit(block);
>+    if (newNameResolver.error())
>+        setError();
> }
> 
> void NameResolver::visit(AST::IfStatement& ifStatement)
>@@ -119,11 +123,15 @@ void NameResolver::visit(AST::IfStatement& ifStatement)
>     NameResolver newNameResolver(nameContext);
>     newNameResolver.setCurrentFunctionDefinition(m_currentFunction);
>     newNameResolver.checkErrorAndVisit(ifStatement.body());
>-    if (ifStatement.elseBody()) {
>+    if (newNameResolver.error())
>+        setError();
>+    else if (ifStatement.elseBody()) {
>         NameContext nameContext(&m_nameContext);
>         NameResolver newNameResolver(nameContext);
>         newNameResolver.setCurrentFunctionDefinition(m_currentFunction);
>         newNameResolver.checkErrorAndVisit(*ifStatement.elseBody());
>+        if (newNameResolver.error())
>+            setError();
>     }
> }
> 
>@@ -134,6 +142,8 @@ void NameResolver::visit(AST::WhileLoop& whileLoop)
>     NameResolver newNameResolver(nameContext);
>     newNameResolver.setCurrentFunctionDefinition(m_currentFunction);
>     newNameResolver.checkErrorAndVisit(whileLoop.body());
>+    if (newNameResolver.error())
>+        setError();
> }
> 
> void NameResolver::visit(AST::DoWhileLoop& whileLoop)
>@@ -143,6 +153,8 @@ void NameResolver::visit(AST::DoWhileLoop& whileLoop)
>     newNameResolver.setCurrentFunctionDefinition(m_currentFunction);
>     newNameResolver.checkErrorAndVisit(whileLoop.body());
>     checkErrorAndVisit(whileLoop.conditional());
>+    if (newNameResolver.error())
>+        setError();
> }
> 
> void NameResolver::visit(AST::ForLoop& forLoop)
>@@ -151,6 +163,8 @@ void NameResolver::visit(AST::ForLoop& forLoop)
>     NameResolver newNameResolver(nameContext);
>     newNameResolver.setCurrentFunctionDefinition(m_currentFunction);
>     newNameResolver.Visitor::visit(forLoop);
>+    if (newNameResolver.error())
>+        setError();
> }
> 
> void NameResolver::visit(AST::VariableDeclaration& variableDeclaration)
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>index d6b2e74d0b264e6c9fef1ad8cd1050ebdce0958e..6ef6c087ae95e0102e3674de4a5c7ec5ce6d70e4 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp
>@@ -31,6 +31,7 @@
> #include "WHLSLASTDumper.h"
> #include "WHLSLAutoInitializeVariables.h"
> #include "WHLSLCheckDuplicateFunctions.h"
>+#include "WHLSLCheckTextureReferences.h"
> #include "WHLSLChecker.h"
> #include "WHLSLComputeDimensions.h"
> #include "WHLSLFunctionStageChecker.h"
>@@ -132,7 +133,8 @@ static Optional<Program> prepareShared(String& whlslSource)
>     RUN_PASS(check, program);
> 
>     checkLiteralTypes(program);
>-    autoInitializeVariables(program);
>+    RUN_PASS(checkTextureReferences, program);
>+    RUN_PASS(autoInitializeVariables, program);
>     resolveProperties(program);
>     findHighZombies(program);
>     RUN_PASS(checkStatementBehavior, program);
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.cpp
>index 12a7048405d0607bd48a97b5fb1a6b7282c445f1..2b91b9510c239f7c5e5c997e1664b7563678438b 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLRecursiveTypeChecker.cpp
>@@ -41,7 +41,7 @@ namespace WHLSL {
> 
> class RecursiveTypeChecker : public Visitor {
> public:
>-    ~RecursiveTypeChecker() = default;
>+    virtual ~RecursiveTypeChecker() = default;
> 
>     void visit(AST::TypeDefinition&) override;
>     void visit(AST::StructureDefinition&) override;
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>index ec28410e06fa04d2a0795a6d2a44ba8b9970aa1e..089c56d8d6ce8e0df50e089b1362908bad38c793 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLStandardLibrary.txt
>@@ -370,9 +370,7 @@ native typedef TextureCube<float2>;
> native typedef TextureCube<float3>;
> native typedef TextureCube<float4>;
> native typedef TextureDepth2D<float>;
>-native typedef RWTextureDepth2D<float>;
> native typedef TextureDepth2DArray<float>;
>-native typedef RWTextureDepth2DArray<float>;
> native typedef TextureDepthCube<float>;
> 
> native operator uchar(ushort);
>@@ -625,7 +623,10404 @@ operator float4(float x, float y, float z, float w) {
>     return result;
> }
> 
>+operator float2(float x, float y) {
>+    float2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+
>+operator int3(int x, int y, int z) {
>+    int3 result;
>+    result.x = x;
>+    result.y = y;
>+    result.z = z;
>+    return result;
>+}
>+
>+operator int2(int x, int y) {
>+    int2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+
>+operator uint2(uint x, uint y) {
>+    uint2 result;
>+    result.x = x;
>+    result.y = y;
>+    return result;
>+}
>+
> native ushort Sample(Texture1D<ushort>, sampler, float location);
>-native ushort Sample(Texture1D<ushort>, sampler, float location, int offset);
>+native ushort Sample(Texture1DArray<ushort>, sampler, float2 location);
>+native ushort Sample(Texture2D<ushort>, sampler, float2 location);
>+native ushort Sample(Texture2D<ushort>, sampler, float2 location, int2 offset);
>+native ushort Sample(Texture2DArray<ushort>, sampler, float3 location);
>+native ushort Sample(Texture2DArray<ushort>, sampler, float3 location, int2 offset);
>+native ushort Sample(Texture3D<ushort>, sampler, float3 location);
>+native ushort Sample(Texture3D<ushort>, sampler, float3 location, int3 offset);
>+native ushort Sample(TextureCube<ushort>, sampler, float3 location);
>+native ushort2 Sample(Texture1D<ushort2>, sampler, float location);
>+native ushort2 Sample(Texture1DArray<ushort2>, sampler, float2 location);
>+native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location);
>+native ushort2 Sample(Texture2D<ushort2>, sampler, float2 location, int2 offset);
>+native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location);
>+native ushort2 Sample(Texture2DArray<ushort2>, sampler, float3 location, int2 offset);
>+native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location);
>+native ushort2 Sample(Texture3D<ushort2>, sampler, float3 location, int3 offset);
>+native ushort2 Sample(TextureCube<ushort2>, sampler, float3 location);
>+native ushort3 Sample(Texture1D<ushort3>, sampler, float location);
>+native ushort3 Sample(Texture1DArray<ushort3>, sampler, float2 location);
>+native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location);
>+native ushort3 Sample(Texture2D<ushort3>, sampler, float2 location, int2 offset);
>+native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location);
>+native ushort3 Sample(Texture2DArray<ushort3>, sampler, float3 location, int2 offset);
>+native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location);
>+native ushort3 Sample(Texture3D<ushort3>, sampler, float3 location, int3 offset);
>+native ushort3 Sample(TextureCube<ushort3>, sampler, float3 location);
>+native ushort4 Sample(Texture1D<ushort4>, sampler, float location);
>+native ushort4 Sample(Texture1DArray<ushort4>, sampler, float2 location);
>+native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location);
>+native ushort4 Sample(Texture2D<ushort4>, sampler, float2 location, int2 offset);
>+native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location);
>+native ushort4 Sample(Texture2DArray<ushort4>, sampler, float3 location, int2 offset);
>+native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location);
>+native ushort4 Sample(Texture3D<ushort4>, sampler, float3 location, int3 offset);
>+native ushort4 Sample(TextureCube<ushort4>, sampler, float3 location);
>+native uint Sample(Texture1D<uint>, sampler, float location);
>+native uint Sample(Texture1DArray<uint>, sampler, float2 location);
>+native uint Sample(Texture2D<uint>, sampler, float2 location);
>+native uint Sample(Texture2D<uint>, sampler, float2 location, int2 offset);
>+native uint Sample(Texture2DArray<uint>, sampler, float3 location);
>+native uint Sample(Texture2DArray<uint>, sampler, float3 location, int2 offset);
>+native uint Sample(Texture3D<uint>, sampler, float3 location);
>+native uint Sample(Texture3D<uint>, sampler, float3 location, int3 offset);
>+native uint Sample(TextureCube<uint>, sampler, float3 location);
>+native uint2 Sample(Texture1D<uint2>, sampler, float location);
>+native uint2 Sample(Texture1DArray<uint2>, sampler, float2 location);
>+native uint2 Sample(Texture2D<uint2>, sampler, float2 location);
>+native uint2 Sample(Texture2D<uint2>, sampler, float2 location, int2 offset);
>+native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location);
>+native uint2 Sample(Texture2DArray<uint2>, sampler, float3 location, int2 offset);
>+native uint2 Sample(Texture3D<uint2>, sampler, float3 location);
>+native uint2 Sample(Texture3D<uint2>, sampler, float3 location, int3 offset);
>+native uint2 Sample(TextureCube<uint2>, sampler, float3 location);
>+native uint3 Sample(Texture1D<uint3>, sampler, float location);
>+native uint3 Sample(Texture1DArray<uint3>, sampler, float2 location);
>+native uint3 Sample(Texture2D<uint3>, sampler, float2 location);
>+native uint3 Sample(Texture2D<uint3>, sampler, float2 location, int2 offset);
>+native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location);
>+native uint3 Sample(Texture2DArray<uint3>, sampler, float3 location, int2 offset);
>+native uint3 Sample(Texture3D<uint3>, sampler, float3 location);
>+native uint3 Sample(Texture3D<uint3>, sampler, float3 location, int3 offset);
>+native uint3 Sample(TextureCube<uint3>, sampler, float3 location);
>+native uint4 Sample(Texture1D<uint4>, sampler, float location);
>+native uint4 Sample(Texture1DArray<uint4>, sampler, float2 location);
>+native uint4 Sample(Texture2D<uint4>, sampler, float2 location);
>+native uint4 Sample(Texture2D<uint4>, sampler, float2 location, int2 offset);
>+native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location);
>+native uint4 Sample(Texture2DArray<uint4>, sampler, float3 location, int2 offset);
>+native uint4 Sample(Texture3D<uint4>, sampler, float3 location);
>+native uint4 Sample(Texture3D<uint4>, sampler, float3 location, int3 offset);
>+native uint4 Sample(TextureCube<uint4>, sampler, float3 location);
>+native short Sample(Texture1D<short>, sampler, float location);
>+native short Sample(Texture1DArray<short>, sampler, float2 location);
>+native short Sample(Texture2D<short>, sampler, float2 location);
>+native short Sample(Texture2D<short>, sampler, float2 location, int2 offset);
>+native short Sample(Texture2DArray<short>, sampler, float3 location);
>+native short Sample(Texture2DArray<short>, sampler, float3 location, int2 offset);
>+native short Sample(Texture3D<short>, sampler, float3 location);
>+native short Sample(Texture3D<short>, sampler, float3 location, int3 offset);
>+native short Sample(TextureCube<short>, sampler, float3 location);
>+native short2 Sample(Texture1D<short2>, sampler, float location);
>+native short2 Sample(Texture1DArray<short2>, sampler, float2 location);
>+native short2 Sample(Texture2D<short2>, sampler, float2 location);
>+native short2 Sample(Texture2D<short2>, sampler, float2 location, int2 offset);
>+native short2 Sample(Texture2DArray<short2>, sampler, float3 location);
>+native short2 Sample(Texture2DArray<short2>, sampler, float3 location, int2 offset);
>+native short2 Sample(Texture3D<short2>, sampler, float3 location);
>+native short2 Sample(Texture3D<short2>, sampler, float3 location, int3 offset);
>+native short2 Sample(TextureCube<short2>, sampler, float3 location);
>+native short3 Sample(Texture1D<short3>, sampler, float location);
>+native short3 Sample(Texture1DArray<short3>, sampler, float2 location);
>+native short3 Sample(Texture2D<short3>, sampler, float2 location);
>+native short3 Sample(Texture2D<short3>, sampler, float2 location, int2 offset);
>+native short3 Sample(Texture2DArray<short3>, sampler, float3 location);
>+native short3 Sample(Texture2DArray<short3>, sampler, float3 location, int2 offset);
>+native short3 Sample(Texture3D<short3>, sampler, float3 location);
>+native short3 Sample(Texture3D<short3>, sampler, float3 location, int3 offset);
>+native short3 Sample(TextureCube<short3>, sampler, float3 location);
>+native short4 Sample(Texture1D<short4>, sampler, float location);
>+native short4 Sample(Texture1DArray<short4>, sampler, float2 location);
>+native short4 Sample(Texture2D<short4>, sampler, float2 location);
>+native short4 Sample(Texture2D<short4>, sampler, float2 location, int2 offset);
>+native short4 Sample(Texture2DArray<short4>, sampler, float3 location);
>+native short4 Sample(Texture2DArray<short4>, sampler, float3 location, int2 offset);
>+native short4 Sample(Texture3D<short4>, sampler, float3 location);
>+native short4 Sample(Texture3D<short4>, sampler, float3 location, int3 offset);
>+native short4 Sample(TextureCube<short4>, sampler, float3 location);
>+native int Sample(Texture1D<int>, sampler, float location);
>+native int Sample(Texture1DArray<int>, sampler, float2 location);
>+native int Sample(Texture2D<int>, sampler, float2 location);
>+native int Sample(Texture2D<int>, sampler, float2 location, int2 offset);
>+native int Sample(Texture2DArray<int>, sampler, float3 location);
>+native int Sample(Texture2DArray<int>, sampler, float3 location, int2 offset);
>+native int Sample(Texture3D<int>, sampler, float3 location);
>+native int Sample(Texture3D<int>, sampler, float3 location, int3 offset);
>+native int Sample(TextureCube<int>, sampler, float3 location);
>+native int2 Sample(Texture1D<int2>, sampler, float location);
>+native int2 Sample(Texture1DArray<int2>, sampler, float2 location);
>+native int2 Sample(Texture2D<int2>, sampler, float2 location);
>+native int2 Sample(Texture2D<int2>, sampler, float2 location, int2 offset);
>+native int2 Sample(Texture2DArray<int2>, sampler, float3 location);
>+native int2 Sample(Texture2DArray<int2>, sampler, float3 location, int2 offset);
>+native int2 Sample(Texture3D<int2>, sampler, float3 location);
>+native int2 Sample(Texture3D<int2>, sampler, float3 location, int3 offset);
>+native int2 Sample(TextureCube<int2>, sampler, float3 location);
>+native int3 Sample(Texture1D<int3>, sampler, float location);
>+native int3 Sample(Texture1DArray<int3>, sampler, float2 location);
>+native int3 Sample(Texture2D<int3>, sampler, float2 location);
>+native int3 Sample(Texture2D<int3>, sampler, float2 location, int2 offset);
>+native int3 Sample(Texture2DArray<int3>, sampler, float3 location);
>+native int3 Sample(Texture2DArray<int3>, sampler, float3 location, int2 offset);
>+native int3 Sample(Texture3D<int3>, sampler, float3 location);
>+native int3 Sample(Texture3D<int3>, sampler, float3 location, int3 offset);
>+native int3 Sample(TextureCube<int3>, sampler, float3 location);
>+native int4 Sample(Texture1D<int4>, sampler, float location);
>+native int4 Sample(Texture1DArray<int4>, sampler, float2 location);
>+native int4 Sample(Texture2D<int4>, sampler, float2 location);
>+native int4 Sample(Texture2D<int4>, sampler, float2 location, int2 offset);
>+native int4 Sample(Texture2DArray<int4>, sampler, float3 location);
>+native int4 Sample(Texture2DArray<int4>, sampler, float3 location, int2 offset);
>+native int4 Sample(Texture3D<int4>, sampler, float3 location);
>+native int4 Sample(Texture3D<int4>, sampler, float3 location, int3 offset);
>+native int4 Sample(TextureCube<int4>, sampler, float3 location);
>+native half Sample(Texture1D<half>, sampler, float location);
>+native half Sample(Texture1DArray<half>, sampler, float2 location);
>+native half Sample(Texture2D<half>, sampler, float2 location);
>+native half Sample(Texture2D<half>, sampler, float2 location, int2 offset);
>+native half Sample(Texture2DArray<half>, sampler, float3 location);
>+native half Sample(Texture2DArray<half>, sampler, float3 location, int2 offset);
>+native half Sample(Texture3D<half>, sampler, float3 location);
>+native half Sample(Texture3D<half>, sampler, float3 location, int3 offset);
>+native half Sample(TextureCube<half>, sampler, float3 location);
>+native half2 Sample(Texture1D<half2>, sampler, float location);
>+native half2 Sample(Texture1DArray<half2>, sampler, float2 location);
>+native half2 Sample(Texture2D<half2>, sampler, float2 location);
>+native half2 Sample(Texture2D<half2>, sampler, float2 location, int2 offset);
>+native half2 Sample(Texture2DArray<half2>, sampler, float3 location);
>+native half2 Sample(Texture2DArray<half2>, sampler, float3 location, int2 offset);
>+native half2 Sample(Texture3D<half2>, sampler, float3 location);
>+native half2 Sample(Texture3D<half2>, sampler, float3 location, int3 offset);
>+native half2 Sample(TextureCube<half2>, sampler, float3 location);
>+native half3 Sample(Texture1D<half3>, sampler, float location);
>+native half3 Sample(Texture1DArray<half3>, sampler, float2 location);
>+native half3 Sample(Texture2D<half3>, sampler, float2 location);
>+native half3 Sample(Texture2D<half3>, sampler, float2 location, int2 offset);
>+native half3 Sample(Texture2DArray<half3>, sampler, float3 location);
>+native half3 Sample(Texture2DArray<half3>, sampler, float3 location, int2 offset);
>+native half3 Sample(Texture3D<half3>, sampler, float3 location);
>+native half3 Sample(Texture3D<half3>, sampler, float3 location, int3 offset);
>+native half3 Sample(TextureCube<half3>, sampler, float3 location);
>+native half4 Sample(Texture1D<half4>, sampler, float location);
>+native half4 Sample(Texture1DArray<half4>, sampler, float2 location);
>+native half4 Sample(Texture2D<half4>, sampler, float2 location);
>+native half4 Sample(Texture2D<half4>, sampler, float2 location, int2 offset);
>+native half4 Sample(Texture2DArray<half4>, sampler, float3 location);
>+native half4 Sample(Texture2DArray<half4>, sampler, float3 location, int2 offset);
>+native half4 Sample(Texture3D<half4>, sampler, float3 location);
>+native half4 Sample(Texture3D<half4>, sampler, float3 location, int3 offset);
>+native half4 Sample(TextureCube<half4>, sampler, float3 location);
>+native float Sample(Texture1D<float>, sampler, float location);
>+native float Sample(Texture1DArray<float>, sampler, float2 location);
>+native float Sample(Texture2D<float>, sampler, float2 location);
>+native float Sample(Texture2D<float>, sampler, float2 location, int2 offset);
>+native float Sample(Texture2DArray<float>, sampler, float3 location);
>+native float Sample(Texture2DArray<float>, sampler, float3 location, int2 offset);
>+native float Sample(Texture3D<float>, sampler, float3 location);
>+native float Sample(Texture3D<float>, sampler, float3 location, int3 offset);
>+native float Sample(TextureCube<float>, sampler, float3 location);
>+native float2 Sample(Texture1D<float2>, sampler, float location);
>+native float2 Sample(Texture1DArray<float2>, sampler, float2 location);
>+native float2 Sample(Texture2D<float2>, sampler, float2 location);
>+native float2 Sample(Texture2D<float2>, sampler, float2 location, int2 offset);
>+native float2 Sample(Texture2DArray<float2>, sampler, float3 location);
>+native float2 Sample(Texture2DArray<float2>, sampler, float3 location, int2 offset);
>+native float2 Sample(Texture3D<float2>, sampler, float3 location);
>+native float2 Sample(Texture3D<float2>, sampler, float3 location, int3 offset);
>+native float2 Sample(TextureCube<float2>, sampler, float3 location);
>+native float3 Sample(Texture1D<float3>, sampler, float location);
>+native float3 Sample(Texture1DArray<float3>, sampler, float2 location);
>+native float3 Sample(Texture2D<float3>, sampler, float2 location);
>+native float3 Sample(Texture2D<float3>, sampler, float2 location, int2 offset);
>+native float3 Sample(Texture2DArray<float3>, sampler, float3 location);
>+native float3 Sample(Texture2DArray<float3>, sampler, float3 location, int2 offset);
>+native float3 Sample(Texture3D<float3>, sampler, float3 location);
>+native float3 Sample(Texture3D<float3>, sampler, float3 location, int3 offset);
>+native float3 Sample(TextureCube<float3>, sampler, float3 location);
>+native float4 Sample(Texture1D<float4>, sampler, float location);
>+native float4 Sample(Texture1DArray<float4>, sampler, float2 location);
>+native float4 Sample(Texture2D<float4>, sampler, float2 location);
>+native float4 Sample(Texture2D<float4>, sampler, float2 location, int2 offset);
>+native float4 Sample(Texture2DArray<float4>, sampler, float3 location);
>+native float4 Sample(Texture2DArray<float4>, sampler, float3 location, int2 offset);
>+native float4 Sample(Texture3D<float4>, sampler, float3 location);
>+native float4 Sample(Texture3D<float4>, sampler, float3 location, int3 offset);
>+native float4 Sample(TextureCube<float4>, sampler, float3 location);
>+native float Sample(TextureDepth2D<float>, sampler, float2 location);
>+native float Sample(TextureDepth2D<float>, sampler, float2 location, int2 offset);
>+native float Sample(TextureDepth2DArray<float>, sampler, float3 location);
>+native float Sample(TextureDepth2DArray<float>, sampler, float3 location, int2 offset);
>+native float Sample(TextureDepthCube<float>, sampler, float3 location);
>+
>+native ushort Load(Texture1D<ushort>, int location);
>+native ushort Load(Texture1DArray<ushort>, int2 location);
>+native ushort Load(Texture2D<ushort>, int2 location);
>+native ushort Load(Texture2DArray<ushort>, int3 location);
>+native ushort Load(Texture3D<ushort>, int3 location);
>+native ushort Load(RWTexture1D<ushort>, int location);
>+native ushort Load(RWTexture1DArray<ushort>, int2 location);
>+native ushort Load(RWTexture2D<ushort>, int2 location);
>+native ushort Load(RWTexture2DArray<ushort>, int3 location);
>+native ushort Load(RWTexture3D<ushort>, int3 location);
>+native ushort2 Load(Texture1D<ushort2>, int location);
>+native ushort2 Load(Texture1DArray<ushort2>, int2 location);
>+native ushort2 Load(Texture2D<ushort2>, int2 location);
>+native ushort2 Load(Texture2DArray<ushort2>, int3 location);
>+native ushort2 Load(Texture3D<ushort2>, int3 location);
>+native ushort2 Load(RWTexture1D<ushort2>, int location);
>+native ushort2 Load(RWTexture1DArray<ushort2>, int2 location);
>+native ushort2 Load(RWTexture2D<ushort2>, int2 location);
>+native ushort2 Load(RWTexture2DArray<ushort2>, int3 location);
>+native ushort2 Load(RWTexture3D<ushort2>, int3 location);
>+native ushort3 Load(Texture1D<ushort3>, int location);
>+native ushort3 Load(Texture1DArray<ushort3>, int2 location);
>+native ushort3 Load(Texture2D<ushort3>, int2 location);
>+native ushort3 Load(Texture2DArray<ushort3>, int3 location);
>+native ushort3 Load(Texture3D<ushort3>, int3 location);
>+native ushort3 Load(RWTexture1D<ushort3>, int location);
>+native ushort3 Load(RWTexture1DArray<ushort3>, int2 location);
>+native ushort3 Load(RWTexture2D<ushort3>, int2 location);
>+native ushort3 Load(RWTexture2DArray<ushort3>, int3 location);
>+native ushort3 Load(RWTexture3D<ushort3>, int3 location);
>+native ushort4 Load(Texture1D<ushort4>, int location);
>+native ushort4 Load(Texture1DArray<ushort4>, int2 location);
>+native ushort4 Load(Texture2D<ushort4>, int2 location);
>+native ushort4 Load(Texture2DArray<ushort4>, int3 location);
>+native ushort4 Load(Texture3D<ushort4>, int3 location);
>+native ushort4 Load(RWTexture1D<ushort4>, int location);
>+native ushort4 Load(RWTexture1DArray<ushort4>, int2 location);
>+native ushort4 Load(RWTexture2D<ushort4>, int2 location);
>+native ushort4 Load(RWTexture2DArray<ushort4>, int3 location);
>+native ushort4 Load(RWTexture3D<ushort4>, int3 location);
>+native uint Load(Texture1D<uint>, int location);
>+native uint Load(Texture1DArray<uint>, int2 location);
>+native uint Load(Texture2D<uint>, int2 location);
>+native uint Load(Texture2DArray<uint>, int3 location);
>+native uint Load(Texture3D<uint>, int3 location);
>+native uint Load(RWTexture1D<uint>, int location);
>+native uint Load(RWTexture1DArray<uint>, int2 location);
>+native uint Load(RWTexture2D<uint>, int2 location);
>+native uint Load(RWTexture2DArray<uint>, int3 location);
>+native uint Load(RWTexture3D<uint>, int3 location);
>+native uint2 Load(Texture1D<uint2>, int location);
>+native uint2 Load(Texture1DArray<uint2>, int2 location);
>+native uint2 Load(Texture2D<uint2>, int2 location);
>+native uint2 Load(Texture2DArray<uint2>, int3 location);
>+native uint2 Load(Texture3D<uint2>, int3 location);
>+native uint2 Load(RWTexture1D<uint2>, int location);
>+native uint2 Load(RWTexture1DArray<uint2>, int2 location);
>+native uint2 Load(RWTexture2D<uint2>, int2 location);
>+native uint2 Load(RWTexture2DArray<uint2>, int3 location);
>+native uint2 Load(RWTexture3D<uint2>, int3 location);
>+native uint3 Load(Texture1D<uint3>, int location);
>+native uint3 Load(Texture1DArray<uint3>, int2 location);
>+native uint3 Load(Texture2D<uint3>, int2 location);
>+native uint3 Load(Texture2DArray<uint3>, int3 location);
>+native uint3 Load(Texture3D<uint3>, int3 location);
>+native uint3 Load(RWTexture1D<uint3>, int location);
>+native uint3 Load(RWTexture1DArray<uint3>, int2 location);
>+native uint3 Load(RWTexture2D<uint3>, int2 location);
>+native uint3 Load(RWTexture2DArray<uint3>, int3 location);
>+native uint3 Load(RWTexture3D<uint3>, int3 location);
>+native uint4 Load(Texture1D<uint4>, int location);
>+native uint4 Load(Texture1DArray<uint4>, int2 location);
>+native uint4 Load(Texture2D<uint4>, int2 location);
>+native uint4 Load(Texture2DArray<uint4>, int3 location);
>+native uint4 Load(Texture3D<uint4>, int3 location);
>+native uint4 Load(RWTexture1D<uint4>, int location);
>+native uint4 Load(RWTexture1DArray<uint4>, int2 location);
>+native uint4 Load(RWTexture2D<uint4>, int2 location);
>+native uint4 Load(RWTexture2DArray<uint4>, int3 location);
>+native uint4 Load(RWTexture3D<uint4>, int3 location);
>+native short Load(Texture1D<short>, int location);
>+native short Load(Texture1DArray<short>, int2 location);
>+native short Load(Texture2D<short>, int2 location);
>+native short Load(Texture2DArray<short>, int3 location);
>+native short Load(Texture3D<short>, int3 location);
>+native short Load(RWTexture1D<short>, int location);
>+native short Load(RWTexture1DArray<short>, int2 location);
>+native short Load(RWTexture2D<short>, int2 location);
>+native short Load(RWTexture2DArray<short>, int3 location);
>+native short Load(RWTexture3D<short>, int3 location);
>+native short2 Load(Texture1D<short2>, int location);
>+native short2 Load(Texture1DArray<short2>, int2 location);
>+native short2 Load(Texture2D<short2>, int2 location);
>+native short2 Load(Texture2DArray<short2>, int3 location);
>+native short2 Load(Texture3D<short2>, int3 location);
>+native short2 Load(RWTexture1D<short2>, int location);
>+native short2 Load(RWTexture1DArray<short2>, int2 location);
>+native short2 Load(RWTexture2D<short2>, int2 location);
>+native short2 Load(RWTexture2DArray<short2>, int3 location);
>+native short2 Load(RWTexture3D<short2>, int3 location);
>+native short3 Load(Texture1D<short3>, int location);
>+native short3 Load(Texture1DArray<short3>, int2 location);
>+native short3 Load(Texture2D<short3>, int2 location);
>+native short3 Load(Texture2DArray<short3>, int3 location);
>+native short3 Load(Texture3D<short3>, int3 location);
>+native short3 Load(RWTexture1D<short3>, int location);
>+native short3 Load(RWTexture1DArray<short3>, int2 location);
>+native short3 Load(RWTexture2D<short3>, int2 location);
>+native short3 Load(RWTexture2DArray<short3>, int3 location);
>+native short3 Load(RWTexture3D<short3>, int3 location);
>+native short4 Load(Texture1D<short4>, int location);
>+native short4 Load(Texture1DArray<short4>, int2 location);
>+native short4 Load(Texture2D<short4>, int2 location);
>+native short4 Load(Texture2DArray<short4>, int3 location);
>+native short4 Load(Texture3D<short4>, int3 location);
>+native short4 Load(RWTexture1D<short4>, int location);
>+native short4 Load(RWTexture1DArray<short4>, int2 location);
>+native short4 Load(RWTexture2D<short4>, int2 location);
>+native short4 Load(RWTexture2DArray<short4>, int3 location);
>+native short4 Load(RWTexture3D<short4>, int3 location);
>+native int Load(Texture1D<int>, int location);
>+native int Load(Texture1DArray<int>, int2 location);
>+native int Load(Texture2D<int>, int2 location);
>+native int Load(Texture2DArray<int>, int3 location);
>+native int Load(Texture3D<int>, int3 location);
>+native int Load(RWTexture1D<int>, int location);
>+native int Load(RWTexture1DArray<int>, int2 location);
>+native int Load(RWTexture2D<int>, int2 location);
>+native int Load(RWTexture2DArray<int>, int3 location);
>+native int Load(RWTexture3D<int>, int3 location);
>+native int2 Load(Texture1D<int2>, int location);
>+native int2 Load(Texture1DArray<int2>, int2 location);
>+native int2 Load(Texture2D<int2>, int2 location);
>+native int2 Load(Texture2DArray<int2>, int3 location);
>+native int2 Load(Texture3D<int2>, int3 location);
>+native int2 Load(RWTexture1D<int2>, int location);
>+native int2 Load(RWTexture1DArray<int2>, int2 location);
>+native int2 Load(RWTexture2D<int2>, int2 location);
>+native int2 Load(RWTexture2DArray<int2>, int3 location);
>+native int2 Load(RWTexture3D<int2>, int3 location);
>+native int3 Load(Texture1D<int3>, int location);
>+native int3 Load(Texture1DArray<int3>, int2 location);
>+native int3 Load(Texture2D<int3>, int2 location);
>+native int3 Load(Texture2DArray<int3>, int3 location);
>+native int3 Load(Texture3D<int3>, int3 location);
>+native int3 Load(RWTexture1D<int3>, int location);
>+native int3 Load(RWTexture1DArray<int3>, int2 location);
>+native int3 Load(RWTexture2D<int3>, int2 location);
>+native int3 Load(RWTexture2DArray<int3>, int3 location);
>+native int3 Load(RWTexture3D<int3>, int3 location);
>+native int4 Load(Texture1D<int4>, int location);
>+native int4 Load(Texture1DArray<int4>, int2 location);
>+native int4 Load(Texture2D<int4>, int2 location);
>+native int4 Load(Texture2DArray<int4>, int3 location);
>+native int4 Load(Texture3D<int4>, int3 location);
>+native int4 Load(RWTexture1D<int4>, int location);
>+native int4 Load(RWTexture1DArray<int4>, int2 location);
>+native int4 Load(RWTexture2D<int4>, int2 location);
>+native int4 Load(RWTexture2DArray<int4>, int3 location);
>+native int4 Load(RWTexture3D<int4>, int3 location);
>+native half Load(Texture1D<half>, int location);
>+native half Load(Texture1DArray<half>, int2 location);
>+native half Load(Texture2D<half>, int2 location);
>+native half Load(Texture2DArray<half>, int3 location);
>+native half Load(Texture3D<half>, int3 location);
>+native half Load(RWTexture1D<half>, int location);
>+native half Load(RWTexture1DArray<half>, int2 location);
>+native half Load(RWTexture2D<half>, int2 location);
>+native half Load(RWTexture2DArray<half>, int3 location);
>+native half Load(RWTexture3D<half>, int3 location);
>+native half2 Load(Texture1D<half2>, int location);
>+native half2 Load(Texture1DArray<half2>, int2 location);
>+native half2 Load(Texture2D<half2>, int2 location);
>+native half2 Load(Texture2DArray<half2>, int3 location);
>+native half2 Load(Texture3D<half2>, int3 location);
>+native half2 Load(RWTexture1D<half2>, int location);
>+native half2 Load(RWTexture1DArray<half2>, int2 location);
>+native half2 Load(RWTexture2D<half2>, int2 location);
>+native half2 Load(RWTexture2DArray<half2>, int3 location);
>+native half2 Load(RWTexture3D<half2>, int3 location);
>+native half3 Load(Texture1D<half3>, int location);
>+native half3 Load(Texture1DArray<half3>, int2 location);
>+native half3 Load(Texture2D<half3>, int2 location);
>+native half3 Load(Texture2DArray<half3>, int3 location);
>+native half3 Load(Texture3D<half3>, int3 location);
>+native half3 Load(RWTexture1D<half3>, int location);
>+native half3 Load(RWTexture1DArray<half3>, int2 location);
>+native half3 Load(RWTexture2D<half3>, int2 location);
>+native half3 Load(RWTexture2DArray<half3>, int3 location);
>+native half3 Load(RWTexture3D<half3>, int3 location);
>+native half4 Load(Texture1D<half4>, int location);
>+native half4 Load(Texture1DArray<half4>, int2 location);
>+native half4 Load(Texture2D<half4>, int2 location);
>+native half4 Load(Texture2DArray<half4>, int3 location);
>+native half4 Load(Texture3D<half4>, int3 location);
>+native half4 Load(RWTexture1D<half4>, int location);
>+native half4 Load(RWTexture1DArray<half4>, int2 location);
>+native half4 Load(RWTexture2D<half4>, int2 location);
>+native half4 Load(RWTexture2DArray<half4>, int3 location);
>+native half4 Load(RWTexture3D<half4>, int3 location);
>+native float Load(Texture1D<float>, int location);
>+native float Load(Texture1DArray<float>, int2 location);
>+native float Load(Texture2D<float>, int2 location);
>+native float Load(Texture2DArray<float>, int3 location);
>+native float Load(Texture3D<float>, int3 location);
>+native float Load(RWTexture1D<float>, int location);
>+native float Load(RWTexture1DArray<float>, int2 location);
>+native float Load(RWTexture2D<float>, int2 location);
>+native float Load(RWTexture2DArray<float>, int3 location);
>+native float Load(RWTexture3D<float>, int3 location);
>+native float2 Load(Texture1D<float2>, int location);
>+native float2 Load(Texture1DArray<float2>, int2 location);
>+native float2 Load(Texture2D<float2>, int2 location);
>+native float2 Load(Texture2DArray<float2>, int3 location);
>+native float2 Load(Texture3D<float2>, int3 location);
>+native float2 Load(RWTexture1D<float2>, int location);
>+native float2 Load(RWTexture1DArray<float2>, int2 location);
>+native float2 Load(RWTexture2D<float2>, int2 location);
>+native float2 Load(RWTexture2DArray<float2>, int3 location);
>+native float2 Load(RWTexture3D<float2>, int3 location);
>+native float3 Load(Texture1D<float3>, int location);
>+native float3 Load(Texture1DArray<float3>, int2 location);
>+native float3 Load(Texture2D<float3>, int2 location);
>+native float3 Load(Texture2DArray<float3>, int3 location);
>+native float3 Load(Texture3D<float3>, int3 location);
>+native float3 Load(RWTexture1D<float3>, int location);
>+native float3 Load(RWTexture1DArray<float3>, int2 location);
>+native float3 Load(RWTexture2D<float3>, int2 location);
>+native float3 Load(RWTexture2DArray<float3>, int3 location);
>+native float3 Load(RWTexture3D<float3>, int3 location);
>+native float4 Load(Texture1D<float4>, int location);
>+native float4 Load(Texture1DArray<float4>, int2 location);
>+native float4 Load(Texture2D<float4>, int2 location);
>+native float4 Load(Texture2DArray<float4>, int3 location);
>+native float4 Load(Texture3D<float4>, int3 location);
>+native float4 Load(RWTexture1D<float4>, int location);
>+native float4 Load(RWTexture1DArray<float4>, int2 location);
>+native float4 Load(RWTexture2D<float4>, int2 location);
>+native float4 Load(RWTexture2DArray<float4>, int3 location);
>+native float4 Load(RWTexture3D<float4>, int3 location);
>+native float Load(TextureDepth2D<float>, int2 location);
>+native float Load(TextureDepth2DArray<float>, int3 location);
>+
>+native void Store(RWTexture1D<ushort>, ushort, uint location);
>+native void Store(RWTexture1DArray<ushort>, ushort, uint2 location);
>+native void Store(RWTexture2D<ushort>, ushort, uint2 location);
>+native void Store(RWTexture2DArray<ushort>, ushort, uint3 location);
>+native void Store(RWTexture3D<ushort>, ushort, uint3 location);
>+native void Store(RWTexture1D<ushort2>, ushort2, uint location);
>+native void Store(RWTexture1DArray<ushort2>, ushort2, uint2 location);
>+native void Store(RWTexture2D<ushort2>, ushort2, uint2 location);
>+native void Store(RWTexture2DArray<ushort2>, ushort2, uint3 location);
>+native void Store(RWTexture3D<ushort2>, ushort2, uint3 location);
>+native void Store(RWTexture1D<ushort3>, ushort3, uint location);
>+native void Store(RWTexture1DArray<ushort3>, ushort3, uint2 location);
>+native void Store(RWTexture2D<ushort3>, ushort3, uint2 location);
>+native void Store(RWTexture2DArray<ushort3>, ushort3, uint3 location);
>+native void Store(RWTexture3D<ushort3>, ushort3, uint3 location);
>+native void Store(RWTexture1D<ushort4>, ushort4, uint location);
>+native void Store(RWTexture1DArray<ushort4>, ushort4, uint2 location);
>+native void Store(RWTexture2D<ushort4>, ushort4, uint2 location);
>+native void Store(RWTexture2DArray<ushort4>, ushort4, uint3 location);
>+native void Store(RWTexture3D<ushort4>, ushort4, uint3 location);
>+native void Store(RWTexture1D<uint>, uint, uint location);
>+native void Store(RWTexture1DArray<uint>, uint, uint2 location);
>+native void Store(RWTexture2D<uint>, uint, uint2 location);
>+native void Store(RWTexture2DArray<uint>, uint, uint3 location);
>+native void Store(RWTexture3D<uint>, uint, uint3 location);
>+native void Store(RWTexture1D<uint2>, uint2, uint location);
>+native void Store(RWTexture1DArray<uint2>, uint2, uint2 location);
>+native void Store(RWTexture2D<uint2>, uint2, uint2 location);
>+native void Store(RWTexture2DArray<uint2>, uint2, uint3 location);
>+native void Store(RWTexture3D<uint2>, uint2, uint3 location);
>+native void Store(RWTexture1D<uint3>, uint3, uint location);
>+native void Store(RWTexture1DArray<uint3>, uint3, uint2 location);
>+native void Store(RWTexture2D<uint3>, uint3, uint2 location);
>+native void Store(RWTexture2DArray<uint3>, uint3, uint3 location);
>+native void Store(RWTexture3D<uint3>, uint3, uint3 location);
>+native void Store(RWTexture1D<uint4>, uint4, uint location);
>+native void Store(RWTexture1DArray<uint4>, uint4, uint2 location);
>+native void Store(RWTexture2D<uint4>, uint4, uint2 location);
>+native void Store(RWTexture2DArray<uint4>, uint4, uint3 location);
>+native void Store(RWTexture3D<uint4>, uint4, uint3 location);
>+native void Store(RWTexture1D<short>, short, uint location);
>+native void Store(RWTexture1DArray<short>, short, uint2 location);
>+native void Store(RWTexture2D<short>, short, uint2 location);
>+native void Store(RWTexture2DArray<short>, short, uint3 location);
>+native void Store(RWTexture3D<short>, short, uint3 location);
>+native void Store(RWTexture1D<short2>, short2, uint location);
>+native void Store(RWTexture1DArray<short2>, short2, uint2 location);
>+native void Store(RWTexture2D<short2>, short2, uint2 location);
>+native void Store(RWTexture2DArray<short2>, short2, uint3 location);
>+native void Store(RWTexture3D<short2>, short2, uint3 location);
>+native void Store(RWTexture1D<short3>, short3, uint location);
>+native void Store(RWTexture1DArray<short3>, short3, uint2 location);
>+native void Store(RWTexture2D<short3>, short3, uint2 location);
>+native void Store(RWTexture2DArray<short3>, short3, uint3 location);
>+native void Store(RWTexture3D<short3>, short3, uint3 location);
>+native void Store(RWTexture1D<short4>, short4, uint location);
>+native void Store(RWTexture1DArray<short4>, short4, uint2 location);
>+native void Store(RWTexture2D<short4>, short4, uint2 location);
>+native void Store(RWTexture2DArray<short4>, short4, uint3 location);
>+native void Store(RWTexture3D<short4>, short4, uint3 location);
>+native void Store(RWTexture1D<int>, int, uint location);
>+native void Store(RWTexture1DArray<int>, int, uint2 location);
>+native void Store(RWTexture2D<int>, int, uint2 location);
>+native void Store(RWTexture2DArray<int>, int, uint3 location);
>+native void Store(RWTexture3D<int>, int, uint3 location);
>+native void Store(RWTexture1D<int2>, int2, uint location);
>+native void Store(RWTexture1DArray<int2>, int2, uint2 location);
>+native void Store(RWTexture2D<int2>, int2, uint2 location);
>+native void Store(RWTexture2DArray<int2>, int2, uint3 location);
>+native void Store(RWTexture3D<int2>, int2, uint3 location);
>+native void Store(RWTexture1D<int3>, int3, uint location);
>+native void Store(RWTexture1DArray<int3>, int3, uint2 location);
>+native void Store(RWTexture2D<int3>, int3, uint2 location);
>+native void Store(RWTexture2DArray<int3>, int3, uint3 location);
>+native void Store(RWTexture3D<int3>, int3, uint3 location);
>+native void Store(RWTexture1D<int4>, int4, uint location);
>+native void Store(RWTexture1DArray<int4>, int4, uint2 location);
>+native void Store(RWTexture2D<int4>, int4, uint2 location);
>+native void Store(RWTexture2DArray<int4>, int4, uint3 location);
>+native void Store(RWTexture3D<int4>, int4, uint3 location);
>+native void Store(RWTexture1D<half>, half, uint location);
>+native void Store(RWTexture1DArray<half>, half, uint2 location);
>+native void Store(RWTexture2D<half>, half, uint2 location);
>+native void Store(RWTexture2DArray<half>, half, uint3 location);
>+native void Store(RWTexture3D<half>, half, uint3 location);
>+native void Store(RWTexture1D<half2>, half2, uint location);
>+native void Store(RWTexture1DArray<half2>, half2, uint2 location);
>+native void Store(RWTexture2D<half2>, half2, uint2 location);
>+native void Store(RWTexture2DArray<half2>, half2, uint3 location);
>+native void Store(RWTexture3D<half2>, half2, uint3 location);
>+native void Store(RWTexture1D<half3>, half3, uint location);
>+native void Store(RWTexture1DArray<half3>, half3, uint2 location);
>+native void Store(RWTexture2D<half3>, half3, uint2 location);
>+native void Store(RWTexture2DArray<half3>, half3, uint3 location);
>+native void Store(RWTexture3D<half3>, half3, uint3 location);
>+native void Store(RWTexture1D<half4>, half4, uint location);
>+native void Store(RWTexture1DArray<half4>, half4, uint2 location);
>+native void Store(RWTexture2D<half4>, half4, uint2 location);
>+native void Store(RWTexture2DArray<half4>, half4, uint3 location);
>+native void Store(RWTexture3D<half4>, half4, uint3 location);
>+native void Store(RWTexture1D<float>, float, uint location);
>+native void Store(RWTexture1DArray<float>, float, uint2 location);
>+native void Store(RWTexture2D<float>, float, uint2 location);
>+native void Store(RWTexture2DArray<float>, float, uint3 location);
>+native void Store(RWTexture3D<float>, float, uint3 location);
>+native void Store(RWTexture1D<float2>, float2, uint location);
>+native void Store(RWTexture1DArray<float2>, float2, uint2 location);
>+native void Store(RWTexture2D<float2>, float2, uint2 location);
>+native void Store(RWTexture2DArray<float2>, float2, uint3 location);
>+native void Store(RWTexture3D<float2>, float2, uint3 location);
>+native void Store(RWTexture1D<float3>, float3, uint location);
>+native void Store(RWTexture1DArray<float3>, float3, uint2 location);
>+native void Store(RWTexture2D<float3>, float3, uint2 location);
>+native void Store(RWTexture2DArray<float3>, float3, uint3 location);
>+native void Store(RWTexture3D<float3>, float3, uint3 location);
>+native void Store(RWTexture1D<float4>, float4, uint location);
>+native void Store(RWTexture1DArray<float4>, float4, uint2 location);
>+native void Store(RWTexture2D<float4>, float4, uint2 location);
>+native void Store(RWTexture2DArray<float4>, float4, uint3 location);
>+native void Store(RWTexture3D<float4>, float4, uint3 location);
>+
>+// FIXME: Uncomment this when the compiler is fast enough.
>+/*native void GetDimensions(RWTexture1D<float2>, device float* Width);
>+native void GetDimensions(RWTexture1D<float2>, device uint* Width);
>+native void GetDimensions(RWTexture1D<float2>, thread float* Width);
>+native void GetDimensions(RWTexture1D<float2>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<float2>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<float2>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<float3>, device float* Width);
>+native void GetDimensions(RWTexture1D<float3>, device uint* Width);
>+native void GetDimensions(RWTexture1D<float3>, thread float* Width);
>+native void GetDimensions(RWTexture1D<float3>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<float3>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<float3>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<float4>, device float* Width);
>+native void GetDimensions(RWTexture1D<float4>, device uint* Width);
>+native void GetDimensions(RWTexture1D<float4>, thread float* Width);
>+native void GetDimensions(RWTexture1D<float4>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<float4>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<float4>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<float>, device float* Width);
>+native void GetDimensions(RWTexture1D<float>, device uint* Width);
>+native void GetDimensions(RWTexture1D<float>, thread float* Width);
>+native void GetDimensions(RWTexture1D<float>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<float>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<float>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<half2>, device float* Width);
>+native void GetDimensions(RWTexture1D<half2>, device uint* Width);
>+native void GetDimensions(RWTexture1D<half2>, thread float* Width);
>+native void GetDimensions(RWTexture1D<half2>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<half2>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<half2>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<half3>, device float* Width);
>+native void GetDimensions(RWTexture1D<half3>, device uint* Width);
>+native void GetDimensions(RWTexture1D<half3>, thread float* Width);
>+native void GetDimensions(RWTexture1D<half3>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<half3>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<half3>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<half4>, device float* Width);
>+native void GetDimensions(RWTexture1D<half4>, device uint* Width);
>+native void GetDimensions(RWTexture1D<half4>, thread float* Width);
>+native void GetDimensions(RWTexture1D<half4>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<half4>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<half4>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<half>, device float* Width);
>+native void GetDimensions(RWTexture1D<half>, device uint* Width);
>+native void GetDimensions(RWTexture1D<half>, thread float* Width);
>+native void GetDimensions(RWTexture1D<half>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<half>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<half>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<int2>, device float* Width);
>+native void GetDimensions(RWTexture1D<int2>, device uint* Width);
>+native void GetDimensions(RWTexture1D<int2>, thread float* Width);
>+native void GetDimensions(RWTexture1D<int2>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<int2>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<int2>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<int3>, device float* Width);
>+native void GetDimensions(RWTexture1D<int3>, device uint* Width);
>+native void GetDimensions(RWTexture1D<int3>, thread float* Width);
>+native void GetDimensions(RWTexture1D<int3>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<int3>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<int3>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<int4>, device float* Width);
>+native void GetDimensions(RWTexture1D<int4>, device uint* Width);
>+native void GetDimensions(RWTexture1D<int4>, thread float* Width);
>+native void GetDimensions(RWTexture1D<int4>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<int4>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<int4>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<int>, device float* Width);
>+native void GetDimensions(RWTexture1D<int>, device uint* Width);
>+native void GetDimensions(RWTexture1D<int>, thread float* Width);
>+native void GetDimensions(RWTexture1D<int>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<int>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<int>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<short2>, device float* Width);
>+native void GetDimensions(RWTexture1D<short2>, device uint* Width);
>+native void GetDimensions(RWTexture1D<short2>, thread float* Width);
>+native void GetDimensions(RWTexture1D<short2>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<short2>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<short2>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<short3>, device float* Width);
>+native void GetDimensions(RWTexture1D<short3>, device uint* Width);
>+native void GetDimensions(RWTexture1D<short3>, thread float* Width);
>+native void GetDimensions(RWTexture1D<short3>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<short3>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<short3>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<short4>, device float* Width);
>+native void GetDimensions(RWTexture1D<short4>, device uint* Width);
>+native void GetDimensions(RWTexture1D<short4>, thread float* Width);
>+native void GetDimensions(RWTexture1D<short4>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<short4>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<short4>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<short>, device float* Width);
>+native void GetDimensions(RWTexture1D<short>, device uint* Width);
>+native void GetDimensions(RWTexture1D<short>, thread float* Width);
>+native void GetDimensions(RWTexture1D<short>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<short>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<short>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<uint2>, device float* Width);
>+native void GetDimensions(RWTexture1D<uint2>, device uint* Width);
>+native void GetDimensions(RWTexture1D<uint2>, thread float* Width);
>+native void GetDimensions(RWTexture1D<uint2>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<uint2>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<uint2>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<uint3>, device float* Width);
>+native void GetDimensions(RWTexture1D<uint3>, device uint* Width);
>+native void GetDimensions(RWTexture1D<uint3>, thread float* Width);
>+native void GetDimensions(RWTexture1D<uint3>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<uint3>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<uint3>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<uint4>, device float* Width);
>+native void GetDimensions(RWTexture1D<uint4>, device uint* Width);
>+native void GetDimensions(RWTexture1D<uint4>, thread float* Width);
>+native void GetDimensions(RWTexture1D<uint4>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<uint4>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<uint4>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<uint>, device float* Width);
>+native void GetDimensions(RWTexture1D<uint>, device uint* Width);
>+native void GetDimensions(RWTexture1D<uint>, thread float* Width);
>+native void GetDimensions(RWTexture1D<uint>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<uint>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<uint>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<ushort2>, device float* Width);
>+native void GetDimensions(RWTexture1D<ushort2>, device uint* Width);
>+native void GetDimensions(RWTexture1D<ushort2>, thread float* Width);
>+native void GetDimensions(RWTexture1D<ushort2>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<ushort2>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<ushort2>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<ushort3>, device float* Width);
>+native void GetDimensions(RWTexture1D<ushort3>, device uint* Width);
>+native void GetDimensions(RWTexture1D<ushort3>, thread float* Width);
>+native void GetDimensions(RWTexture1D<ushort3>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<ushort3>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<ushort3>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<ushort4>, device float* Width);
>+native void GetDimensions(RWTexture1D<ushort4>, device uint* Width);
>+native void GetDimensions(RWTexture1D<ushort4>, thread float* Width);
>+native void GetDimensions(RWTexture1D<ushort4>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<ushort4>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<ushort4>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1D<ushort>, device float* Width);
>+native void GetDimensions(RWTexture1D<ushort>, device uint* Width);
>+native void GetDimensions(RWTexture1D<ushort>, thread float* Width);
>+native void GetDimensions(RWTexture1D<ushort>, thread uint* Width);
>+native void GetDimensions(RWTexture1D<ushort>, threadgroup float* Width);
>+native void GetDimensions(RWTexture1D<ushort>, threadgroup uint* Width);
>+native void GetDimensions(RWTexture1DArray<float2>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<float>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<half>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<int>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<short>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<uint>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, device float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, device float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, device float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, device uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, device uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, device uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, thread float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, thread float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, thread float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, thread uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, thread uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, thread uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup float* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup float* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup float* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup uint* Width, device uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup uint* Width, thread uint* Elements);
>+native void GetDimensions(RWTexture1DArray<ushort>, threadgroup uint* Width, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2D<float2>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float2>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float2>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float2>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float2>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float2>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float2>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float2>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float2>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float2>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float2>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float3>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float3>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float3>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float3>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float3>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float3>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float3>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float3>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float3>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float3>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float4>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float4>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float4>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float4>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float4>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float4>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float4>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float4>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float4>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float4>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<float>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<float>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<float>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<float>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<float>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<float>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half2>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half2>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half2>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half2>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half2>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half2>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half2>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half2>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half2>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half2>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half3>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half3>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half3>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half3>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half3>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half3>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half3>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half3>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half3>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half3>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half4>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half4>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half4>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half4>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half4>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half4>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half4>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half4>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half4>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half4>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<half>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<half>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<half>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<half>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<half>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<half>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int2>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int2>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int2>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int2>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int2>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int2>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int2>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int2>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int2>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int2>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int3>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int3>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int3>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int3>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int3>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int3>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int3>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int3>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int3>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int3>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int4>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int4>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int4>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int4>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int4>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int4>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int4>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int4>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int4>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int4>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<int>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<int>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<int>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<int>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<int>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<int>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short2>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short2>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short2>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short2>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short2>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short2>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short2>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short2>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short2>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short2>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short3>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short3>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short3>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short3>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short3>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short3>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short3>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short3>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short3>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short3>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short4>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short4>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short4>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short4>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short4>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short4>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short4>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short4>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short4>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short4>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<short>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<short>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<short>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<short>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<short>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<short>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint2>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint2>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint3>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint3>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint4>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint4>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<uint>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<uint>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<uint>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<uint>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort2>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort3>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort4>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, device float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, device float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, device float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, device uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, device uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, device uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, thread float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, thread float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, thread float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, thread uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, thread uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, thread uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, threadgroup float* Width, device float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, threadgroup float* Width, thread float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, threadgroup float* Width, threadgroup float* Height);
>+native void GetDimensions(RWTexture2D<ushort>, threadgroup uint* Width, device uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, threadgroup uint* Width, thread uint* Height);
>+native void GetDimensions(RWTexture2D<ushort>, threadgroup uint* Width, threadgroup uint* Height);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<float>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<half>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<int>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<short>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<uint>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, device float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, device float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, device float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, thread float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, thread float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, thread float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, threadgroup float* Height, device float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, threadgroup float* Height, thread float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, device uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, device uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, thread uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, thread uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements);
>+native void GetDimensions(RWTexture2DArray<ushort>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<float>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<half>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<int>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<short>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<uint>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort2>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort3>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort4>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, device float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, device float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, device float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, thread float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, thread float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, thread float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, threadgroup float* Height, device float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, threadgroup float* Height, thread float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup float* Width, threadgroup float* Height, threadgroup float* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, device uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, device uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, thread uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, thread uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth);
>+native void GetDimensions(RWTexture3D<ushort>, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, device uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, device uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, thread uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, thread uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture1DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);*/
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+/*native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture2DArray<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, device uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, thread uint* NumberOfLevels);
>+native void GetDimensions(Texture3D<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Depth, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<half>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<int>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<short>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<uint>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort2>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort3>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort4>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureCube<ushort>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2D<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepth2DArray<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* Elements, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, device uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, thread uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, device uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, thread uint* Height, threadgroup uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, device uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, thread uint* NumberOfLevels);
>+native void GetDimensions(TextureDepthCube<float>, uint MipLevel, threadgroup uint* Width, threadgroup uint* Height, threadgroup uint* NumberOfLevels);*/
> 
> // FIXME: https://bugs.webkit.org/show_bug.cgi?id=192890 Insert the rest of the standard library once the parser is fast enough
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp
>index 9cb5c81ebf913a8bb94b4cda4303adb8464babb0..b584b9e44e9beae688166b24c8e2dd6e37befd1e 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp
>@@ -39,7 +39,7 @@ namespace WHLSL {
> 
> class FindArrayTypes : public Visitor {
> public:
>-    ~FindArrayTypes() = default;
>+    virtual ~FindArrayTypes() = default;
> 
>     void visit(AST::ArrayType& arrayType) override
>     {
>diff --git a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp
>index 65240dcf104f37f9a055a3c1ffd39618cc2c4d65..764341128f75ce52ffd3bde5f0fa0058451b17f5 100644
>--- a/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp
>+++ b/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp
>@@ -47,7 +47,7 @@ namespace WHLSL {
> 
> class FindAllTypes : public Visitor {
> public:
>-    ~FindAllTypes() = default;
>+    virtual ~FindAllTypes() = default;
> 
>     void visit(AST::PointerType& pointerType) override
>     {
>@@ -124,7 +124,7 @@ bool synthesizeConstructors(Program& program)
>     for (auto& namedType : namedTypes) {
>         if (matches(namedType, program.intrinsics().voidType()))
>             continue;
>-        if (is<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)) && downcast<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)).isAtom())
>+        if (is<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)) && downcast<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)).isAtomic())
>             continue;
> 
>         auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(namedType.get().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get())), String(), WTF::nullopt, WTF::nullopt);
>@@ -133,9 +133,12 @@ bool synthesizeConstructors(Program& program)
>         AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
>         program.append(WTFMove(copyConstructor));
> 
>-        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, AST::VariableDeclarations(), WTF::nullopt, isOperator));
>-        if (!program.append(WTFMove(defaultConstructor)))
>-            return false;
>+        if (!is<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType))
>+            || !downcast<AST::NativeTypeDeclaration>(static_cast<AST::NamedType&>(namedType)).isTexture()) {
>+            AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, AST::VariableDeclarations(), WTF::nullopt, isOperator));
>+            if (!program.append(WTFMove(defaultConstructor)))
>+                return false;
>+        }
>     }
>     return true;
> }
>diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
>index 1b2cfd19487f8d62d530d75b54055d57bcf504af..5610250d49e0ee324790620579a9805b08a63343 100644
>--- a/Source/WebCore/Sources.txt
>+++ b/Source/WebCore/Sources.txt
>@@ -312,6 +312,7 @@ Modules/webgpu/WHLSL/WHLSLAutoInitializeVariables.cpp
> Modules/webgpu/WHLSL/WHLSLInferTypes.cpp
> Modules/webgpu/WHLSL/WHLSLLexer.cpp
> Modules/webgpu/WHLSL/WHLSLParser.cpp
>+Modules/webgpu/WHLSL/WHLSLCheckTextureReferences.cpp
> Modules/webgpu/WHLSL/WHLSLChecker.cpp
> Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp
> Modules/webgpu/WHLSL/WHLSLCheckDuplicateFunctions.cpp
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index aacba4c14b071add6cd196b1ea7925fe76e5fe72..f096e0506e6c21c5a68f4e27115dfbdbd2dad486 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -6376,6 +6376,8 @@
> 		1C24EEA61C72A7B40080F8FC /* JSFontFaceSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JSFontFaceSet.cpp; path = DerivedSources/WebCore/JSFontFaceSet.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1C24EEA71C72A7B40080F8FC /* JSFontFaceSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JSFontFaceSet.h; path = DerivedSources/WebCore/JSFontFaceSet.h; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1C2649790D7E248A00BD10F2 /* DocumentLoaderMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DocumentLoaderMac.cpp; sourceTree = "<group>"; };
>+		1C281C6D22B87B9800691C00 /* WHLSLCheckTextureReferences.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLCheckTextureReferences.cpp; sourceTree = "<group>"; };
>+		1C281C6E22B87B9800691C00 /* WHLSLCheckTextureReferences.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLCheckTextureReferences.h; sourceTree = "<group>"; };
> 		1C3249101C6D6A3B007EDB32 /* FontVariantBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontVariantBuilder.cpp; sourceTree = "<group>"; };
> 		1C33277121CF0BE1000DC9F2 /* WHLSLNamedType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLNamedType.h; sourceTree = "<group>"; };
> 		1C33277221CF0D2E000DC9F2 /* WHLSLUnnamedType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLUnnamedType.h; sourceTree = "<group>"; };
>@@ -25452,6 +25454,8 @@
> 				C234A9AE21E92C1A003C984D /* WHLSLCheckDuplicateFunctions.h */,
> 				1C840B9B21EC400900D0500D /* WHLSLChecker.cpp */,
> 				1C840B9721EC400700D0500D /* WHLSLChecker.h */,
>+				1C281C6D22B87B9800691C00 /* WHLSLCheckTextureReferences.cpp */,
>+				1C281C6E22B87B9800691C00 /* WHLSLCheckTextureReferences.h */,
> 				1C86CA4B22AA19FF001BF961 /* WHLSLComputeDimensions.cpp */,
> 				1C86CA4C22AA19FF001BF961 /* WHLSLComputeDimensions.h */,
> 				1CA0C2E421EED12A00A11860 /* WHLSLFunctionStageChecker.cpp */,
>diff --git a/Source/WebCore/platform/graphics/gpu/GPUTexture.h b/Source/WebCore/platform/graphics/gpu/GPUTexture.h
>index d11bfcc4ab0cc24fa91bdc68272d14aafc4003fa..61912af0be1126e2a7a07cfc29236947ef3c70fd 100644
>--- a/Source/WebCore/platform/graphics/gpu/GPUTexture.h
>+++ b/Source/WebCore/platform/graphics/gpu/GPUTexture.h
>@@ -54,6 +54,8 @@ public:
>     bool isTransferDestination() const { return m_usage.contains(GPUTextureUsage::Flags::TransferDestination); }
>     bool isOutputAttachment() const { return m_usage.contains(GPUTextureUsage::Flags::OutputAttachment); }
>     bool isReadOnly() const { return m_usage.containsAny({ GPUTextureUsage::Flags::TransferSource, GPUTextureUsage::Flags::Sampled }); }
>+    bool isSampled() const { return m_usage.contains(GPUTextureUsage::Flags::Sampled); }
>+    bool isStorage() const { return m_usage.contains(GPUTextureUsage::Flags::Storage); }
> 
>     RefPtr<GPUTexture> tryCreateDefaultTextureView();
>     void destroy() { m_platformTexture = nullptr; }
>diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm
>index 6262e5f6d4156cd55ec0edabdc5a5c764d42ae48..3e0c7d38ae1690b9631f43e0a76c48e648b83aed 100644
>--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm
>+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBindGroupMetal.mm
>@@ -216,22 +216,22 @@ RefPtr<GPUBindGroup> GPUBindGroup::tryCreate(const GPUBindGroupDescriptor& descr
>             if (!samplerState)
>                 return false;
>             if (isForVertex)
>-                setSamplerOnEncoder(vertexEncoder, samplerState, index);
>+                setSamplerOnEncoder(vertexEncoder, samplerState, layoutBinding.internalName);
>             if (isForFragment)
>-                setSamplerOnEncoder(fragmentEncoder, samplerState, index);
>+                setSamplerOnEncoder(fragmentEncoder, samplerState, layoutBinding.internalName);
>             if (isForCompute)
>-                setSamplerOnEncoder(computeEncoder, samplerState, index);
>+                setSamplerOnEncoder(computeEncoder, samplerState, layoutBinding.internalName);
>             return true;
>         }, [&](GPUBindGroupLayout::SampledTexture&) -> bool {
>             auto textureResource = tryGetResourceAsTexture(resourceBinding.resource, functionName);
>             if (!textureResource)
>                 return false;
>             if (isForVertex)
>-                setTextureOnEncoder(vertexEncoder, textureResource->platformTexture(), index);
>+                setTextureOnEncoder(vertexEncoder, textureResource->platformTexture(), layoutBinding.internalName);
>             if (isForFragment)
>-                setTextureOnEncoder(fragmentEncoder, textureResource->platformTexture(), index);
>+                setTextureOnEncoder(fragmentEncoder, textureResource->platformTexture(), layoutBinding.internalName);
>             if (isForCompute)
>-                setTextureOnEncoder(computeEncoder, textureResource->platformTexture(), index);
>+                setTextureOnEncoder(computeEncoder, textureResource->platformTexture(), layoutBinding.internalName);
>             boundTextures.append(textureResource.releaseNonNull());
>             return true;
>         }, [&](GPUBindGroupLayout::StorageBuffer& storageBuffer) -> bool {
>diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm
>index e81f7cadd2708c6cdfaa3fdf9b1eff72eba7ef79..7ba25aa8f020af5da191322322e674eecd25a322 100644
>--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm
>+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm
>@@ -85,6 +85,9 @@ static Optional<WHLSL::ComputeDimensions> trySetFunctions(const char* const func
>         auto whlslCompileResult = WHLSL::prepare(whlslSource, *whlslDescriptor);
>         if (!whlslCompileResult)
>             return WTF::nullopt;
>+
>+        WTFLogAlways("%s", whlslCompileResult->metalSource.utf8().data());
>+
>         computeDimensions = whlslCompileResult->computeDimensions;
> 
>         NSError *error = nil;
>diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm
>index 2e9871802588bae3c97fecd56f9e4062623d5ef6..62e1158e02e1408c931d482b21b702566dfcc3f1 100644
>--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm
>+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUProgrammablePassEncoderMetal.mm
>@@ -63,11 +63,27 @@ void GPUProgrammablePassEncoder::setBindGroup(unsigned index, GPUBindGroup& bind
>         setComputeBuffer(bindGroup.computeArgsBuffer(), 0, index);
> 
>     for (auto& bufferRef : bindGroup.boundBuffers()) {
>-        useResource(bufferRef->platformBuffer(), bufferRef->isReadOnly() ? MTLResourceUsageRead : MTLResourceUsageRead | MTLResourceUsageWrite);
>+        MTLResourceUsage usage = 0;
>+        if (bufferRef->isUniform()) {
>+            ASSERT(!bufferRef->isStorage());
>+            usage = MTLResourceUsageRead;
>+        } else if (bufferRef->isStorage()) {
>+            ASSERT(!bufferRef->isUniform());
>+            usage = MTLResourceUsageRead | MTLResourceUsageWrite;
>+        }
>+        useResource(bufferRef->platformBuffer(), usage);
>         m_commandBuffer->useBuffer(bufferRef.copyRef());
>     }
>     for (auto& textureRef : bindGroup.boundTextures()) {
>-        useResource(textureRef->platformTexture(), textureRef->isReadOnly() ? MTLResourceUsageRead : MTLResourceUsageRead | MTLResourceUsageWrite);
>+        MTLResourceUsage usage = 0;
>+        if (textureRef->isSampled()) {
>+            ASSERT(!textureRef->isStorage());
>+            usage = MTLResourceUsageRead | MTLResourceUsageSample;
>+        } else if (textureRef->isStorage()) {
>+            ASSERT(!textureRef->isSampled());
>+            usage = MTLResourceUsageRead | MTLResourceUsageWrite;
>+        }
>+        useResource(textureRef->platformTexture(), usage);
>         m_commandBuffer->useTexture(textureRef.copyRef());
>     }
> }
>diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
>index f56661d6c280c031cff02a664e865dbd8117f05f..dcdac99c44514f282fad5e834f957ecd05e1b102 100644
>--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
>+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
>@@ -410,6 +410,8 @@ static bool trySetFunctions(const char* const functionName, const GPUPipelineSta
>         if (!whlslCompileResult)
>             return false;
> 
>+        WTFLogAlways("%s", whlslCompileResult->metalSource.utf8().data());
>+
>         NSError *error = nil;
> 
>         BEGIN_BLOCK_OBJC_EXCEPTIONS;
>diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUTextureMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUTextureMetal.mm
>index 783c0130ba69b24387cd817eee2c85cc306389a7..ee48928618db282590a894240648abc88ceda0b3 100644
>--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUTextureMetal.mm
>+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUTextureMetal.mm
>@@ -59,27 +59,26 @@ static Optional<MTLTextureUsage> mtlTextureUsageForGPUTextureUsageFlags(OptionSe
> #if LOG_DISABLED
>     UNUSED_PARAM(functionName);
> #endif
>+
>     if (flags.containsAny({ GPUTextureUsage::Flags::TransferSource, GPUTextureUsage::Flags::Sampled }) && (flags & GPUTextureUsage::Flags::Storage)) {
>         LOG(WebGPU, "%s: Texture cannot have both STORAGE and a read-only usage!", functionName);
>         return WTF::nullopt;
>     }
> 
>-    if (flags & GPUTextureUsage::Flags::OutputAttachment) {
>-        if (flags.containsAny({ GPUTextureUsage::Flags::Storage, GPUTextureUsage::Flags::Sampled })) {
>-            LOG(WebGPU, "%s: Texture cannot have OUTPUT_ATTACHMENT usage with STORAGE or SAMPLED usages!", functionName);
>-            return WTF::nullopt;
>-        }
>-
>-        return MTLTextureUsageRenderTarget | MTLTextureUsagePixelFormatView;
>+    if (flags & GPUTextureUsage::Flags::OutputAttachment && flags.containsAny({ GPUTextureUsage::Flags::Storage, GPUTextureUsage::Flags::Sampled })) {
>+        LOG(WebGPU, "%s: Texture cannot have OUTPUT_ATTACHMENT usage with STORAGE or SAMPLED usages!", functionName);
>+        return WTF::nullopt;
>     }
> 
>-    if (flags & GPUTextureUsage::Flags::Storage)
>-        return MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead | MTLTextureUsagePixelFormatView;
>-
>-    if (flags & GPUTextureUsage::Flags::Sampled)
>-        return MTLTextureUsageShaderRead | MTLTextureUsagePixelFormatView;
>+    MTLTextureUsage result = MTLTextureUsagePixelFormatView;
>+    if (flags.contains(GPUTextureUsage::Flags::OutputAttachment))
>+        result |= MTLTextureUsageRenderTarget;
>+    if (flags.containsAny({ GPUTextureUsage::Flags::Storage, GPUTextureUsage::Flags::Sampled }))
>+        result |= MTLTextureUsageShaderRead;
>+    if (flags.contains(GPUTextureUsage::Flags::Storage))
>+        result |= MTLTextureUsageShaderWrite;
> 
>-    return MTLTextureUsageUnknown;
>+    return result;
> }
> 
> #if !PLATFORM(MAC)
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index c4ec313e8be98b59b10400b1e999f0546b85cb80..837908249e3d44514bff95c93f5ff4cfb57527c0 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,25 @@
>+2019-06-18  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [WHLSL] Hook up common texture functions
>+        https://bugs.webkit.org/show_bug.cgi?id=198704
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * webgpu/whlsl-compute-expected.txt:
>+        * webgpu/whlsl-compute.html:
>+        * webgpu/whlsl-null-dereference-expected.txt:
>+        * webgpu/whlsl-null-dereference.html:
>+        * webgpu/whlsl-oob-access-expected.txt:
>+        * webgpu/whlsl-oob-access.html:
>+        * webgpu/whlsl-textures-getdimensions-expected.txt: Added.
>+        * webgpu/whlsl-textures-getdimensions.html: Added.
>+        * webgpu/whlsl-textures-load-expected.html: Added.
>+        * webgpu/whlsl-textures-load.html: Added.
>+        * webgpu/whlsl-textures-sample-expected.html: Added.
>+        * webgpu/whlsl-textures-sample.html: Added.
>+        * webgpu/whlsl-textures-store-expected.html: Added.
>+        * webgpu/whlsl-textures-store.html: Added.
>+
> 2019-06-17  Saam Barati  <sbarati@apple.com>
> 
>         [WHLSL] Make .length work
>diff --git a/LayoutTests/webgpu/whlsl-compute-expected.txt b/LayoutTests/webgpu/whlsl-compute-expected.txt
>index 6e1668a103beb92f76ea7e8d7aa7ffb50e89e241..a935cf8404f6c968a6d7537d5ead3a299b97ebb0 100644
>--- a/LayoutTests/webgpu/whlsl-compute-expected.txt
>+++ b/LayoutTests/webgpu/whlsl-compute-expected.txt
>@@ -1,6 +1,3 @@
>-PASS successfullyParsed is true
>-
>-TEST COMPLETE
> PASS resultsFloat32Array[0] is 2
> PASS resultsFloat32Array[1] is 4
> PASS resultsFloat32Array[2] is 6
>@@ -9,4 +6,7 @@ PASS resultsFloat32Array[4] is 5
> PASS resultsFloat32Array[5] is 6
> PASS resultsFloat32Array[6] is 7
> PASS resultsFloat32Array[7] is 8
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
> 
>diff --git a/LayoutTests/webgpu/whlsl-compute.html b/LayoutTests/webgpu/whlsl-compute.html
>index 8a68efdfe0e3f218133fbfb4a5a05d7d4d88f43d..8093e8511c64cd40cde384291e277faa100624cb 100644
>--- a/LayoutTests/webgpu/whlsl-compute.html
>+++ b/LayoutTests/webgpu/whlsl-compute.html
>@@ -73,15 +73,12 @@ async function start() {
>     shouldBe("resultsFloat32Array[7]", "8");
>     resultsBuffer.unmap();
> }
>-if (window.testRunner)
>-    testRunner.waitUntilDone();
>+window.jsTestIsAsync = true;
> window.addEventListener("load", function() {
>     start().then(function() {
>-        if (window.testRunner)
>-            testRunner.notifyDone();
>+        finishJSTest();
>     }, function() {
>-        if (window.testRunner)
>-            testRunner.notifyDone();
>+        finishJSTest();
>     });
> });
> </script>
>diff --git a/LayoutTests/webgpu/whlsl-null-dereference-expected.txt b/LayoutTests/webgpu/whlsl-null-dereference-expected.txt
>index 6e1668a103beb92f76ea7e8d7aa7ffb50e89e241..a935cf8404f6c968a6d7537d5ead3a299b97ebb0 100644
>--- a/LayoutTests/webgpu/whlsl-null-dereference-expected.txt
>+++ b/LayoutTests/webgpu/whlsl-null-dereference-expected.txt
>@@ -1,6 +1,3 @@
>-PASS successfullyParsed is true
>-
>-TEST COMPLETE
> PASS resultsFloat32Array[0] is 2
> PASS resultsFloat32Array[1] is 4
> PASS resultsFloat32Array[2] is 6
>@@ -9,4 +6,7 @@ PASS resultsFloat32Array[4] is 5
> PASS resultsFloat32Array[5] is 6
> PASS resultsFloat32Array[6] is 7
> PASS resultsFloat32Array[7] is 8
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
> 
>diff --git a/LayoutTests/webgpu/whlsl-null-dereference.html b/LayoutTests/webgpu/whlsl-null-dereference.html
>index a8488675059f0ae6f4868bc31bf68ee2ccf4f5e3..d6924575d5e4fda1d32bb3c745c21c46260505af 100644
>--- a/LayoutTests/webgpu/whlsl-null-dereference.html
>+++ b/LayoutTests/webgpu/whlsl-null-dereference.html
>@@ -109,15 +109,12 @@ async function start() {
>     shouldBe("resultsFloat32Array[7]", "8");
>     resultsBuffer.unmap();
> }
>-if (window.testRunner)
>-    testRunner.waitUntilDone();
>+window.jsTestIsAsync = true;
> window.addEventListener("load", function() {
>     start().then(function() {
>-        if (window.testRunner)
>-            testRunner.notifyDone();
>+        finishJSTest();
>     }, function() {
>-        if (window.testRunner)
>-            testRunner.notifyDone();
>+        finishJSTest();
>     });
> });
> </script>
>diff --git a/LayoutTests/webgpu/whlsl-oob-access-expected.txt b/LayoutTests/webgpu/whlsl-oob-access-expected.txt
>index 6e1668a103beb92f76ea7e8d7aa7ffb50e89e241..a935cf8404f6c968a6d7537d5ead3a299b97ebb0 100644
>--- a/LayoutTests/webgpu/whlsl-oob-access-expected.txt
>+++ b/LayoutTests/webgpu/whlsl-oob-access-expected.txt
>@@ -1,6 +1,3 @@
>-PASS successfullyParsed is true
>-
>-TEST COMPLETE
> PASS resultsFloat32Array[0] is 2
> PASS resultsFloat32Array[1] is 4
> PASS resultsFloat32Array[2] is 6
>@@ -9,4 +6,7 @@ PASS resultsFloat32Array[4] is 5
> PASS resultsFloat32Array[5] is 6
> PASS resultsFloat32Array[6] is 7
> PASS resultsFloat32Array[7] is 8
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
> 
>diff --git a/LayoutTests/webgpu/whlsl-oob-access.html b/LayoutTests/webgpu/whlsl-oob-access.html
>index 8c696f21ef7f3a769316b10ad21b72200584fff9..31760d7253428650b1cfec5ff137293eb6659cd2 100644
>--- a/LayoutTests/webgpu/whlsl-oob-access.html
>+++ b/LayoutTests/webgpu/whlsl-oob-access.html
>@@ -76,15 +76,12 @@ async function start() {
>     shouldBe("resultsFloat32Array[7]", "8");
>     resultsBuffer.unmap();
> }
>-if (window.testRunner)
>-    testRunner.waitUntilDone();
>+window.jsTestIsAsync = true;
> window.addEventListener("load", function() {
>     start().then(function() {
>-        if (window.testRunner)
>-            testRunner.notifyDone();
>+        finishJSTest();
>     }, function() {
>-        if (window.testRunner)
>-            testRunner.notifyDone();
>+        finishJSTest();
>     });
> });
> </script>
>diff --git a/LayoutTests/webgpu/whlsl-textures-getdimensions-expected.txt b/LayoutTests/webgpu/whlsl-textures-getdimensions-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..794166f85b9052d9ef6393848934d64bf76608ea
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-getdimensions-expected.txt
>@@ -0,0 +1,7 @@
>+PASS resultsUint32Array[0] is 2
>+PASS resultsUint32Array[1] is 2
>+PASS resultsUint32Array[2] is 1
>+PASS successfullyParsed is true
>+
>+TEST COMPLETE
>+
>diff --git a/LayoutTests/webgpu/whlsl-textures-getdimensions.html b/LayoutTests/webgpu/whlsl-textures-getdimensions.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..1a80f7e777cc86e0716cac741b39087010889cdd
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-getdimensions.html
>@@ -0,0 +1,75 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<script src="../resources/js-test-pre.js"></script>
>+</head>
>+<body>
>+<script>
>+const shaderSource = `
>+[numthreads(1, 1, 1)]
>+compute void computeShader(Texture2D<float4> theTexture : register(t0), device uint[] theBuffer : register(u1)) {
>+    uint width;
>+    uint height;
>+    uint numberOfLevels;
>+    GetDimensions(theTexture, 0, &width, &height, &numberOfLevels);
>+    theBuffer[0] = width;
>+    theBuffer[1] = height;
>+    theBuffer[2] = numberOfLevels;
>+}
>+`;
>+let resultsUint32Array;
>+async function start() {
>+    const adapter = await navigator.gpu.requestAdapter();
>+    const device = await adapter.requestDevice();
>+
>+    const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
>+    const computeStage = {module: shaderModule, entryPoint: "computeShader"};
>+
>+    const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "sampled-texture"}, {binding: 1, visibility: 7, type: "storage-buffer"}]};
>+    const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
>+    const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
>+    const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
>+
>+    const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
>+    const computePipeline = device.createComputePipeline(computePipelineDescriptor);
>+
>+    const textureDescriptor = {size: {width: 2, height: 2, depth: 1}, format: "rgba8unorm", usage: GPUTextureUsage.SAMPLED};
>+    const texture = device.createTexture(textureDescriptor);
>+    const textureView = texture.createDefaultView();
>+
>+    const resultsBufferDescriptor = {size: Uint32Array.BYTES_PER_ELEMENT * 3, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.MAP_READ};
>+    const resultsBuffer = device.createBuffer(resultsBufferDescriptor);
>+
>+    const bufferBinding = {buffer: resultsBuffer, size: Uint32Array.BYTES_PER_ELEMENT * 3};
>+    const bindGroupBindings = [{binding: 0, resource: textureView}, {binding: 1, resource: bufferBinding}];
>+    const bindGroupDescriptor = {layout: bindGroupLayout, bindings: bindGroupBindings};
>+    const bindGroup = device.createBindGroup(bindGroupDescriptor);
>+
>+    const commandEncoder = device.createCommandEncoder(); // {}
>+    const computePassEncoder = commandEncoder.beginComputePass();
>+    computePassEncoder.setPipeline(computePipeline);
>+    computePassEncoder.setBindGroup(0, bindGroup);
>+    computePassEncoder.dispatch(1, 1, 1);
>+    computePassEncoder.endPass();
>+    const commandBuffer = commandEncoder.finish();
>+    device.getQueue().submit([commandBuffer]);
>+
>+    const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
>+    resultsUint32Array = new Uint32Array(resultsArrayBuffer);
>+    shouldBe("resultsUint32Array[0]", "2");
>+    shouldBe("resultsUint32Array[1]", "2");
>+    shouldBe("resultsUint32Array[2]", "1");
>+    resultsBuffer.unmap();
>+}
>+window.jsTestIsAsync = true;
>+window.addEventListener("load", function() {
>+    start().then(function() {
>+        finishJSTest();
>+    }, function(e) {
>+        finishJSTest();
>+    });
>+});
>+</script>
>+<script src="../resources/js-test-post.js"></script>
>+</body>
>+</html>
>diff --git a/LayoutTests/webgpu/whlsl-textures-load-expected.html b/LayoutTests/webgpu/whlsl-textures-load-expected.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..f417050f9a743f05e9006fc91ac64d502dadd633
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-load-expected.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+</head>
>+<body>
>+<canvas id="canvas" width="400" height="400"></canvas>
>+<script>
>+async function start() {
>+    const canvas = document.getElementById("canvas");
>+    const context = canvas.getContext("2d");
>+    context.fillStyle = "blue";
>+    context.fillRect(0, 0, 400, 400);
>+    context.fillStyle = "white";
>+    context.fillRect(100, 100, 200, 200);
>+}
>+window.addEventListener("load", start);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/webgpu/whlsl-textures-load.html b/LayoutTests/webgpu/whlsl-textures-load.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..edcd4e2015c86eb53466e255a4f08754ae0983f7
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-load.html
>@@ -0,0 +1,131 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+</head>
>+<body>
>+<canvas id="canvas" width="400" height="400"></canvas>
>+<script>
>+const shaderSource = `
>+vertex float4 vertexShader(float4 position : attribute(0)) : SV_Position {
>+    return position;
>+}
>+
>+fragment float4 fragmentShader(Texture2D<float4> theTexture : register(t0)) : SV_Target 0 {
>+    return Load(theTexture, int2(0, 0));
>+}
>+`;
>+async function start() {
>+    const adapter = await navigator.gpu.requestAdapter();
>+    const device = await adapter.requestDevice();
>+
>+    const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
>+    const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
>+    const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
>+    const primitiveTopology = "triangle-strip";
>+    const rasterizationState = {frontFace: "cw", cullMode: "none"};
>+    const alphaBlend = {};
>+    const colorBlend = {};
>+    const colorStates = [{format: "rgba8unorm", alphaBlend, colorBlend, writeMask: 15}]; // GPUColorWriteBits.ALL
>+    const depthStencilState = null;
>+    
>+    const attribute0 = {shaderLocation: 0, format: "float4"};
>+    const input0 = {stride: 16, attributeSet: [attribute0]};
>+    const inputs = [input0];
>+    const vertexInput = {vertexBuffers: inputs};
>+
>+    const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "sampled-texture"}]};
>+    const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
>+    const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
>+    const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
>+
>+    const renderPipelineDescriptor = {vertexStage, fragmentStage, primitiveTopology, rasterizationState, colorStates, depthStencilState, vertexInput, sampleCount: 1, layout: pipelineLayout};
>+    const renderPipeline = device.createRenderPipeline(renderPipelineDescriptor);
>+
>+    const vertexBuffer0Descriptor = {size: Float32Array.BYTES_PER_ELEMENT * 4 * 4, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.MAP_WRITE};
>+    const vertexBuffer0 = device.createBuffer(vertexBuffer0Descriptor);
>+    const vertexBuffer0ArrayBuffer = await vertexBuffer0.mapWriteAsync();
>+    const vertexBuffer0Float32Array = new Float32Array(vertexBuffer0ArrayBuffer);
>+    vertexBuffer0Float32Array[0] = -0.5;
>+    vertexBuffer0Float32Array[1] = -0.5;
>+    vertexBuffer0Float32Array[2] = 1.0;
>+    vertexBuffer0Float32Array[3] = 1;
>+    vertexBuffer0Float32Array[4] = -0.5;
>+    vertexBuffer0Float32Array[5] = 0.5;
>+    vertexBuffer0Float32Array[6] = 1.0;
>+    vertexBuffer0Float32Array[7] = 1;
>+    vertexBuffer0Float32Array[8] = 0.5;
>+    vertexBuffer0Float32Array[9] = -0.5;
>+    vertexBuffer0Float32Array[10] = 1.0;
>+    vertexBuffer0Float32Array[11] = 1;
>+    vertexBuffer0Float32Array[12] = 0.5;
>+    vertexBuffer0Float32Array[13] = 0.5;
>+    vertexBuffer0Float32Array[14] = 1.0;
>+    vertexBuffer0Float32Array[15] = 1;
>+    vertexBuffer0.unmap();
>+
>+    const textureDataBufferDescriptor = {size: Uint8Array.BYTES_PER_ELEMENT * 4 * 2 * 2, usage: GPUBufferUsage.TRANSFER_SRC | GPUBufferUsage.MAP_WRITE};
>+    const textureDataBuffer = device.createBuffer(textureDataBufferDescriptor);
>+    const textureDataBufferArrayBuffer = await textureDataBuffer.mapWriteAsync();
>+    const textureDataBufferUint8Array = new Uint8Array(textureDataBufferArrayBuffer);
>+    textureDataBufferUint8Array[0] = 255;
>+    textureDataBufferUint8Array[1] = 255;
>+    textureDataBufferUint8Array[2] = 255;
>+    textureDataBufferUint8Array[3] = 255;
>+    textureDataBufferUint8Array[4] = 128;
>+    textureDataBufferUint8Array[5] = 128;
>+    textureDataBufferUint8Array[6] = 128;
>+    textureDataBufferUint8Array[7] = 255;
>+    textureDataBufferUint8Array[8] = 128;
>+    textureDataBufferUint8Array[9] = 128;
>+    textureDataBufferUint8Array[10] = 128;
>+    textureDataBufferUint8Array[11] = 255;
>+    textureDataBufferUint8Array[12] = 128;
>+    textureDataBufferUint8Array[13] = 128;
>+    textureDataBufferUint8Array[14] = 128;
>+    textureDataBufferUint8Array[15] = 255;
>+    textureDataBuffer.unmap();
>+
>+    const textureDescriptor = {size: {width: 2, height: 2, depth: 1}, format: "rgba8unorm", usage: GPUTextureUsage.SAMPLED | GPUTextureUsage.TRANSFER_DST};
>+    const texture = device.createTexture(textureDescriptor);
>+    const textureView = texture.createDefaultView();
>+
>+    const bindGroupBindings = [{binding: 0, resource: textureView}];
>+    const bindGroupDescriptor = {layout: bindGroupLayout, bindings: bindGroupBindings};
>+    const bindGroup = device.createBindGroup(bindGroupDescriptor);
>+
>+    const canvas = document.getElementById("canvas");
>+    const context = canvas.getContext("gpu");
>+    const swapChainDescriptor = {device, format: "bgra8unorm"};
>+    const swapChain = context.configureSwapChain(swapChainDescriptor);
>+    const outputTexture = swapChain.getCurrentTexture();
>+    const outputTextureView = outputTexture.createDefaultView();
>+
>+    const commandEncoder = device.createCommandEncoder(); // {}
>+
>+    const bufferCopyView = {buffer: textureDataBuffer, rowPitch: Uint8Array.BYTES_PER_ELEMENT * 4 * 2, imageHeight: Uint8Array.BYTES_PER_ELEMENT * 4 * 2 * 2};
>+    const textureCopyView = {texture: texture};
>+    const copySize = {width: 2, height: 2, depth: 1};
>+    commandEncoder.copyBufferToTexture(bufferCopyView, textureCopyView, copySize);
>+
>+    const clearColor = {r: 0, g: 0, b: 1, a: 1};
>+    const colorAttachments = [{attachment: outputTextureView, resolveTarget: null, loadOp: "clear", storeOp: "store", clearColor}];
>+    const depthStencilAttachment = null;
>+    const renderPassDescriptor = {colorAttachments, depthStencilAttachment};
>+    const renderPassEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
>+    renderPassEncoder.setPipeline(renderPipeline);
>+    renderPassEncoder.setBindGroup(0, bindGroup);
>+    renderPassEncoder.setVertexBuffers(0, [vertexBuffer0], [0]);
>+    renderPassEncoder.draw(4, 1, 0, 0);
>+    renderPassEncoder.endPass();
>+    const commandBuffer = commandEncoder.finish();
>+    device.getQueue().submit([commandBuffer]);
>+
>+    if (window.testRunner)
>+        testRunner.notifyDone();
>+}
>+if (window.testRunner)
>+    testRunner.waitUntilDone();
>+window.addEventListener("load", start);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/webgpu/whlsl-textures-sample-expected.html b/LayoutTests/webgpu/whlsl-textures-sample-expected.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..f417050f9a743f05e9006fc91ac64d502dadd633
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-sample-expected.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+</head>
>+<body>
>+<canvas id="canvas" width="400" height="400"></canvas>
>+<script>
>+async function start() {
>+    const canvas = document.getElementById("canvas");
>+    const context = canvas.getContext("2d");
>+    context.fillStyle = "blue";
>+    context.fillRect(0, 0, 400, 400);
>+    context.fillStyle = "white";
>+    context.fillRect(100, 100, 200, 200);
>+}
>+window.addEventListener("load", start);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/webgpu/whlsl-textures-sample.html b/LayoutTests/webgpu/whlsl-textures-sample.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..2dffb00d41d06d05b7efd73f6ec75851c06c48f1
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-sample.html
>@@ -0,0 +1,134 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+</head>
>+<body>
>+<canvas id="canvas" width="400" height="400"></canvas>
>+<script>
>+const shaderSource = `
>+vertex float4 vertexShader(float4 position : attribute(0)) : SV_Position {
>+    return position;
>+}
>+
>+fragment float4 fragmentShader(Texture2D<float4> theTexture : register(t0), sampler theSampler : register(s1)) : SV_Target 0 {
>+    return Sample(theTexture, theSampler, float2(0.5, 0.5));
>+}
>+`;
>+async function start() {
>+    const adapter = await navigator.gpu.requestAdapter();
>+    const device = await adapter.requestDevice();
>+
>+    const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
>+    const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
>+    const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
>+    const primitiveTopology = "triangle-strip";
>+    const rasterizationState = {frontFace: "cw", cullMode: "none"};
>+    const alphaBlend = {};
>+    const colorBlend = {};
>+    const colorStates = [{format: "rgba8unorm", alphaBlend, colorBlend, writeMask: 15}]; // GPUColorWriteBits.ALL
>+    const depthStencilState = null;
>+    
>+    const attribute0 = {shaderLocation: 0, format: "float4"};
>+    const input0 = {stride: 16, attributeSet: [attribute0]};
>+    const inputs = [input0];
>+    const vertexInput = {vertexBuffers: inputs};
>+
>+    const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "sampled-texture"}, {binding: 1, visibility: 7, type: "sampler"}]};
>+    const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
>+    const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
>+    const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
>+
>+    const renderPipelineDescriptor = {vertexStage, fragmentStage, primitiveTopology, rasterizationState, colorStates, depthStencilState, vertexInput, sampleCount: 1, layout: pipelineLayout};
>+    const renderPipeline = device.createRenderPipeline(renderPipelineDescriptor);
>+
>+    const vertexBuffer0Descriptor = {size: Float32Array.BYTES_PER_ELEMENT * 4 * 4, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.MAP_WRITE};
>+    const vertexBuffer0 = device.createBuffer(vertexBuffer0Descriptor);
>+    const vertexBuffer0ArrayBuffer = await vertexBuffer0.mapWriteAsync();
>+    const vertexBuffer0Float32Array = new Float32Array(vertexBuffer0ArrayBuffer);
>+    vertexBuffer0Float32Array[0] = -0.5;
>+    vertexBuffer0Float32Array[1] = -0.5;
>+    vertexBuffer0Float32Array[2] = 1.0;
>+    vertexBuffer0Float32Array[3] = 1;
>+    vertexBuffer0Float32Array[4] = -0.5;
>+    vertexBuffer0Float32Array[5] = 0.5;
>+    vertexBuffer0Float32Array[6] = 1.0;
>+    vertexBuffer0Float32Array[7] = 1;
>+    vertexBuffer0Float32Array[8] = 0.5;
>+    vertexBuffer0Float32Array[9] = -0.5;
>+    vertexBuffer0Float32Array[10] = 1.0;
>+    vertexBuffer0Float32Array[11] = 1;
>+    vertexBuffer0Float32Array[12] = 0.5;
>+    vertexBuffer0Float32Array[13] = 0.5;
>+    vertexBuffer0Float32Array[14] = 1.0;
>+    vertexBuffer0Float32Array[15] = 1;
>+    vertexBuffer0.unmap();
>+
>+    const textureDataBufferDescriptor = {size: Uint8Array.BYTES_PER_ELEMENT * 4 * 2 * 2, usage: GPUBufferUsage.TRANSFER_SRC | GPUBufferUsage.MAP_WRITE};
>+    const textureDataBuffer = device.createBuffer(textureDataBufferDescriptor);
>+    const textureDataBufferArrayBuffer = await textureDataBuffer.mapWriteAsync();
>+    const textureDataBufferUint8Array = new Uint8Array(textureDataBufferArrayBuffer);
>+    textureDataBufferUint8Array[0] = 255;
>+    textureDataBufferUint8Array[1] = 255;
>+    textureDataBufferUint8Array[2] = 255;
>+    textureDataBufferUint8Array[3] = 255;
>+    textureDataBufferUint8Array[4] = 255;
>+    textureDataBufferUint8Array[5] = 255;
>+    textureDataBufferUint8Array[6] = 255;
>+    textureDataBufferUint8Array[7] = 255;
>+    textureDataBufferUint8Array[8] = 255;
>+    textureDataBufferUint8Array[9] = 255;
>+    textureDataBufferUint8Array[10] = 255;
>+    textureDataBufferUint8Array[11] = 255;
>+    textureDataBufferUint8Array[12] = 255;
>+    textureDataBufferUint8Array[13] = 255;
>+    textureDataBufferUint8Array[14] = 255;
>+    textureDataBufferUint8Array[15] = 255;
>+    textureDataBuffer.unmap();
>+
>+    const textureDescriptor = {size: {width: 2, height: 2, depth: 1}, format: "rgba8unorm", usage: GPUTextureUsage.SAMPLED | GPUTextureUsage.TRANSFER_DST};
>+    const texture = device.createTexture(textureDescriptor);
>+    const textureView = texture.createDefaultView();
>+
>+    const samplerDescriptor = {magFilter: "linear", minFilter: "linear"};
>+    const sampler = device.createSampler(samplerDescriptor);
>+
>+    const bindGroupBindings = [{binding: 0, resource: textureView}, {binding: 1, resource: sampler}];
>+    const bindGroupDescriptor = {layout: bindGroupLayout, bindings: bindGroupBindings};
>+    const bindGroup = device.createBindGroup(bindGroupDescriptor);
>+
>+    const canvas = document.getElementById("canvas");
>+    const context = canvas.getContext("gpu");
>+    const swapChainDescriptor = {device, format: "bgra8unorm"};
>+    const swapChain = context.configureSwapChain(swapChainDescriptor);
>+    const outputTexture = swapChain.getCurrentTexture();
>+    const outputTextureView = outputTexture.createDefaultView();
>+
>+    const commandEncoder = device.createCommandEncoder(); // {}
>+
>+    const bufferCopyView = {buffer: textureDataBuffer, rowPitch: Uint8Array.BYTES_PER_ELEMENT * 4 * 2, imageHeight: Uint8Array.BYTES_PER_ELEMENT * 4 * 2 * 2};
>+    const textureCopyView = {texture: texture};
>+    const copySize = {width: 2, height: 2, depth: 1};
>+    commandEncoder.copyBufferToTexture(bufferCopyView, textureCopyView, copySize);
>+
>+    const clearColor = {r: 0, g: 0, b: 1, a: 1};
>+    const colorAttachments = [{attachment: outputTextureView, resolveTarget: null, loadOp: "clear", storeOp: "store", clearColor}];
>+    const depthStencilAttachment = null;
>+    const renderPassDescriptor = {colorAttachments, depthStencilAttachment};
>+    const renderPassEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
>+    renderPassEncoder.setPipeline(renderPipeline);
>+    renderPassEncoder.setBindGroup(0, bindGroup);
>+    renderPassEncoder.setVertexBuffers(0, [vertexBuffer0], [0]);
>+    renderPassEncoder.draw(4, 1, 0, 0);
>+    renderPassEncoder.endPass();
>+    const commandBuffer = commandEncoder.finish();
>+    device.getQueue().submit([commandBuffer]);
>+
>+    if (window.testRunner)
>+        testRunner.notifyDone();
>+}
>+if (window.testRunner)
>+    testRunner.waitUntilDone();
>+window.addEventListener("load", start);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/webgpu/whlsl-textures-store-expected.html b/LayoutTests/webgpu/whlsl-textures-store-expected.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..f417050f9a743f05e9006fc91ac64d502dadd633
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-store-expected.html
>@@ -0,0 +1,19 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+</head>
>+<body>
>+<canvas id="canvas" width="400" height="400"></canvas>
>+<script>
>+async function start() {
>+    const canvas = document.getElementById("canvas");
>+    const context = canvas.getContext("2d");
>+    context.fillStyle = "blue";
>+    context.fillRect(0, 0, 400, 400);
>+    context.fillStyle = "white";
>+    context.fillRect(100, 100, 200, 200);
>+}
>+window.addEventListener("load", start);
>+</script>
>+</body>
>+</html>
>diff --git a/LayoutTests/webgpu/whlsl-textures-store.html b/LayoutTests/webgpu/whlsl-textures-store.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..1c5a2ebcb22bddace1c1759339ac20bbd867c9c1
>--- /dev/null
>+++ b/LayoutTests/webgpu/whlsl-textures-store.html
>@@ -0,0 +1,149 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+</head>
>+<body>
>+<canvas id="canvas" width="400" height="400"></canvas>
>+<script>
>+const shaderSource = `
>+[numthreads(1, 1, 1)]
>+compute void computeShader(RWTexture2D<float4> theTexture : register(t0)) {
>+    Store(theTexture, float4(1.0, 1.0, 1.0, 1.0), uint2(0, 0));
>+}
>+vertex float4 vertexShader(float4 position : attribute(0)) : SV_Position {
>+    return position;
>+}
>+
>+fragment float4 fragmentShader(RWTexture2D<float4> theTexture : register(t0)) : SV_Target 0 {
>+    return Load(theTexture, int2(0, 0));
>+}
>+`;
>+let resultsUint8Array;
>+async function start() {
>+    const adapter = await navigator.gpu.requestAdapter();
>+    const device = await adapter.requestDevice();
>+
>+    const shaderModule = device.createShaderModule({code: shaderSource, isWHLSL: true});
>+    const computeStage = {module: shaderModule, entryPoint: "computeShader"};
>+    const vertexStage = {module: shaderModule, entryPoint: "vertexShader"};
>+    const fragmentStage = {module: shaderModule, entryPoint: "fragmentShader"};
>+    
>+    const attribute = {shaderLocation: 0, format: "float4"};
>+    const input = {stride: 16, attributeSet: [attribute]};
>+    const vertexInput = {vertexBuffers: [input]};
>+
>+    const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "sampled-texture"}]};
>+    const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
>+    const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
>+    const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);
>+
>+    const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
>+    const computePipeline = device.createComputePipeline(computePipelineDescriptor);
>+
>+    const primitiveTopology = "triangle-strip";
>+    const rasterizationState = {frontFace: "cw", cullMode: "none"};
>+    const alphaBlend = {};
>+    const colorBlend = {};
>+    const colorStates = [{format: "rgba8unorm", alphaBlend, colorBlend, writeMask: 15}]; // GPUColorWriteBits.ALL
>+    const depthStencilState = null;
>+    const renderPipelineDescriptor = {vertexStage, fragmentStage, primitiveTopology, rasterizationState, colorStates, depthStencilState, vertexInput, sampleCount: 1, layout: pipelineLayout};
>+    const renderPipeline = device.createRenderPipeline(renderPipelineDescriptor);
>+
>+    const vertexBufferDescriptor = {size: Float32Array.BYTES_PER_ELEMENT * 4 * 4, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.MAP_WRITE};
>+    const vertexBuffer = device.createBuffer(vertexBufferDescriptor);
>+    const vertexBufferArrayBuffer = await vertexBuffer.mapWriteAsync();
>+    const vertexBufferFloat32Array = new Float32Array(vertexBufferArrayBuffer);
>+    vertexBufferFloat32Array[0] = -0.5;
>+    vertexBufferFloat32Array[1] = -0.5;
>+    vertexBufferFloat32Array[2] = 1.0;
>+    vertexBufferFloat32Array[3] = 1;
>+    vertexBufferFloat32Array[4] = -0.5;
>+    vertexBufferFloat32Array[5] = 0.5;
>+    vertexBufferFloat32Array[6] = 1.0;
>+    vertexBufferFloat32Array[7] = 1;
>+    vertexBufferFloat32Array[8] = 0.5;
>+    vertexBufferFloat32Array[9] = -0.5;
>+    vertexBufferFloat32Array[10] = 1.0;
>+    vertexBufferFloat32Array[11] = 1;
>+    vertexBufferFloat32Array[12] = 0.5;
>+    vertexBufferFloat32Array[13] = 0.5;
>+    vertexBufferFloat32Array[14] = 1.0;
>+    vertexBufferFloat32Array[15] = 1;
>+    vertexBuffer.unmap();
>+
>+    const textureDataBufferDescriptor = {size: Uint8Array.BYTES_PER_ELEMENT * 4 * 2 * 2, usage: GPUBufferUsage.TRANSFER_SRC | GPUBufferUsage.MAP_WRITE};
>+    const textureDataBuffer = device.createBuffer(textureDataBufferDescriptor);
>+    const textureDataBufferArrayBuffer = await textureDataBuffer.mapWriteAsync();
>+    const textureDataBufferUint8Array = new Uint8Array(textureDataBufferArrayBuffer);
>+    textureDataBufferUint8Array[0] = 0;
>+    textureDataBufferUint8Array[1] = 0;
>+    textureDataBufferUint8Array[2] = 0;
>+    textureDataBufferUint8Array[3] = 0;
>+    textureDataBufferUint8Array[4] = 0;
>+    textureDataBufferUint8Array[5] = 0;
>+    textureDataBufferUint8Array[6] = 0;
>+    textureDataBufferUint8Array[7] = 0;
>+    textureDataBufferUint8Array[8] = 0;
>+    textureDataBufferUint8Array[9] = 0;
>+    textureDataBufferUint8Array[10] = 0;
>+    textureDataBufferUint8Array[11] = 0;
>+    textureDataBufferUint8Array[12] = 0;
>+    textureDataBufferUint8Array[13] = 0;
>+    textureDataBufferUint8Array[14] = 0;
>+    textureDataBufferUint8Array[15] = 0;
>+    textureDataBuffer.unmap();
>+
>+    const textureDescriptor = {size: {width: 2, height: 2, depth: 1}, format: "rgba8unorm", usage: GPUTextureUsage.STORAGE | GPUTextureUsage.TRANSFER_DST};
>+    const texture = device.createTexture(textureDescriptor);
>+    const textureView = texture.createDefaultView();
>+
>+    const bindGroupBinding = {binding: 0, resource: textureView};
>+    const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
>+    const bindGroup = device.createBindGroup(bindGroupDescriptor);
>+
>+    const canvas = document.getElementById("canvas");
>+    const context = canvas.getContext("gpu");
>+    const swapChainDescriptor = {device, format: "bgra8unorm"};
>+    const swapChain = context.configureSwapChain(swapChainDescriptor);
>+    const outputTexture = swapChain.getCurrentTexture();
>+    const outputTextureView = outputTexture.createDefaultView();
>+
>+    const bufferCopyView = {buffer: textureDataBuffer, rowPitch: Uint8Array.BYTES_PER_ELEMENT * 4 * 2, imageHeight: Uint8Array.BYTES_PER_ELEMENT * 4 * 2 * 2};
>+    const textureCopyView = {texture};
>+    const copySize = {width: 2, height: 2, depth: 1};
>+
>+    const commandEncoder = device.createCommandEncoder(); // {}
>+    commandEncoder.copyBufferToTexture(bufferCopyView, textureCopyView, copySize);
>+    const computePassEncoder = commandEncoder.beginComputePass();
>+    computePassEncoder.setPipeline(computePipeline);
>+    computePassEncoder.setBindGroup(0, bindGroup);
>+    computePassEncoder.dispatch(1, 1, 1);
>+    computePassEncoder.endPass();
>+    const red = {r: 0, g: 0, b: 1, a: 1};
>+    const colorAttachments = [{attachment: outputTextureView, resolveTarget: null, loadOp: "clear", storeOp: "store", clearColor: red}];
>+    const depthStencilAttachment = null;
>+    const renderPassDescriptor = {colorAttachments, depthStencilAttachment};
>+    const renderPassEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
>+    renderPassEncoder.setPipeline(renderPipeline);
>+    renderPassEncoder.setBindGroup(0, bindGroup);
>+    renderPassEncoder.setVertexBuffers(0, [vertexBuffer], [0]);
>+    renderPassEncoder.draw(4, 1, 0, 0);
>+    renderPassEncoder.endPass();
>+    const commandBuffer = commandEncoder.finish();
>+    device.getQueue().submit([commandBuffer]);
>+}
>+if (window.testRunner)
>+    testRunner.waitUntilDone();
>+window.addEventListener("load", function() {
>+    start().then(function() {
>+        if (window.testRunner)
>+            testRunner.notifyDone();
>+    }, function(e) {
>+        alert(e);
>+        if (window.testRunner)
>+            testRunner.notifyDone();
>+    });
>+});
>+</script>
>+</body>
>+</html>

Actions: View | Formatted Diff | Diff

Attachments on bug 198704: 371723 | 371725 | 372024 | 372027 | 372105 | 372109 | 372115 | 372195 | 372234 | 372235 | 372238 | 372239 | 372316 | 372378 | 372421 | 372423 | 372470