GFX renaming work part 2: slang-gfx.h renames (#2194)

* Fixed all build errors and type conversion warnings from renames in slang-gfx.h * Made necessary build fixes to the CUDA implementation * Renamed ITextureResource::Size to ITextureResource::Extents * More rename changes based on CI errors * More renames to fix CI build errors * Rerun tests
author: lucy96chen <47800040+lucy96chen@users.noreply.github.com> 2022-04-21 12:59:09 -0700
committer: GitHub <noreply@github.com> 2022-04-21 12:59:09 -0700
commit: f493d24c70a6227754296439e97adf35ec412496 (patch)
tree: 25fffb03c067477bef68ccdc66865683159e3ab5 /tools
parent: 1b6cea2219307f6271e131c43d6e8f48910bd435 (diff)
32 files changed, 857 insertions, 850 deletions
diff --git a/tools/gfx-unit-test/copy-texture-tests.cpp b/tools/gfx-unit-test/copy-texture-tests.cpp
index 3461a8cdf..6a9d39d22 100644
--- a/tools/gfx-unit-test/copy-texture-tests.cpp
+++ b/tools/gfx-unit-test/copy-texture-tests.cpp
@@ -19,7 +19,7 @@ namespace gfx_test
     {
         SubresourceRange srcSubresource;
         SubresourceRange dstSubresource;
-        ITextureResource::Size extent;
+        ITextureResource::Extents extent;
         ITextureResource::Offset3D srcOffset;
         ITextureResource::Offset3D dstOffset;
     };
@@ -27,10 +27,10 @@ namespace gfx_test
     struct TextureToBufferCopyInfo
     {
         SubresourceRange srcSubresource;
-        ITextureResource::Size extent;
+        ITextureResource::Extents extent;
         ITextureResource::Offset3D textureOffset;
-        size_t bufferOffset;
-        size_t bufferSize;
+        Offset bufferOffset;
+        Offset bufferSize;
     };
 
     struct BaseCopyTextureTest
@@ -38,7 +38,7 @@ namespace gfx_test
         IDevice* device;
         UnitTestContext* context;
 
-        size_t alignedRowStride;
+        Size alignedRowStride;
 
         RefPtr<TextureInfo> srcTextureInfo;
         RefPtr<TextureInfo> dstTextureInfo;
@@ -185,7 +185,7 @@ namespace gfx_test
             queue->waitOnHost();
         }
 
-        bool isWithinCopyBounds(Int x, Int y, Int z)
+        bool isWithinCopyBounds(GfxIndex x, GfxIndex y, GfxIndex z)
         {
             auto copyExtents = texCopyInfo.extent;
             auto copyOffset = texCopyInfo.dstOffset;
@@ -213,11 +213,11 @@ namespace gfx_test
             auto srcTexOffset = texCopyInfo.srcOffset;
             auto dstTexOffset = texCopyInfo.dstOffset;
 
-            for (Int x = 0; x < actualExtents.width; ++x)
+            for (GfxIndex x = 0; x < actualExtents.width; ++x)
             {
-                for (Int y = 0; y < actualExtents.height; ++y)
+                for (GfxIndex y = 0; y < actualExtents.height; ++y)
                 {
-                    for (Int z = 0; z < actualExtents.depth; ++z)
+                    for (GfxIndex z = 0; z < actualExtents.depth; ++z)
                     {
                         auto actualBlock = actual.getBlockAt(x, y, z);
                         if (isWithinCopyBounds(x, y, z))
@@ -241,7 +241,7 @@ namespace gfx_test
             }
         }
 
-        void checkTestResults(ITextureResource::Size srcMipExtent, const void* expectedCopiedData, const void* expectedOriginalData)
+        void checkTestResults(ITextureResource::Extents srcMipExtent, const void* expectedCopiedData, const void* expectedOriginalData)
         {
             ComPtr<ISlangBlob> resultBlob;
             GFX_CHECK_CALL_ABORT(device->readBufferResource(resultsBuffer, 0, bufferCopyInfo.bufferSize, resultBlob.writeRef()));
@@ -251,7 +251,7 @@ namespace gfx_test
             actual.extents = bufferCopyInfo.extent;
             actual.textureData = results;
             actual.strides.x = getTexelSize(dstTextureInfo->format);
-            actual.strides.y = (uint32_t)alignedRowStride;
+            actual.strides.y = alignedRowStride;
             actual.strides.z = actual.extents.height * actual.strides.y;
 
             ValidationTextureData expectedCopied;
@@ -746,9 +746,9 @@ namespace gfx_test
     {
         // Skip Type::Unknown and Type::Buffer as well as Format::Unknown
         // TODO: Add support for TextureCube
-        for (uint32_t i = 2; i < (uint32_t)ITextureResource::Type::CountOf - 1; ++i)
+        for (uint32_t i = 2; i < (uint32_t)ITextureResource::Type::_Count - 1; ++i)
         {
-            for (uint32_t j = 1; j < (uint32_t)Format::CountOf; ++j)
+            for (uint32_t j = 1; j < (uint32_t)Format::_Count; ++j)
             {
                 auto type = (ITextureResource::Type)i;
                 auto format = (Format)j;
diff --git a/tools/gfx-unit-test/format-unit-tests.cpp b/tools/gfx-unit-test/format-unit-tests.cpp
index 8d3d07221..5755e03cd 100644
--- a/tools/gfx-unit-test/format-unit-tests.cpp
+++ b/tools/gfx-unit-test/format-unit-tests.cpp
@@ -97,7 +97,7 @@ namespace gfx_test
 
     ComPtr<IResourceView> createTexView(
         IDevice* device,
-        ITextureResource::Size size,
+        ITextureResource::Extents size,
         gfx::Format format,
         ITextureResource::SubresourceData* data,
         int mips = 1)
@@ -175,12 +175,12 @@ namespace gfx_test
         auto intResults = createBuffer<uint32_t>(device, 16, initIntData);
         auto intBufferView = createBufferView(device, intResults);
 
-        ITextureResource::Size size = {};
+        ITextureResource::Extents size = {};
         size.width = 2;
         size.height = 2;
         size.depth = 1;
 
-        ITextureResource::Size bcSize = {};
+        ITextureResource::Extents bcSize = {};
         bcSize.width = 4;
         bcSize.height = 4;
         bcSize.depth = 1;
@@ -939,7 +939,7 @@ namespace gfx_test
                 ITextureResource::SubresourceData {(void*)texData, 16, 32},
                 ITextureResource::SubresourceData {(void*)(texData + 32), 8, 0}
             };
-            ITextureResource::Size size = {};
+            ITextureResource::Extents size = {};
             size.width = 8;
             size.height = 8;
             size.depth = 1;
diff --git a/tools/gfx-unit-test/get-supported-resource-states-test.cpp b/tools/gfx-unit-test/get-supported-resource-states-test.cpp
index 209cf1ba5..fc7c57771 100644
--- a/tools/gfx-unit-test/get-supported-resource-states-test.cpp
+++ b/tools/gfx-unit-test/get-supported-resource-states-test.cpp
@@ -109,7 +109,7 @@ namespace
         void run()
         {
             // Skip Format::Unknown
-            for (uint32_t i = 1; i < (uint32_t)Format::CountOf; ++i)
+            for (uint32_t i = 1; i < (uint32_t)Format::_Count; ++i)
             {
                 auto baseFormat = (Format)i;
                 FormatInfo info;
@@ -148,7 +148,7 @@ namespace
                     ResourceState::CopyDestination);
 
                 ResourceState currentState = ResourceState::CopySource;
-                ITextureResource::Size extent;
+                ITextureResource::Extents extent;
                 extent.width = 4;
                 extent.height = 4;
                 extent.depth = 1;
diff --git a/tools/gfx-unit-test/gfx-test-texture-util.cpp b/tools/gfx-unit-test/gfx-test-texture-util.cpp
index c7c85db58..e9d884894 100644
--- a/tools/gfx-unit-test/gfx-test-texture-util.cpp
+++ b/tools/gfx-unit-test/gfx-test-texture-util.cpp
@@ -29,14 +29,14 @@ namespace gfx_test
         }
     }
 
-    uint32_t getTexelSize(Format format)
+    Size getTexelSize(Format format)
     {
         FormatInfo info;
         GFX_CHECK_CALL_ABORT(gfxGetFormatInfo(format, &info));
         return info.blockSizeInBytes / info.pixelsPerBlock;
     }
 
-    uint32_t getSubresourceIndex(uint32_t mipLevel, uint32_t mipLevelCount, uint32_t baseArrayLayer)
+    GfxIndex getSubresourceIndex(GfxIndex mipLevel, GfxCount mipLevelCount, GfxIndex baseArrayLayer)
     {
         return baseArrayLayer * mipLevelCount + mipLevel;
     }
@@ -155,9 +155,9 @@ namespace gfx_test
         auto mipLevels = texture->mipLevelCount;
         auto texelSize = getTexelSize(texture->format);
 
-        for (uint32_t layer = 0; layer < arrayLayers; ++layer)
+        for (GfxIndex layer = 0; layer < arrayLayers; ++layer)
         {
-            for (uint32_t mip = 0; mip < mipLevels; ++mip)
+            for (GfxIndex mip = 0; mip < mipLevels; ++mip)
             {
                 RefPtr<ValidationTextureData> subresource = new ValidationTextureData();
 
diff --git a/tools/gfx-unit-test/gfx-test-texture-util.h b/tools/gfx-unit-test/gfx-test-texture-util.h
index 7e59c60e1..6b51af699 100644
--- a/tools/gfx-unit-test/gfx-test-texture-util.h
+++ b/tools/gfx-unit-test/gfx-test-texture-util.h
@@ -10,11 +10,18 @@ using namespace gfx;
 
 namespace gfx_test
 {
+    struct Strides
+    {
+        Size x;
+        Size y;
+        Size z;
+    };
+
     struct ValidationTextureFormatBase : RefObject
     {
         virtual void validateBlocksEqual(const void* actual, const void* expected) = 0;
 
-        virtual void initializeTexel(void* texel, int x, int y, int z, int mipLevel, int arrayLayer) = 0;
+        virtual void initializeTexel(void* texel, GfxIndex x, GfxIndex y, GfxIndex z, GfxIndex mipLevel, GfxIndex arrayLayer) = 0;
     };
 
     template <typename T>
@@ -35,7 +42,7 @@ namespace gfx_test
             }
         }
 
-        virtual void initializeTexel(void* texel, int x, int y, int z, int mipLevel, int arrayLayer) override
+        virtual void initializeTexel(void* texel, GfxIndex x, GfxIndex y, GfxIndex z, GfxIndex mipLevel, GfxIndex arrayLayer) override
         {
             auto temp = (T*)texel;
 
@@ -90,7 +97,7 @@ namespace gfx_test
             }
         }
 
-        virtual void initializeTexel(void* texel, int x, int y, int z, int mipLevel, int arrayLayer) override
+        virtual void initializeTexel(void* texel, GfxIndex x, GfxIndex y, GfxIndex z, GfxIndex mipLevel, GfxIndex arrayLayer) override
         {
             T temp = 0;
 
@@ -137,10 +144,10 @@ namespace gfx_test
     struct ValidationTextureData : RefObject
     {
         const void* textureData;
-        ITextureResource::Size extents;
-        ITextureResource::Offset3D strides;
+        ITextureResource::Extents extents;
+        Strides strides;
 
-        void* getBlockAt(Int x, Int y, Int z)
+        void* getBlockAt(GfxIndex x, GfxIndex y, GfxIndex z)
         {
             assert(x >= 0 && x < extents.width);
             assert(y >= 0 && y < extents.height);
@@ -159,17 +166,17 @@ namespace gfx_test
         Format format;
         ITextureResource::Type textureType;
 
-        ITextureResource::Size extents;
-        uint32_t mipLevelCount;
-        uint32_t arrayLayerCount;
+        ITextureResource::Extents extents;
+        GfxCount mipLevelCount;
+        GfxCount arrayLayerCount;
 
         List<RefPtr<ValidationTextureData>> subresourceObjects;
         List<ITextureResource::SubresourceData> subresourceDatas;
     };
 
     TextureAspect getTextureAspect(Format format);
-    uint32_t getTexelSize(Format format);
-    uint32_t getSubresourceIndex(uint32_t mipLevel, uint32_t mipLevelCount, uint32_t baseArrayLayer);
+    Size getTexelSize(Format format);
+    GfxIndex getSubresourceIndex(GfxIndex mipLevel, GfxCount mipLevelCount, GfxIndex baseArrayLayer);
     RefPtr<ValidationTextureFormatBase> getValidationTextureFormat(Format format);
     void generateTextureData(RefPtr<TextureInfo> texture, ValidationTextureFormatBase* validationFormat);
 }
diff --git a/tools/gfx-unit-test/resolve-resource-tests.cpp b/tools/gfx-unit-test/resolve-resource-tests.cpp
index 2876be880..cc5dffd00 100644
--- a/tools/gfx-unit-test/resolve-resource-tests.cpp
+++ b/tools/gfx-unit-test/resolve-resource-tests.cpp
@@ -101,7 +101,7 @@ namespace
 
         struct TextureInfo
         {
-            ITextureResource::Size extent;
+            ITextureResource::Extents extent;
             int numMipLevels;
             int arraySize;
             ITextureResource::SubresourceData const* initData;
@@ -222,7 +222,7 @@ namespace
             GFX_CHECK_CALL_ABORT(device->createFramebuffer(framebufferDesc, framebuffer.writeRef()));
         }
 
-        void submitGPUWork(SubresourceRange msaaSubresource, SubresourceRange dstSubresource, ITextureResource::Size extent)
+        void submitGPUWork(SubresourceRange msaaSubresource, SubresourceRange dstSubresource, ITextureResource::Extents extent)
         {
             Slang::ComPtr<ITransientResourceHeap> transientHeap;
             ITransientResourceHeap::Desc transientHeapDesc = {};
@@ -296,7 +296,7 @@ namespace
     {
         void run()
         {
-            ITextureResource::Size extent = {};
+            ITextureResource::Extents extent = {};
             extent.width = kWidth;
             extent.height = kHeight;
             extent.depth = 1;
diff --git a/tools/gfx-unit-test/shared-textures-tests.cpp b/tools/gfx-unit-test/shared-textures-tests.cpp
index 831296c72..4afa23546 100644
--- a/tools/gfx-unit-test/shared-textures-tests.cpp
+++ b/tools/gfx-unit-test/shared-textures-tests.cpp
@@ -67,7 +67,7 @@ namespace gfx_test
         }
     }
 
-    ComPtr<ITextureResource> createTexture(IDevice* device, ITextureResource::Size extents, gfx::Format format, ITextureResource::SubresourceData* initialData)
+    ComPtr<ITextureResource> createTexture(IDevice* device, ITextureResource::Extents extents, gfx::Format format, ITextureResource::SubresourceData* initialData)
     {
         ITextureResource::Desc texDesc = {};
         texDesc.type = IResource::Type::Texture2D;
@@ -152,12 +152,12 @@ namespace gfx_test
         auto intResults = createBuffer<uint32_t>(dstDevice, 16, initIntData);
         auto intBufferView = createOutBufferView(dstDevice, intResults);
 
-        ITextureResource::Size size = {};
+        ITextureResource::Extents size = {};
         size.width = 2;
         size.height = 2;
         size.depth = 1;
 
-        ITextureResource::Size bcSize = {};
+        ITextureResource::Extents bcSize = {};
         bcSize.width = 4;
         bcSize.height = 4;
         bcSize.depth = 1;
diff --git a/tools/gfx-unit-test/texture-types-tests.cpp b/tools/gfx-unit-test/texture-types-tests.cpp
index 94f7a764f..4d8037ce8 100644
--- a/tools/gfx-unit-test/texture-types-tests.cpp
+++ b/tools/gfx-unit-test/texture-types-tests.cpp
@@ -234,11 +234,11 @@ namespace gfx_test
         void validateTextureValues(ValidationTextureData actual, ValidationTextureData original)
         {
             // TODO: needs to be extended to cover mip levels and array layers
-            for (Int x = 0; x < actual.extents.width; ++x)
+            for (GfxIndex x = 0; x < actual.extents.width; ++x)
             {
-                for (Int y = 0; y < actual.extents.height; ++y)
+                for (GfxIndex y = 0; y < actual.extents.height; ++y)
                 {
-                    for (Int z = 0; z < actual.extents.depth; ++z)
+                    for (GfxIndex z = 0; z < actual.extents.depth; ++z)
                     {
                         auto actualBlock = (uint8_t*)actual.getBlockAt(x, y, z);
                         for (Int i = 0; i < 4; ++i)
@@ -536,11 +536,11 @@ namespace gfx_test
         // TODO: Needs to handle either the correct slice or array layer (will not always check z)
         void validateTextureValues(ValidationTextureData actual)
         {
-            for (Int x = 0; x < actual.extents.width; ++x)
+            for (GfxIndex x = 0; x < actual.extents.width; ++x)
             {
-                for (Int y = 0; y < actual.extents.height; ++y)
+                for (GfxIndex y = 0; y < actual.extents.height; ++y)
                 {
-                    for (Int z = 0; z < actual.extents.depth; ++z)
+                    for (GfxIndex z = 0; z < actual.extents.depth; ++z)
                     {
                         auto actualBlock = (float*)actual.getBlockAt(x, y, z);
                         for (Int i = 0; i < 4; ++i)
diff --git a/tools/gfx-util/shader-cursor.cpp b/tools/gfx-util/shader-cursor.cpp
index efdde44b8..5a2cdfd33 100644
--- a/tools/gfx-util/shader-cursor.cpp
+++ b/tools/gfx-util/shader-cursor.cpp
@@ -66,7 +66,7 @@ Result ShaderCursor::getField(const char* name, const char* nameEnd, ShaderCurso
             //
             fieldCursor.m_offset.uniformOffset = m_offset.uniformOffset + fieldLayout->getOffset();
             fieldCursor.m_offset.bindingRangeIndex =
-                m_offset.bindingRangeIndex + m_typeLayout->getFieldBindingRangeOffset(fieldIndex);
+                m_offset.bindingRangeIndex + (GfxIndex)m_typeLayout->getFieldBindingRangeOffset(fieldIndex);
 
             // The index of the field within any binding ranges will be the same
             // as the index computed for the parent structure.
@@ -126,8 +126,8 @@ Result ShaderCursor::getField(const char* name, const char* nameEnd, ShaderCurso
     //
     // TODO: figure out whether we should support this long-term.
     //
-    auto entryPointCount = (gfx::Int) m_baseObject->getEntryPointCount();
-    for( gfx::Int e = 0; e < entryPointCount; ++e )
+    auto entryPointCount = (GfxIndex) m_baseObject->getEntryPointCount();
+    for( GfxIndex e = 0; e < entryPointCount; ++e )
     {
         ComPtr<IShaderObject> entryPoint;
         m_baseObject->getEntryPoint(e, entryPoint.writeRef());
@@ -142,7 +142,7 @@ Result ShaderCursor::getField(const char* name, const char* nameEnd, ShaderCurso
     return SLANG_E_INVALID_ARG;
 }
 
-ShaderCursor ShaderCursor::getElement(SlangInt index) const
+ShaderCursor ShaderCursor::getElement(GfxIndex index) const
 {
     if (m_containerType != ShaderObjectContainerType::None)
     {
@@ -168,7 +168,7 @@ ShaderCursor ShaderCursor::getElement(SlangInt index) const
                 index * m_typeLayout->getElementStride(SLANG_PARAMETER_CATEGORY_UNIFORM);
             elementCursor.m_offset.bindingRangeIndex = m_offset.bindingRangeIndex;
             elementCursor.m_offset.bindingArrayIndex =
-                m_offset.bindingArrayIndex * m_typeLayout->getElementCount() + index;
+                m_offset.bindingArrayIndex * (GfxCount)m_typeLayout->getElementCount() + index;
             return elementCursor;
         }
         break;
@@ -189,7 +189,7 @@ ShaderCursor ShaderCursor::getElement(SlangInt index) const
             fieldCursor.m_typeLayout = fieldLayout->getTypeLayout();
             fieldCursor.m_offset.uniformOffset = m_offset.uniformOffset + fieldLayout->getOffset();
             fieldCursor.m_offset.bindingRangeIndex =
-                m_offset.bindingRangeIndex + m_typeLayout->getFieldBindingRangeOffset(fieldIndex);
+                m_offset.bindingRangeIndex + (GfxIndex)m_typeLayout->getFieldBindingRangeOffset(fieldIndex);
             fieldCursor.m_offset.bindingArrayIndex = m_offset.bindingArrayIndex;
 
             return fieldCursor;
@@ -266,7 +266,7 @@ Result ShaderCursor::followPath(const char* path, ShaderCursor& ioCursor)
                 return SLANG_E_INVALID_ARG;
 
             _get(rest);
-            SlangInt index = 0;
+            GfxCount index = 0;
             while (_peek(rest) != ']')
             {
                 int d = _get(rest);
diff --git a/tools/gfx-util/shader-cursor.h b/tools/gfx-util/shader-cursor.h
index 4c281c99a..5dfc57f6d 100644
--- a/tools/gfx-util/shader-cursor.h
+++ b/tools/gfx-util/shader-cursor.h
@@ -63,7 +63,7 @@ struct ShaderCursor
         return cursor;
     }
 
-    ShaderCursor getElement(SlangInt index) const;
+    ShaderCursor getElement(GfxIndex index) const;
 
     static Result followPath(const char* path, ShaderCursor& ioCursor);
 
@@ -82,7 +82,7 @@ struct ShaderCursor
         , m_containerType(object->getContainerType())
     {}
 
-    SlangResult setData(void const* data, size_t size) const
+    SlangResult setData(void const* data, Size size) const
     {
         return m_baseObject->setData(m_offset, data, size);
     }
@@ -98,7 +98,7 @@ struct ShaderCursor
         return m_baseObject->setObject(m_offset, object);
     }
 
-    SlangResult setSpecializationArgs(const slang::SpecializationArg* args, uint32_t count) const
+    SlangResult setSpecializationArgs(const slang::SpecializationArg* args, GfxCount count) const
     {
         return m_baseObject->setSpecializationArgs(m_offset, args, count);
     }
@@ -129,13 +129,13 @@ struct ShaderCursor
         /// Produce a cursor to the element or field with the given `index`.
         ///
         /// This is a convenience wrapper around `getElement()`.
-    ShaderCursor operator[](int64_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](uint64_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](int32_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](uint32_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](int16_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](uint16_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](int8_t index) const { return getElement((SlangInt)index); }
-    ShaderCursor operator[](uint8_t index) const { return getElement((SlangInt)index); }
+    ShaderCursor operator[](int64_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](uint64_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](int32_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](uint32_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](int16_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](uint16_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](int8_t index) const { return getElement((GfxIndex)index); }
+    ShaderCursor operator[](uint8_t index) const { return getElement((GfxIndex)index); }
 };
 }
diff --git a/tools/gfx/command-encoder-com-forward.h b/tools/gfx/command-encoder-com-forward.h
index 8f69c6063..50539cba1 100644
--- a/tools/gfx/command-encoder-com-forward.h
+++ b/tools/gfx/command-encoder-com-forward.h
@@ -3,10 +3,10 @@
 #define SLANG_GFX_FORWARD_RESOURCE_COMMAND_ENCODER_IMPL(ResourceCommandEncoderBase)                     \
     virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(                                                 \
         IBufferResource* dst,                                                                           \
-        size_t dstOffset,                                                                               \
+        Offset dstOffset,                                                                               \
         IBufferResource* src,                                                                           \
-        size_t srcOffset,                                                                               \
-        size_t size) override                                                                           \
+        Offset srcOffset,                                                                               \
+        Size size) override                                                                             \
     {                                                                                                   \
         ResourceCommandEncoderBase::copyBuffer(dst, dstOffset, src, srcOffset, size);                   \
     }                                                                                                   \
@@ -19,7 +19,7 @@
         ResourceState srcState,                                                                         \
         SubresourceRange srcSubresource,                                                                \
         ITextureResource::Offset3D srcOffset,                                                           \
-        ITextureResource::Size extent) override                                                         \
+        ITextureResource::Extents extent) override                                                         \
     {                                                                                                   \
         ResourceCommandEncoderBase::copyTexture(                                                        \
             dst,                                                                                        \
@@ -34,14 +34,14 @@
     }                                                                                                   \
     virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(                                        \
         IBufferResource* dst,                                                                           \
-        size_t dstOffset,                                                                               \
-        size_t dstSize,                                                                                 \
-        size_t dstRowStride,                                                                            \
+        Offset dstOffset,                                                                               \
+        Size dstSize,                                                                                   \
+        Size dstRowStride,                                                                              \
         ITextureResource* src,                                                                          \
         ResourceState srcState,                                                                         \
         SubresourceRange srcSubresource,                                                                \
         ITextureResource::Offset3D srcOffset,                                                           \
-        ITextureResource::Size extent) override                                                         \
+        ITextureResource::Extents extent) override                                                         \
     {                                                                                                   \
         ResourceCommandEncoderBase::copyTextureToBuffer(                                                \
             dst, dstOffset, dstSize, dstRowStride, src, srcState, srcSubresource, srcOffset, extent);   \
@@ -50,20 +50,20 @@
         ITextureResource* dst,                                                                          \
         SubresourceRange subResourceRange,                                                              \
         ITextureResource::Offset3D offset,                                                              \
-        ITextureResource::Size extent,                                                                  \
+        ITextureResource::Extents extent,                                                                  \
         ITextureResource::SubresourceData* subResourceData,                                             \
-        size_t subResourceDataCount) override                                                           \
+        GfxCount subResourceDataCount) override                                                         \
     {                                                                                                   \
         ResourceCommandEncoderBase::uploadTextureData(                                                  \
             dst, subResourceRange, offset, extent, subResourceData, subResourceDataCount);              \
     }                                                                                                   \
     virtual SLANG_NO_THROW void SLANG_MCALL uploadBufferData(                                           \
-        IBufferResource* dst, size_t offset, size_t size, void* data) override                          \
+        IBufferResource* dst, Offset offset, Size size, void* data) override                            \
     {                                                                                                   \
         ResourceCommandEncoderBase::uploadBufferData(dst, offset, size, data);                          \
     }                                                                                                   \
     virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(                                             \
-        size_t count, ITextureResource* const* textures, ResourceState src, ResourceState dst)          \
+        GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst)        \
         override                                                                                        \
     {                                                                                                   \
         ResourceCommandEncoderBase::textureBarrier(count, textures, src, dst);                          \
@@ -78,7 +78,7 @@
             texture, subresourceRange, src, dst);                                                       \
     }                                                                                                   \
     virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(                                              \
-        size_t count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)            \
+        GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)          \
         override                                                                                        \
     {                                                                                                   \
         ResourceCommandEncoderBase::bufferBarrier(count, buffers, src, dst);                            \
@@ -101,14 +101,14 @@
     }                                                                                                   \
     virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(                                               \
         IQueryPool* queryPool,                                                                          \
-        uint32_t index,                                                                                 \
-        uint32_t count,                                                                                 \
+        GfxIndex index,                                                                                 \
+        GfxCount count,                                                                                 \
         IBufferResource* buffer,                                                                        \
-        uint64_t offset) override                                                                       \
+        Offset offset) override                                                                         \
     {                                                                                                   \
         ResourceCommandEncoderBase::resolveQuery(queryPool, index, count, buffer, offset);              \
     }                                                                                                   \
-    virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, SlangInt index)            \
+    virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* pool, GfxIndex index)            \
         override                                                                                        \
     {                                                                                                   \
         ResourceCommandEncoderBase::writeTimestamp(pool, index);                                        \
diff --git a/tools/gfx/command-writer.h b/tools/gfx/command-writer.h
index dc793a3e5..03ac3ac6d 100644
--- a/tools/gfx/command-writer.h
+++ b/tools/gfx/command-writer.h
@@ -100,17 +100,17 @@ public:
     }
 
     // Copies user data into `m_data` buffer and returns the offset to retrieve the data.
-    uint32_t encodeData(const void* data, size_t size)
+    Offset encodeData(const void* data, Size size)
     {
-        uint32_t offset = (uint32_t)m_data.getCount();
-        m_data.setCount(m_data.getCount() + (Slang::Index)size);
+        Offset offset = (Offset)m_data.getCount();
+        m_data.setCount(m_data.getCount() + size);
         memcpy(m_data.getBuffer() + offset, data, size);
         return offset;
     }
 
-    uint32_t encodeObject(Slang::RefObject* obj)
+    Offset encodeObject(Slang::RefObject* obj)
     {
-        uint32_t offset = (uint32_t)m_objects.getCount();
+        Offset offset = (Offset)m_objects.getCount();
         m_objects.add(obj);
         return offset;
     }
@@ -120,7 +120,7 @@ public:
         return static_cast<T*>(m_objects[offset].Ptr());
     }
 
-    template <typename T> T* getData(uint32_t offset)
+    template <typename T> T* getData(Offset offset)
     {
         return reinterpret_cast<T*>(m_data.getBuffer() + offset);
     }
@@ -128,49 +128,49 @@ public:
     void setPipelineState(IPipelineState* state)
     {
         auto offset = encodeObject(static_cast<PipelineStateBase*>(state));
-        m_commands.add(Command(CommandName::SetPipelineState, offset));
+        m_commands.add(Command(CommandName::SetPipelineState, (uint32_t)offset));
     }
 
     void bindRootShaderObject(IShaderObject* object)
     {
         auto rootOffset = encodeObject(static_cast<ShaderObjectBase*>(object));
-        m_commands.add(Command(CommandName::BindRootShaderObject, rootOffset));
+        m_commands.add(Command(CommandName::BindRootShaderObject, (uint32_t)rootOffset));
     }
 
-    void uploadBufferData(IBufferResource* buffer, size_t offset, size_t size, void* data)
+    void uploadBufferData(IBufferResource* buffer, Offset offset, Size size, void* data)
     {
         auto bufferOffset = encodeObject(static_cast<BufferResource*>(buffer));
         auto dataOffset = encodeData(data, size);
         m_commands.add(Command(
             CommandName::UploadBufferData,
-            bufferOffset,
+            (uint32_t)bufferOffset,
             (uint32_t)offset,
             (uint32_t)size,
-            dataOffset));
+            (uint32_t)dataOffset));
     }
 
     void copyBuffer(
         IBufferResource* dst,
-        size_t dstOffset,
+        Offset dstOffset,
         IBufferResource* src,
-        size_t srcOffset,
-        size_t size)
+        Offset srcOffset,
+        Size size)
     {
         auto dstBuffer = encodeObject(static_cast<BufferResource*>(dst));
         auto srcBuffer = encodeObject(static_cast<BufferResource*>(src));
         m_commands.add(Command(
             CommandName::CopyBuffer,
-            dstBuffer,
+            (uint32_t)dstBuffer,
             (uint32_t)dstOffset,
-            srcBuffer,
+            (uint32_t)srcBuffer,
             (uint32_t)srcOffset,
             (uint32_t)size));
     }
 
     void setFramebuffer(IFramebuffer* frameBuffer)
     {
-        uint32_t framebufferOffset = encodeObject(static_cast<FramebufferBase*>(frameBuffer));
-        m_commands.add(Command(CommandName::SetFramebuffer, framebufferOffset));
+        auto framebufferOffset = encodeObject(static_cast<FramebufferBase*>(frameBuffer));
+        m_commands.add(Command(CommandName::SetFramebuffer, (uint32_t)framebufferOffset));
     }
 
     void clearFrame(uint32_t colorBufferMask, bool clearDepth, bool clearStencil)
@@ -179,16 +179,16 @@ public:
             CommandName::ClearFrame, colorBufferMask, clearDepth ? 1 : 0, clearStencil ? 1 : 0));
     }
 
