Cleanup (#61)

* rename subResource -> subresource

* fix

* Rename numMipLevels -> mipLevelCount

* Rename numFeatures -> featureCount

docs/api.md

@@ -196,5 +196,3 @@
 | API           | CPU | CUDA | D3D11 | D3D12 | Vulkan | Metal | WGPU |
 |---------------|-----|------|-------|-------|--------|-------|------|
 | `endEncoding` | :x: | :x:  | :x:   | :x:   | :x:    | :x:   | :x:  |
-
-

include/slang-rhi.h

@@ -683,7 +683,7 @@ struct TextureDesc
     /// Array length.
     GfxCount arrayLength = 0;
     /// Number of mip levels - if 0 will create all mip levels.
-    GfxCount numMipLevels = 0;
+    GfxCount mipLevelCount = 0;
     /// The resources format.
     Format format;
     /// Number of samples per pixel.
@@ -2517,7 +2517,7 @@ inline AdapterList rhiGetAdapters(DeviceType type)
 struct D3D12ExperimentalFeaturesDesc
 {
     StructType structType = StructType::D3D12ExperimentalFeaturesDesc;
-    uint32_t numFeatures;
+    uint32_t featureCount;
     const void* featureIIDs;
     void* configurationStructs;
     uint32_t* configurationStructSizes;

src/cpu/cpu-texture-view.cpp

@@ -11,7 +11,7 @@ slang_prelude::TextureDimensions TextureViewImpl::GetDimensions(int mipLevel)
     auto baseShape = texture->m_baseShape;
 
     dimensions.arrayElementCount = desc.arrayLength;
-    dimensions.numberOfLevels = desc.numMipLevels;
+    dimensions.numberOfLevels = desc.mipLevelCount;
     dimensions.shape = baseShape->rank;
     dimensions.width = desc.size.width;
     dimensions.height = desc.size.height;
@@ -57,8 +57,8 @@ void TextureViewImpl::SampleLevel(
     int32_t baseCoordCount = baseShape->baseCoordCount;
 
     int32_t integerMipLevel = int32_t(level + 0.5f);
-    if (integerMipLevel >= desc.numMipLevels)
-        integerMipLevel = desc.numMipLevels - 1;
+    if (integerMipLevel >= desc.mipLevelCount)
+        integerMipLevel = desc.mipLevelCount - 1;
     if (integerMipLevel < 0)
         integerMipLevel = 0;
 
@@ -134,8 +134,8 @@ void* TextureViewImpl::_getTexelPtr(int32_t const* texelCoords)
     int32_t mipLevel = 0;
     if (!hasMipLevels)
         mipLevel = texelCoords[coordIndex++];
-    if (mipLevel >= desc.numMipLevels)
-        mipLevel = desc.numMipLevels - 1;
+    if (mipLevel >= desc.mipLevelCount)
+        mipLevel = desc.mipLevelCount - 1;
     if (mipLevel < 0)
         mipLevel = 0;
 

src/cpu/cpu-texture.cpp

@@ -135,7 +135,7 @@ Result TextureImpl::init(SubresourceData const* initData)
     for (int32_t axis = rank; axis < kMaxRank; ++axis)
         extents[axis] = 1;
 
-    int32_t levelCount = desc.numMipLevels;
+    int32_t levelCount = desc.mipLevelCount;
 
     m_mipLevels.resize(levelCount);
 
@@ -172,12 +172,12 @@ Result TextureImpl::init(SubresourceData const* initData)
 
     if (initData)
     {
-        int32_t subResourceCounter = 0;
+        int32_t subresourceCounter = 0;
         for (int32_t arrayElementIndex = 0; arrayElementIndex < effectiveArrayElementCount; ++arrayElementIndex)
         {
-            for (int32_t mipLevel = 0; mipLevel < m_desc.numMipLevels; ++mipLevel)
+            for (int32_t mipLevel = 0; mipLevel < m_desc.mipLevelCount; ++mipLevel)
             {
-                int32_t subResourceIndex = subResourceCounter++;
+                int32_t subresourceIndex = subresourceCounter++;
 
                 auto dstRowStride = m_mipLevels[mipLevel].strides[1];
                 auto dstLayerStride = m_mipLevels[mipLevel].strides[2];
@@ -188,7 +188,7 @@ Result TextureImpl::init(SubresourceData const* initData)
                 auto rowCount = m_mipLevels[mipLevel].extents[1];
                 auto depthLayerCount = m_mipLevels[mipLevel].extents[2];
 
-                auto& srcImage = initData[subResourceIndex];
+                auto& srcImage = initData[subresourceIndex];
                 ptrdiff_t srcRowStride = ptrdiff_t(srcImage.strideY);
                 ptrdiff_t srcLayerStride = ptrdiff_t(srcImage.strideZ);
 

src/cuda/cuda-command-encoder.cpp

@@ -71,19 +71,19 @@ void ResourceCommandEncoderImpl::copyTexture(
 
 void ResourceCommandEncoderImpl::uploadTextureData(
     ITexture* dst,
-    SubresourceRange subResourceRange,
+    SubresourceRange subresourceRange,
     Offset3D offset,
     Extents extent,
-    SubresourceData* subResourceData,
-    GfxCount subResourceDataCount
+    SubresourceData* subresourceData,
+    GfxCount subresourceDataCount
 )
 {
     SLANG_UNUSED(dst);
-    SLANG_UNUSED(subResourceRange);
+    SLANG_UNUSED(subresourceRange);
     SLANG_UNUSED(offset);
     SLANG_UNUSED(extent);
-    SLANG_UNUSED(subResourceData);
-    SLANG_UNUSED(subResourceDataCount);
+    SLANG_UNUSED(subresourceData);
+    SLANG_UNUSED(subresourceDataCount);
     SLANG_RHI_UNIMPLEMENTED("uploadTextureData");
 }
 

src/cuda/cuda-command-encoder.h

@@ -77,11 +77,11 @@ class ResourceCommandEncoderImpl : public IResourceCommandEncoder, public Comman
 
     virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
         ITexture* dst,
-        SubresourceRange subResourceRange,
+        SubresourceRange subresourceRange,
         Offset3D offset,
         Extents extent,
-        SubresourceData* subResourceData,
-        GfxCount subResourceDataCount
+        SubresourceData* subresourceData,
+        GfxCount subresourceDataCount
     ) override;
 
     virtual SLANG_NO_THROW void SLANG_MCALL clearBuffer(IBuffer* buffer, const BufferRange* range) override;

src/cuda/cuda-device.cpp

@@ -392,7 +392,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc, const SubresourceData*
         }
         }
 
-        if (desc.numMipLevels > 1)
+        if (desc.mipLevelCount > 1)
         {
             resourceType = CU_RESOURCE_TYPE_MIPMAPPED_ARRAY;
 
@@ -427,7 +427,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc, const SubresourceData*
                 arrayDesc.Depth *= 6;
             }
 
-            SLANG_CUDA_RETURN_ON_FAIL(cuMipmappedArrayCreate(&tex->m_cudaMipMappedArray, &arrayDesc, desc.numMipLevels)
+            SLANG_CUDA_RETURN_ON_FAIL(cuMipmappedArrayCreate(&tex->m_cudaMipMappedArray, &arrayDesc, desc.mipLevelCount)
             );
         }
         else
@@ -507,7 +507,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc, const SubresourceData*
     if (initData)
     {
         std::vector<uint8_t> workspace;
-        for (int mipLevel = 0; mipLevel < desc.numMipLevels; ++mipLevel)
+        for (int mipLevel = 0; mipLevel < desc.mipLevelCount; ++mipLevel)
         {
             int mipWidth = width >> mipLevel;
             int mipHeight = height >> mipLevel;
@@ -566,7 +566,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc, const SubresourceData*
                 // We iterate over face count so we copy all of the cubemap faces
                 for (Index j = 0; j < faceCount; j++)
                 {
-                    const auto srcData = initData[mipLevel + j * desc.numMipLevels].data;
+                    const auto srcData = initData[mipLevel + j * desc.mipLevelCount].data;
                     // Copy over to the workspace to make contiguous
                     ::memcpy(workspace.data() + faceSizeInBytes * j, srcData, faceSizeInBytes);
                 }
@@ -583,7 +583,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc, const SubresourceData*
                     // Copy the data over to make contiguous
                     for (Index j = 0; j < 6; j++)
                     {
-                        const auto srcData = initData[mipLevel + j * desc.numMipLevels].data;
+                        const auto srcData = initData[mipLevel + j * desc.mipLevelCount].data;
                         ::memcpy(workspace.data() + faceSizeInBytes * j, srcData, faceSizeInBytes);
                     }
                     srcDataPtr = workspace.data();
@@ -701,7 +701,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc, const SubresourceData*
         if (is_set(desc.usage, TextureUsage::UnorderedAccess))
         {
             // On CUDA surfaces only support a single MIP map
-            SLANG_RHI_ASSERT(desc.numMipLevels == 1);
+            SLANG_RHI_ASSERT(desc.mipLevelCount == 1);
 
             SLANG_CUDA_RETURN_ON_FAIL(cuSurfObjectCreate(&tex->m_cudaSurfObj, &resDesc));
         }
@@ -849,7 +849,7 @@ Result DeviceImpl::createTextureFromSharedHandle(
     memset(&externalMemoryMipDesc, 0, sizeof(externalMemoryMipDesc));
     externalMemoryMipDesc.offset = 0;
     externalMemoryMipDesc.arrayDesc = arrayDesc;
-    externalMemoryMipDesc.numLevels = desc.numMipLevels;
+    externalMemoryMipDesc.numLevels = desc.mipLevelCount;
 
     CUmipmappedArray mipArray;
     SLANG_CUDA_RETURN_ON_FAIL(cuExternalMemoryGetMappedMipmappedArray(&mipArray, externalMemory, &externalMemoryMipDesc)

src/d3d11/d3d11-device.cpp

@@ -494,31 +494,31 @@ Result DeviceImpl::createTexture(const TextureDesc& descIn, const SubresourceDat
 
     // Set up the initialize data
     std::vector<D3D11_SUBRESOURCE_DATA> subRes;
-    D3D11_SUBRESOURCE_DATA* subResourcesPtr = nullptr;
+    D3D11_SUBRESOURCE_DATA* subresourcesPtr = nullptr;
     if (initData)
     {
         int arrayLayerCount = srcDesc.arrayLength * (srcDesc.type == TextureType::TextureCube ? 6 : 1);
-        subRes.resize(srcDesc.numMipLevels * arrayLayerCount);
+        subRes.resize(srcDesc.mipLevelCount * arrayLayerCount);
         {
-            int subResourceIndex = 0;
+            int subresourceIndex = 0;
             for (int i = 0; i < arrayLayerCount; i++)
             {
-                for (int j = 0; j < srcDesc.numMipLevels; j++)
+                for (int j = 0; j < srcDesc.mipLevelCount; j++)
                 {
                     const int mipHeight = calcMipSize(srcDesc.size.height, j);
 
-                    D3D11_SUBRESOURCE_DATA& data = subRes[subResourceIndex];
-                    auto& srcData = initData[subResourceIndex];
+                    D3D11_SUBRESOURCE_DATA& data = subRes[subresourceIndex];
+                    auto& srcData = initData[subresourceIndex];
 
                     data.pSysMem = srcData.data;
                     data.SysMemPitch = UINT(srcData.strideY);
                     data.SysMemSlicePitch = UINT(srcData.strideZ);
 
-                    subResourceIndex++;
+                    subresourceIndex++;
                 }
             }
         }
-        subResourcesPtr = subRes.data();
+        subresourcesPtr = subRes.data();
     }
 
     const int accessFlags = _calcResourceAccessFlags(srcDesc.memoryType);
@@ -534,13 +534,13 @@ Result DeviceImpl::createTexture(const TextureDesc& descIn, const SubresourceDat
         desc.CPUAccessFlags = accessFlags;
         desc.Format = format;
         desc.MiscFlags = 0;
-        desc.MipLevels = srcDesc.numMipLevels;
+        desc.MipLevels = srcDesc.mipLevelCount;
         desc.ArraySize = srcDesc.arrayLength;
         desc.Width = srcDesc.size.width;
         desc.Usage = D3D11_USAGE_DEFAULT;
 
         ComPtr<ID3D11Texture1D> texture1D;
-        SLANG_RETURN_ON_FAIL(m_device->CreateTexture1D(&desc, subResourcesPtr, texture1D.writeRef()));
+        SLANG_RETURN_ON_FAIL(m_device->CreateTexture1D(&desc, subresourcesPtr, texture1D.writeRef()));
 
         texture->m_resource = texture1D;
         break;
@@ -553,7 +553,7 @@ Result DeviceImpl::createTexture(const TextureDesc& descIn, const SubresourceDat
         desc.CPUAccessFlags = accessFlags;
         desc.Format = format;
         desc.MiscFlags = 0;
-        desc.MipLevels = srcDesc.numMipLevels;
+        desc.MipLevels = srcDesc.mipLevelCount;
         desc.ArraySize = srcDesc.arrayLength * (srcDesc.type == TextureType::TextureCube ? 6 : 1);
 
         desc.Width = srcDesc.size.width;
@@ -568,7 +568,7 @@ Result DeviceImpl::createTexture(const TextureDesc& descIn, const SubresourceDat
         }
 
         ComPtr<ID3D11Texture2D> texture2D;
-        SLANG_RETURN_ON_FAIL(m_device->CreateTexture2D(&desc, subResourcesPtr, texture2D.writeRef()));
+        SLANG_RETURN_ON_FAIL(m_device->CreateTexture2D(&desc, subresourcesPtr, texture2D.writeRef()));
 
         texture->m_resource = texture2D;
         break;
@@ -580,14 +580,14 @@ Result DeviceImpl::createTexture(const TextureDesc& descIn, const SubresourceDat
         desc.CPUAccessFlags = accessFlags;
         desc.Format = format;
         desc.MiscFlags = 0;
-        desc.MipLevels = srcDesc.numMipLevels;
+        desc.MipLevels = srcDesc.mipLevelCount;
         desc.Width = srcDesc.size.width;
         desc.Height = srcDesc.size.height;
         desc.Depth = srcDesc.size.depth;
         desc.Usage = D3D11_USAGE_DEFAULT;
 
         ComPtr<ID3D11Texture3D> texture3D;
-        SLANG_RETURN_ON_FAIL(m_device->CreateTexture3D(&desc, subResourcesPtr, texture3D.writeRef()));
+        SLANG_RETURN_ON_FAIL(m_device->CreateTexture3D(&desc, subresourcesPtr, texture3D.writeRef()));
 
         texture->m_resource = texture3D;
         break;
@@ -673,14 +673,14 @@ Result DeviceImpl::createBuffer(const BufferDesc& descIn, const void* initData,
         bufferDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
     }
 
-    D3D11_SUBRESOURCE_DATA subResourceData = {0};
-    subResourceData.pSysMem = initData;
+    D3D11_SUBRESOURCE_DATA subresourceData = {0};
+    subresourceData.pSysMem = initData;
 
     RefPtr<BufferImpl> buffer(new BufferImpl(this, srcDesc));
     buffer->m_device = this;
 
     SLANG_RETURN_ON_FAIL(
-        m_device->CreateBuffer(&bufferDesc, initData ? &subResourceData : nullptr, buffer->m_buffer.writeRef())
+        m_device->CreateBuffer(&bufferDesc, initData ? &subresourceData : nullptr, buffer->m_buffer.writeRef())
     );
     buffer->m_d3dUsage = bufferDesc.Usage;
 

src/d3d11/d3d11-helper-functions.cpp

@@ -299,52 +299,52 @@ void initSrvDesc(const TextureDesc& textureDesc, DXGI_FORMAT pixelFormat, D3D11_
         {
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
             descOut.Texture1DArray.MostDetailedMip = 0;
-            descOut.Texture1DArray.MipLevels = textureDesc.numMipLevels;
+            descOut.Texture1DArray.MipLevels = textureDesc.mipLevelCount;
             descOut.Texture1DArray.FirstArraySlice = 0;
             descOut.Texture1DArray.ArraySize = textureDesc.arrayLength;
         }
         else
         {
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
             descOut.Texture1D.MostDetailedMip = 0;
-            descOut.Texture1D.MipLevels = textureDesc.numMipLevels;
+            descOut.Texture1D.MipLevels = textureDesc.mipLevelCount;
         }
         break;
     case TextureType::Texture2D:
         if (textureDesc.arrayLength > 1)
         {
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
             descOut.Texture2DArray.MostDetailedMip = 0;
-            descOut.Texture2DArray.MipLevels = textureDesc.numMipLevels;
+            descOut.Texture2DArray.MipLevels = textureDesc.mipLevelCount;
             descOut.Texture2DArray.FirstArraySlice = 0;
             descOut.Texture2DArray.ArraySize = textureDesc.arrayLength;
         }
         else
         {
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
             descOut.Texture2D.MostDetailedMip = 0;
-            descOut.Texture2D.MipLevels = textureDesc.numMipLevels;
+            descOut.Texture2D.MipLevels = textureDesc.mipLevelCount;
         }
         break;
     case TextureType::Texture3D:
         descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
         descOut.Texture3D.MostDetailedMip = 0;
-        descOut.Texture3D.MipLevels = textureDesc.numMipLevels;
+        descOut.Texture3D.MipLevels = textureDesc.mipLevelCount;
         break;
     case TextureType::TextureCube:
         if (textureDesc.arrayLength > 1)
         {
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
             descOut.TextureCubeArray.MostDetailedMip = 0;
-            descOut.TextureCubeArray.MipLevels = textureDesc.numMipLevels;
+            descOut.TextureCubeArray.MipLevels = textureDesc.mipLevelCount;
             descOut.TextureCubeArray.First2DArrayFace = 0;
             descOut.TextureCubeArray.NumCubes = textureDesc.arrayLength;
         }
         else
         {
             descOut.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
             descOut.TextureCube.MostDetailedMip = 0;
-            descOut.TextureCube.MipLevels = textureDesc.numMipLevels;
+            descOut.TextureCube.MipLevels = textureDesc.mipLevelCount;
         }
         break;
     }

src/d3d11/d3d11-swap-chain.cpp

@@ -22,7 +22,7 @@ void SwapchainImpl::createSwapchainBufferImages()
     TextureDesc imageDesc = {};
     imageDesc.type = TextureType::Texture2D;
     imageDesc.arrayLength = 1;
-    imageDesc.numMipLevels = 1;
+    imageDesc.mipLevelCount = 1;
     imageDesc.size.width = m_desc.width;
     imageDesc.size.height = m_desc.height;
     imageDesc.size.depth = 1;

src/d3d12/d3d12-command-buffer.cpp

@@ -88,7 +88,7 @@ void CommandBufferImpl::commitBarriers()
         }
         else
         {
-            uint32_t mipLevelCount = texture->m_desc.numMipLevels;
+            uint32_t mipLevelCount = texture->m_desc.mipLevelCount;
             uint32_t arrayLayerCount =
                 texture->m_desc.arrayLength * (texture->m_desc.type == TextureType::TextureCube ? 6 : 1);
             barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;