-    void setViewports(UInt count, const Viewport* viewports)
+    void setViewports(GfxCount count, const Viewport* viewports)
     {
         auto offset = encodeData(viewports, sizeof(Viewport) * count);
-        m_commands.add(Command(CommandName::SetViewports, (uint32_t)count, offset));
+        m_commands.add(Command(CommandName::SetViewports, (uint32_t)count, (uint32_t)offset));
     }
 
-    void setScissorRects(UInt count, const ScissorRect* scissors)
+    void setScissorRects(GfxCount count, const ScissorRect* scissors)
     {
         auto offset = encodeData(scissors, sizeof(ScissorRect) * count);
-        m_commands.add(Command(CommandName::SetScissorRects, (uint32_t)count, offset));
+        m_commands.add(Command(CommandName::SetScissorRects, (uint32_t)count, (uint32_t)offset));
     }
 
     void setPrimitiveTopology(PrimitiveTopology topology)
@@ -197,40 +197,40 @@ public:
     }
 
     void setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets)
+        const Offset* offsets)
     {
-        uint32_t bufferOffset = 0;
-        for (UInt i = 0; i < slotCount; i++)
+        Offset bufferOffset = 0;
+        for (GfxCount i = 0; i < slotCount; i++)
         {
             auto offset = encodeObject(static_cast<BufferResource*>(buffers[i]));
             if (i == 0)
                 bufferOffset = offset;
         }
-        uint32_t offsetsOffset = encodeData(offsets, sizeof(uint32_t) * slotCount);
+        auto offsetsOffset = encodeData(offsets, sizeof(Size) * slotCount);
         m_commands.add(Command(
             CommandName::SetVertexBuffers,
-            startSlot,
-            slotCount,
-            bufferOffset,
-            offsetsOffset));
+            (uint32_t)startSlot,
+            (uint32_t)slotCount,
+            (uint32_t)bufferOffset,
+            (uint32_t)offsetsOffset));
     }
 
-    void setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset)
+    void setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset)
     {
         auto bufferOffset = encodeObject(static_cast<BufferResource*>(buffer));
         m_commands.add(Command(
-            CommandName::SetIndexBuffer, bufferOffset, (uint32_t)indexFormat, (uint32_t)offset));
+            CommandName::SetIndexBuffer, (uint32_t)bufferOffset, (uint32_t)indexFormat, (uint32_t)offset));
     }
 
-    void draw(UInt vertexCount, UInt startVertex)
+    void draw(GfxCount vertexCount, GfxIndex startVertex)
     {
         m_commands.add(Command(CommandName::Draw, (uint32_t)vertexCount, (uint32_t)startVertex));
     }
 
-    void drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex)
+    void drawIndexed(GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
     {
         m_commands.add(Command(
             CommandName::DrawIndexed,
@@ -240,10 +240,10 @@ public:
     }
 
     void drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation)
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation)
     {
         m_commands.add(Command(
             CommandName::DrawInstanced,
@@ -254,18 +254,18 @@ public:
     }
 
     void drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation)
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation)
     {
         m_commands.add(Command(
             CommandName::DrawIndexedInstanced,
             (uint32_t)indexCount,
             (uint32_t)instanceCount,
             (uint32_t)startIndexLocation,
-            (int32_t)baseVertexLocation,
+            (uint32_t)baseVertexLocation,
             (uint32_t)startInstanceLocation));
     }
 
@@ -280,11 +280,11 @@ public:
             Command(CommandName::DispatchCompute, (uint32_t)x, (uint32_t)y, (uint32_t)z));
     }
 
-    void writeTimestamp(IQueryPool* pool, SlangInt index)
+    void writeTimestamp(IQueryPool* pool, GfxIndex index)
     {
         auto poolOffset = encodeObject(static_cast<QueryPoolBase*>(pool));
         m_commands.add(
-            Command(CommandName::WriteTimestamp, poolOffset, (uint32_t)index));
+            Command(CommandName::WriteTimestamp, (uint32_t)poolOffset, (uint32_t)index));
         m_hasWriteTimestamps = true;
     }
 };
diff --git a/tools/gfx/cpu/render-cpu.cpp b/tools/gfx/cpu/render-cpu.cpp
index 7e1de796a..9f3fcfa2e 100644
--- a/tools/gfx/cpu/render-cpu.cpp
+++ b/tools/gfx/cpu/render-cpu.cpp
@@ -78,7 +78,7 @@ struct CPUTextureBaseShapeInfo
     int32_t implicitArrayElementCount;
 };
 
-static const CPUTextureBaseShapeInfo kCPUTextureBaseShapeInfos[(int)ITextureResource::Type::CountOf] =
+static const CPUTextureBaseShapeInfo kCPUTextureBaseShapeInfos[(int)ITextureResource::Type::_Count] =
 {
     /* Unknown */       { 0, 0, 0 },
     /* Buffer */        { 1, 1, 1 },
@@ -208,7 +208,7 @@ struct CPUFormatInfoMap
     }
     SLANG_FORCE_INLINE const CPUTextureFormatInfo& get(Format format) const { return m_infos[Index(format)]; }
 
-    CPUTextureFormatInfo m_infos[Index(Format::CountOf)];
+    CPUTextureFormatInfo m_infos[Index(Format::_Count)];
 };
 
 static const CPUFormatInfoMap g_formatInfoMap;
@@ -852,9 +852,9 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
         init(IDevice* device, CPUShaderObjectLayout* typeLayout);
 
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override { return 0; }
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override { return 0; }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override
     {
         *outEntryPoint = nullptr;
         return SLANG_OK;
@@ -993,9 +993,9 @@ public:
 
     List<RefPtr<CPUEntryPointShaderObject>> m_entryPoints;
 
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override { return m_entryPoints.getCount(); }
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override { return (GfxCount)m_entryPoints.getCount(); }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override
     {
         returnComPtr(outEntryPoint, m_entryPoints[index]);
         return SLANG_OK;
@@ -1045,9 +1045,9 @@ public:
         return SLANG_OK;
     }
     virtual SLANG_NO_THROW Result SLANG_MCALL getResult(
-        SlangInt queryIndex, SlangInt count, uint64_t* data) override
+        GfxIndex queryIndex, GfxCount count, uint64_t* data) override
     {
-        for (SlangInt i = 0; i < count; i++)
+        for (GfxCount i = 0; i < count; i++)
         {
             data[i] = m_queries[queryIndex + i];
         }
@@ -1305,7 +1305,7 @@ public:
         return SLANG_OK;
     }
 
-    virtual void writeTimestamp(IQueryPool* pool, SlangInt index) override
+    virtual void writeTimestamp(IQueryPool* pool, GfxIndex index) override
     {
         static_cast<CPUQueryPool*>(pool)->m_queries[index] =
             std::chrono::high_resolution_clock::now().time_since_epoch().count();
@@ -1395,8 +1395,8 @@ SlangResult CPUShaderObject::init(IDevice* device, CPUShaderObjectLayout* typeLa
 
             ShaderOffset offset;
             offset.uniformOffset = bindingRangeInfo.uniformOffset + sizeof(void*) * i;
-            offset.bindingRangeIndex = subObjectRange.bindingRangeIndex;
-            offset.bindingArrayIndex = i;
+            offset.bindingRangeIndex = (GfxIndex)subObjectRange.bindingRangeIndex;
+            offset.bindingArrayIndex = (GfxIndex)i;
 
             SLANG_RETURN_ON_FAIL(setObject(offset, subObject));
         }
diff --git a/tools/gfx/cuda/render-cuda.cpp b/tools/gfx/cuda/render-cuda.cpp
index bf265861c..114751a3d 100644
--- a/tools/gfx/cuda/render-cuda.cpp
+++ b/tools/gfx/cuda/render-cuda.cpp
@@ -567,9 +567,9 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
         init(IDevice* device, CUDAShaderObjectLayout* typeLayout);
 
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override { return 0; }
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override { return 0; }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override
     {
         *outEntryPoint = nullptr;
         return SLANG_OK;
@@ -580,15 +580,15 @@ public:
         return m_data.getBuffer();
     }
 
-    virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override
+    virtual SLANG_NO_THROW Size SLANG_MCALL getSize() override
     {
-        return (size_t)m_data.getCount();
+        return (Size)m_data.getCount();
     }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        setData(ShaderOffset const& offset, void const* data, size_t size) override
+        setData(ShaderOffset const& offset, void const* data, Size size) override
     {
-        size = Math::Min(size, (size_t)m_data.getCount() - offset.uniformOffset);
+        size = Math::Min(size, (Size)m_data.getCount() - offset.uniformOffset);
         SLANG_CUDA_RETURN_ON_FAIL(cudaMemcpy(
             (uint8_t*)m_data.getBuffer() + offset.uniformOffset, data, size, cudaMemcpyDefault));
         return SLANG_OK;
@@ -709,9 +709,9 @@ public:
     List<RefPtr<CUDAEntryPointShaderObject>> entryPointObjects;
     virtual SLANG_NO_THROW Result SLANG_MCALL
         init(IDevice* device, CUDAShaderObjectLayout* typeLayout) override;
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override { return entryPointObjects.getCount(); }
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override { return (GfxCount)entryPointObjects.getCount(); }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override
     {
         returnComPtr(outEntryPoint, entryPointObjects[index]);
         return SLANG_OK;
@@ -786,9 +786,9 @@ public:
     }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getResult(
-        SlangInt queryIndex, SlangInt count, uint64_t* data) override
+        GfxIndex queryIndex, GfxCount count, uint64_t* data) override
     {
-        for (SlangInt i = 0; i < count; i++)
+        for (GfxIndex i = 0; i < count; i++)
         {
             float time = 0.0f;
             cuEventSynchronize(m_events[i + queryIndex]);
@@ -975,36 +975,36 @@ public:
             virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override {}
             virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
                 IBufferResource* dst,
-                size_t dstOffset,
+                Offset dstOffset,
                 IBufferResource* src,
-                size_t srcOffset,
-                size_t size) override
+                Offset srcOffset,
+                Size size) override
             {
                 m_writer->copyBuffer(dst, dstOffset, src, srcOffset, size);
             }
 
             virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
-                size_t count,
+                GfxCount count,
                 ITextureResource* const* textures,
                 ResourceState src,
                 ResourceState dst) override
             {}
 
             virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
-                size_t count,
+                GfxCount count,
                 IBufferResource* const* buffers,
                 ResourceState src,
                 ResourceState dst) override
             {}
 
             virtual SLANG_NO_THROW void SLANG_MCALL uploadBufferData(
-                IBufferResource* dst, size_t offset, size_t size, void* data) override
+                IBufferResource* dst, Offset offset, Size size, void* data) override
             {
                 m_writer->uploadBufferData(dst, offset, size, data);
             }
 
             virtual SLANG_NO_THROW void SLANG_MCALL
-                writeTimestamp(IQueryPool* pool, SlangInt index) override
+                writeTimestamp(IQueryPool* pool, GfxIndex index) override
             {
                 m_writer->writeTimestamp(pool, index);
             }
@@ -1018,7 +1018,7 @@ public:
                 ResourceState srcState,
                 SubresourceRange srcSubresource,
                 ITextureResource::Offset3D srcOffset,
-                ITextureResource::Size extent) override
+                ITextureResource::Extents extent) override
             {
                 SLANG_UNUSED(dst);
                 SLANG_UNUSED(dstState);
@@ -1036,9 +1036,9 @@ public:
                 ITextureResource* dst,
                 SubresourceRange subResourceRange,
                 ITextureResource::Offset3D offset,
-                ITextureResource::Size extent,
+                ITextureResource::Extents extent,
                 ITextureResource::SubresourceData* subResourceData,
-                size_t subResourceDataCount) override
+                GfxCount subResourceDataCount) override
             {
                 SLANG_UNUSED(dst);
                 SLANG_UNUSED(subResourceRange);
@@ -1079,10 +1079,10 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
                 IQueryPool* queryPool,
-                uint32_t index,
-                uint32_t count,
+                GfxIndex index,
+                GfxCount count,
                 IBufferResource* buffer,
-                uint64_t offset) override
+                Offset offset) override
             {
                 SLANG_UNUSED(queryPool);
                 SLANG_UNUSED(index);
@@ -1094,14 +1094,14 @@ public:
 
             virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
                 IBufferResource* dst,
-                size_t dstOffset,
-                size_t dstSize,
-                size_t dstRowStride,
+                Offset dstOffset,
+                Size dstSize,
+                Size dstRowStride,
                 ITextureResource* src,
                 ResourceState srcState,
                 SubresourceRange srcSubresource,
                 ITextureResource::Offset3D srcOffset,
-                ITextureResource::Size extent) override
+                ITextureResource::Extents extent) override
             {
                 SLANG_UNUSED(dst);
                 SLANG_UNUSED(dstOffset);
@@ -1191,7 +1191,7 @@ public:
             }
 
             virtual SLANG_NO_THROW void SLANG_MCALL
-                dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset) override
+                dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override
             {
                 SLANG_UNIMPLEMENTED_X("dispatchComputeIndirect");
             }
@@ -1260,12 +1260,12 @@ public:
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL executeCommandBuffers(
-            uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal) override
+            GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal) override
         {
             SLANG_UNUSED(valueToSignal);
             // TODO: implement fence.
             assert(fence == nullptr);
-            for (uint32_t i = 0; i < count; i++)
+            for (GfxIndex i = 0; i < count; i++)
             {
                 execute(static_cast<CommandBufferImpl*>(commandBuffers[i]));
             }
@@ -1279,7 +1279,7 @@ public:
         }
 
         virtual SLANG_NO_THROW Result SLANG_MCALL waitForFenceValuesOnDevice(
-            uint32_t fenceCount, IFence** fences, uint64_t* waitValues) override
+            GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override
         {
             return SLANG_FAIL;
         }
@@ -2472,8 +2472,8 @@ SlangResult CUDAShaderObject::init(IDevice* device, CUDAShaderObjectLayout* type
 
             ShaderOffset offset;
             offset.uniformOffset = bindingRangeInfo.uniformOffset + sizeof(void*) * i;
-            offset.bindingRangeIndex = subObjectRange.bindingRangeIndex;
-            offset.bindingArrayIndex = i;
+            offset.bindingRangeIndex = (GfxIndex)subObjectRange.bindingRangeIndex;
+            offset.bindingArrayIndex = (GfxIndex)i;
 
             SLANG_RETURN_ON_FAIL(setObject(offset, subObject));
         }
diff --git a/tools/gfx/d3d/d3d-swapchain.h b/tools/gfx/d3d/d3d-swapchain.h
index 36a35f754..0d4b3fafb 100644
--- a/tools/gfx/d3d/d3d-swapchain.h
+++ b/tools/gfx/d3d/d3d-swapchain.h
@@ -92,7 +92,7 @@ public:
     }
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override { return m_desc; }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getImage(uint32_t index, ITextureResource** outResource) override
+        getImage(GfxIndex index, ITextureResource** outResource) override
     {
         returnComPtr(outResource, m_images[index]);
         return SLANG_OK;
@@ -114,7 +114,7 @@ public:
     }
 
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL resize(uint32_t width, uint32_t height) override
+    virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override
     {
         if (width == m_desc.width && height == m_desc.height)
             return SLANG_OK;
diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp
index aecadcf46..2aae21a6d 100644
--- a/tools/gfx/d3d11/render-d3d11.cpp
+++ b/tools/gfx/d3d11/render-d3d11.cpp
@@ -137,29 +137,29 @@ public:
     virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
 
     virtual void setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) override;
+        const Offset* offsets) override;
     virtual void setIndexBuffer(
-        IBufferResource* buffer, Format indexFormat, uint32_t offset) override;
-    virtual void setViewports(UInt count, Viewport const* viewports) override;
-    virtual void setScissorRects(UInt count, ScissorRect const* rects) override;
+        IBufferResource* buffer, Format indexFormat, Offset  offset) override;
+    virtual void setViewports(GfxCount count, Viewport const* viewports) override;
+    virtual void setScissorRects(GfxCount count, ScissorRect const* rects) override;
     virtual void setPipelineState(IPipelineState* state) override;
-    virtual void draw(uint32_t vertexCount, uint32_t startVertex) override;
+    virtual void draw(GfxCount vertexCount, GfxIndex startVertex) override;
     virtual void drawIndexed(
-        uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex) override;
+        GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) override;
     virtual void drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) override;
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override;
     virtual void drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) override;
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override;
     virtual void dispatchCompute(int x, int y, int z) override;
     virtual void submitGpuWork() override {}
     virtual void waitForGpu() override
@@ -184,7 +184,7 @@ public:
             m_immediateContext->End(m_disjointQuery);
         }
     }
-    virtual void writeTimestamp(IQueryPool* pool, SlangInt index) override
+    virtual void writeTimestamp(IQueryPool* pool, GfxIndex index) override
     {
         auto poolImpl = static_cast<QueryPoolImpl*>(pool);
         m_immediateContext->End(poolImpl->getQuery(index));
@@ -357,14 +357,14 @@ protected:
                 ResourceState::RenderTarget);
             RefPtr<TextureResourceImpl> image = new TextureResourceImpl(imageDesc);
             image->m_resource = d3dResource;
-            for (uint32_t i = 0; i < m_desc.imageCount; i++)
+            for (GfxIndex i = 0; i < m_desc.imageCount; i++)
             {
                 m_images.add(image);
             }
         }
         virtual IDXGIFactory* getDXGIFactory() override { return m_dxgiFactory; }
         virtual IUnknown* getOwningDevice() override { return m_device; }
-        virtual SLANG_NO_THROW Result SLANG_MCALL resize(uint32_t width, uint32_t height) override
+        virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override
         {
             m_renderer->m_currentFramebuffer = nullptr;
             m_renderer->m_immediateContext->ClearState();
@@ -416,7 +416,7 @@ protected:
         }
 
         virtual SLANG_NO_THROW Result SLANG_MCALL getResult(
-            SlangInt queryIndex, SlangInt count, uint64_t* data) override
+            GfxIndex queryIndex, GfxCount count, uint64_t* data) override
         {
             D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData;
             while (S_OK != m_device->m_immediateContext->GetData(
@@ -1268,9 +1268,9 @@ protected:
 
         RendererBase* getDevice() { return m_layout->getDevice(); }
 
-        SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; }
+        SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; }
 
-        SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+        SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
             SLANG_OVERRIDE
         {
             *outEntryPoint = nullptr;
@@ -1859,8 +1859,8 @@ protected:
 
         RootShaderObjectLayoutImpl* getLayout() { return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr()); }
 
-        UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (UInt)m_entryPoints.getCount(); }
-        SlangResult SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint) SLANG_OVERRIDE
+        GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (GfxCount)m_entryPoints.getCount(); }
+        SlangResult SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) SLANG_OVERRIDE
         {
             returnComPtr(outEntryPoint, m_entryPoints[index]);
             return SLANG_OK;
@@ -2417,7 +2417,7 @@ Result D3D11Device::createFramebufferLayout(
 {
     RefPtr<FramebufferLayoutImpl> layout = new FramebufferLayoutImpl();
     layout->m_renderTargets.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         layout->m_renderTargets[i] = desc.renderTargets[i];
     }
@@ -2441,7 +2441,7 @@ Result D3D11Device::createFramebuffer(
     RefPtr<FramebufferImpl> framebuffer = new FramebufferImpl();
     framebuffer->renderTargetViews.setCount(desc.renderTargetCount);
     framebuffer->d3dRenderTargetViews.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         framebuffer->renderTargetViews[i] = static_cast<RenderTargetViewImpl*>(desc.renderTargetViews[i]);
         framebuffer->d3dRenderTargetViews[i] = framebuffer->renderTargetViews[i]->m_rtv;
@@ -2782,7 +2782,7 @@ Result D3D11Device::createBufferResource(const IBufferResource::Desc& descIn, co
         //desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
         if (srcDesc.elementSize != 0)
         {
-            bufferDesc.StructureByteStride = srcDesc.elementSize;
+            bufferDesc.StructureByteStride = (UINT)srcDesc.elementSize;
             bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
         }
         else
@@ -3191,7 +3191,7 @@ Result D3D11Device::createInputLayout(IInputLayout::Desc const& desc, IInputLayo
     impl->m_vertexStreamStrides.setCount(vertexStreamCount);
     for (Int i = 0; i < vertexStreamCount; ++i)
     {
-        impl->m_vertexStreamStrides[i] = desc.vertexStreams[i].stride;
+        impl->m_vertexStreamStrides[i] = (UINT)desc.vertexStreams[i].stride;
     }
 
     returnComPtr(outLayout, impl);
@@ -3305,10 +3305,10 @@ void D3D11Device::setPrimitiveTopology(PrimitiveTopology topology)
 }
 
 void D3D11Device::setVertexBuffers(
-    uint32_t startSlot,
-    uint32_t slotCount,
+    GfxIndex startSlot,
+    GfxCount slotCount,
     IBufferResource* const* buffersIn,
-    const uint32_t* offsetsIn)
+    const Offset* offsetsIn)
 {
     static const int kMaxVertexBuffers = 16;
 	assert(slotCount <= kMaxVertexBuffers);
@@ -3320,7 +3320,7 @@ void D3D11Device::setVertexBuffers(
 
 	auto buffers = (BufferResourceImpl*const*)buffersIn;
 
-    for (UInt ii = 0; ii < slotCount; ++ii)
+    for (GfxIndex ii = 0; ii < slotCount; ++ii)
     {
         auto inputLayout = (InputLayoutImpl*)m_currentPipelineState->inputLayout.Ptr();
         vertexStrides[ii] = inputLayout->m_vertexStreamStrides[startSlot + ii];
@@ -3331,19 +3331,19 @@ void D3D11Device::setVertexBuffers(
     m_immediateContext->IASetVertexBuffers((UINT)startSlot, (UINT)slotCount, dxBuffers, &vertexStrides[0], &vertexOffsets[0]);
 }
 
-void D3D11Device::setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint32_t offset)
+void D3D11Device::setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset)
 {
     DXGI_FORMAT dxFormat = D3DUtil::getMapFormat(indexFormat);
     m_immediateContext->IASetIndexBuffer(((BufferResourceImpl*)buffer)->m_buffer, dxFormat, UINT(offset));
 }
 
-void D3D11Device::setViewports(UInt count, Viewport const* viewports)
+void D3D11Device::setViewports(GfxCount count, Viewport const* viewports)
 {
     static const int kMaxViewports = D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX + 1;
     assert(count <= kMaxViewports);
 
     D3D11_VIEWPORT dxViewports[kMaxViewports];
-    for(UInt ii = 0; ii < count; ++ii)
+    for(GfxIndex ii = 0; ii < count; ++ii)
     {
         auto& inViewport = viewports[ii];
         auto& dxViewport = dxViewports[ii];
@@ -3359,13 +3359,13 @@ void D3D11Device::setViewports(UInt count, Viewport const* viewports)
     m_immediateContext->RSSetViewports(UINT(count), dxViewports);
 }
 
-void D3D11Device::setScissorRects(UInt count, ScissorRect const* rects)
+void D3D11Device::setScissorRects(GfxCount count, ScissorRect const* rects)
 {
     static const int kMaxScissorRects = D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX + 1;
     assert(count <= kMaxScissorRects);
 
     D3D11_RECT dxRects[kMaxScissorRects];
-    for(UInt ii = 0; ii < count; ++ii)
+    for(GfxIndex ii = 0; ii < count; ++ii)
     {
         auto& inRect = rects[ii];
         auto& dxRect = dxRects[ii];
@@ -3451,23 +3451,23 @@ void D3D11Device::setPipelineState(IPipelineState* state)
     /// ...
 }
 
-void D3D11Device::draw(uint32_t vertexCount, uint32_t startVertex)
+void D3D11Device::draw(GfxCount vertexCount, GfxIndex startVertex)
 {
     _flushGraphicsState();
     m_immediateContext->Draw(vertexCount, startVertex);
 }
 
-void D3D11Device::drawIndexed(uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex)
+void D3D11Device::drawIndexed(GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
 {
     _flushGraphicsState();
     m_immediateContext->DrawIndexed(indexCount, startIndex, baseVertex);
 }
 
 void D3D11Device::drawInstanced(
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t startVertex,
-    uint32_t startInstanceLocation)
+    GfxCount vertexCount,
+    GfxCount instanceCount,
+    GfxIndex startVertex,
+    GfxIndex startInstanceLocation)
 {
     _flushGraphicsState();
     m_immediateContext->DrawInstanced(
@@ -3478,11 +3478,11 @@ void D3D11Device::drawInstanced(
 }
 
 void D3D11Device::drawIndexedInstanced(
-    uint32_t indexCount,
-    uint32_t instanceCount,
-    uint32_t startIndexLocation,
-    int32_t baseVertexLocation,
-    uint32_t startInstanceLocation)
+    GfxCount indexCount,
+    GfxCount instanceCount,
+    GfxIndex startIndexLocation,
+    GfxIndex baseVertexLocation,
+    GfxIndex startInstanceLocation)
 {
     _flushGraphicsState();
     m_immediateContext->DrawIndexedInstanced(
@@ -3903,7 +3903,7 @@ Result D3D11Device::createGraphicsPipelineState(const GraphicsPipelineStateDesc&
         static const UInt kMaxTargets = D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT;
         if(srcDesc.targetCount > kMaxTargets) return SLANG_FAIL;
 
-        for(UInt ii = 0; ii < kMaxTargets; ++ii)
+        for(GfxIndex ii = 0; ii < kMaxTargets; ++ii)
         {
             TargetBlendDesc const* srcTargetBlendDescPtr = nullptr;
             if(ii < srcDesc.targetCount)
@@ -3983,10 +3983,10 @@ Result D3D11Device::createComputePipelineState(const ComputePipelineStateDesc& i
 
 void D3D11Device::copyBuffer(
     IBufferResource* dst,
-    size_t dstOffset,
+    Offset dstOffset,
     IBufferResource* src,
-    size_t srcOffset,
-    size_t size)
+    Offset srcOffset,
+    Size size)
 {
     auto dstImpl = static_cast<BufferResourceImpl*>(dst);
     auto srcImpl = static_cast<BufferResourceImpl*>(src);
diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp
index f964c73df..98f56958c 100644
--- a/tools/gfx/d3d12/render-d3d12.cpp
+++ b/tools/gfx/d3d12/render-d3d12.cpp
@@ -205,7 +205,7 @@ uint32_t getViewDescriptorCount(const ITransientResourceHeap::Desc& desc)
             desc.uavDescriptorCount,
             desc.accelerationStructureDescriptorCount),
         desc.constantBufferDescriptorCount,
-        2048u);
+        2048);
 }
 
 void initSrvDesc(
@@ -879,7 +879,7 @@ Result DeviceImpl::initialize(const Desc& desc)
     SLANG_RETURN_ON_FAIL(RendererBase::initialize(desc));
 
     // Find extended desc.
-    for (uint32_t i = 0; i < desc.extendedDescCount; i++)
+    for (GfxIndex i = 0; i < desc.extendedDescCount; i++)
     {
         StructType stype;
         memcpy(&stype, desc.extendedDescs[i], sizeof(stype));
@@ -1315,7 +1315,7 @@ Result DeviceImpl::createTransientResourceHeap(
         desc.flags,
         desc.constantBufferSize,
         getViewDescriptorCount(desc),
-        Math::Max(1024u, desc.samplerDescriptorCount),
+        Math::Max(1024, desc.samplerDescriptorCount),
         heap.writeRef()));
     returnComPtr(outHeap, heap);
     return SLANG_OK;
@@ -1500,7 +1500,7 @@ Result DeviceImpl::createTextureResource(
                 const D3D12_PLACED_SUBRESOURCE_FOOTPRINT& layout = layouts[j];
                 const D3D12_SUBRESOURCE_FOOTPRINT& footprint = layout.Footprint;
 
-                TextureResource::Size mipSize = calcMipSize(srcDesc.size, j);
+                TextureResource::Extents mipSize = calcMipSize(srcDesc.size, j);
                 if (gfxIsCompressedFormat(descIn.format))
                 {
                     mipSize.width = int(D3DUtil::calcAligned(mipSize.width, 4));
@@ -1962,7 +1962,7 @@ Result DeviceImpl::createBufferView(
             uint64_t viewSize = 0;
             if (desc.bufferElementSize)
             {
-                uavDesc.Buffer.StructureByteStride = desc.bufferElementSize;
+                uavDesc.Buffer.StructureByteStride = (UINT)desc.bufferElementSize;
                 uavDesc.Buffer.NumElements =
                     desc.bufferRange.elementCount == 0
                         ? UINT(resourceDesc.sizeInBytes / desc.bufferElementSize)
@@ -2023,7 +2023,7 @@ Result DeviceImpl::createBufferView(
             uint64_t viewSize = 0;
             if (desc.bufferElementSize)
             {
-                srvDesc.Buffer.StructureByteStride = desc.bufferElementSize;
+                srvDesc.Buffer.StructureByteStride = (UINT)desc.bufferElementSize;
                 srvDesc.Buffer.NumElements =
                     desc.bufferRange.elementCount == 0
                         ? UINT(resourceDesc.sizeInBytes / desc.bufferElementSize)
@@ -2079,7 +2079,7 @@ Result DeviceImpl::createFramebuffer(IFramebuffer::Desc const& desc, IFramebuffe
     framebuffer->renderTargetViews.setCount(desc.renderTargetCount);
     framebuffer->renderTargetDescriptors.setCount(desc.renderTargetCount);
     framebuffer->renderTargetClearValues.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         framebuffer->renderTargetViews[i] =
             static_cast<ResourceViewImpl*>(desc.renderTargetViews[i]);
@@ -2123,7 +2123,7 @@ Result DeviceImpl::createFramebufferLayout(
 {
     RefPtr<FramebufferLayoutImpl> layout = new FramebufferLayoutImpl();
     layout->m_renderTargets.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         layout->m_renderTargets[i] = desc.renderTargets[i];
     }
@@ -2198,9 +2198,9 @@ Result DeviceImpl::createInputLayout(IInputLayout::Desc const& desc, IInputLayou
 
     auto& vertexStreamStrides = layout->m_vertexStreamStrides;
     vertexStreamStrides.setCount(vertexStreamCount);
-    for (Int i = 0; i < vertexStreamCount; ++i)
+    for (GfxIndex i = 0; i < vertexStreamCount; ++i)
     {
-        vertexStreamStrides[i] = vertexStreams[i].stride;
+        vertexStreamStrides[i] = (UINT)vertexStreams[i].stride;
     }
 
     returnComPtr(outLayout, layout);
@@ -2418,10 +2418,10 @@ Result DeviceImpl::createFence(const IFence::Desc& desc, IFence** outFence)
 }
 
 Result DeviceImpl::waitForFences(
-    uint32_t fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
+    GfxCount fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
 {
     ShortList<HANDLE> waitHandles;
-    for (uint32_t i = 0; i < fenceCount; ++i)
+    for (GfxCount i = 0; i < fenceCount; ++i)
     {
         auto fenceImpl = static_cast<FenceImpl*>(fences[i]);
         waitHandles.add(fenceImpl->getWaitEvent());
@@ -2451,9 +2451,9 @@ Result DeviceImpl::getAccelerationStructurePrebuildInfo(
     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO prebuildInfo;
     m_device5->GetRaytracingAccelerationStructurePrebuildInfo(&inputsBuilder.desc, &prebuildInfo);
 
-    outPrebuildInfo->resultDataMaxSize = prebuildInfo.ResultDataMaxSizeInBytes;
-    outPrebuildInfo->scratchDataSize = prebuildInfo.ScratchDataSizeInBytes;
-    outPrebuildInfo->updateScratchDataSize = prebuildInfo.UpdateScratchDataSizeInBytes;
+    outPrebuildInfo->resultDataMaxSize = (Size)prebuildInfo.ResultDataMaxSizeInBytes;
+    outPrebuildInfo->scratchDataSize = (Size)prebuildInfo.ScratchDataSizeInBytes;
+    outPrebuildInfo->updateScratchDataSize = (Size)prebuildInfo.UpdateScratchDataSizeInBytes;
     return SLANG_OK;
 }
 
@@ -2864,8 +2864,8 @@ Result TransientResourceHeapImpl::queryInterface(SlangUUID const& uuid, void** o
 
 Result TransientResourceHeapImpl::allocateTransientDescriptorTable(
     DescriptorType type,
-    uint32_t count,
-    uint64_t& outDescriptorOffset,
+    GfxCount count,
+    Offset& outDescriptorOffset,
     void** outD3DDescriptorHeapHandle)
 {
     auto& heap =
@@ -2875,7 +2875,7 @@ Result TransientResourceHeapImpl::allocateTransientDescriptorTable(
     {
         return SLANG_E_OUT_OF_MEMORY;
     }
-    outDescriptorOffset = (uint64_t)allocResult;
+    outDescriptorOffset = (Offset)allocResult;
     *outD3DDescriptorHeapHandle = heap.getHeap();
     return SLANG_OK;
 }
@@ -3173,7 +3173,7 @@ Result QueryPoolImpl::init(const IQueryPool::Desc& desc, DeviceImpl* device)
     return SLANG_OK;
 }
 
-Result QueryPoolImpl::getResult(SlangInt queryIndex, SlangInt count, uint64_t* data)
+Result QueryPoolImpl::getResult(GfxIndex queryIndex, GfxCount count, uint64_t* data)
 {
     m_commandList->Reset(m_commandAllocator, nullptr);
     m_commandList->ResolveQueryData(
@@ -3201,7 +3201,7 @@ Result QueryPoolImpl::getResult(SlangInt queryIndex, SlangInt count, uint64_t* d
     return SLANG_OK;
 }
 
-void QueryPoolImpl::writeTimestamp(ID3D12GraphicsCommandList* cmdList, SlangInt index)
+void QueryPoolImpl::writeTimestamp(ID3D12GraphicsCommandList* cmdList, GfxIndex index)
 {
     cmdList->EndQuery(m_queryHeap, D3D12_QUERY_TYPE_TIMESTAMP, (UINT)index);
 }
@@ -3249,7 +3249,7 @@ Result PlainBufferProxyQueryPoolImpl::reset()
     return SLANG_OK;
 }
 
-Result PlainBufferProxyQueryPoolImpl::getResult(SlangInt queryIndex, SlangInt count, uint64_t* data)
+Result PlainBufferProxyQueryPoolImpl::getResult(GfxIndex queryIndex, GfxCount count, uint64_t* data)
 {
     if (m_resultDirty)
     {
@@ -3343,7 +3343,7 @@ void translatePostBuildInfoDescs(
 
 void RayTracingCommandEncoderImpl::buildAccelerationStructure(
     const IAccelerationStructure::BuildDesc& desc,
-    int propertyQueryCount,
+    GfxCount propertyQueryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     if (!m_commandBuffer->m_cmdList4)
@@ -3401,15 +3401,15 @@ void RayTracingCommandEncoderImpl::copyAccelerationStructure(
 }
 
 void RayTracingCommandEncoderImpl::queryAccelerationStructureProperties(
-    int accelerationStructureCount,
+    GfxCount accelerationStructureCount,
     IAccelerationStructure* const* accelerationStructures,
-    int queryCount,
+    GfxCount queryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     List<D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC> postBuildInfoDescs;
     List<DeviceAddress> asAddresses;
     asAddresses.setCount(accelerationStructureCount);
-    for (int i = 0; i < accelerationStructureCount; i++)
+    for (GfxIndex i = 0; i < accelerationStructureCount; i++)
         asAddresses[i] = accelerationStructures[i]->getDeviceAddress();
     translatePostBuildInfoDescs(queryCount, queryDescs, postBuildInfoDescs);
     m_commandBuffer->m_cmdList4->EmitRaytracingAccelerationStructurePostbuildInfo(
@@ -3443,11 +3443,11 @@ void RayTracingCommandEncoderImpl::bindPipeline(
 }
 
 void RayTracingCommandEncoderImpl::dispatchRays(
-    uint32_t rayGenShaderIndex,
+    GfxIndex rayGenShaderIndex,
     IShaderTable* shaderTable,
-    int32_t width,
-    int32_t height,
-    int32_t depth)
+    GfxCount width,
+    GfxCount height,
+    GfxCount depth)
 {
     RefPtr<PipelineStateBase> newPipeline;
     PipelineStateBase* pipeline = m_currentPipeline.Ptr();
@@ -3632,8 +3632,8 @@ Result RayTracingPipelineStateImpl::ensureAPIPipelineStateCreated()
     D3D12_RAYTRACING_SHADER_CONFIG shaderConfig = {};
     // According to DXR spec, fixed function triangle intersections must use float2 as ray
     // attributes that defines the barycentric coordinates at intersection.
-    shaderConfig.MaxAttributeSizeInBytes = desc.rayTracing.maxAttributeSizeInBytes;
-    shaderConfig.MaxPayloadSizeInBytes = desc.rayTracing.maxRayPayloadSize;
+    shaderConfig.MaxAttributeSizeInBytes = (UINT)desc.rayTracing.maxAttributeSizeInBytes;
+    shaderConfig.MaxPayloadSizeInBytes = (UINT)desc.rayTracing.maxRayPayloadSize;
     D3D12_STATE_SUBOBJECT shaderConfigSubObject = {};
     shaderConfigSubObject.Type = D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG;
     shaderConfigSubObject.pDesc = &shaderConfig;
@@ -3676,9 +3676,9 @@ Result RayTracingPipelineStateImpl::ensureAPIPipelineStateCreated()
 
 #endif
 
-UInt ShaderObjectImpl::getEntryPointCount() { return 0; }
+GfxCount ShaderObjectImpl::getEntryPointCount() { return 0; }
 
-Result ShaderObjectImpl::getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+Result ShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
 {
     *outEntryPoint = nullptr;
     return SLANG_OK;
@@ -3686,8 +3686,7 @@ Result ShaderObjectImpl::getEntryPoint(UInt index, IShaderObject** outEntryPoint
 
 const void* ShaderObjectImpl::getRawData() { return m_data.getBuffer(); }
 
-// TODO: Change to Count?
-size_t ShaderObjectImpl::getSize() { return (size_t)m_data.getCount(); }
+Size ShaderObjectImpl::getSize() { return (Size)m_data.getCount(); }
 
 // TODO: Change Index to Offset/Size?
 Result ShaderObjectImpl::setData(ShaderOffset const& inOffset, void const* data, size_t inSize)
@@ -4098,8 +4097,8 @@ void ShaderObjectImpl::updateSubObjectsRecursive()
             if (m_subObjectVersions[objectIndex] != m_objects[objectIndex]->m_version)
             {
                 ShaderOffset offset;
-                offset.bindingRangeIndex = subObjectRange.bindingRangeIndex;
-                offset.bindingArrayIndex = subObjectIndexInRange;
+                offset.bindingRangeIndex = (GfxIndex)subObjectRange.bindingRangeIndex;
+                offset.bindingArrayIndex = (GfxIndex)subObjectIndexInRange;
                 setObject(offset, subObject);
             }
         }
@@ -4754,7 +4753,7 @@ Result PipelineStateImpl::ensureAPIPipelineStateCreated()
             blend.IndependentBlendEnable = FALSE;
             blend.AlphaToCoverageEnable = desc.graphics.blend.alphaToCoverageEnable ? TRUE : FALSE;
             blend.RenderTarget[0].RenderTargetWriteMask = (uint8_t)RenderTargetWriteMask::EnableAll;
-            for (uint32_t i = 0; i < desc.graphics.blend.targetCount; i++)
+            for (GfxIndex i = 0; i < desc.graphics.blend.targetCount; i++)
             {
                 auto& d3dDesc = blend.RenderTarget[i];
                 d3dDesc.BlendEnable = desc.graphics.blend.targets[i].enableBlend ? TRUE : FALSE;
@@ -4772,7 +4771,7 @@ Result PipelineStateImpl::ensureAPIPipelineStateCreated()
                 d3dDesc.SrcBlendAlpha =
                     D3DUtil::getBlendFactor(desc.graphics.blend.targets[i].alpha.srcFactor);
             }
-            for (uint32_t i = 1; i < desc.graphics.blend.targetCount; i++)
+            for (GfxIndex i = 1; i < desc.graphics.blend.targetCount; i++)
             {
                 if (memcmp(
                         &desc.graphics.blend.targets[i],
@@ -4906,7 +4905,7 @@ Result SwapchainImpl::init(
     renderer->m_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(m_fence.writeRef()));
 
     SLANG_RETURN_ON_FAIL(m_swapChain->QueryInterface(m_swapChain3.writeRef()));
-    for (uint32_t i = 0; i < swapchainDesc.imageCount; i++)
+    for (GfxIndex i = 0; i < swapchainDesc.imageCount; i++)
     {
         m_frameEvents.add(CreateEventEx(
             nullptr,
@@ -4917,7 +4916,7 @@ Result SwapchainImpl::init(
     return SLANG_OK;
 }
 
-Result SwapchainImpl::resize(uint32_t width, uint32_t height)
+Result SwapchainImpl::resize(GfxCount width, GfxCount height)
 {
     for (auto evt : m_frameEvents)
         SetEvent(evt);
@@ -4929,7 +4928,7 @@ void SwapchainImpl::createSwapchainBufferImages()
 {
     m_images.clear();
 
-    for (uint32_t i = 0; i < m_desc.imageCount; i++)
+    for (GfxIndex i = 0; i < m_desc.imageCount; i++)
     {
         ComPtr<ID3D12Resource> d3dResource;
         m_swapChain->GetBuffer(i, IID_PPV_ARGS(d3dResource.writeRef()));
@@ -5007,10 +5006,10 @@ CommandQueueImpl::~CommandQueueImpl()
 }
 
 void CommandQueueImpl::executeCommandBuffers(
-    uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
+    GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
 {
     ShortList<ID3D12CommandList*> commandLists;
-    for (uint32_t i = 0; i < count; i++)
+    for (GfxCount i = 0; i < count; i++)
     {
         auto cmdImpl = static_cast<CommandBufferImpl*>(commandBuffers[i]);
         commandLists.add(cmdImpl->m_cmdList);
@@ -5021,7 +5020,7 @@ void CommandQueueImpl::executeCommandBuffers(
 
         m_fenceValue++;
 
-        for (uint32_t i = 0; i < count; i++)
+        for (GfxCount i = 0; i < count; i++)
         {
             if (i > 0 && commandBuffers[i] == commandBuffers[i - 1])
                 continue;
@@ -5051,9 +5050,9 @@ void CommandQueueImpl::waitOnHost()
 }
 
 Result CommandQueueImpl::waitForFenceValuesOnDevice(
-    uint32_t fenceCount, IFence** fences, uint64_t* waitValues)
+    GfxCount fenceCount, IFence** fences, uint64_t* waitValues)
 {
-    for (uint32_t i = 0; i < fenceCount; ++i)
+    for (GfxCount i = 0; i < fenceCount; ++i)
     {
         auto fenceImpl = static_cast<FenceImpl*>(fences[i]);
         m_d3dQueue->Wait(fenceImpl->m_fence.get(), waitValues[i]);
@@ -6117,9 +6116,9 @@ RootShaderObjectLayoutImpl* RootShaderObjectImpl::getLayout()
     return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr());
 }
 
-UInt RootShaderObjectImpl::getEntryPointCount() { return (UInt)m_entryPoints.getCount(); }
+GfxCount RootShaderObjectImpl::getEntryPointCount() { return (GfxCount)m_entryPoints.getCount(); }
 
-SlangResult RootShaderObjectImpl::getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+SlangResult RootShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
 {
     returnComPtr(outEntryPoint, m_entryPoints[index]);
     return SLANG_OK;
@@ -6527,13 +6526,12 @@ void ResourceCommandEncoderImpl::uploadBufferData(
         data);
 }
 
-// TODO: Change size_t to Count?
 void ResourceCommandEncoderImpl::textureBarrier(
-    size_t count, ITextureResource* const* textures, ResourceState src, ResourceState dst)
+    GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst)
 {
     ShortList<D3D12_RESOURCE_BARRIER> barriers;
 
-    for (size_t i = 0; i < count; i++)
+    for (GfxIndex i = 0; i < count; i++)
     {
         auto textureImpl = static_cast<TextureResourceImpl*>(textures[i]);
         auto d3dFormat = D3DUtil::getMapFormat(textureImpl->getDesc()->format);
@@ -6569,12 +6567,11 @@ void ResourceCommandEncoderImpl::textureBarrier(
     }
 }
 
-// TODO: Change size_t to Count?
 void ResourceCommandEncoderImpl::bufferBarrier(
-    size_t count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)
+    GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)
 {
     ShortList<D3D12_RESOURCE_BARRIER, 16> barriers;
-    for (size_t i = 0; i < count; i++)
+    for (GfxIndex i = 0; i < count; i++)
     {
         auto bufferImpl = static_cast<BufferResourceImpl*>(buffers[i]);
 
@@ -6607,7 +6604,7 @@ void ResourceCommandEncoderImpl::bufferBarrier(
     }
 }
 
-void ResourceCommandEncoderImpl::writeTimestamp(IQueryPool* pool, SlangInt index)
+void ResourceCommandEncoderImpl::writeTimestamp(IQueryPool* pool, GfxIndex index)
 {
     static_cast<QueryPoolImpl*>(pool)->writeTimestamp(m_commandBuffer->m_cmdList, index);
 }
@@ -6621,7 +6618,7 @@ void ResourceCommandEncoderImpl::copyTexture(
     ResourceState srcState,
     SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
-    ITextureResource::Size extent)
+    ITextureResource::Extents extent)
 {
     auto dstTexture = static_cast<TextureResourceImpl*>(dst);
     auto srcTexture = static_cast<TextureResourceImpl*>(src);
@@ -6643,9 +6640,9 @@ void ResourceCommandEncoderImpl::copyTexture(
         auto aspect = Math::getLowestBit((int32_t)aspectMask);
         aspectMask &= ~aspect;
         auto planeIndex = D3DUtil::getPlaneSlice(d3dFormat, (TextureAspect)aspect);
-        for (uint32_t layer = 0; layer < dstSubresource.layerCount; layer++)
+        for (GfxIndex layer = 0; layer < dstSubresource.layerCount; layer++)
         {
-            for (uint32_t mipLevel = 0; mipLevel < dstSubresource.mipLevelCount; mipLevel++)
+            for (GfxIndex mipLevel = 0; mipLevel < dstSubresource.mipLevelCount; mipLevel++)
             {
                 D3D12_TEXTURE_COPY_LOCATION dstRegion = {};
 
@@ -6683,14 +6680,13 @@ void ResourceCommandEncoderImpl::copyTexture(
     }
 }
 
-// TODO: Change size_t to Count?
 void ResourceCommandEncoderImpl::uploadTextureData(
     ITextureResource* dst,
     SubresourceRange subResourceRange,
     ITextureResource::Offset3D offset,
-    ITextureResource::Size extent,
+    ITextureResource::Extents extent,
     ITextureResource::SubresourceData* subResourceData,
-    size_t subResourceDataCount)
+    GfxCount subResourceDataCount)
 {
     auto dstTexture = static_cast<TextureResourceImpl*>(dst);
     auto baseSubresourceIndex = D3DUtil::getSubresourceIndex(
@@ -6702,7 +6698,7 @@ void ResourceCommandEncoderImpl::uploadTextureData(
     auto textureSize = dstTexture->getDesc()->size;
     FormatInfo formatInfo = {};
     gfxGetFormatInfo(dstTexture->getDesc()->format, &formatInfo);
-    for (uint32_t i = 0; i < (uint32_t)subResourceDataCount; i++)
+    for (GfxCount i = 0; i < subResourceDataCount; i++)
     {
         auto subresourceIndex = baseSubresourceIndex + i;
         // Get the footprint
@@ -6883,9 +6879,9 @@ void ResourceCommandEncoderImpl::resolveResource(
     auto dstTexture = static_cast<TextureResourceImpl*>(dest);
     auto dstDesc = dstTexture->getDesc();
 
-    for (uint32_t layer = 0; layer < sourceRange.layerCount; ++layer)
+    for (GfxIndex layer = 0; layer < sourceRange.layerCount; ++layer)
     {
-        for (uint32_t mip = 0; mip < sourceRange.mipLevelCount; ++mip)
+        for (GfxIndex mip = 0; mip < sourceRange.mipLevelCount; ++mip)
         {
             auto srcSubresourceIndex = D3DUtil::getSubresourceIndex(
                 mip + sourceRange.mipLevel,
@@ -6913,7 +6909,7 @@ void ResourceCommandEncoderImpl::resolveResource(
 }
 
 void ResourceCommandEncoderImpl::resolveQuery(
-    IQueryPool* queryPool, uint32_t index, uint32_t count, IBufferResource* buffer, uint64_t offset)
+    IQueryPool* queryPool, GfxIndex index, GfxCount count, IBufferResource* buffer, Offset offset)
 {
     auto queryBase = static_cast<QueryPoolBase*>(queryPool);
     switch (queryBase->m_desc.type)
@@ -6935,7 +6931,7 @@ void ResourceCommandEncoderImpl::resolveQuery(
 
             m_commandBuffer->m_cmdList->CopyBufferRegion(
                 bufferImpl->m_resource.getResource(),
-                offset,
+                (uint64_t)offset,
                 srcQueryBuffer,
                 index * sizeof(uint64_t),
                 count * sizeof(uint64_t));
@@ -6972,7 +6968,7 @@ void ResourceCommandEncoderImpl::copyTextureToBuffer(
     ResourceState srcState,
     SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
-    ITextureResource::Size extent)
+    ITextureResource::Extents extent)
 {
     assert(srcSubresource.mipLevelCount <= 1);
 
@@ -6992,7 +6988,7 @@ void ResourceCommandEncoderImpl::copyTextureToBuffer(
     if (srcSubresource.layerCount == 0)
         srcSubresource.layerCount = srcTexture->getDesc()->arraySize;
 
-    for (uint32_t layer = 0; layer < srcSubresource.layerCount; layer++)
+    for (GfxCount layer = 0; layer < srcSubresource.layerCount; layer++)
     {
         // Get the footprint
         D3D12_RESOURCE_DESC texDesc = srcTexture->m_resource.getResource()->GetDesc();
@@ -7092,9 +7088,9 @@ void ResourceCommandEncoderImpl::textureSubresourceBarrier(
             auto aspect = Math::getLowestBit((int32_t)aspectMask);
             aspectMask &= ~aspect;
             auto planeIndex = D3DUtil::getPlaneSlice(d3dFormat, (TextureAspect)aspect);
-            for (uint32_t layer = 0; layer < subresourceRange.layerCount; layer++)
+            for (GfxCount layer = 0; layer < subresourceRange.layerCount; layer++)
             {
-                for (uint32_t mip = 0; mip < subresourceRange.mipLevelCount; mip++)
+                for (GfxCount mip = 0; mip < subresourceRange.mipLevelCount; mip++)
                 {
                     barrier.Transition.Subresource = D3DUtil::getSubresourceIndex(
                         mip + subresourceRange.mipLevel,
@@ -7263,11 +7259,11 @@ Result RenderCommandEncoderImpl::bindPipelineWithRootObject(
     return bindPipelineWithRootObjectImpl(state, rootObject);
 }
 
-void RenderCommandEncoderImpl::setViewports(uint32_t count, const Viewport* viewports)
+void RenderCommandEncoderImpl::setViewports(GfxCount count, const Viewport* viewports)
 {
     static const int kMaxViewports = D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
     assert(count <= kMaxViewports && count <= kMaxRTVCount);
-    for (UInt ii = 0; ii < count; ++ii)
+    for (GfxIndex ii = 0; ii < count; ++ii)
     {
         auto& inViewport = viewports[ii];
         auto& dxViewport = m_viewports[ii];
@@ -7282,12 +7278,12 @@ void RenderCommandEncoderImpl::setViewports(uint32_t count, const Viewport* view
     m_d3dCmdList->RSSetViewports(UINT(count), m_viewports);
 }
 
-void RenderCommandEncoderImpl::setScissorRects(uint32_t count, const ScissorRect* rects)
+void RenderCommandEncoderImpl::setScissorRects(GfxCount count, const ScissorRect* rects)
 {
     static const int kMaxScissorRects = D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
     assert(count <= kMaxScissorRects && count <= kMaxRTVCount);
 
-    for (UInt ii = 0; ii < count; ++ii)
+    for (GfxIndex ii = 0; ii < count; ++ii)
     {
         auto& inRect = rects[ii];
         auto& dxRect = m_scissorRects[ii];
@@ -7308,10 +7304,10 @@ void RenderCommandEncoderImpl::setPrimitiveTopology(PrimitiveTopology topology)
 }
 
 void RenderCommandEncoderImpl::setVertexBuffers(
-    uint32_t startSlot,
-    uint32_t slotCount,
+    GfxIndex startSlot,
+    GfxCount slotCount,
     IBufferResource* const* buffers,
-    const uint32_t* offsets)
+    const Offset* offsets)
 {
     {
         const Index num = startSlot + slotCount;
@@ -7321,7 +7317,7 @@ void RenderCommandEncoderImpl::setVertexBuffers(
         }
     }
 
-    for (UInt i = 0; i < slotCount; i++)
+    for (GfxIndex i = 0; i < slotCount; i++)
     {
         BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]);
 
@@ -7332,11 +7328,11 @@ void RenderCommandEncoderImpl::setVertexBuffers(
 }
 
 void RenderCommandEncoderImpl::setIndexBuffer(
-    IBufferResource* buffer, Format indexFormat, uint32_t offset)
+    IBufferResource* buffer, Format indexFormat, Offset offset)
 {
     m_boundIndexBuffer = (BufferResourceImpl*)buffer;
     m_boundIndexFormat = D3DUtil::getMapFormat(indexFormat);
-    m_boundIndexOffset = offset;
+    m_boundIndexOffset = (UINT)offset;
 }
 
 void RenderCommandEncoderImpl::prepareDraw()
@@ -7400,17 +7396,17 @@ void RenderCommandEncoderImpl::prepareDraw()
     }
 }
 
-void RenderCommandEncoderImpl::draw(uint32_t vertexCount, uint32_t startVertex)
+void RenderCommandEncoderImpl::draw(GfxCount vertexCount, GfxIndex startVertex)
 {
     prepareDraw();
-    m_d3dCmdList->DrawInstanced(vertexCount, 1, startVertex, 0);
+    m_d3dCmdList->DrawInstanced((uint32_t)vertexCount, 1, (uint32_t)startVertex, 0);
 }
 
 void RenderCommandEncoderImpl::drawIndexed(
-    uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex)
+    GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
 {
     prepareDraw();
-    m_d3dCmdList->DrawIndexedInstanced(indexCount, 1, startIndex, baseVertex, 0);
+    m_d3dCmdList->DrawIndexedInstanced((uint32_t)indexCount, 1, (uint32_t)startIndex, (uint32_t)baseVertex, 0);
 }
 
 void RenderCommandEncoderImpl::endEncoding()
@@ -7462,11 +7458,11 @@ void RenderCommandEncoderImpl::setStencilReference(uint32_t referenceValue)
 }
 
 void RenderCommandEncoderImpl::drawIndirect(
-    uint32_t maxDrawCount,
+    GfxCount maxDrawCount,
     IBufferResource* argBuffer,
-    uint64_t argOffset,
+    Offset argOffset,
     IBufferResource* countBuffer,
-    uint64_t countOffset)
+    Offset countOffset)
 {
     prepareDraw();
 
@@ -7475,19 +7471,19 @@ void RenderCommandEncoderImpl::drawIndirect(
 
     m_d3dCmdList->ExecuteIndirect(
         m_renderer->drawIndirectCmdSignature,
-        maxDrawCount,
+        (uint32_t)maxDrawCount,
         argBufferImpl->m_resource,
-        argOffset,
+        (uint64_t)argOffset,
         countBufferImpl ? countBufferImpl->m_resource.getResource() : nullptr,
-        countOffset);
+        (uint64_t)countOffset);
 }
 
 void RenderCommandEncoderImpl::drawIndexedIndirect(
-    uint32_t maxDrawCount,
+    GfxCount maxDrawCount,
     IBufferResource* argBuffer,
-    uint64_t argOffset,
+    Offset argOffset,
     IBufferResource* countBuffer,
-    uint64_t countOffset)
+    Offset countOffset)
 {
     prepareDraw();
 
@@ -7496,45 +7492,53 @@ void RenderCommandEncoderImpl::drawIndexedIndirect(
 
     m_d3dCmdList->ExecuteIndirect(
         m_renderer->drawIndexedIndirectCmdSignature,
-        maxDrawCount,
+        (uint32_t)maxDrawCount,
         argBufferImpl->m_resource,
-        argOffset,
+        (uint64_t)argOffset,
         countBufferImpl ? countBufferImpl->m_resource.getResource() : nullptr,
-        countOffset);
+        (uint64_t)countOffset);
 }
 
 Result RenderCommandEncoderImpl::setSamplePositions(
-    uint32_t samplesPerPixel, uint32_t pixelCount, const SamplePosition* samplePositions)
+    GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions)
 {
     if (m_commandBuffer->m_cmdList1)
     {
         m_commandBuffer->m_cmdList1->SetSamplePositions(
-            samplesPerPixel, pixelCount, (D3D12_SAMPLE_POSITION*)samplePositions);
+            (uint32_t)samplesPerPixel, (uint32_t)pixelCount, (D3D12_SAMPLE_POSITION*)samplePositions);
         return SLANG_OK;
     }
     return SLANG_E_NOT_AVAILABLE;
 }
 
 void RenderCommandEncoderImpl::drawInstanced(
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t startVertex,
-    uint32_t startInstanceLocation)
+    GfxCount vertexCount,
+    GfxCount instanceCount,
+    GfxIndex startVertex,
+    GfxIndex startInstanceLocation)
 {
     prepareDraw();
-    m_d3dCmdList->DrawInstanced(vertexCount, instanceCount, startVertex, startInstanceLocation);
+    m_d3dCmdList->DrawInstanced(
+        (uint32_t)vertexCount,
+        (uint32_t)instanceCount,
+        (uint32_t)startVertex,
+        (uint32_t)startInstanceLocation);
 }
 
 void RenderCommandEncoderImpl::drawIndexedInstanced(
-    uint32_t indexCount,
-    uint32_t instanceCount,
-    uint32_t startIndexLocation,
-    int32_t baseVertexLocation,
-    uint32_t startInstanceLocation)
+    GfxCount indexCount,
+    GfxCount instanceCount,
+    GfxIndex startIndexLocation,
+    GfxIndex baseVertexLocation,
+    GfxIndex startInstanceLocation)
 {
     prepareDraw();
     m_d3dCmdList->DrawIndexedInstanced(
-        indexCount, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation);
+        (uint32_t)indexCount,
+        (uint32_t)instanceCount,
+        (uint32_t)startIndexLocation,
+        baseVertexLocation,
+        (uint32_t)startInstanceLocation);
 }
 
 void ComputeCommandEncoderImpl::endEncoding() { PipelineCommandEncoder::endEncodingImpl(); }
@@ -7573,7 +7577,7 @@ void ComputeCommandEncoderImpl::dispatchCompute(int x, int y, int z)
     m_d3dCmdList->Dispatch(x, y, z);
 }
 
-void ComputeCommandEncoderImpl::dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset)
+void ComputeCommandEncoderImpl::dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset)
 {
     // Submit binding for compute
     {
@@ -7587,7 +7591,7 @@ void ComputeCommandEncoderImpl::dispatchComputeIndirect(IBufferResource* argBuff
     auto argBufferImpl = static_cast<BufferResourceImpl*>(argBuffer);
 
     m_d3dCmdList->ExecuteIndirect(
-        m_renderer->dispatchIndirectCmdSignature, 1, argBufferImpl->m_resource, offset, nullptr, 0);
+        m_renderer->dispatchIndirectCmdSignature, 1, argBufferImpl->m_resource, (uint64_t)offset, nullptr, 0);
 }
 
 FenceImpl::~FenceImpl()
diff --git a/tools/gfx/d3d12/render-d3d12.h b/tools/gfx/d3d12/render-d3d12.h
index b08cdb510..5dae6a383 100644
--- a/tools/gfx/d3d12/render-d3d12.h
+++ b/tools/gfx/d3d12/render-d3d12.h
@@ -205,7 +205,7 @@ public:
         createFence(const IFence::Desc& desc, IFence** outFence) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFences(
-        uint32_t fenceCount,
+        GfxCount fenceCount,
         IFence** fences,
         uint64_t* fenceValues,
         bool waitForAll,
@@ -425,9 +425,9 @@ public:
     Result init(const IQueryPool::Desc& desc, DeviceImpl* device);
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getResult(SlangInt queryIndex, SlangInt count, uint64_t* data) override;
+        getResult(GfxIndex queryIndex, GfxCount count, uint64_t* data) override;
 
-    void writeTimestamp(ID3D12GraphicsCommandList* cmdList, SlangInt index);
+    void writeTimestamp(ID3D12GraphicsCommandList* cmdList, GfxIndex index);
 
 public:
     D3D12_QUERY_TYPE m_queryType;
@@ -455,7 +455,7 @@ public:
 
     virtual SLANG_NO_THROW Result SLANG_MCALL reset() override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getResult(SlangInt queryIndex, SlangInt count, uint64_t* data) override;
+        getResult(GfxIndex queryIndex, GfxCount count, uint64_t* data) override;
 
 public:
     QueryType m_queryType;
@@ -525,8 +525,8 @@ public:
 
     virtual SLANG_NO_THROW Result SLANG_MCALL allocateTransientDescriptorTable(
         DescriptorType type,
-        uint32_t count,
-        uint64_t& outDescriptorOffset,
+        GfxCount count,
+        Offset& outDescriptorOffset,
         void** outD3DDescriptorHeapHandle) override;
 
     ~TransientResourceHeapImpl();
@@ -1182,18 +1182,18 @@ public:
 
     RendererBase* getDevice() { return m_device.get(); }
 
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override;
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override;
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
 
     virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() override;
 
-    // TODO: Change size_t to Count?
-    virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override;
+    virtual SLANG_NO_THROW Size SLANG_MCALL getSize() override;
 
+    // TODO: What to do with size_t?
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        setData(ShaderOffset const& inOffset, void const* data, Size inSize) override;
+        setData(ShaderOffset const& inOffset, void const* data, size_t inSize) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
         setObject(ShaderOffset const& offset, IShaderObject* object) override;
 
@@ -1340,9 +1340,9 @@ public:
 public:
     RootShaderObjectLayoutImpl* getLayout();
 
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override;
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override;
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override;
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
     virtual Result collectSpecializationArgs(ExtendedShaderObjectTypeList& args) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
         copyFrom(IShaderObject* object, ITransientResourceHeap* transientHeap) override;
@@ -1407,18 +1407,18 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL
         uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data) override;
     virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
-        size_t count, // TODO: Change size_t to Count?
+        GfxCount count,
         ITextureResource* const* textures,
         ResourceState src,
         ResourceState dst) override;
     virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
-        size_t count, // TODO: Change size_t to Count?
+        GfxCount count,
         IBufferResource* const* buffers,
         ResourceState src,
         ResourceState dst) override;
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() {}
     virtual SLANG_NO_THROW void SLANG_MCALL
-        writeTimestamp(IQueryPool* pool, SlangInt index) override;
+        writeTimestamp(IQueryPool* pool, GfxIndex index) override;
     virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
         ITextureResource* dst,
         ResourceState dstState,
@@ -1428,15 +1428,15 @@ public:
         ResourceState srcState,
         SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
-        ITextureResource::Size extent) override;
+        ITextureResource::Extents extent) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
         ITextureResource* dst,
         SubresourceRange subResourceRange,
         ITextureResource::Offset3D offset,
-        ITextureResource::Size extent,
+        ITextureResource::Extents extent,
         ITextureResource::SubresourceData* subResourceData,
-        size_t subResourceDataCount) override; // TODO: Change size_t to Count?
+        GfxCount subResourceDataCount) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
         IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags) override;
@@ -1451,10 +1451,10 @@ public:
 
     virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
         IQueryPool* queryPool,
-        uint32_t index,
-        uint32_t count,
+        GfxIndex index,
+        GfxCount count,
         IBufferResource* buffer,
-        uint64_t offset) override;
+        Offset offset) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
         IBufferResource* dst,
@@ -1465,7 +1465,7 @@ public:
         ResourceState srcState,
         SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
-        ITextureResource::Size extent) override;
+        ITextureResource::Extents extent) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
         ITextureResource* texture,
@@ -1500,7 +1500,7 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset) override;
+        dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
 };
 class RenderCommandEncoderImpl
     : public IRenderCommandEncoder
@@ -1539,63 +1539,63 @@ public:
         bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setViewports(uint32_t count, const Viewport* viewports) override;
+        setViewports(GfxCount count, const Viewport* viewports) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setScissorRects(uint32_t count, const ScissorRect* rects) override;
+        setScissorRects(GfxCount count, const ScissorRect* rects) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
         setPrimitiveTopology(PrimitiveTopology topology) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) override;
+        const Offset* offsets) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint32_t offset = 0) override;
+        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
 
     void prepareDraw();
     virtual SLANG_NO_THROW void SLANG_MCALL
-        draw(uint32_t vertexCount, uint32_t startVertex = 0) override;
+        draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        drawIndexed(uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) override;
+        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
-        uint32_t maxDrawCount,
+        GfxCount maxDrawCount,
         IBufferResource* argBuffer,
-        uint64_t argOffset,
+        Offset argOffset,
         IBufferResource* countBuffer,
-        uint64_t countOffset) override;
+        Offset countOffset) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
-        uint32_t maxDrawCount,
+        GfxCount maxDrawCount,
         IBufferResource* argBuffer,
-        uint64_t argOffset,
+        Offset argOffset,
         IBufferResource* countBuffer,
-        uint64_t countOffset) override;
+        Offset countOffset) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
-        uint32_t samplesPerPixel,
-        uint32_t pixelCount,
+        GfxCount samplesPerPixel,
+        GfxCount pixelCount,
         const SamplePosition* samplePositions) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) override;
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) override;
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override;
 };
 
 #if SLANG_GFX_HAS_DXR_SUPPORT
@@ -1608,16 +1608,16 @@ public:
 public:
     virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
         const IAccelerationStructure::BuildDesc& desc,
-        int propertyQueryCount,
+        GfxCount propertyQueryCount,
         AccelerationStructureQueryDesc* queryDescs) override;
     virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
         IAccelerationStructure* dest,
         IAccelerationStructure* src,
         AccelerationStructureCopyMode mode) override;
     virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
-        int accelerationStructureCount,
+        GfxCount accelerationStructureCount,
         IAccelerationStructure* const* accelerationStructures,
-        int queryCount,
+        GfxCount queryCount,
         AccelerationStructureQueryDesc* queryDescs) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
@@ -1631,11 +1631,11 @@ public:
         return bindPipelineWithRootObjectImpl(state, rootObject);
     }
     virtual SLANG_NO_THROW void SLANG_MCALL dispatchRays(
-        uint32_t rayGenShaderIndex,
+        GfxIndex rayGenShaderIndex,
         IShaderTable* shaderTable,
-        int32_t width,
-        int32_t height,
-        int32_t depth) override;
+        GfxCount width,
+        GfxCount height,
+        GfxCount depth) override;
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() {}
 };
 #endif
@@ -1750,7 +1750,7 @@ public:
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL executeCommandBuffers(
-        uint32_t count,
+        GfxCount count,
         ICommandBuffer* const* commandBuffers,
         IFence* fence,
         uint64_t valueToSignal) override;
@@ -1758,7 +1758,7 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL waitOnHost() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFenceValuesOnDevice(
-        uint32_t fenceCount, IFence** fences, uint64_t* waitValues) override;
+        GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override;
 };
 
 class SwapchainImpl : public D3DSwapchainBase
@@ -1772,7 +1772,7 @@ public:
     uint64_t fenceValue = 0;
     Result init(DeviceImpl* renderer, const ISwapchain::Desc& swapchainDesc, WindowHandle window);
 
-    virtual SLANG_NO_THROW Result SLANG_MCALL resize(uint32_t width, uint32_t height) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override;
 
     virtual void createSwapchainBufferImages() override;
     virtual IDXGIFactory* getDXGIFactory() override { return m_dxgiFactory; }
diff --git a/tools/gfx/debug-layer.cpp b/tools/gfx/debug-layer.cpp
index 414434da6..36624245b 100644
--- a/tools/gfx/debug-layer.cpp
+++ b/tools/gfx/debug-layer.cpp
@@ -293,7 +293,7 @@ Result DebugDevice::getNativeDeviceHandles(InteropHandles* outHandles)
     return baseObject->getNativeDeviceHandles(outHandles);
 }
 
-Result DebugDevice::getFeatures(const char** outFeatures, UInt bufferSize, UInt* outFeatureCount)
+Result DebugDevice::getFeatures(const char** outFeatures, Size bufferSize, GfxCount* outFeatureCount)
 {
     SLANG_GFX_API_FUNC;
 
@@ -532,7 +532,7 @@ Result DebugDevice::createFramebuffer(IFramebuffer::Desc const& desc, IFramebuff
             ? static_cast<DebugResourceView*>(desc.depthStencilView)->baseObject.get()
             : nullptr;
     List<IResourceView*> innerRenderTargets;
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         auto innerRenderTarget =
             desc.renderTargetViews[i]
@@ -828,7 +828,7 @@ Result DebugDevice::createFence(const IFence::Desc& desc, IFence** outFence)
 }
 
 Result DebugDevice::waitForFences(
-    uint32_t fenceCount, IFence** fences, uint64_t* values , bool waitForAll, uint64_t timeout)
+    GfxCount fenceCount, IFence** fences, uint64_t* values , bool waitForAll, uint64_t timeout)
 {
     SLANG_GFX_API_FUNC;
     return baseObject->waitForFences(fenceCount, fences, values, waitForAll, timeout);
@@ -1113,7 +1113,7 @@ void DebugComputeCommandEncoder::dispatchCompute(int x, int y, int z)
 }
 
 void DebugComputeCommandEncoder::dispatchComputeIndirect(
-    IBufferResource* cmdBuffer, uint64_t offset)
+    IBufferResource* cmdBuffer, Offset offset)
 {
     SLANG_GFX_API_FUNC;
     baseObject->dispatchComputeIndirect(getInnerObj(cmdBuffer), offset);
@@ -1148,13 +1148,13 @@ Result DebugRenderCommandEncoder::bindPipelineWithRootObject(
     return baseObject->bindPipelineWithRootObject(getInnerObj(state), getInnerObj(rootObject));
 }
 
-void DebugRenderCommandEncoder::setViewports(uint32_t count, const Viewport* viewports)
+void DebugRenderCommandEncoder::setViewports(GfxCount count, const Viewport* viewports)
 {
     SLANG_GFX_API_FUNC;
     baseObject->setViewports(count, viewports);
 }
 
-void DebugRenderCommandEncoder::setScissorRects(uint32_t count, const ScissorRect* scissors)
+void DebugRenderCommandEncoder::setScissorRects(GfxCount count, const ScissorRect* scissors)
 {
     SLANG_GFX_API_FUNC;
     baseObject->setScissorRects(count, scissors);
@@ -1167,15 +1167,15 @@ void DebugRenderCommandEncoder::setPrimitiveTopology(PrimitiveTopology topology)
 }
 
 void DebugRenderCommandEncoder::setVertexBuffers(
-    uint32_t startSlot,
-    uint32_t slotCount,
+    GfxIndex startSlot,
+    GfxCount slotCount,
     IBufferResource* const* buffers,
-    const uint32_t* offsets)
+    const Offset* offsets)
 {
     SLANG_GFX_API_FUNC;
 
     List<IBufferResource*> innerBuffers;
-    for (UInt i = 0; i < slotCount; i++)
+    for (GfxIndex i = 0; i < slotCount; i++)
     {
         innerBuffers.add(static_cast<DebugBufferResource*>(buffers[i])->baseObject.get());
     }
@@ -1183,32 +1183,32 @@ void DebugRenderCommandEncoder::setVertexBuffers(
 }
 
 void DebugRenderCommandEncoder::setIndexBuffer(
-    IBufferResource* buffer, Format indexFormat, uint32_t offset)
+    IBufferResource* buffer, Format indexFormat, Offset offset)
 {
     SLANG_GFX_API_FUNC;
     auto innerBuffer = static_cast<DebugBufferResource*>(buffer)->baseObject.get();
     baseObject->setIndexBuffer(innerBuffer, indexFormat, offset);
 }
 
-void DebugRenderCommandEncoder::draw(uint32_t vertexCount, uint32_t startVertex)
+void DebugRenderCommandEncoder::draw(GfxCount vertexCount, GfxIndex startVertex)
 {
     SLANG_GFX_API_FUNC;
     baseObject->draw(vertexCount, startVertex);
 }
 
 void DebugRenderCommandEncoder::drawIndexed(
-    uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex)
+    GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
 {
     SLANG_GFX_API_FUNC;
     baseObject->drawIndexed(indexCount, startIndex, baseVertex);
 }
 
 void DebugRenderCommandEncoder::drawIndirect(
-    uint32_t maxDrawCount,
+    GfxCount maxDrawCount,
     IBufferResource* argBuffer,
-    uint64_t argOffset,
+    Offset argOffset,
     IBufferResource* countBuffer,
-    uint64_t countOffset)
+    Offset countOffset)
 {
     SLANG_GFX_API_FUNC;
     baseObject->drawIndirect(
@@ -1216,11 +1216,11 @@ void DebugRenderCommandEncoder::drawIndirect(
 }
 
 void DebugRenderCommandEncoder::drawIndexedIndirect(
-    uint32_t maxDrawCount,
+    GfxCount maxDrawCount,
     IBufferResource* argBuffer,
-    uint64_t argOffset,
+    Offset argOffset,
     IBufferResource* countBuffer,
-    uint64_t countOffset)
+    Offset countOffset)
 {
     SLANG_GFX_API_FUNC;
     baseObject->drawIndexedIndirect(
@@ -1234,17 +1234,17 @@ void DebugRenderCommandEncoder::setStencilReference(uint32_t referenceValue)
 }
 
 Result DebugRenderCommandEncoder::setSamplePositions(
-    uint32_t samplesPerPixel, uint32_t pixelCount, const SamplePosition* samplePositions)
+    GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions)
 {
     SLANG_GFX_API_FUNC;
     return baseObject->setSamplePositions(samplesPerPixel, pixelCount, samplePositions);
 }
 
 void DebugRenderCommandEncoder::drawInstanced(
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t startVertex,
-    uint32_t startInstanceLocation)
+    GfxCount vertexCount,
+    GfxCount instanceCount,
+    GfxIndex startVertex,
+    GfxIndex startInstanceLocation)
 {
     SLANG_GFX_API_FUNC;
     return baseObject->drawInstanced(
@@ -1252,11 +1252,11 @@ void DebugRenderCommandEncoder::drawInstanced(
 }
 
 void DebugRenderCommandEncoder::drawIndexedInstanced(
-    uint32_t indexCount,
-    uint32_t instanceCount,
-    uint32_t startIndexLocation,
-    int32_t baseVertexLocation,
-    uint32_t startInstanceLocation)
+    GfxCount indexCount,
+    GfxCount instanceCount,
+    GfxIndex startIndexLocation,
+    GfxIndex baseVertexLocation,
+    GfxIndex startInstanceLocation)
 {
     SLANG_GFX_API_FUNC;
     return baseObject->drawIndexedInstanced(
@@ -1270,7 +1270,7 @@ void DebugResourceCommandEncoder::endEncoding()
     baseObject->endEncoding();
 }
 
-void DebugResourceCommandEncoderImpl::writeTimestamp(IQueryPool* pool, SlangInt index)
+void DebugResourceCommandEncoderImpl::writeTimestamp(IQueryPool* pool, GfxIndex index)
 {
     SLANG_GFX_API_FUNC;
     getBaseResourceEncoder()->writeTimestamp(static_cast<DebugQueryPool*>(pool)->baseObject, index);
@@ -1278,10 +1278,10 @@ void DebugResourceCommandEncoderImpl::writeTimestamp(IQueryPool* pool, SlangInt
 
 void DebugResourceCommandEncoderImpl::copyBuffer(
     IBufferResource* dst,
-    size_t dstOffset,
+    Offset dstOffset,
     IBufferResource* src,
-    size_t srcOffset,
-    size_t size)
+    Offset srcOffset,
+    Size size)
 {
     SLANG_GFX_API_FUNC;
     auto dstImpl = static_cast<DebugBufferResource*>(dst);
@@ -1292,8 +1292,8 @@ void DebugResourceCommandEncoderImpl::copyBuffer(
 
 void DebugResourceCommandEncoderImpl::uploadBufferData(
     IBufferResource* dst,
-    size_t offset,
-    size_t size,
+    Offset offset,
+    Size size,
     void* data)
 {
     SLANG_GFX_API_FUNC;
@@ -1302,7 +1302,7 @@ void DebugResourceCommandEncoderImpl::uploadBufferData(
 }
 
 void DebugResourceCommandEncoderImpl::textureBarrier(
-    size_t count,
+    GfxCount count,
     ITextureResource* const* textures,
     ResourceState src,
     ResourceState dst)
@@ -1310,7 +1310,7 @@ void DebugResourceCommandEncoderImpl::textureBarrier(
     SLANG_GFX_API_FUNC;
 
     List<ITextureResource*> innerTextures;
-    for (size_t i = 0; i < count; i++)
+    for (GfxIndex i = 0; i < count; i++)
     {
         innerTextures.add(static_cast<DebugTextureResource*>(textures[i])->baseObject.get());
     }
@@ -1318,7 +1318,7 @@ void DebugResourceCommandEncoderImpl::textureBarrier(
 }
 
 void DebugResourceCommandEncoderImpl::bufferBarrier(
-    size_t count,
+    GfxCount count,
     IBufferResource* const* buffers,
     ResourceState src,
     ResourceState dst)
@@ -1326,7 +1326,7 @@ void DebugResourceCommandEncoderImpl::bufferBarrier(
     SLANG_GFX_API_FUNC;
 
     List<IBufferResource*> innerBuffers;
-    for(size_t i = 0; i < count; i++)
+    for(GfxIndex i = 0; i < count; i++)
     {
         innerBuffers.add(static_cast<DebugBufferResource*>(buffers[i])->baseObject.get());
     }
@@ -1342,7 +1342,7 @@ void DebugResourceCommandEncoderImpl::copyTexture(
     ResourceState srcState,
     SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
-    ITextureResource::Size extent)
+    ITextureResource::Extents extent)
 {
     SLANG_GFX_API_FUNC;
     getBaseResourceEncoder()->copyTexture(
@@ -1361,9 +1361,9 @@ void DebugResourceCommandEncoderImpl::uploadTextureData(
     ITextureResource* dst,
     SubresourceRange subResourceRange,
     ITextureResource::Offset3D offset,
-    ITextureResource::Size extent,
+    ITextureResource::Extents extent,
     ITextureResource::SubresourceData* subResourceData,
-    size_t subResourceDataCount)
+    GfxCount subResourceDataCount)
 {
     SLANG_GFX_API_FUNC;
     getBaseResourceEncoder()->uploadTextureData(
@@ -1403,7 +1403,7 @@ void DebugResourceCommandEncoderImpl::resolveResource(
 }
 
 void DebugResourceCommandEncoderImpl::resolveQuery(
-    IQueryPool* queryPool, uint32_t index, uint32_t count, IBufferResource* buffer, uint64_t offset)
+    IQueryPool* queryPool, GfxIndex index, GfxCount count, IBufferResource* buffer, Offset offset)
 {
     SLANG_GFX_API_FUNC;
     getBaseResourceEncoder()->resolveQuery(getInnerObj(queryPool), index, count, buffer, offset);
@@ -1411,14 +1411,14 @@ void DebugResourceCommandEncoderImpl::resolveQuery(
 
 void DebugResourceCommandEncoderImpl::copyTextureToBuffer(
     IBufferResource* dst,
-    size_t dstOffset,
-    size_t dstSize,
-    size_t dstRowStride,
+    Offset dstOffset,
+    Size dstSize,
+    Size dstRowStride,
     ITextureResource* src,
     ResourceState srcState,
     SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
-    ITextureResource::Size extent)
+    ITextureResource::Extents extent)
 {
     SLANG_GFX_API_FUNC;
     getBaseResourceEncoder()->copyTextureToBuffer(
@@ -1457,7 +1457,7 @@ void DebugRayTracingCommandEncoder::endEncoding()
 
 void DebugRayTracingCommandEncoder::buildAccelerationStructure(
     const IAccelerationStructure::BuildDesc& desc,
-    int propertyQueryCount,
+    GfxCount propertyQueryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     SLANG_GFX_API_FUNC;
@@ -1487,14 +1487,14 @@ void DebugRayTracingCommandEncoder::copyAccelerationStructure(
 }
 
 void DebugRayTracingCommandEncoder::queryAccelerationStructureProperties(
-    int accelerationStructureCount,
+    GfxCount accelerationStructureCount,
     IAccelerationStructure* const* accelerationStructures,
-    int queryCount,
+    GfxCount queryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     SLANG_GFX_API_FUNC;
     List<IAccelerationStructure*> innerAS;
-    for (int i = 0; i < accelerationStructureCount; i++)
+    for (GfxIndex i = 0; i < accelerationStructureCount; i++)
     {
         innerAS.add(getInnerObj(accelerationStructures[i]));
     }
@@ -1544,11 +1544,11 @@ Result DebugRayTracingCommandEncoder::bindPipelineWithRootObject(
 }
 
 void DebugRayTracingCommandEncoder::dispatchRays(
-    uint32_t rayGenShaderIndex,
+    GfxIndex rayGenShaderIndex,
     IShaderTable* shaderTable,
-    int32_t width,
-    int32_t height,
-    int32_t depth)
+    GfxCount width,
+    GfxCount height,
+    GfxCount depth)
 {
     SLANG_GFX_API_FUNC;
     baseObject->dispatchRays(rayGenShaderIndex, getInnerObj(shaderTable), width, height, depth);
@@ -1560,11 +1560,11 @@ const ICommandQueue::Desc& DebugCommandQueue::getDesc()
     return baseObject->getDesc();
 }
 
-void DebugCommandQueue::executeCommandBuffers(uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
+void DebugCommandQueue::executeCommandBuffers(GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
 {
     SLANG_GFX_API_FUNC;
     List<ICommandBuffer*> innerCommandBuffers;
-    for (uint32_t i = 0; i < count; i++)
+    for (GfxIndex i = 0; i < count; i++)
     {
         auto cmdBufferIn = commandBuffers[i];
         auto cmdBufferImpl = static_cast<DebugCommandBuffer*>(cmdBufferIn);
@@ -1596,11 +1596,11 @@ void DebugCommandQueue::waitOnHost()
 }
 
 Result DebugCommandQueue::waitForFenceValuesOnDevice(
-    uint32_t fenceCount, IFence** fences, uint64_t* waitValues)
+    GfxCount fenceCount, IFence** fences, uint64_t* waitValues)
 {
     SLANG_GFX_API_FUNC;
     List<IFence*> innerFences;
-    for (uint32_t i = 0; i < fenceCount; ++i)
+    for (GfxIndex i = 0; i < fenceCount; ++i)
     {
         innerFences.add(getInnerObj(fences[i]));
     }
@@ -1645,11 +1645,11 @@ const ISwapchain::Desc& DebugSwapchain::getDesc()
     return desc;
 }
 
-Result DebugSwapchain::getImage(uint32_t index, ITextureResource** outResource)
+Result DebugSwapchain::getImage(GfxIndex index, ITextureResource** outResource)
 {
     SLANG_GFX_API_FUNC;
     maybeRebuildImageList();
-    if (index > (uint32_t)m_images.getCount())
+    if (index > (GfxCount)m_images.getCount())
     {
         GFX_DIAGNOSE_ERROR_FORMAT(
             "`index`(%d) must not exceed total number of images (%d) in the swapchain.",
@@ -1672,7 +1672,7 @@ int DebugSwapchain::acquireNextImage()
     return baseObject->acquireNextImage();
 }
 
-Result DebugSwapchain::resize(uint32_t width, uint32_t height)
+Result DebugSwapchain::resize(GfxCount width, GfxCount height)
 {
     SLANG_GFX_API_FUNC;
     for (auto& image : m_images)
@@ -1705,7 +1705,7 @@ void DebugSwapchain::maybeRebuildImageList()
     if (m_images.getCount() != 0)
         return;
     m_images.clearAndDeallocate();
-    for (uint32_t i = 0; i < baseObject->getDesc().imageCount; i++)
+    for (GfxIndex i = 0; i < baseObject->getDesc().imageCount; i++)
     {
         RefPtr<DebugTextureResource> image = new DebugTextureResource();
         baseObject->getImage(i, image->baseObject.writeRef());
@@ -1725,18 +1725,18 @@ slang::TypeLayoutReflection* DebugShaderObject::getElementTypeLayout()
     return baseObject->getElementTypeLayout();
 }
 
-UInt DebugShaderObject::getEntryPointCount()
+GfxCount DebugShaderObject::getEntryPointCount()
 {
     SLANG_GFX_API_FUNC;
     return baseObject->getEntryPointCount();
 }
 
-Result DebugShaderObject::getEntryPoint(UInt index, IShaderObject** entryPoint)
+Result DebugShaderObject::getEntryPoint(GfxIndex index, IShaderObject** entryPoint)
 {
     SLANG_GFX_API_FUNC;
     if (m_entryPoints.getCount() == 0)
     {
-        for (UInt i = 0; i < getEntryPointCount(); i++)
+        for (GfxIndex i = 0; i < getEntryPointCount(); i++)
         {
             RefPtr<DebugShaderObject> entryPointObj = new DebugShaderObject();
             SLANG_RETURN_ON_FAIL(
@@ -1744,7 +1744,7 @@ Result DebugShaderObject::getEntryPoint(UInt index, IShaderObject** entryPoint)
             m_entryPoints.add(entryPointObj);
         }
     }
-    if (index > (UInt)m_entryPoints.getCount())
+    if (index > (GfxCount)m_entryPoints.getCount())
     {
         GFX_DIAGNOSE_ERROR("`index` must not exceed `entryPointCount`.");
         return SLANG_FAIL;
@@ -1753,7 +1753,7 @@ Result DebugShaderObject::getEntryPoint(UInt index, IShaderObject** entryPoint)
     return SLANG_OK;
 }
 
-Result DebugShaderObject::setData(ShaderOffset const& offset, void const* data, size_t size)
+Result DebugShaderObject::setData(ShaderOffset const& offset, void const* data, Size size)
 {
     SLANG_GFX_API_FUNC;
     return baseObject->setData(offset, data, size);
@@ -1824,7 +1824,7 @@ Result DebugShaderObject::setCombinedTextureSampler(
 Result DebugShaderObject::setSpecializationArgs(
     ShaderOffset const& offset,
     const slang::SpecializationArg* args,
-    uint32_t count)
+    GfxCount count)
 {
     SLANG_GFX_API_FUNC;
     return baseObject->setSpecializationArgs(offset, args, count);
@@ -1870,7 +1870,7 @@ DebugObjectBase::DebugObjectBase()
 Result DebugRootShaderObject::setSpecializationArgs(
     ShaderOffset const& offset,
     const slang::SpecializationArg* args,
-    uint32_t count)
+    GfxCount count)
 {
     SLANG_GFX_API_FUNC;
 
@@ -1886,7 +1886,7 @@ void DebugRootShaderObject::reset()
     baseObject.detach();
 }
 
-Result DebugQueryPool::getResult(SlangInt index, SlangInt count, uint64_t* data)
+Result DebugQueryPool::getResult(GfxIndex index, GfxCount count, uint64_t* data)
 {
     SLANG_GFX_API_FUNC;
 
diff --git a/tools/gfx/debug-layer.h b/tools/gfx/debug-layer.h
index de8ccfe8e..f061ed0a0 100644
--- a/tools/gfx/debug-layer.h
+++ b/tools/gfx/debug-layer.h
@@ -44,7 +44,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL getNativeDeviceHandles(InteropHandles* outHandles) override;
     virtual SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* feature) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getFeatures(const char** outFeatures, UInt bufferSize, UInt* outFeatureCount) override;
+        getFeatures(const char** outFeatures, Size bufferSize, GfxCount* outFeatureCount) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
         getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates) override;
 
@@ -64,7 +64,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL createTextureFromSharedHandle(
         InteropHandle handle,
         const ITextureResource::Desc& srcDesc,
-        const size_t size,
+        const Size size,
         ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
         const IBufferResource::Desc& desc,
@@ -141,12 +141,12 @@ public:
         ITextureResource* resource,
         ResourceState state,
         ISlangBlob** outBlob,
-        size_t* outRowPitch,
-        size_t* outPixelSize) override;
+        Size* outRowPitch,
+        Size* outPixelSize) override;
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL readBufferResource(
         IBufferResource* buffer,
-        size_t offset,
-        size_t size,
+        Offset offset,
+        Size size,
         ISlangBlob** outBlob) override;
     virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const override;
     virtual SLANG_NO_THROW Result SLANG_MCALL createQueryPool(
@@ -155,7 +155,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
         createFence(const IFence::Desc& desc, IFence** outFence) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFences(
-        uint32_t fenceCount,
+        GfxCount fenceCount,
         IFence** fences,
         uint64_t* values,
         bool waitForAll,
@@ -183,7 +183,7 @@ public:
 public:
     IQueryPool* getInterface(const Slang::Guid& guid);
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getResult(SlangInt index, SlangInt count, uint64_t* data) override;
+        getResult(GfxIndex index, GfxCount count, uint64_t* data) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL reset() override;
 };
 
@@ -286,9 +286,9 @@ public:
     IShaderObject* getInterface(const Slang::Guid& guid);
     virtual SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL getElementTypeLayout() override;
     virtual SLANG_NO_THROW ShaderObjectContainerType SLANG_MCALL getContainerType() override;
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override;
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** entryPoint) override;
+        getEntryPoint(GfxIndex index, IShaderObject** entryPoint) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
         setData(ShaderOffset const& offset, void const* data, size_t size) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
@@ -306,7 +306,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL setSpecializationArgs(
         ShaderOffset const& offset,
         const slang::SpecializationArg* args,
-        uint32_t count) override;
+        GfxCount count) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getCurrentVersion(
         ITransientResourceHeap* transientHeap, IShaderObject** outObject) override;
@@ -342,7 +342,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL setSpecializationArgs(
         ShaderOffset const& offset,
         const slang::SpecializationArg* args,
-        uint32_t count) override;
+        GfxCount count) override;
     void reset();
 };
 
@@ -358,21 +358,21 @@ public:
 public:
     virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
         IBufferResource* dst,
-        size_t dstOffset,
+        Offset dstOffset,
         IBufferResource* src,
-        size_t srcOffset,
-        size_t size);
+        Offset srcOffset,
+        Size size);
     virtual SLANG_NO_THROW void SLANG_MCALL
-        uploadBufferData(IBufferResource* dst, size_t offset, size_t size, void* data);
+        uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data);
     virtual SLANG_NO_THROW void SLANG_MCALL
-        writeTimestamp(IQueryPool* pool, SlangInt index);
+        writeTimestamp(IQueryPool* pool, GfxIndex index);
     virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
-        size_t count,
+        GfxCount count,
         ITextureResource* const* textures,
         ResourceState src,
         ResourceState dst);
     virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
-        size_t count,
+        GfxCount count,
         IBufferResource* const* buffers,
         ResourceState src,
         ResourceState dst);
@@ -385,14 +385,14 @@ public:
         ResourceState srcState,
         SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
-        ITextureResource::Size extent);
+        ITextureResource::Extents extent);
     virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
         ITextureResource* dst,
         SubresourceRange subResourceRange,
         ITextureResource::Offset3D offset,
-        ITextureResource::Size extent,
+        ITextureResource::Extents extent,
         ITextureResource::SubresourceData* subResourceData,
-        size_t subResourceDataCount);
+        GfxCount subResourceDataCount);
     virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
         IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags);
     virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
@@ -404,14 +404,14 @@ public:
         SubresourceRange destRange);
     virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
         IBufferResource* dst,
-        size_t dstOffset,
-        size_t dstSize,
-        size_t dstRowStride,
+        Offset dstOffset,
+        Size dstSize,
+        Size dstRowStride,
         ITextureResource* src,
         ResourceState srcState,
         SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
-        ITextureResource::Size extent);
+        ITextureResource::Extents extent);
     virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
         ITextureResource* texture,
         SubresourceRange subresourceRange,
@@ -419,10 +419,10 @@ public:
         ResourceState dst);
     virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
         IQueryPool* queryPool,
-        uint32_t index,
-        uint32_t count,
+        GfxIndex index,
+        GfxCount count,
         IBufferResource* buffer,
-        uint64_t offset);
+        Offset offset);
     virtual SLANG_NO_THROW void SLANG_MCALL beginDebugEvent(const char* name, float rgbColor[3]);
     virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent();
 };
@@ -445,7 +445,7 @@ public:
         bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
     virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        dispatchComputeIndirect(IBufferResource* cmdBuffer, uint64_t offset) override;
+        dispatchComputeIndirect(IBufferResource* cmdBuffer, Offset offset) override;
 
 public:
     DebugCommandBuffer* commandBuffer;
@@ -491,51 +491,51 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
         bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setViewports(uint32_t count, const Viewport* viewports) override;
+        setViewports(GfxCount count, const Viewport* viewports) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setScissorRects(uint32_t count, const ScissorRect* scissors) override;
+        setScissorRects(GfxCount count, const ScissorRect* scissors) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         setPrimitiveTopology(PrimitiveTopology topology) override;
     virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) override;
+        const Offset* offsets) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint32_t offset = 0) override;
+        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        draw(uint32_t vertexCount, uint32_t startVertex = 0) override;
+        draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        drawIndexed(uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) override;
+        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
-        uint32_t maxDrawCount,
+        GfxCount maxDrawCount,
         IBufferResource* argBuffer,
-        uint64_t argOffset,
+        Offset argOffset,
         IBufferResource* countBuffer,
-        uint64_t countOffset) override;
+        Offset countOffset) override;
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
-        uint32_t maxDrawCount,
+        GfxCount maxDrawCount,
         IBufferResource* argBuffer,
-        uint64_t argOffset,
+        Offset argOffset,
         IBufferResource* countBuffer,
-        uint64_t countOffset) override;
+        Offset countOffset) override;
     virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
-        uint32_t samplesPerPixel,
-        uint32_t pixelCount,
+        GfxCount samplesPerPixel,
+        GfxCount pixelCount,
         const SamplePosition* samplePositions) override;
     virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) override;
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) override;
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override;
 
 public:
     DebugCommandBuffer* commandBuffer;
@@ -556,16 +556,16 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
     virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
         const IAccelerationStructure::BuildDesc& desc,
-        int propertyQueryCount,
+        GfxCount propertyQueryCount,
         AccelerationStructureQueryDesc* queryDescs) override;
     virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
         IAccelerationStructure* dest,
         IAccelerationStructure* src,
         AccelerationStructureCopyMode mode) override;
     virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
-        int accelerationStructureCount,
+        GfxCount accelerationStructureCount,
         IAccelerationStructure* const* accelerationStructures,
-        int queryCount,
+        GfxCount queryCount,
         AccelerationStructureQueryDesc* queryDescs) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
         serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) override;
@@ -577,11 +577,11 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
         bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) override;
     virtual SLANG_NO_THROW void SLANG_MCALL dispatchRays(
-        uint32_t rayGenShaderIndex,
+        GfxIndex rayGenShaderIndex,
         IShaderTable* shaderTable,
-        int32_t width,
-        int32_t height,
-        int32_t depth) override;
+        GfxCount width,
+        GfxCount height,
+        GfxCount depth) override;
 
 public:
     DebugCommandBuffer* commandBuffer;
@@ -648,10 +648,10 @@ public:
     ICommandQueue* getInterface(const Slang::Guid& guid);
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        executeCommandBuffers(uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal) override;
+        executeCommandBuffers(GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal) override;
     virtual SLANG_NO_THROW void SLANG_MCALL waitOnHost() override;
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFenceValuesOnDevice(
-        uint32_t fenceCount, IFence** fences, uint64_t* waitValues) override;
+        GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) override;
 };
 
@@ -738,10 +738,10 @@ public:
     ISwapchain* getInterface(const Slang::Guid& guid);
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override;
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getImage(uint32_t index, ITextureResource** outResource) override;
+        getImage(GfxIndex index, ITextureResource** outResource) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL present() override;
     virtual SLANG_NO_THROW int SLANG_MCALL acquireNextImage() override;
-    virtual SLANG_NO_THROW Result SLANG_MCALL resize(uint32_t width, uint32_t height) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override;
     virtual SLANG_NO_THROW bool SLANG_MCALL isOccluded() override;
     virtual SLANG_NO_THROW Result SLANG_MCALL setFullScreenMode(bool mode) override;
 
diff --git a/tools/gfx/immediate-renderer-base.cpp b/tools/gfx/immediate-renderer-base.cpp
index d12837af6..11b09db29 100644
--- a/tools/gfx/immediate-renderer-base.cpp
+++ b/tools/gfx/immediate-renderer-base.cpp
@@ -78,20 +78,20 @@ public:
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL
-            writeTimestamp(IQueryPool* pool, SlangInt index) override
+            writeTimestamp(IQueryPool* pool, GfxIndex index) override
         {
             m_writer->writeTimestamp(pool, index);
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
-            size_t count,
+            GfxCount count,
             ITextureResource* const* textures,
             ResourceState src,
             ResourceState dst) override
         {}
 
         virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
-            size_t count,
+            GfxCount count,
             IBufferResource* const* buffers,
             ResourceState src,
             ResourceState dst) override
@@ -106,7 +106,7 @@ public:
             ResourceState srcState,
             SubresourceRange srcSubresource,
             ITextureResource::Offset3D srcOffset,
-            ITextureResource::Size extent) override
+            ITextureResource::Extents extent) override
         {
             SLANG_UNUSED(dst);
             SLANG_UNUSED(dstState);
@@ -124,9 +124,9 @@ public:
             ITextureResource* dst,
             SubresourceRange subResourceRange,
             ITextureResource::Offset3D offset,
-            ITextureResource::Size extend,
+            ITextureResource::Extents extend,
             ITextureResource::SubresourceData* subResourceData,
-            size_t subResourceDataCount) override
+            GfxCount subResourceDataCount) override
         {
             SLANG_UNUSED(dst);
             SLANG_UNUSED(subResourceRange);
@@ -167,10 +167,10 @@ public:
 
         virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
             IQueryPool* queryPool,
-            uint32_t index,
-            uint32_t count,
+            GfxIndex index,
+            GfxCount count,
             IBufferResource* buffer,
-            uint64_t offset) override
+            Offset offset) override
         {
             SLANG_UNUSED(queryPool);
             SLANG_UNUSED(index);
@@ -182,14 +182,14 @@ public:
 
         virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
             IBufferResource* dst,
-            size_t dstOffset,
-            size_t dstSize,
-            size_t dstRowStride,
+            Offset dstOffset,
+            Size dstSize,
+            Size dstRowStride,
             ITextureResource* src,
             ResourceState srcState,
             SubresourceRange srcSubresource,
             ITextureResource::Offset3D srcOffset,
-            ITextureResource::Size extent) override
+            ITextureResource::Extents extent) override
         {
             SLANG_UNUSED(dst);
             SLANG_UNUSED(dstOffset);
@@ -303,12 +303,12 @@ public:
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL
-            setViewports(uint32_t count, const Viewport* viewports) override
+            setViewports(GfxCount count, const Viewport* viewports) override
         {
             m_writer->setViewports(count, viewports);
         }
         virtual SLANG_NO_THROW void SLANG_MCALL
-            setScissorRects(uint32_t count, const ScissorRect* scissors) override
+            setScissorRects(GfxCount count, const ScissorRect* scissors) override
         {
             m_writer->setScissorRects(count, scissors);
         }
@@ -317,29 +317,29 @@ public:
             m_writer->setPrimitiveTopology(topology);
         }
         virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
-            uint32_t startSlot,
-            uint32_t slotCount,
+            GfxIndex startSlot,
+            GfxCount slotCount,
             IBufferResource* const* buffers,
-            const uint32_t* offsets) override
+            const Offset* offsets) override
         {
             m_writer->setVertexBuffers(startSlot, slotCount, buffers, offsets);
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL
-            setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint32_t offset) override
+            setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset) override
         {
             m_writer->setIndexBuffer(buffer, indexFormat, offset);
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL
-            draw(uint32_t vertexCount, uint32_t startVertex) override
+            draw(GfxCount vertexCount, GfxIndex startVertex) override
         {
             m_writer->bindRootShaderObject(m_commandBuffer->m_rootShaderObject);
             m_writer->draw(vertexCount, startVertex);
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL
-            drawIndexed(uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex) override
+            drawIndexed(GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) override
         {
             m_writer->bindRootShaderObject(m_commandBuffer->m_rootShaderObject);
             m_writer->drawIndexed(indexCount, startIndex, baseVertex);
@@ -351,11 +351,11 @@ public:
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
-            uint32_t maxDrawCount,
+            GfxCount maxDrawCount,
             IBufferResource* argBuffer,
-            uint64_t argOffset,
+            Offset argOffset,
             IBufferResource* countBuffer,
-            uint64_t countOffset) override
+            Offset countOffset) override
         {
             SLANG_UNUSED(maxDrawCount);
             SLANG_UNUSED(argBuffer);
@@ -366,11 +366,11 @@ public:
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
-            uint32_t maxDrawCount,
+            GfxCount maxDrawCount,
             IBufferResource* argBuffer,
-            uint64_t argOffset,
+            Offset argOffset,
             IBufferResource* countBuffer,
-            uint64_t countOffset) override
+            Offset countOffset) override
         {
             SLANG_UNUSED(maxDrawCount);
             SLANG_UNUSED(argBuffer);
@@ -381,8 +381,8 @@ public:
         }
 
         virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
-            uint32_t samplesPerPixel,
-            uint32_t pixelCount,
+            GfxCount samplesPerPixel,
+            GfxCount pixelCount,
             const SamplePosition* samplePositions) override
         {
             SLANG_UNUSED(samplesPerPixel);
@@ -392,21 +392,21 @@ public:
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
-            uint32_t vertexCount,
-            uint32_t instanceCount,
-            uint32_t startVertex,
-            uint32_t startInstanceLocation) override
+            GfxCount vertexCount,
+            GfxCount instanceCount,
+            GfxIndex startVertex,
+            GfxIndex startInstanceLocation) override
         {
             m_writer->bindRootShaderObject(m_commandBuffer->m_rootShaderObject);
             m_writer->drawInstanced(vertexCount, instanceCount, startVertex, startInstanceLocation);
         }
 
         virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
-            uint32_t indexCount,
-            uint32_t instanceCount,
-            uint32_t startIndexLocation,
-            int32_t baseVertexLocation,
-            uint32_t startInstanceLocation) override
+            GfxCount indexCount,
+            GfxCount instanceCount,
+            GfxIndex startIndexLocation,
+            GfxIndex baseVertexLocation,
+            GfxIndex startInstanceLocation) override
         {
             m_writer->bindRootShaderObject(m_commandBuffer->m_rootShaderObject);
             m_writer->drawIndexedInstanced(indexCount, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation);
@@ -466,7 +466,7 @@ public:
             m_writer->dispatchCompute(x, y, z);
         }
 
-        virtual SLANG_NO_THROW void SLANG_MCALL dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset) override
+        virtual SLANG_NO_THROW void SLANG_MCALL dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override
         {
             SLANG_UNIMPLEMENTED_X("ImmediateRenderBase::dispatchComputeIndirect");
         }
@@ -536,7 +536,7 @@ public:
                         cmd.operands[0],
                         cmd.operands[1],
                         bufferResources.getArrayView().getBuffer(),
-                        m_writer.getData<uint32_t>(cmd.operands[3]));
+                        m_writer.getData<Offset>(cmd.operands[3]));
                 }
                 break;
             case CommandName::SetIndexBuffer:
@@ -583,7 +583,7 @@ public:
                     cmd.operands[4]);
                 break;
             case CommandName::WriteTimestamp:
-                m_renderer->writeTimestamp(m_writer.getObject<QueryPoolBase>(cmd.operands[0]), (SlangInt)cmd.operands[1]);
+                m_renderer->writeTimestamp(m_writer.getObject<QueryPoolBase>(cmd.operands[0]), (GfxIndex)cmd.operands[1]);
                 break;
             default:
                 assert(!"unknown command");
@@ -619,18 +619,18 @@ public:
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override { return m_desc; }
 
     virtual SLANG_NO_THROW void SLANG_MCALL executeCommandBuffers(
-        uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal) override
+        GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal) override
     {
         // TODO: implement fence signal.
         assert(fence == nullptr);
 
         CommandBufferInfo info = {};
-        for (uint32_t i = 0; i < count; i++)
+        for (GfxIndex i = 0; i < count; i++)
         {
             info.hasWriteTimestamps |= static_cast<CommandBufferImpl*>(commandBuffers[i])->m_writer.m_hasWriteTimestamps;
         }
         static_cast<ImmediateRendererBase*>(m_renderer.get())->beginCommandBuffer(info);
-        for (uint32_t i = 0; i < count; i++)
+        for (GfxIndex i = 0; i < count; i++)
         {
             static_cast<CommandBufferImpl*>(commandBuffers[i])->execute();
         }
@@ -640,7 +640,7 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL waitOnHost() override { getRenderer()->waitForGpu(); }
 
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFenceValuesOnDevice(
-        uint32_t fenceCount, IFence** fences, uint64_t* waitValues) override
+        GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override
     {
         return SLANG_FAIL;
     }
diff --git a/tools/gfx/immediate-renderer-base.h b/tools/gfx/immediate-renderer-base.h
index f7530d985..894d00bf7 100644
--- a/tools/gfx/immediate-renderer-base.h
+++ b/tools/gfx/immediate-renderer-base.h
@@ -56,43 +56,43 @@ public:
     virtual void setPipelineState(IPipelineState* state) = 0;
     virtual void setFramebuffer(IFramebuffer* frameBuffer) = 0;
     virtual void clearFrame(uint32_t colorBufferMask, bool clearDepth, bool clearStencil) = 0;
-    virtual void setViewports(UInt count, const Viewport* viewports) = 0;
-    virtual void setScissorRects(UInt count, const ScissorRect* scissors) = 0;
+    virtual void setViewports(GfxCount count, const Viewport* viewports) = 0;
+    virtual void setScissorRects(GfxCount count, const ScissorRect* scissors) = 0;
     virtual void setPrimitiveTopology(PrimitiveTopology topology) = 0;
     virtual void setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) = 0;
+        const Offset* offsets) = 0;
     virtual void setIndexBuffer(
-        IBufferResource* buffer, Format indexFormat, uint32_t offset = 0) = 0;
-    virtual void draw(uint32_t vertexCount, uint32_t startVertex = 0) = 0;
+        IBufferResource* buffer, Format indexFormat, Offset offset = 0) = 0;
+    virtual void draw(GfxCount vertexCount, GfxIndex startVertex = 0) = 0;
     virtual void drawIndexed(
-        uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) = 0;
+        GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) = 0;
     virtual void drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) = 0;
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) = 0;
     virtual void drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) = 0;
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) = 0;
     virtual void setStencilReference(uint32_t referenceValue) = 0;
     virtual void dispatchCompute(int x, int y, int z) = 0;
     virtual void copyBuffer(
         IBufferResource* dst,
-        size_t dstOffset,
+        Offset dstOffset,
         IBufferResource* src,
-        size_t srcOffset,
-        size_t size) = 0;
+        Offset srcOffset,
+        Size size) = 0;
     virtual void submitGpuWork() = 0;
     virtual void waitForGpu() = 0;
     virtual void* map(IBufferResource* buffer, MapFlavor flavor) = 0;
     virtual void unmap(IBufferResource* buffer, size_t offsetWritten, size_t sizeWritten) = 0;
-    virtual void writeTimestamp(IQueryPool* pool, SlangInt index) = 0;
+    virtual void writeTimestamp(IQueryPool* pool, GfxIndex index) = 0;
     virtual void beginCommandBuffer(const CommandBufferInfo&) {}
     virtual void endCommandBuffer(const CommandBufferInfo&) {}
 
@@ -113,13 +113,13 @@ public:
 
     void uploadBufferData(
         IBufferResource* dst,
-        size_t offset,
-        size_t size, void* data);
+        Offset offset,
+        Size size, void* data);
 
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL readBufferResource(
         IBufferResource* buffer,
-        size_t offset,
-        size_t size,
+        Offset offset,
+        Size size,
         ISlangBlob** outBlob) override;
 };
 
@@ -134,12 +134,12 @@ public:
         SLANG_UNUSED(clearDepth);
         SLANG_UNUSED(clearStencil);
     }
-    virtual void setViewports(UInt count, const Viewport* viewports) override
+    virtual void setViewports(GfxCount count, const Viewport* viewports) override
     {
         SLANG_UNUSED(count);
         SLANG_UNUSED(viewports);
     }
-    virtual void setScissorRects(UInt count, const ScissorRect* scissors) override
+    virtual void setScissorRects(GfxCount count, const ScissorRect* scissors) override
     {
         SLANG_UNUSED(count);
         SLANG_UNUSED(scissors);
@@ -149,10 +149,10 @@ public:
         SLANG_UNUSED(topology);
     }
     virtual void setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) override
+        const Offset* offsets) override
     {
         SLANG_UNUSED(startSlot);
         SLANG_UNUSED(slotCount);
@@ -160,30 +160,30 @@ public:
         SLANG_UNUSED(offsets);
     }
     virtual void setIndexBuffer(
-        IBufferResource* buffer, Format indexFormat, uint32_t offset = 0)
+        IBufferResource* buffer, Format indexFormat, Offset offset = 0)
         override
     {
         SLANG_UNUSED(buffer);
         SLANG_UNUSED(indexFormat);
         SLANG_UNUSED(offset);
     }
-    virtual void draw(uint32_t vertexCount, uint32_t startVertex = 0) override
+    virtual void draw(GfxCount vertexCount, GfxIndex startVertex = 0) override
     {
         SLANG_UNUSED(vertexCount);
         SLANG_UNUSED(startVertex);
     }
     virtual void drawIndexed(
-        uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) override
+        GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override
     {
         SLANG_UNUSED(indexCount);
         SLANG_UNUSED(startIndex);
         SLANG_UNUSED(baseVertex);
     }
     virtual void drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) override
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override
     {
         SLANG_UNUSED(vertexCount);
         SLANG_UNUSED(instanceCount);
@@ -192,11 +192,11 @@ public:
     }
 
     virtual void drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) override
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override
     {
         SLANG_UNUSED(indexCount);
         SLANG_UNUSED(instanceCount);
@@ -263,8 +263,8 @@ public:
         ITextureResource* texture,
         ResourceState state,
         ISlangBlob** outBlob,
-        size_t* outRowPitch,
-        size_t* outPixelSize) override
+        Size* outRowPitch,
+        Size* outPixelSize) override
     {
         SLANG_UNUSED(texture);
         SLANG_UNUSED(outBlob);
diff --git a/tools/gfx/mutable-shader-object.h b/tools/gfx/mutable-shader-object.h
index a9562f200..9653986ad 100644
--- a/tools/gfx/mutable-shader-object.h
+++ b/tools/gfx/mutable-shader-object.h
@@ -276,20 +276,20 @@ namespace gfx
             return ShaderObjectContainerType::None;
         }
 
-        virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override
+        virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override
         {
-            return (UInt)m_entryPoints.getCount();
+            return (GfxCount)m_entryPoints.getCount();
         }
 
         virtual SLANG_NO_THROW Result SLANG_MCALL
-            getEntryPoint(UInt index, IShaderObject** entryPoint) override
+            getEntryPoint(GfxIndex index, IShaderObject** entryPoint) override
         {
             returnComPtr(entryPoint, m_entryPoints[index]);
             return SLANG_OK;
         }
 
         virtual SLANG_NO_THROW Result SLANG_MCALL
-            setData(ShaderOffset const& offset, void const* data, size_t size) override
+            setData(ShaderOffset const& offset, void const* data, Size size) override
         {
             auto newSize = Slang::Index(size + offset.uniformOffset);
             if (newSize > m_data.getCount())
@@ -342,7 +342,7 @@ namespace gfx
         virtual SLANG_NO_THROW Result SLANG_MCALL setSpecializationArgs(
             ShaderOffset const& offset,
             const slang::SpecializationArg* args,
-            uint32_t count) override
+            GfxCount count) override
         {
             Slang::List<slang::SpecializationArg> specArgs;
             specArgs.addRange(args, count);
@@ -368,9 +368,9 @@ namespace gfx
             return m_data.begin();
         }
 
-        virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override
+        virtual SLANG_NO_THROW Size SLANG_MCALL getSize() override
         {
-            return (size_t)m_data.getCount();
+            return (Size)m_data.getCount();
         }
 
         virtual SLANG_NO_THROW Result SLANG_MCALL
diff --git a/tools/gfx/open-gl/render-gl.cpp b/tools/gfx/open-gl/render-gl.cpp
index 934510fb2..8c596cebb 100644
--- a/tools/gfx/open-gl/render-gl.cpp
+++ b/tools/gfx/open-gl/render-gl.cpp
@@ -170,33 +170,33 @@ public:
     virtual void setPrimitiveTopology(PrimitiveTopology topology) override;
 
     virtual void setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) override;
+        const Offset* offsets) override;
     virtual void setIndexBuffer(
-        IBufferResource* buffer, Format indexFormat, uint32_t offset) override;
-    virtual void setViewports(UInt count, Viewport const* viewports) override;
-    virtual void setScissorRects(UInt count, ScissorRect const* rects) override;
+        IBufferResource* buffer, Format indexFormat, Offset offset) override;
+    virtual void setViewports(GfxCount count, Viewport const* viewports) override;
+    virtual void setScissorRects(GfxCount count, ScissorRect const* rects) override;
     virtual void setPipelineState(IPipelineState* state) override;
-    virtual void draw(uint32_t vertexCount, uint32_t startVertex) override;
+    virtual void draw(GfxCount vertexCount, GfxCount startVertex) override;
     virtual void drawIndexed(
-        uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex) override;
+        GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex) override;
     virtual void drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) override;
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override;
     virtual void drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) override;
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override;
     virtual void dispatchCompute(int x, int y, int z) override;
     virtual void submitGpuWork() override {}
     virtual void waitForGpu() override {}
-    virtual void writeTimestamp(IQueryPool* pool, SlangInt index) override
+    virtual void writeTimestamp(IQueryPool* pool, GfxIndex index) override
     {
         SLANG_UNUSED(pool);
         SLANG_UNUSED(index);
@@ -496,7 +496,7 @@ public:
                     GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_backBuffer, 0);
 
                 m_images.clear();
-                for (uint32_t i = 0; i < m_desc.imageCount; i++)
+                for (GfxIndex i = 0; i < m_desc.imageCount; i++)
                 {
                     ITextureResource::Desc imageDesc = {};
                     imageDesc.allowedStates = ResourceStateSet(
@@ -535,7 +535,7 @@ public:
         }
         virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override { return m_desc; }
         virtual SLANG_NO_THROW Result SLANG_MCALL
-            getImage(uint32_t index, ITextureResource** outResource) override
+            getImage(GfxIndex index, ITextureResource** outResource) override
         {
             returnComPtr(outResource, m_images[index]);
             return SLANG_OK;
@@ -570,7 +570,7 @@ public:
             return -1;
         }
 
-        virtual SLANG_NO_THROW Result SLANG_MCALL resize(uint32_t width, uint32_t height) override
+        virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override
         {
             if (width > 0 && height > 0 && (width != m_desc.width || height != m_desc.height))
             {
@@ -983,9 +983,9 @@ public:
 
         RendererBase* getDevice() { return m_layout->getDevice(); }
 
-        SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; }
+        SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; }
 
-        SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+        SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
             SLANG_OVERRIDE
         {
             *outEntryPoint = nullptr;
@@ -1450,8 +1450,8 @@ public:
 
         RootShaderObjectLayoutImpl* getLayout() { return static_cast<RootShaderObjectLayoutImpl*>(m_layout.Ptr()); }
 
-        UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (UInt)m_entryPoints.getCount(); }
-        SlangResult SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint) SLANG_OVERRIDE
+        GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (GfxCount)m_entryPoints.getCount(); }
+        SlangResult SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) SLANG_OVERRIDE
         {
             *outEntryPoint = m_entryPoints[index];
             m_entryPoints[index]->addRef();
@@ -2175,7 +2175,7 @@ SLANG_NO_THROW Result SLANG_MCALL GLDevice::createFramebufferLayout(
 {
     RefPtr<FramebufferLayoutImpl> layout = new FramebufferLayoutImpl();
     layout->m_renderTargets.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         layout->m_renderTargets[i] = desc.renderTargets[i];
     }
@@ -2198,7 +2198,7 @@ SLANG_NO_THROW Result SLANG_MCALL
 {
     RefPtr<FramebufferImpl> framebuffer = new FramebufferImpl(m_weakRenderer);
     framebuffer->renderTargetViews.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
     {
         framebuffer->renderTargetViews[i] =
             static_cast<TextureViewImpl*>(desc.renderTargetViews[i]);
@@ -2222,10 +2222,10 @@ void GLDevice::setStencilReference(uint32_t referenceValue)
 
 void GLDevice::copyBuffer(
     IBufferResource* dst,
-    size_t dstOffset,
+    Offset dstOffset,
     IBufferResource* src,
-    size_t srcOffset,
-    size_t size)
+    Offset srcOffset,
+    Size size)
 {
     auto dstImpl = static_cast<BufferResourceImpl*>(dst);
     auto srcImpl = static_cast<BufferResourceImpl*>(src);
@@ -2235,7 +2235,7 @@ void GLDevice::copyBuffer(
 }
 
 SLANG_NO_THROW Result SLANG_MCALL GLDevice::readTextureResource(
-    ITextureResource* texture, ResourceState state, ISlangBlob** outBlob, size_t* outRowPitch, size_t* outPixelSize)
+    ITextureResource* texture, ResourceState state, ISlangBlob** outBlob, Size* outRowPitch, Size* outPixelSize)
 {
     SLANG_UNUSED(state);
     auto resource = static_cast<TextureResourceImpl*>(texture);
@@ -2652,10 +2652,10 @@ void GLDevice::setPrimitiveTopology(PrimitiveTopology topology)
 }
 
 void GLDevice::setVertexBuffers(
-    uint32_t startSlot,
-    uint32_t slotCount,
+    GfxIndex startSlot,
+    GfxCount slotCount,
     IBufferResource* const* buffers,
-    const uint32_t* offsets)
+    const Offset* offsets)
 {
     for (UInt ii = 0; ii < slotCount; ++ii)
     {
@@ -2669,7 +2669,7 @@ void GLDevice::setVertexBuffers(
     }
 }
 
-void GLDevice::setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint32_t offset)
+void GLDevice::setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset)
 {
     auto bufferImpl = static_cast<BufferResourceImpl*>(buffer);
     m_boundIndexBuffer = bufferImpl->m_handle;
@@ -2677,7 +2677,7 @@ void GLDevice::setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint3
     m_boundIndexBufferSize = bufferImpl->m_size;
 }
 
-void GLDevice::setViewports(UInt count, Viewport const* viewports)
+void GLDevice::setViewports(GfxCount count, Viewport const* viewports)
 {
     assert(count == 1);
     auto viewport = viewports[0];
@@ -2689,7 +2689,7 @@ void GLDevice::setViewports(UInt count, Viewport const* viewports)
     glDepthRange(viewport.minZ, viewport.maxZ);
 }
 
-void GLDevice::setScissorRects(UInt count, ScissorRect const* rects)
+void GLDevice::setScissorRects(GfxCount count, ScissorRect const* rects)
 {
     assert(count <= 1);
     if( count )
@@ -2728,14 +2728,14 @@ void GLDevice::setPipelineState(IPipelineState* state)
     glUseProgram(programID);
 }
 
-void GLDevice::draw(uint32_t vertexCount, uint32_t startVertex = 0)
+void GLDevice::draw(GfxCount vertexCount, GfxIndex startVertex = 0)
 {
     flushStateForDraw();
 
     glDrawArrays(m_boundPrimitiveTopology, (GLint)startVertex, (GLsizei)vertexCount);
 }
 
-void GLDevice::drawIndexed(uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex)
+void GLDevice::drawIndexed(GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
 {
     flushStateForDraw();
 
@@ -2748,20 +2748,20 @@ void GLDevice::drawIndexed(uint32_t indexCount, uint32_t startIndex, uint32_t ba
 }
 
 void GLDevice::drawInstanced(
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t startVertex,
-    uint32_t startInstanceLocation)
+    GfxCount vertexCount,
+    GfxCount instanceCount,
+    GfxIndex startVertex,
+    GfxIndex startInstanceLocation)
 {
     SLANG_UNIMPLEMENTED_X("drawInstanced");
 }
 
 void GLDevice::drawIndexedInstanced(
-    uint32_t indexCount,
-    uint32_t instanceCount,
-    uint32_t startIndexLocation,
-    int32_t baseVertexLocation,
-    uint32_t startInstanceLocation)
+    GfxCount indexCount,
+    GfxCount instanceCount,
+    GfxIndex startIndexLocation,
+    GfxIndex baseVertexLocation,
+    GfxIndex startInstanceLocation)
 {
     SLANG_UNIMPLEMENTED_X("drawIndexedInstanced");
 }
diff --git a/tools/gfx/render.cpp b/tools/gfx/render.cpp
index 80c662597..4d6e1bb85 100644
--- a/tools/gfx/render.cpp
+++ b/tools/gfx/render.cpp
@@ -35,7 +35,7 @@ static bool _checkFormat()
 #define GFX_FORMAT_CHECK(name, blockSizeInBytes, pixelsPerblock) count += Index(Index(Format::name) == value++);
     GFX_FORMAT(GFX_FORMAT_CHECK)
 
-    const bool r = (count == Index(Format::CountOf));
+    const bool r = (count == Index(Format::_Count));
     SLANG_ASSERT(r);
     return r;
 }
@@ -168,14 +168,14 @@ struct FormatInfoMap
 
     const FormatInfo& get(Format format) const { return m_infos[Index(format)]; }
 
-    FormatInfo m_infos[Index(Format::CountOf)];
+    FormatInfo m_infos[Index(Format::_Count)];
 };
 
 static const FormatInfoMap s_formatInfoMap;
 
 static void _compileTimeAsserts()
 {
-    SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_formatSizeInfo) == int(Format::CountOf));
+    SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_formatSizeInfo) == int(Format::_Count));
 }
 
 extern "C"
diff --git a/tools/gfx/renderer-shared.cpp b/tools/gfx/renderer-shared.cpp
index 33e34ddb8..dd949efd4 100644
--- a/tools/gfx/renderer-shared.cpp
+++ b/tools/gfx/renderer-shared.cpp
@@ -343,7 +343,7 @@ SLANG_NO_THROW Result SLANG_MCALL RendererBase::getNativeDeviceHandles(InteropHa
 }
 
 SLANG_NO_THROW Result SLANG_MCALL RendererBase::getFeatures(
-    const char** outFeatures, UInt bufferSize, UInt* outFeatureCount)
+    const char** outFeatures, Size bufferSize, GfxCount* outFeatureCount)
 {
     if (bufferSize >= (UInt)m_features.getCount())
     {
@@ -353,7 +353,7 @@ SLANG_NO_THROW Result SLANG_MCALL RendererBase::getFeatures(
         }
     }
     if (outFeatureCount)
-        *outFeatureCount = (UInt)m_features.getCount();
+        *outFeatureCount = (GfxCount)m_features.getCount();
     return SLANG_OK;
 }
 
@@ -524,7 +524,7 @@ Result RendererBase::createFence(const IFence::Desc& desc, IFence** outFence)
 }
 
 Result RendererBase::waitForFences(
-    uint32_t fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
+    GfxCount fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
 {
     SLANG_UNUSED(fenceCount);
     SLANG_UNUSED(fences);
@@ -781,7 +781,7 @@ void ShaderProgramBase::init(const IShaderProgram::Desc& inDesc)
     desc = inDesc;
 
     slangGlobalScope = desc.slangGlobalScope;
-    for (uint32_t i = 0; i < desc.entryPointCount; i++)
+    for (GfxIndex i = 0; i < desc.entryPointCount; i++)
     {
         slangEntryPoints.add(ComPtr<slang::IComponentType>(desc.slangEntryPoints[i]));
     }
@@ -794,7 +794,7 @@ void ShaderProgramBase::init(const IShaderProgram::Desc& inDesc)
         {
             components.add(desc.slangGlobalScope);
         }
-        for (uint32_t i = 0; i < desc.entryPointCount; i++)
+        for (GfxIndex i = 0; i < desc.entryPointCount; i++)
         {
             if (!session)
             {
@@ -807,7 +807,7 @@ void ShaderProgramBase::init(const IShaderProgram::Desc& inDesc)
     }
     else
     {
-        for (uint32_t i = 0; i < desc.entryPointCount; i++)
+        for (GfxIndex i = 0; i < desc.entryPointCount; i++)
         {
             if (desc.slangGlobalScope)
             {
@@ -1044,7 +1044,7 @@ Result ShaderTableBase::init(const IShaderTable::Desc& desc)
     m_hitGroupCount = desc.hitGroupCount;
     m_shaderGroupNames.reserve(desc.hitGroupCount + desc.missShaderCount + desc.rayGenShaderCount);
     m_recordOverwrites.reserve(desc.hitGroupCount + desc.missShaderCount + desc.rayGenShaderCount);
-    for (uint32_t i = 0; i < desc.rayGenShaderCount; i++)
+    for (GfxIndex i = 0; i < desc.rayGenShaderCount; i++)
     {
         m_shaderGroupNames.add(desc.rayGenShaderEntryPointNames[i]);
         if (desc.rayGenShaderRecordOverwrites)
@@ -1056,7 +1056,7 @@ Result ShaderTableBase::init(const IShaderTable::Desc& desc)
             m_recordOverwrites.add(ShaderRecordOverwrite{});
         }
     }
-    for (uint32_t i = 0; i < desc.missShaderCount; i++)
+    for (GfxIndex i = 0; i < desc.missShaderCount; i++)
     {
         m_shaderGroupNames.add(desc.missShaderEntryPointNames[i]);
         if (desc.missShaderRecordOverwrites)
@@ -1068,7 +1068,7 @@ Result ShaderTableBase::init(const IShaderTable::Desc& desc)
             m_recordOverwrites.add(ShaderRecordOverwrite{});
         }
     }
-    for (uint32_t i = 0; i < desc.hitGroupCount; i++)
+    for (GfxIndex i = 0; i < desc.hitGroupCount; i++)
     {
         m_shaderGroupNames.add(desc.hitGroupNames[i]);
         if (desc.hitGroupRecordOverwrites)
diff --git a/tools/gfx/renderer-shared.h b/tools/gfx/renderer-shared.h
index 53557caf7..f4ca259e7 100644
--- a/tools/gfx/renderer-shared.h
+++ b/tools/gfx/renderer-shared.h
@@ -520,9 +520,9 @@ public:
         ShaderOffset offset);
 
 public:
-    SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; }
+    SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; }
 
-    SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+    SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
         SLANG_OVERRIDE
     {
         *outEntryPoint = nullptr;
@@ -774,7 +774,7 @@ public:
     virtual SLANG_NO_THROW Result SLANG_MCALL setSpecializationArgs(
         ShaderOffset const& offset,
         const slang::SpecializationArg* args,
-        uint32_t count) override
+        GfxCount count) override
     {
         auto layout = getLayout();
 
@@ -939,8 +939,8 @@ struct OwnedRayTracingPipelineStateDesc
     Slang::List<OwnedHitGroupDesc> hitGroups;
     Slang::List<HitGroupDesc> hitGroupDescs;
     int maxRecursion = 0;
-    int maxRayPayloadSize = 0;
-    int maxAttributeSizeInBytes = 8;
+    Size maxRayPayloadSize = 0;
+    Size maxAttributeSizeInBytes = 8;
     RayTracingPipelineFlags::Enum flags = RayTracingPipelineFlags::None;
 
     RayTracingPipelineStateDesc get()
@@ -1208,7 +1208,7 @@ public:
 
     virtual SLANG_NO_THROW Result SLANG_MCALL getNativeDeviceHandles(InteropHandles* outHandles) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW Result SLANG_MCALL getFeatures(
-        const char** outFeatures, UInt bufferSize, UInt* outFeatureCount) SLANG_OVERRIDE;
+        const char** outFeatures, Size bufferSize, GfxCount* outFeatureCount) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* featureName) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW Result SLANG_MCALL
         getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates) override;
@@ -1284,7 +1284,7 @@ public:
 
     // Provides a default implementation that returns SLANG_E_NOT_AVAILABLE.
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        waitForFences(uint32_t fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout) override;
+        waitForFences(GfxCount fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout) override;
 
     // Provides a default implementation that returns SLANG_E_NOT_AVAILABLE.
     virtual SLANG_NO_THROW Result SLANG_MCALL getTextureAllocationInfo(
diff --git a/tools/gfx/resource-desc-utils.h b/tools/gfx/resource-desc-utils.h
index 09d909bdb..25dcc43b6 100644
--- a/tools/gfx/resource-desc-utils.h
+++ b/tools/gfx/resource-desc-utils.h
@@ -12,9 +12,9 @@ inline int calcMipSize(int size, int level)
     return size > 0 ? size : 1;
 }
 
-inline ITextureResource::Size calcMipSize(ITextureResource::Size size, int mipLevel)
+inline ITextureResource::Extents calcMipSize(ITextureResource::Extents size, int mipLevel)
 {
-    ITextureResource::Size rs;
+    ITextureResource::Extents rs;
     rs.width = calcMipSize(size.width, mipLevel);
     rs.height = calcMipSize(size.height, mipLevel);
     rs.depth = calcMipSize(size.depth, mipLevel);
@@ -45,7 +45,7 @@ inline int calcEffectiveArraySize(const ITextureResource::Desc& desc)
 }
 
 /// Given the type works out the maximum dimension size
-inline int calcMaxDimension(ITextureResource::Size size, IResource::Type type)
+inline int calcMaxDimension(ITextureResource::Extents size, IResource::Type type)
 {
     switch (type)
     {
@@ -64,7 +64,7 @@ inline int calcMaxDimension(ITextureResource::Size size, IResource::Type type)
 }
 
 /// Given the type, calculates the number of mip maps. 0 on error
-inline int calcNumMipLevels(IResource::Type type, ITextureResource::Size size)
+inline int calcNumMipLevels(IResource::Type type, ITextureResource::Extents size)
 {
     const int maxDimensionSize = calcMaxDimension(size, type);
     return (maxDimensionSize > 0) ? (Slang::Math::Log2Floor(maxDimensionSize) + 1) : 0;
diff --git a/tools/gfx/simple-render-pass-layout.cpp b/tools/gfx/simple-render-pass-layout.cpp
index 8821df87c..1c937e708 100644
--- a/tools/gfx/simple-render-pass-layout.cpp
+++ b/tools/gfx/simple-render-pass-layout.cpp
@@ -15,7 +15,7 @@ IRenderPassLayout* SimpleRenderPassLayout::getInterface(const Slang::Guid& guid)
 void SimpleRenderPassLayout::init(const IRenderPassLayout::Desc& desc)
 {
     m_renderTargetAccesses.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; i++)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; i++)
         m_renderTargetAccesses[i] = desc.renderTargetAccess[i];
     m_hasDepthStencil = (desc.depthStencilAccess != nullptr);
     if (m_hasDepthStencil)
diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp
index 6d8e9464c..ccf76dd88 100644
--- a/tools/gfx/vulkan/render-vk.cpp
+++ b/tools/gfx/vulkan/render-vk.cpp
@@ -1251,7 +1251,7 @@ SlangResult DeviceImpl::readTextureResource(
     Size pixelSize = sizeInfo.blockSizeInBytes / sizeInfo.pixelsPerBlock;
     Size rowPitch = width * pixelSize;
 
-    List<TextureResource::Size> mipSizes;
+    List<TextureResource::Extents> mipSizes;
 
     const int numMipMaps = desc->numMipLevels;
     auto arraySize = calcEffectiveArraySize(*desc);
@@ -1261,7 +1261,7 @@ SlangResult DeviceImpl::readTextureResource(
     // Calculate how large an array entry is
     for (int j = 0; j < numMipMaps; ++j)
     {
-        const TextureResource::Size mipSize = calcMipSize(desc->size, j);
+        const TextureResource::Extents mipSize = calcMipSize(desc->size, j);
 
         auto rowSizeInBytes = calcRowSize(desc->format, mipSize.width);
         auto numRows = calcNumRows(desc->format, mipSize.height);
@@ -1389,9 +1389,9 @@ Result DeviceImpl::getAccelerationStructurePrebuildInfo(
         &geomInfoBuilder.buildInfo,
         geomInfoBuilder.primitiveCounts.getBuffer(),
         &sizeInfo);
-    outPrebuildInfo->resultDataMaxSize = sizeInfo.accelerationStructureSize;
-    outPrebuildInfo->scratchDataSize = sizeInfo.buildScratchSize;
-    outPrebuildInfo->updateScratchDataSize = sizeInfo.updateScratchSize;
+    outPrebuildInfo->resultDataMaxSize = (Size)sizeInfo.accelerationStructureSize;
+    outPrebuildInfo->scratchDataSize = (Size)sizeInfo.buildScratchSize;
+    outPrebuildInfo->updateScratchDataSize = (Size)sizeInfo.updateScratchSize;
     return SLANG_OK;
 }
 
@@ -1709,7 +1709,7 @@ Result DeviceImpl::createTextureResource(
     VKBufferHandleRAII uploadBuffer;
     if (initData)
     {
-        List<TextureResource::Size> mipSizes;
+        List<TextureResource::Extents> mipSizes;
 
         VkCommandBuffer commandBuffer = m_deviceQueue.getCommandBuffer();
 
@@ -1720,7 +1720,7 @@ Result DeviceImpl::createTextureResource(
         // Calculate how large an array entry is
         for (int j = 0; j < numMipMaps; ++j)
         {
-            const TextureResource::Size mipSize = calcMipSize(desc.size, j);
+            const TextureResource::Extents mipSize = calcMipSize(desc.size, j);
 
             auto rowSizeInBytes = calcRowSize(desc.format, mipSize.width);
             auto numRows = calcNumRows(desc.format, mipSize.height);
@@ -2324,7 +2324,7 @@ Result DeviceImpl::createInputLayout(IInputLayout::Desc const& desc, IInputLayou
     {
         auto& dstStream = dstStreams[i];
         auto& srcStream = srcVertexStreams[i];
-        dstStream.stride = srcStream.stride;
+        dstStream.stride = (uint32_t)srcStream.stride;
         dstStream.binding = (uint32_t)i;
         dstStream.inputRate = (srcStream.slotClass == InputSlotClass::PerInstance)
                                   ? VK_VERTEX_INPUT_RATE_INSTANCE
@@ -2473,10 +2473,10 @@ Result DeviceImpl::createFence(const IFence::Desc& desc, IFence** outFence)
 }
 
 Result DeviceImpl::waitForFences(
-    uint32_t fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
+    GfxCount fenceCount, IFence** fences, uint64_t* fenceValues, bool waitForAll, uint64_t timeout)
 {
     ShortList<VkSemaphore> semaphores;
-    for (uint32_t i = 0; i < fenceCount; ++i)
+    for (GfxIndex i = 0; i < fenceCount; ++i)
     {
         auto fenceImpl = static_cast<FenceImpl*>(fences[i]);
         semaphores.add(fenceImpl->m_semaphore);
@@ -3007,7 +3007,7 @@ Result FramebufferLayoutImpl::init(DeviceImpl* renderer, const IFramebufferLayou
     }
     // We need extra space if we have depth buffer
     m_attachmentDescs.setCount(numAttachments);
-    for (uint32_t i = 0; i < desc.renderTargetCount; ++i)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; ++i)
     {
         auto& renderTarget = desc.renderTargets[i];
         VkAttachmentDescription& dst = m_attachmentDescs[i];
@@ -3051,7 +3051,7 @@ Result FramebufferLayoutImpl::init(DeviceImpl* renderer, const IFramebufferLayou
 
     Array<VkAttachmentReference, kMaxRenderTargets>& colorReferences = m_colorReferences;
     colorReferences.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; ++i)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; ++i)
     {
         VkAttachmentReference& dst = colorReferences[i];
         dst.attachment = i;
@@ -3108,7 +3108,7 @@ Result RenderPassLayoutImpl::init(DeviceImpl* renderer, const IRenderPassLayout:
     // We need extra space if we have depth buffer
     Array<VkAttachmentDescription, kMaxAttachments> attachmentDescs;
     attachmentDescs = framebufferLayout->m_attachmentDescs;
-    for (uint32_t i = 0; i < desc.renderTargetCount; ++i)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; ++i)
     {
         VkAttachmentDescription& dst = attachmentDescs[i];
         auto access = desc.renderTargetAccess[i];
@@ -3207,7 +3207,7 @@ Result FramebufferImpl::init(DeviceImpl* renderer, const IFramebuffer::Desc& des
     Array<VkImageView, kMaxAttachments> imageViews;
     imageViews.setCount(numAttachments);
     renderTargetViews.setCount(desc.renderTargetCount);
-    for (uint32_t i = 0; i < desc.renderTargetCount; ++i)
+    for (GfxIndex i = 0; i < desc.renderTargetCount; ++i)
     {
         auto resourceView = static_cast<TextureResourceViewImpl*>(desc.renderTargetViews[i]);
         renderTargetViews[i] = resourceView;
@@ -4736,9 +4736,9 @@ Result ShaderObjectImpl::create(
 
 RendererBase* ShaderObjectImpl::getDevice() { return m_layout->getDevice(); }
 
-UInt ShaderObjectImpl::getEntryPointCount() { return 0; }
+GfxCount ShaderObjectImpl::getEntryPointCount() { return 0; }
 
-Result ShaderObjectImpl::getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+Result ShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
 {
     *outEntryPoint = nullptr;
     return SLANG_OK;
@@ -4746,8 +4746,7 @@ Result ShaderObjectImpl::getEntryPoint(UInt index, IShaderObject** outEntryPoint
 
 const void* ShaderObjectImpl::getRawData() { return m_data.getBuffer(); }
 
-// TODO: Change size_t to Count?
-size_t ShaderObjectImpl::getSize() { return (size_t)m_data.getCount(); }
+Size ShaderObjectImpl::getSize() { return (Size)m_data.getCount(); }
 
 // TODO: Change size_t and Index to Size?
 Result ShaderObjectImpl::setData(ShaderOffset const& inOffset, void const* data, size_t inSize)
@@ -5792,9 +5791,9 @@ List<RefPtr<EntryPointShaderObject>> const& RootShaderObjectImpl::getEntryPoints
     return m_entryPoints;
 }
 
-UInt RootShaderObjectImpl::getEntryPointCount() { return (UInt)m_entryPoints.getCount(); }
+GfxCount RootShaderObjectImpl::getEntryPointCount() { return (GfxCount)m_entryPoints.getCount(); }
 
-Result RootShaderObjectImpl::getEntryPoint(UInt index, IShaderObject** outEntryPoint)
+Result RootShaderObjectImpl::getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint)
 {
     returnComPtr(outEntryPoint, m_entryPoints[index]);
     return SLANG_OK;
@@ -6468,13 +6467,12 @@ void ResourceCommandEncoder::uploadBufferData(
         data);
 }
 
-// TODO: Change size_t to Count?
 void ResourceCommandEncoder::textureBarrier(
-    size_t count, ITextureResource* const* textures, ResourceState src, ResourceState dst)
+    GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst)
 {
     ShortList<VkImageMemoryBarrier, 16> barriers;
 
-    for (size_t i = 0; i < count; i++)
+    for (GfxIndex i = 0; i < count; i++)
     {
         auto image = static_cast<TextureResourceImpl*>(textures[i]);
         auto desc = image->getDesc();
@@ -6513,12 +6511,12 @@ void ResourceCommandEncoder::textureBarrier(
 
 // TODO: Change size_t to Count?
 void ResourceCommandEncoder::bufferBarrier(
-    size_t count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)
+    GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst)
 {
     List<VkBufferMemoryBarrier> barriers;
     barriers.reserve(count);
 
-    for (size_t i = 0; i < count; i++)
+    for (GfxIndex i = 0; i < count; i++)
     {
         auto bufferImpl = static_cast<BufferResourceImpl*>(buffers[i]);
 
@@ -6571,7 +6569,7 @@ void ResourceCommandEncoder::endEncoding()
         nullptr);
 }
 
-void ResourceCommandEncoder::writeTimestamp(IQueryPool* queryPool, SlangInt index)
+void ResourceCommandEncoder::writeTimestamp(IQueryPool* queryPool, GfxIndex index)
 {
     _writeTimestamp(
         &m_commandBuffer->m_renderer->m_api, m_commandBuffer->m_commandBuffer, queryPool, index);
@@ -6599,7 +6597,7 @@ void ResourceCommandEncoder::copyTexture(
     ResourceState srcState,
     SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
-    ITextureResource::Size extent)
+    ITextureResource::Extents extent)
 {
     auto srcImage = static_cast<TextureResourceImpl*>(src);
     auto srcDesc = srcImage->getDesc();
@@ -6647,31 +6645,30 @@ void ResourceCommandEncoder::copyTexture(
         &region);
 }
 
-// TODO: Change size_t to Count?
 void ResourceCommandEncoder::uploadTextureData(
     ITextureResource* dst,
     SubresourceRange subResourceRange,
     ITextureResource::Offset3D offset,
-    ITextureResource::Size extend,
+    ITextureResource::Extents extend,
     ITextureResource::SubresourceData* subResourceData,
-    size_t subResourceDataCount)
+    GfxCount subResourceDataCount)
 {
     // VALIDATION: dst must be in TransferDst state.
 
     auto& vkApi = m_commandBuffer->m_renderer->m_api;
     auto dstImpl = static_cast<TextureResourceImpl*>(dst);
-    List<TextureResource::Size> mipSizes;
+    List<TextureResource::Extents> mipSizes;
 
     VkCommandBuffer commandBuffer = m_commandBuffer->m_commandBuffer;
     auto& desc = *dstImpl->getDesc();
     // Calculate how large the buffer has to be
     Size bufferSize = 0;
     // Calculate how large an array entry is
-    for (uint32_t j = subResourceRange.mipLevel;
+    for (GfxIndex j = subResourceRange.mipLevel;
          j < subResourceRange.mipLevel + subResourceRange.mipLevelCount;
          ++j)
     {
-        const TextureResource::Size mipSize = calcMipSize(desc.size, j);
+        const TextureResource::Extents mipSize = calcMipSize(desc.size, j);
 
         auto rowSizeInBytes = calcRowSize(desc.format, mipSize.width);
         auto numRows = calcNumRows(desc.format, mipSize.height);
@@ -6700,9 +6697,9 @@ void ResourceCommandEncoder::uploadTextureData(
         dstDataStart = dstData;
 
         Offset dstSubresourceOffset = 0;
-        for (uint32_t i = 0; i < subResourceRange.layerCount; ++i)
+        for (GfxIndex i = 0; i < subResourceRange.layerCount; ++i)
         {
-            for (Index j = 0; j < mipSizes.getCount(); ++j)
+            for (GfxIndex j = 0; j < (GfxCount)mipSizes.getCount(); ++j)
             {
                 const auto& mipSize = mipSizes[j];
 
@@ -6743,9 +6740,9 @@ void ResourceCommandEncoder::uploadTextureData(
     }
     {
         Offset srcOffset = uploadBufferOffset;
-        for (uint32_t i = 0; i < subResourceRange.layerCount; ++i)
+        for (GfxIndex i = 0; i < subResourceRange.layerCount; ++i)
         {
-            for (Index j = 0; j < mipSizes.getCount(); ++j)
+            for (GfxIndex j = 0; j < (GfxCount)mipSizes.getCount(); ++j)
             {
                 const auto& mipSize = mipSizes[j];
 
@@ -7010,9 +7007,9 @@ void ResourceCommandEncoder::resolveResource(
     auto srcImageLayout = VulkanUtil::getImageLayoutFromState(sourceState);
     auto dstImageLayout = VulkanUtil::getImageLayoutFromState(destState);
 
-    for (uint32_t layer = 0; layer < sourceRange.layerCount; ++layer)
+    for (GfxIndex layer = 0; layer < sourceRange.layerCount; ++layer)
     {
-        for (uint32_t mip = 0; mip < sourceRange.mipLevelCount; ++mip)
+        for (GfxIndex mip = 0; mip < sourceRange.mipLevelCount; ++mip)
         {
             VkImageResolve region = {};
             region.srcSubresource.aspectMask = getAspectMask(sourceRange.aspectMask);
@@ -7042,7 +7039,7 @@ void ResourceCommandEncoder::resolveResource(
 }
 
 void ResourceCommandEncoder::resolveQuery(
-    IQueryPool* queryPool, uint32_t index, uint32_t count, IBufferResource* buffer, uint64_t offset)
+    IQueryPool* queryPool, GfxIndex index, GfxCount count, IBufferResource* buffer, Offset offset)
 {
     auto& vkApi = m_commandBuffer->m_renderer->m_api;
     auto poolImpl = static_cast<QueryPoolImpl*>(queryPool);
@@ -7067,7 +7064,7 @@ void ResourceCommandEncoder::copyTextureToBuffer(
     ResourceState srcState,
     SubresourceRange srcSubresource,
     ITextureResource::Offset3D srcOffset,
-    ITextureResource::Size extent)
+    ITextureResource::Extents extent)
 {
     assert(srcSubresource.mipLevelCount <= 1);
 
@@ -7204,13 +7201,13 @@ Result RenderCommandEncoder::bindPipelineWithRootObject(
     return setPipelineStateWithRootObjectImpl(pipelineState, rootObject);
 }
 
-void RenderCommandEncoder::setViewports(uint32_t count, const Viewport* viewports)
+void RenderCommandEncoder::setViewports(GfxCount count, const Viewport* viewports)
 {
     static const int kMaxViewports = 8; // TODO: base on device caps
     assert(count <= kMaxViewports);
 
     m_viewports.setCount(count);
-    for (UInt ii = 0; ii < count; ++ii)
+    for (GfxIndex ii = 0; ii < count; ++ii)
     {
         auto& inViewport = viewports[ii];
         auto& vkViewport = m_viewports[ii];
@@ -7227,13 +7224,13 @@ void RenderCommandEncoder::setViewports(uint32_t count, const Viewport* viewport
     api.vkCmdSetViewport(m_vkCommandBuffer, 0, uint32_t(count), m_viewports.getBuffer());
 }
 
-void RenderCommandEncoder::setScissorRects(uint32_t count, const ScissorRect* rects)
+void RenderCommandEncoder::setScissorRects(GfxCount count, const ScissorRect* rects)
 {
     static const int kMaxScissorRects = 8; // TODO: base on device caps
     assert(count <= kMaxScissorRects);
 
     m_scissorRects.setCount(count);
-    for (UInt ii = 0; ii < count; ++ii)
+    for (GfxIndex ii = 0; ii < count; ++ii)
     {
         auto& inRect = rects[ii];
         auto& vkRect = m_scissorRects[ii];
@@ -7273,14 +7270,14 @@ void RenderCommandEncoder::setPrimitiveTopology(PrimitiveTopology topology)
 }
 
 void RenderCommandEncoder::setVertexBuffers(
-    uint32_t startSlot,
-    uint32_t slotCount,
+    GfxIndex startSlot,
+    GfxCount slotCount,
     IBufferResource* const* buffers,
-    const uint32_t* offsets)
+    const Offset* offsets)
 {
-    for (Index i = 0; i < Index(slotCount); i++)
+    for (GfxIndex i = 0; i < GfxIndex(slotCount); i++)
     {
-        Index slotIndex = startSlot + i;
+        GfxIndex slotIndex = startSlot + i;
         BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]);
         if (buffer)
         {
@@ -7294,7 +7291,7 @@ void RenderCommandEncoder::setVertexBuffers(
 }
 
 void RenderCommandEncoder::setIndexBuffer(
-    IBufferResource* buffer, Format indexFormat, uint32_t offset)
+    IBufferResource* buffer, Format indexFormat, Offset offset)
 {
     VkIndexType indexType = VK_INDEX_TYPE_UINT16;
     switch (indexFormat)
@@ -7326,7 +7323,7 @@ void RenderCommandEncoder::prepareDraw()
     bindRenderState(VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
 
-void RenderCommandEncoder::draw(uint32_t vertexCount, uint32_t startVertex)
+void RenderCommandEncoder::draw(GfxCount vertexCount, GfxIndex startVertex)
 {
     prepareDraw();
     auto& api = *m_api;
@@ -7334,7 +7331,7 @@ void RenderCommandEncoder::draw(uint32_t vertexCount, uint32_t startVertex)
 }
 
 void RenderCommandEncoder::drawIndexed(
-    uint32_t indexCount, uint32_t startIndex, uint32_t baseVertex)
+    GfxCount indexCount, GfxIndex startIndex, GfxIndex baseVertex)
 {
     prepareDraw();
     auto& api = *m_api;
@@ -7348,11 +7345,11 @@ void RenderCommandEncoder::setStencilReference(uint32_t referenceValue)
 }
 
 void RenderCommandEncoder::drawIndirect(
-    uint32_t maxDrawCount,
+    GfxCount maxDrawCount,
     IBufferResource* argBuffer,
-    uint64_t argOffset,
+    Offset argOffset,
     IBufferResource* countBuffer,
-    uint64_t countOffset)
+    Offset countOffset)
 {
     // Vulkan does not support sourcing the count from a buffer.
     assert(!countBuffer);
@@ -7369,11 +7366,11 @@ void RenderCommandEncoder::drawIndirect(
 }
 
 void RenderCommandEncoder::drawIndexedIndirect(
-    uint32_t maxDrawCount,
+    GfxCount maxDrawCount,
     IBufferResource* argBuffer,
-    uint64_t argOffset,
+    Offset argOffset,
     IBufferResource* countBuffer,
-    uint64_t countOffset)
+    Offset countOffset)
 {
     // Vulkan does not support sourcing the count from a buffer.
     assert(!countBuffer);
@@ -7390,7 +7387,7 @@ void RenderCommandEncoder::drawIndexedIndirect(
 }
 
 Result RenderCommandEncoder::setSamplePositions(
-    uint32_t samplesPerPixel, uint32_t pixelCount, const SamplePosition* samplePositions)
+    GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions)
 {
     if (m_api->vkCmdSetSampleLocationsEXT)
     {
@@ -7405,10 +7402,10 @@ Result RenderCommandEncoder::setSamplePositions(
 }
 
 void RenderCommandEncoder::drawInstanced(
-    uint32_t vertexCount,
-    uint32_t instanceCount,
-    uint32_t startVertex,
-    uint32_t startInstanceLocation)
+    GfxCount vertexCount,
+    GfxCount instanceCount,
+    GfxIndex startVertex,
+    GfxIndex startInstanceLocation)
 {
     prepareDraw();
     auto& api = *m_api;
@@ -7417,11 +7414,11 @@ void RenderCommandEncoder::drawInstanced(
 }
 
 void RenderCommandEncoder::drawIndexedInstanced(
-    uint32_t indexCount,
-    uint32_t instanceCount,
-    uint32_t startIndexLocation,
-    int32_t baseVertexLocation,
-    uint32_t startInstanceLocation)
+    GfxCount indexCount,
+    GfxCount instanceCount,
+    GfxIndex startIndexLocation,
+    GfxIndex baseVertexLocation,
+    GfxIndex startInstanceLocation)
 {
     prepareDraw();
     auto& api = *m_api;
@@ -7462,7 +7459,7 @@ void ComputeCommandEncoder::dispatchCompute(int x, int y, int z)
     m_api->vkCmdDispatch(m_vkCommandBuffer, x, y, z);
 }
 
-void ComputeCommandEncoder::dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset)
+void ComputeCommandEncoder::dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset)
 {
     SLANG_UNIMPLEMENTED_X("dispatchComputeIndirect");
 }
@@ -7507,20 +7504,20 @@ void RayTracingCommandEncoder::_memoryBarrier(
 }
 
 void RayTracingCommandEncoder::_queryAccelerationStructureProperties(
-    int accelerationStructureCount,
+    GfxCount accelerationStructureCount,
     IAccelerationStructure* const* accelerationStructures,
-    int queryCount,
+    GfxCount queryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     ShortList<VkAccelerationStructureKHR> vkHandles;
     vkHandles.setCount(accelerationStructureCount);
-    for (int i = 0; i < accelerationStructureCount; i++)
+    for (GfxIndex i = 0; i < accelerationStructureCount; i++)
     {
         vkHandles[i] =
             static_cast<AccelerationStructureImpl*>(accelerationStructures[i])->m_vkHandle;
     }
     auto vkHandlesView = vkHandles.getArrayView();
-    for (int i = 0; i < queryCount; i++)
+    for (GfxIndex i = 0; i < queryCount; i++)
     {
         VkQueryType queryType;
         switch (queryDescs[i].queryType)
@@ -7558,7 +7555,7 @@ void RayTracingCommandEncoder::_queryAccelerationStructureProperties(
 
 void RayTracingCommandEncoder::buildAccelerationStructure(
     const IAccelerationStructure::BuildDesc& desc,
-    int propertyQueryCount,
+    GfxCount propertyQueryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     AccelerationStructureBuildGeometryInfoBuilder geomInfoBuilder;
@@ -7626,9 +7623,9 @@ void RayTracingCommandEncoder::copyAccelerationStructure(
 }
 
 void RayTracingCommandEncoder::queryAccelerationStructureProperties(
-    int accelerationStructureCount,
+    GfxCount accelerationStructureCount,
     IAccelerationStructure* const* accelerationStructures,
-    int queryCount,
+    GfxCount queryCount,
     AccelerationStructureQueryDesc* queryDescs)
 {
     _queryAccelerationStructureProperties(
@@ -7671,11 +7668,11 @@ Result RayTracingCommandEncoder::bindPipelineWithRootObject(
 }
 
 void RayTracingCommandEncoder::dispatchRays(
-    uint32_t raygenShaderIndex,
+    GfxIndex raygenShaderIndex,
     IShaderTable* shaderTable,
-    int32_t width,
-    int32_t height,
-    int32_t depth)
+    GfxCount width,
+    GfxCount height,
+    GfxCount depth)
 {
     auto vkApi = m_commandBuffer->m_renderer->m_api;
     auto vkCommandBuffer = m_commandBuffer->m_commandBuffer;
@@ -7769,9 +7766,9 @@ Result CommandQueueImpl::getNativeHandle(InteropHandle* outHandle)
 const CommandQueueImpl::Desc& CommandQueueImpl::getDesc() { return m_desc; }
 
 Result CommandQueueImpl::waitForFenceValuesOnDevice(
-    uint32_t fenceCount, IFence** fences, uint64_t* waitValues)
+    GfxCount fenceCount, IFence** fences, uint64_t* waitValues)
 {
-    for (uint32_t i = 0; i < fenceCount; ++i)
+    for (GfxIndex i = 0; i < fenceCount; ++i)
     {
         FenceWaitInfo waitInfo;
         waitInfo.fence = static_cast<FenceImpl*>(fences[i]);
@@ -7857,7 +7854,7 @@ void CommandQueueImpl::queueSubmitImpl(
 }
 
 void CommandQueueImpl::executeCommandBuffers(
-    uint32_t count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
+    GfxCount count, ICommandBuffer* const* commandBuffers, IFence* fence, uint64_t valueToSignal)
 {
     if (count == 0 && fence == nullptr)
         return;
@@ -7898,7 +7895,7 @@ QueryPoolImpl::~QueryPoolImpl()
     m_device->m_api.vkDestroyQueryPool(m_device->m_api.m_device, m_pool, nullptr);
 }
 
-Result QueryPoolImpl::getResult(SlangInt index, SlangInt count, uint64_t* data)
+Result QueryPoolImpl::getResult(GfxIndex index, GfxCount count, uint64_t* data)
 {
     if (!m_pool)
     {
@@ -8056,7 +8053,7 @@ Result SwapchainImpl::createSwapchainAndImages()
             m_api->m_device, m_swapChain, &numSwapChainImages, vkImages.getBuffer());
     }
 
-    for (uint32_t i = 0; i < m_desc.imageCount; i++)
+    for (GfxIndex i = 0; i < m_desc.imageCount; i++)
     {
         ITextureResource::Desc imageDesc = {};
         imageDesc.allowedStates = ResourceStateSet(
@@ -8185,7 +8182,7 @@ Result SwapchainImpl::init(DeviceImpl* renderer, const ISwapchain::Desc& desc, W
     return SLANG_OK;
 }
 
-Result SwapchainImpl::getImage(uint32_t index, ITextureResource** outResource)
+Result SwapchainImpl::getImage(GfxIndex index, ITextureResource** outResource)
 {
     if (m_images.getCount() <= (Index)index)
         return SLANG_FAIL;
@@ -8193,7 +8190,7 @@ Result SwapchainImpl::getImage(uint32_t index, ITextureResource** outResource)
     return SLANG_OK;
 }
 
-Result SwapchainImpl::resize(uint32_t width, uint32_t height)
+Result SwapchainImpl::resize(GfxCount width, GfxCount height)
 {
     SLANG_UNUSED(width);
     SLANG_UNUSED(height);
diff --git a/tools/gfx/vulkan/render-vk.h b/tools/gfx/vulkan/render-vk.h
index 756cc6e8c..091a490f2 100644
--- a/tools/gfx/vulkan/render-vk.h
+++ b/tools/gfx/vulkan/render-vk.h
@@ -126,7 +126,7 @@ public:
         createFence(const IFence::Desc& desc, IFence** outFence) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFences(
-        uint32_t fenceCount,
+        GfxCount fenceCount,
         IFence** fences,
         uint64_t* fenceValues,
         bool waitForAll,
@@ -1125,15 +1125,14 @@ public:
 
     RendererBase* getDevice();
 
-    virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override;
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getEntryPoint(UInt index, IShaderObject** outEntryPoint) override;
+        getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
 
     virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() override;
 
-    // TODO: Change size_t to Count?
-    virtual SLANG_NO_THROW size_t SLANG_MCALL getSize() override;
+    virtual SLANG_NO_THROW Size SLANG_MCALL getSize() override;
 
     // TODO: Changed size_t to Size? inSize assigned to an Index variable inside implementation
     virtual SLANG_NO_THROW Result SLANG_MCALL
@@ -1342,8 +1341,8 @@ public:
 
     List<RefPtr<EntryPointShaderObject>> const& getEntryPoints() const;
 
-    virtual UInt SLANG_MCALL getEntryPointCount() override;
-    virtual Result SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint) override;
+    virtual GfxCount SLANG_MCALL getEntryPointCount() override;
+    virtual Result SLANG_MCALL getEntryPoint(GfxIndex index, IShaderObject** outEntryPoint) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL
         copyFrom(IShaderObject* object, ITransientResourceHeap* transientHeap) override;
@@ -1395,19 +1394,19 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL
         uploadBufferData(IBufferResource* buffer, Offset offset, Size size, void* data) override;
     virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
-        size_t count, // TODO: Change size_t to Count?
+        GfxCount count,
         ITextureResource* const* textures,
         ResourceState src,
         ResourceState dst) override;
     virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
-        size_t count, // TODO: Change size_t to Count?
+        GfxCount count,
         IBufferResource* const* buffers,
         ResourceState src,
         ResourceState dst) override;
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        writeTimestamp(IQueryPool* queryPool, SlangInt index) override;
+        writeTimestamp(IQueryPool* queryPool, GfxIndex index) override;
 
     VkImageAspectFlags getAspectMask(TextureAspect aspect);
 
@@ -1420,15 +1419,15 @@ public:
         ResourceState srcState,
         SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
-        ITextureResource::Size extent) override;
+        ITextureResource::Extents extent) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
         ITextureResource* dst,
         SubresourceRange subResourceRange,
         ITextureResource::Offset3D offset,
-        ITextureResource::Size extend,
+        ITextureResource::Extents extend,
         ITextureResource::SubresourceData* subResourceData,
-        size_t subResourceDataCount) override; // TODO: Change size_t to Count?
+        GfxCount subResourceDataCount) override;
 
     void _clearColorImage(TextureResourceViewImpl* viewImpl, ClearValue* clearValue);
 
@@ -1453,10 +1452,10 @@ public:
 
     virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
         IQueryPool* queryPool,
-        uint32_t index,
-        uint32_t count,
+        GfxIndex index,
+        GfxCount count,
         IBufferResource* buffer,
-        uint64_t offset) override;
+        Offset offset) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
         IBufferResource* dst,
@@ -1467,7 +1466,7 @@ public:
         ResourceState srcState,
         SubresourceRange srcSubresource,
         ITextureResource::Offset3D srcOffset,
-        ITextureResource::Size extent) override;
+        ITextureResource::Extents extent) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
         ITextureResource* texture,
@@ -1502,63 +1501,63 @@ public:
         IPipelineState* pipelineState, IShaderObject* rootObject) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setViewports(uint32_t count, const Viewport* viewports) override;
+        setViewports(GfxCount count, const Viewport* viewports) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setScissorRects(uint32_t count, const ScissorRect* rects) override;
+        setScissorRects(GfxCount count, const ScissorRect* rects) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
         setPrimitiveTopology(PrimitiveTopology topology) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
-        uint32_t startSlot,
-        uint32_t slotCount,
+        GfxIndex startSlot,
+        GfxCount slotCount,
         IBufferResource* const* buffers,
-        const uint32_t* offsets) override;
+        const Offset* offsets) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        setIndexBuffer(IBufferResource* buffer, Format indexFormat, uint32_t offset = 0) override;
+        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) override;
 
     void prepareDraw();
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        draw(uint32_t vertexCount, uint32_t startVertex = 0) override;
+        draw(GfxCount vertexCount, GfxIndex startVertex = 0) override;
     virtual SLANG_NO_THROW void SLANG_MCALL
-        drawIndexed(uint32_t indexCount, uint32_t startIndex = 0, uint32_t baseVertex = 0) override;
+        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndirect(
-        uint32_t maxDrawCount,
+        GfxCount maxDrawCount,
         IBufferResource* argBuffer,
-        uint64_t argOffset,
+        Offset argOffset,
         IBufferResource* countBuffer,
-        uint64_t countOffset) override;
+        Offset countOffset) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedIndirect(
-        uint32_t maxDrawCount,
+        GfxCount maxDrawCount,
         IBufferResource* argBuffer,
-        uint64_t argOffset,
+        Offset argOffset,
         IBufferResource* countBuffer,
-        uint64_t countOffset) override;
+        Offset countOffset) override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
-        uint32_t samplesPerPixel,
-        uint32_t pixelCount,
+        GfxCount samplesPerPixel,
+        GfxCount pixelCount,
         const SamplePosition* samplePositions) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawInstanced(
-        uint32_t vertexCount,
-        uint32_t instanceCount,
-        uint32_t startVertex,
-        uint32_t startInstanceLocation) override;
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL drawIndexedInstanced(
-        uint32_t indexCount,
-        uint32_t instanceCount,
-        uint32_t startIndexLocation,
-        int32_t baseVertexLocation,
-        uint32_t startInstanceLocation) override;
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) override;
 };
 
 class ComputeCommandEncoder
@@ -1579,7 +1578,7 @@ public:
     virtual SLANG_NO_THROW void SLANG_MCALL dispatchCompute(int x, int y, int z) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
-        dispatchComputeIndirect(IBufferResource* argBuffer, uint64_t offset) override;
+        dispatchComputeIndirect(IBufferResource* argBuffer, Offset offset) override;
 };
 
 class RayTracingCommandEncoder
@@ -1596,14 +1595,14 @@ public:
         AccessFlag destAccess);
 
     void _queryAccelerationStructureProperties(
-        int accelerationStructureCount,
+        GfxCount accelerationStructureCount,
         IAccelerationStructure* const* accelerationStructures,
-        int queryCount,
+        GfxCount queryCount,
         AccelerationStructureQueryDesc* queryDescs);
 
     virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
         const IAccelerationStructure::BuildDesc& desc,
-        int propertyQueryCount,
+        GfxCount propertyQueryCount,
         AccelerationStructureQueryDesc* queryDescs) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
@@ -1612,9 +1611,9 @@ public:
         AccelerationStructureCopyMode mode) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
-        int accelerationStructureCount,
+        GfxCount accelerationStructureCount,
         IAccelerationStructure* const* accelerationStructures,
-        int queryCount,
+        GfxCount queryCount,
         AccelerationStructureQueryDesc* queryDescs) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL
@@ -1630,11 +1629,11 @@ public:
         IPipelineState* pipelineState, IShaderObject* rootObject) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL dispatchRays(
-        uint32_t raygenShaderIndex,
+        GfxIndex raygenShaderIndex,
         IShaderTable* shaderTable,
-        int32_t width,
-        int32_t height,
-        int32_t depth) override;
+        GfxCount width,
+        GfxCount height,
+        GfxCount depth) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() override;
 };
@@ -1725,7 +1724,7 @@ public:
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override;
 
     virtual SLANG_NO_THROW Result SLANG_MCALL waitForFenceValuesOnDevice(
-        uint32_t fenceCount, IFence** fences, uint64_t* waitValues) override;
+        GfxCount fenceCount, IFence** fences, uint64_t* waitValues) override;
 
     void queueSubmitImpl(
         uint32_t count,
@@ -1734,7 +1733,7 @@ public:
         uint64_t valueToSignal);
 
     virtual SLANG_NO_THROW void SLANG_MCALL executeCommandBuffers(
-        uint32_t count,
+        GfxCount count,
         ICommandBuffer* const* commandBuffers,
         IFence* fence,
         uint64_t valueToSignal) override;
@@ -1773,7 +1772,7 @@ public:
 
 public:
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getResult(SlangInt index, SlangInt count, uint64_t* data) override;
+        getResult(GfxIndex index, GfxCount count, uint64_t* data) override;
 
 public:
     VkQueryPool m_pool;
@@ -1832,8 +1831,8 @@ public:
 
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() override { return m_desc; }
     virtual SLANG_NO_THROW Result SLANG_MCALL
-        getImage(uint32_t index, ITextureResource** outResource) override;
-    virtual SLANG_NO_THROW Result SLANG_MCALL resize(uint32_t width, uint32_t height) override;
+        getImage(GfxIndex index, ITextureResource** outResource) override;
+    virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) override;
     virtual SLANG_NO_THROW Result SLANG_MCALL present() override;
     virtual SLANG_NO_THROW int SLANG_MCALL acquireNextImage() override;
     virtual SLANG_NO_THROW bool SLANG_MCALL isOccluded() override { return false; }
diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp
index aa0a60829..1e3caf781 100644
--- a/tools/render-test/render-test-main.cpp
+++ b/tools/render-test/render-test-main.cpp
@@ -293,7 +293,7 @@ struct AssignValsFromLayoutContext
             if(field.name.getLength() == 0)
             {
                 // If no name was given, assume by-indexing matching is requested
-                auto fieldCursor = dstCursor.getElement(fieldIndex);
+                auto fieldCursor = dstCursor.getElement((GfxIndex)fieldIndex);
                 if(!fieldCursor.isValid())
                 {
                     StdWriters::getError().print("error: could not find shader parameter at index %d\n", (int)fieldIndex);
author	lucy96chen <47800040+lucy96chen@users.noreply.github.com>	2022-04-21 12:59:09 -0700
committer	GitHub <noreply@github.com>	2022-04-21 12:59:09 -0700
commit	f493d24c70a6227754296439e97adf35ec412496 (patch)
tree	25fffb03c067477bef68ccdc66865683159e3ab5 /tools
parent	1b6cea2219307f6271e131c43d6e8f48910bd435 (diff)