rhi: Make the clang code model happy as much as we can

When interfacing with reality (i.e. native platform APIs provided in C,
ObjC, or COM), each of the APIs has its own idea of what types it likes
to use for sizes, points, rects, etc.

Out of the hundreds of warnings Qt Creator throws at us with the default
clang check level when opening one of the rhi backends not a single one
is useful. Regardless, let's try getting rid of what we can. This mostly
involves throwing in int/uint conversions in order to get the signedness
change warnings to shut up. The things that are either unacceptable to
change or are beyond our control are left untouched.

Change-Id: I6e4cb7cd373bf48dc990eaf83344242bbf30bd66
Reviewed-by: Christian Strømme <christian.stromme@qt.io>

7 files changed, 470 insertions, 464 deletions

diff --git a/src/gui/rhi/qrhi.cpp b/src/gui/rhi/qrhi.cpp
index 88d2f73541..65cfaf5123 100644
--- a/src/gui/rhi/qrhi.cpp
+++ b/src/gui/rhi/qrhi.cpp
@@ -673,7 +673,7 @@ bool operator!=(const QRhiDepthStencilClearValue &a, const QRhiDepthStencilClear
  */
 uint qHash(const QRhiDepthStencilClearValue &v, uint seed) Q_DECL_NOTHROW
 {
-    return seed * (qFloor(v.depthClearValue() * 100) + v.stencilClearValue());
+    return seed * (uint(qFloor(qreal(v.depthClearValue()) * 100)) + v.stencilClearValue());
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -768,7 +768,8 @@ bool operator!=(const QRhiViewport &a, const QRhiViewport &b) Q_DECL_NOTHROW
 uint qHash(const QRhiViewport &v, uint seed) Q_DECL_NOTHROW
 {
     const std::array<float, 4> r = v.viewport();
-    return seed + r[0] + r[1] + r[2] + r[3] + qFloor(v.minDepth() * 100) + qFloor(v.maxDepth() * 100);
+    return seed + uint(r[0]) + uint(r[1]) + uint(r[2]) + uint(r[3])
+            + uint(qFloor(qreal(v.minDepth()) * 100)) + uint(qFloor(qreal(v.maxDepth()) * 100));
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -850,7 +851,7 @@ bool operator!=(const QRhiScissor &a, const QRhiScissor &b) Q_DECL_NOTHROW
 uint qHash(const QRhiScissor &v, uint seed) Q_DECL_NOTHROW
 {
     const std::array<int, 4> r = v.scissor();
-    return seed + r[0] + r[1] + r[2] + r[3];
+    return seed + uint(r[0]) + uint(r[1]) + uint(r[2]) + uint(r[3]);
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -1136,7 +1137,7 @@ bool operator!=(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribut
  */
 uint qHash(const QRhiVertexInputAttribute &v, uint seed) Q_DECL_NOTHROW
 {
-    return seed + v.binding() + v.location() + v.format() + v.offset();
+    return seed + uint(v.binding()) + uint(v.location()) + uint(v.format()) + v.offset();
 }
 
 #ifndef QT_NO_DEBUG_STREAM
@@ -3001,7 +3002,7 @@ bool operator!=(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBind
 uint qHash(const QRhiShaderResourceBinding &b, uint seed) Q_DECL_NOTHROW
 {
     const char *u = reinterpret_cast<const char *>(&b.d->u);
-    return seed + b.d->binding + 10 * b.d->stage + 100 * b.d->type
+    return seed + uint(b.d->binding) + 10 * uint(b.d->stage) + 100 * uint(b.d->type)
             + qHash(QByteArray::fromRawData(u, sizeof(b.d->u)), seed);
 }
 
@@ -3823,8 +3824,8 @@ void QRhiImplementation::compressedFormatInfo(QRhiTexture::Format format, const
         break;
     }
 
-    const quint32 wblocks = (size.width() + xdim - 1) / xdim;
-    const quint32 hblocks = (size.height() + ydim - 1) / ydim;
+    const quint32 wblocks = uint((size.width() + xdim - 1) / xdim);
+    const quint32 hblocks = uint((size.height() + ydim - 1) / ydim);
 
     if (bpl)
         *bpl = wblocks * blockSize;
@@ -3880,9 +3881,9 @@ void QRhiImplementation::textureFormatInfo(QRhiTexture::Format format, const QSi
     }
 
     if (bpl)
-        *bpl = size.width() * bpc;
+        *bpl = uint(size.width()) * bpc;
     if (byteSize)
-        *byteSize = size.width() * size.height() * bpc;
+        *byteSize = uint(size.width() * size.height()) * bpc;
 }
 
 // Approximate because it excludes subresource alignment or multisampling.
@@ -3892,12 +3893,12 @@ quint32 QRhiImplementation::approxByteSizeForTexture(QRhiTexture::Format format,
     quint32 approxSize = 0;
     for (int level = 0; level < mipCount; ++level) {
         quint32 byteSize = 0;
-        const QSize size(qFloor(float(qMax(1, baseSize.width() >> level))),
-                         qFloor(float(qMax(1, baseSize.height() >> level))));
+        const QSize size(qFloor(qreal(qMax(1, baseSize.width() >> level))),
+                         qFloor(qreal(qMax(1, baseSize.height() >> level))));
         textureFormatInfo(format, size, nullptr, &byteSize);
         approxSize += byteSize;
     }
-    approxSize *= layerCount;
+    approxSize *= uint(layerCount);
     return approxSize;
 }
 
diff --git a/src/gui/rhi/qrhid3d11.cpp b/src/gui/rhi/qrhid3d11.cpp
index f12e376b58..2828256a90 100644
--- a/src/gui/rhi/qrhid3d11.cpp
+++ b/src/gui/rhi/qrhid3d11.cpp
@@ -161,7 +161,7 @@ static QString comErrorMessage(HRESULT hr)
 }
 
 template <class Int>
-static inline Int aligned(Int v, Int byteAlign)
+inline Int aligned(Int v, Int byteAlign)
 {
     return (v + byteAlign - 1) & ~(byteAlign - 1);
 }
@@ -172,7 +172,7 @@ static IDXGIFactory1 *createDXGIFactory2()
     if (QOperatingSystemVersion::current() > QOperatingSystemVersion::Windows7) {
         using PtrCreateDXGIFactory2 = HRESULT (WINAPI *)(UINT, REFIID, void **);
         QSystemLibrary dxgilib(QStringLiteral("dxgi"));
-        if (auto createDXGIFactory2 = (PtrCreateDXGIFactory2)dxgilib.resolve("CreateDXGIFactory2")) {
+        if (auto createDXGIFactory2 = reinterpret_cast<PtrCreateDXGIFactory2>(dxgilib.resolve("CreateDXGIFactory2"))) {
             const HRESULT hr = createDXGIFactory2(0, IID_IDXGIFactory2, reinterpret_cast<void **>(&result));
             if (FAILED(hr)) {
                 qWarning("CreateDXGIFactory2() failed to create DXGI factory: %s", qPrintable(comErrorMessage(hr)));
@@ -227,10 +227,10 @@ bool QRhiD3D11::create(QRhi::Flags flags)
         int requestedAdapterIndex = -1;
         if (qEnvironmentVariableIsSet("QT_D3D_ADAPTER_INDEX"))
             requestedAdapterIndex = qEnvironmentVariableIntValue("QT_D3D_ADAPTER_INDEX");
-        for (int adapterIndex = 0; dxgiFactory->EnumAdapters1(adapterIndex, &adapter) != DXGI_ERROR_NOT_FOUND; ++adapterIndex) {
+        for (int adapterIndex = 0; dxgiFactory->EnumAdapters1(UINT(adapterIndex), &adapter) != DXGI_ERROR_NOT_FOUND; ++adapterIndex) {
             DXGI_ADAPTER_DESC1 desc;
             adapter->GetDesc1(&desc);
-            const QString name = QString::fromUtf16((char16_t *) desc.Description);
+            const QString name = QString::fromUtf16(reinterpret_cast<char16_t *>(desc.Description));
             qCDebug(QRHI_LOG_INFO, "Adapter %d: '%s' (flags 0x%x)", adapterIndex, qPrintable(name), desc.Flags);
             if (!adapterToUse && (requestedAdapterIndex < 0 || requestedAdapterIndex == adapterIndex)) {
                 adapterToUse = adapter;
@@ -343,9 +343,9 @@ DXGI_SAMPLE_DESC QRhiD3D11::effectiveSampleCount(int sampleCount) const
         return desc;
     }
 
-    desc.Count = s;
+    desc.Count = UINT(s);
     if (s > 1)
-        desc.Quality = D3D11_STANDARD_MULTISAMPLE_PATTERN;
+        desc.Quality = UINT(D3D11_STANDARD_MULTISAMPLE_PATTERN);
     else
         desc.Quality = 0;
 
@@ -666,7 +666,7 @@ void QRhiD3D11::setShaderResources(QRhiCommandBuffer *cb, QRhiShaderResourceBind
                 uint *p = cmd.args.bindShaderResources.dynamicOffsetPairs;
                 for (int i = 0; i < dynamicOffsetCount; ++i) {
                     const QRhiCommandBuffer::DynamicOffset &dynOfs(dynamicOffsets[i]);
-                    const uint binding = dynOfs.first;
+                    const uint binding = uint(dynOfs.first);
                     Q_ASSERT(aligned(dynOfs.second, quint32(256)) == dynOfs.second);
                     const uint offsetInConstants = dynOfs.second / 16;
                     *p++ = binding;
@@ -802,10 +802,10 @@ void QRhiD3D11::setBlendConstants(QRhiCommandBuffer *cb, const QColor &c)
     QD3D11CommandBuffer::Command cmd;
     cmd.cmd = QD3D11CommandBuffer::Command::BlendConstants;
     cmd.args.blendConstants.ps = QRHI_RES(QD3D11GraphicsPipeline, cbD->currentGraphicsPipeline);
-    cmd.args.blendConstants.c[0] = c.redF();
-    cmd.args.blendConstants.c[1] = c.greenF();
-    cmd.args.blendConstants.c[2] = c.blueF();
-    cmd.args.blendConstants.c[3] = c.alphaF();
+    cmd.args.blendConstants.c[0] = float(c.redF());
+    cmd.args.blendConstants.c[1] = float(c.greenF());
+    cmd.args.blendConstants.c[2] = float(c.blueF());
+    cmd.args.blendConstants.c[3] = float(c.alphaF());
     cbD->commands.append(cmd);
 }
 
@@ -1201,7 +1201,7 @@ QRhi::FrameOpResult QRhiD3D11::finish()
 void QRhiD3D11::enqueueSubresUpload(QD3D11Texture *texD, QD3D11CommandBuffer *cbD,
                                     int layer, int level, const QRhiTextureSubresourceUploadDescription &subresDesc)
 {
-    UINT subres = D3D11CalcSubresource(level, layer, texD->mipLevelCount);
+    UINT subres = D3D11CalcSubresource(UINT(level), UINT(layer), texD->mipLevelCount);
     const QPoint dp = subresDesc.destinationTopLeft();
     D3D11_BOX box;
     box.front = 0;
@@ -1232,13 +1232,13 @@ void QRhiD3D11::enqueueSubresUpload(QD3D11Texture *texD, QD3D11CommandBuffer *cb
         } else {
             cmd.args.updateSubRes.src = cbD->retainImage(img);
         }
-        box.left = dp.x();
-        box.top = dp.y();
-        box.right = dp.x() + size.width();
-        box.bottom = dp.y() + size.height();
+        box.left = UINT(dp.x());
+        box.top = UINT(dp.y());
+        box.right = UINT(dp.x() + size.width());
+        box.bottom = UINT(dp.y() + size.height());
         cmd.args.updateSubRes.hasDstBox = true;
         cmd.args.updateSubRes.dstBox = box;
-        cmd.args.updateSubRes.srcRowPitch = bpl;
+        cmd.args.updateSubRes.srcRowPitch = UINT(bpl);
     } else if (!subresDesc.data().isEmpty() && isCompressedFormat(texD->m_format)) {
         const QSize size = subresDesc.sourceSize().isEmpty() ? q->sizeForMipLevel(level, texD->m_pixelSize)
                                                              : subresDesc.sourceSize();
@@ -1248,10 +1248,10 @@ void QRhiD3D11::enqueueSubresUpload(QD3D11Texture *texD, QD3D11CommandBuffer *cb
         // Everything must be a multiple of the block width and
         // height, so e.g. a mip level of size 2x2 will be 4x4 when it
         // comes to the actual data.
-        box.left = aligned(dp.x(), blockDim.width());
-        box.top = aligned(dp.y(), blockDim.height());
-        box.right = aligned(dp.x() + size.width(), blockDim.width());
-        box.bottom = aligned(dp.y() + size.height(), blockDim.height());
+        box.left = UINT(aligned(dp.x(), blockDim.width()));
+        box.top = UINT(aligned(dp.y(), blockDim.height()));
+        box.right = UINT(aligned(dp.x() + size.width(), blockDim.width()));
+        box.bottom = UINT(aligned(dp.y() + size.height(), blockDim.height()));
         cmd.args.updateSubRes.hasDstBox = true;
         cmd.args.updateSubRes.dstBox = box;
         cmd.args.updateSubRes.src = cbD->retainData(subresDesc.data());
@@ -1261,10 +1261,10 @@ void QRhiD3D11::enqueueSubresUpload(QD3D11Texture *texD, QD3D11CommandBuffer *cb
                                                              : subresDesc.sourceSize();
         quint32 bpl = 0;
         textureFormatInfo(texD->m_format, size, &bpl, nullptr);
-        box.left = dp.x();
-        box.top = dp.y();
-        box.right = dp.x() + size.width();
-        box.bottom = dp.y() + size.height();
+        box.left = UINT(dp.x());
+        box.top = UINT(dp.y());
+        box.right = UINT(dp.x() + size.width());
+        box.bottom = UINT(dp.y() + size.height());
         cmd.args.updateSubRes.hasDstBox = true;
         cmd.args.updateSubRes.dstBox = box;
         cmd.args.updateSubRes.src = cbD->retainData(subresDesc.data());
@@ -1286,7 +1286,7 @@ void QRhiD3D11::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
     for (const QRhiResourceUpdateBatchPrivate::DynamicBufferUpdate &u : ud->dynamicBufferUpdates) {
         QD3D11Buffer *bufD = QRHI_RES(QD3D11Buffer, u.buf);
         Q_ASSERT(bufD->m_type == QRhiBuffer::Dynamic);
-        memcpy(bufD->dynBuf.data() + u.offset, u.data.constData(), u.data.size());
+        memcpy(bufD->dynBuf.data() + u.offset, u.data.constData(), size_t(u.data.size()));
         bufD->hasPendingDynamicUpdates = true;
     }
 
@@ -1304,10 +1304,10 @@ void QRhiD3D11::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
         // since the ID3D11Buffer's size is rounded up to be a multiple of 256
         // while the data we have has the original size.
         D3D11_BOX box;
-        box.left = u.offset;
+        box.left = UINT(u.offset);
         box.top = box.front = 0;
         box.back = box.bottom = 1;
-        box.right = u.offset + u.data.size(); // no -1: right, bottom, back are exclusive, see D3D11_BOX doc
+        box.right = UINT(u.offset + u.data.size()); // no -1: right, bottom, back are exclusive, see D3D11_BOX doc
         cmd.args.updateSubRes.hasDstBox = true;
         cmd.args.updateSubRes.dstBox = box;
         cbD->commands.append(cmd);
@@ -1326,25 +1326,25 @@ void QRhiD3D11::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
             Q_ASSERT(u.copy.src && u.copy.dst);
             QD3D11Texture *srcD = QRHI_RES(QD3D11Texture, u.copy.src);
             QD3D11Texture *dstD = QRHI_RES(QD3D11Texture, u.copy.dst);
-            UINT srcSubRes = D3D11CalcSubresource(u.copy.desc.sourceLevel(), u.copy.desc.sourceLayer(), srcD->mipLevelCount);
-            UINT dstSubRes = D3D11CalcSubresource(u.copy.desc.destinationLevel(), u.copy.desc.destinationLayer(), dstD->mipLevelCount);
+            UINT srcSubRes = D3D11CalcSubresource(UINT(u.copy.desc.sourceLevel()), UINT(u.copy.desc.sourceLayer()), srcD->mipLevelCount);
+            UINT dstSubRes = D3D11CalcSubresource(UINT(u.copy.desc.destinationLevel()), UINT(u.copy.desc.destinationLayer()), dstD->mipLevelCount);
             const QPoint dp = u.copy.desc.destinationTopLeft();
             const QSize size = u.copy.desc.pixelSize().isEmpty() ? srcD->m_pixelSize : u.copy.desc.pixelSize();
             const QPoint sp = u.copy.desc.sourceTopLeft();
             D3D11_BOX srcBox;
-            srcBox.left = sp.x();
-            srcBox.top = sp.y();
+            srcBox.left = UINT(sp.x());
+            srcBox.top = UINT(sp.y());
             srcBox.front = 0;
             // back, right, bottom are exclusive
-            srcBox.right = srcBox.left + size.width();
-            srcBox.bottom = srcBox.top + size.height();
+            srcBox.right = srcBox.left + UINT(size.width());
+            srcBox.bottom = srcBox.top + UINT(size.height());
             srcBox.back = 1;
             QD3D11CommandBuffer::Command cmd;
             cmd.cmd = QD3D11CommandBuffer::Command::CopySubRes;
             cmd.args.copySubRes.dst = dstD->tex;
             cmd.args.copySubRes.dstSubRes = dstSubRes;
-            cmd.args.copySubRes.dstX = dp.x();
-            cmd.args.copySubRes.dstY = dp.y();
+            cmd.args.copySubRes.dstX = UINT(dp.x());
+            cmd.args.copySubRes.dstY = UINT(dp.y());
             cmd.args.copySubRes.src = srcD->tex;
             cmd.args.copySubRes.srcSubRes = srcSubRes;
             cmd.args.copySubRes.hasSrcBox = true;
@@ -1372,7 +1372,7 @@ void QRhiD3D11::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
                 dxgiFormat = texD->dxgiFormat;
                 pixelSize = u.read.rb.level() > 0 ? q->sizeForMipLevel(u.read.rb.level(), texD->m_pixelSize) : texD->m_pixelSize;
                 format = texD->m_format;
-                subres = D3D11CalcSubresource(u.read.rb.level(), u.read.rb.layer(), texD->mipLevelCount);
+                subres = D3D11CalcSubresource(UINT(u.read.rb.level()), UINT(u.read.rb.layer()), texD->mipLevelCount);
             } else {
                 Q_ASSERT(contextState.currentSwapChain);
                 swapChainD = QRHI_RES(QD3D11SwapChain, contextState.currentSwapChain);
@@ -1401,8 +1401,8 @@ void QRhiD3D11::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
 
             D3D11_TEXTURE2D_DESC desc;
             memset(&desc, 0, sizeof(desc));
-            desc.Width = pixelSize.width();
-            desc.Height = pixelSize.height();
+            desc.Width = UINT(pixelSize.width());
+            desc.Height = UINT(pixelSize.height());
             desc.MipLevels = 1;
             desc.ArraySize = 1;
             desc.Format = dxgiFormat;
@@ -1415,7 +1415,7 @@ void QRhiD3D11::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
                 qWarning("Failed to create readback staging texture: %s", qPrintable(comErrorMessage(hr)));
                 return;
             }
-            QRHI_PROF_F(newReadbackBuffer(quint64(quintptr(stagingTex)),
+            QRHI_PROF_F(newReadbackBuffer(qint64(qintptr(stagingTex)),
                                           texD ? static_cast<QRhiResource *>(texD) : static_cast<QRhiResource *>(swapChainD),
                                           bufSize));
 
@@ -1458,7 +1458,7 @@ void QRhiD3D11::finishActiveReadbacks()
         const QRhiD3D11::ActiveReadback &aRb(activeReadbacks[i]);
         aRb.result->format = aRb.format;
         aRb.result->pixelSize = aRb.pixelSize;
-        aRb.result->data.resize(aRb.bufSize);
+        aRb.result->data.resize(int(aRb.bufSize));
 
         D3D11_MAPPED_SUBRESOURCE mp;
         HRESULT hr = context->Map(aRb.stagingTex, 0, D3D11_MAP_READ, 0, &mp);
@@ -1479,7 +1479,7 @@ void QRhiD3D11::finishActiveReadbacks()
         context->Unmap(aRb.stagingTex, 0);
 
         aRb.stagingTex->Release();
-        QRHI_PROF_F(releaseReadbackBuffer(quint64(quintptr(aRb.stagingTex))));
+        QRHI_PROF_F(releaseReadbackBuffer(qint64(qintptr(aRb.stagingTex))));
 
         if (aRb.result->completed)
             completedCallbacks.append(aRb.result->completed);
@@ -1548,10 +1548,10 @@ void QRhiD3D11::beginPass(QRhiCommandBuffer *cb,
     if (rtD->dsAttCount && wantsDsClear)
         clearCmd.args.clear.mask |= QD3D11CommandBuffer::Command::Depth | QD3D11CommandBuffer::Command::Stencil;
 
-    clearCmd.args.clear.c[0] = colorClearValue.redF();
-    clearCmd.args.clear.c[1] = colorClearValue.greenF();
-    clearCmd.args.clear.c[2] = colorClearValue.blueF();
-    clearCmd.args.clear.c[3] = colorClearValue.alphaF();
+    clearCmd.args.clear.c[0] = float(colorClearValue.redF());
+    clearCmd.args.clear.c[1] = float(colorClearValue.greenF());
+    clearCmd.args.clear.c[2] = float(colorClearValue.blueF());
+    clearCmd.args.clear.c[3] = float(colorClearValue.alphaF());
     clearCmd.args.clear.d = depthStencilClearValue.depthClearValue();
     clearCmd.args.clear.s = depthStencilClearValue.stencilClearValue();
     cbD->commands.append(clearCmd);
@@ -1582,8 +1582,8 @@ void QRhiD3D11::endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resource
             QD3D11CommandBuffer::Command cmd;
             cmd.cmd = QD3D11CommandBuffer::Command::ResolveSubRes;
             cmd.args.resolveSubRes.dst = dstTexD->tex;
-            cmd.args.resolveSubRes.dstSubRes = D3D11CalcSubresource(colorAtt.resolveLevel(),
-                                                                    colorAtt.resolveLayer(),
+            cmd.args.resolveSubRes.dstSubRes = D3D11CalcSubresource(UINT(colorAtt.resolveLevel()),
+                                                                    UINT(colorAtt.resolveLayer()),
                                                                     dstTexD->mipLevelCount);
             if (srcTexD) {
                 cmd.args.resolveSubRes.src = srcTexD->tex;
@@ -1610,7 +1610,7 @@ void QRhiD3D11::endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resource
                     continue;
                 }
             }
-            cmd.args.resolveSubRes.srcSubRes = D3D11CalcSubresource(0, colorAtt.layer(), 1);
+            cmd.args.resolveSubRes.srcSubRes = D3D11CalcSubresource(0, UINT(colorAtt.layer()), 1);
             cmd.args.resolveSubRes.format = dstTexD->dxgiFormat;
             cbD->commands.append(cmd);
         }
@@ -1677,9 +1677,9 @@ void QRhiD3D11::dispatch(QRhiCommandBuffer *cb, int x, int y, int z)
 
     QD3D11CommandBuffer::Command cmd;
     cmd.cmd = QD3D11CommandBuffer::Command::Dispatch;
-    cmd.args.dispatch.x = x;
-    cmd.args.dispatch.y = y;
-    cmd.args.dispatch.z = z;
+    cmd.args.dispatch.x = UINT(x);
+    cmd.args.dispatch.y = UINT(y);
+    cmd.args.dispatch.z = UINT(z);
     cbD->commands.append(cmd);
 }
 
@@ -1721,11 +1721,11 @@ void QRhiD3D11::updateShaderResourceBindings(QD3D11ShaderResourceBindings *srbD)
             // dynamic ubuf offsets are not considered here, those are baked in
             // at a later stage, which is good as vsubufoffsets and friends are
             // per-srb, not per-setShaderResources call
-            const uint offsetInConstants = b->u.ubuf.offset / 16;
+            const uint offsetInConstants = uint(b->u.ubuf.offset) / 16;
             // size must be 16 mult. (in constants, i.e. multiple of 256 bytes).
             // We can round up if needed since the buffers's actual size
             // (ByteWidth) is always a multiple of 256.
-            const uint sizeInConstants = aligned(b->u.ubuf.maybeSize ? b->u.ubuf.maybeSize : bufD->m_size, 256) / 16;
+            const uint sizeInConstants = uint(aligned(b->u.ubuf.maybeSize ? b->u.ubuf.maybeSize : bufD->m_size, 256) / 16);
             if (b->stage.testFlag(QRhiShaderResourceBinding::VertexStage)) {
                 srbD->vsubufs.feed(b->binding, bufD->buffer);
                 srbD->vsubufoffsets.feed(b->binding, offsetInConstants);
@@ -1843,7 +1843,7 @@ void QRhiD3D11::executeBufferHostWritesForCurrentFrame(QD3D11Buffer *bufD)
     D3D11_MAPPED_SUBRESOURCE mp;
     HRESULT hr = context->Map(bufD->buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mp);
     if (SUCCEEDED(hr)) {
-        memcpy(mp.pData, bufD->dynBuf.constData(), bufD->dynBuf.size());
+        memcpy(mp.pData, bufD->dynBuf.constData(), size_t(bufD->dynBuf.size()));
         context->Unmap(bufD->buffer, 0);
     } else {
         qWarning("Failed to map buffer: %s", qPrintable(comErrorMessage(hr)));
@@ -1856,13 +1856,13 @@ static void applyDynamicOffsets(QVarLengthArray<UINT, 4> *offsets,
                                 QRhiBatchedBindings<UINT> *ubufoffsets,
                                 const uint *dynOfsPairs, int dynOfsPairCount)
 {
-    const UINT count = ubufs->batches[batchIndex].resources.count();
+    const int count = ubufs->batches[batchIndex].resources.count();
     const UINT startBinding = ubufs->batches[batchIndex].startBinding;
     *offsets = ubufoffsets->batches[batchIndex].resources;
-    for (UINT b = 0; b < count; ++b) {
+    for (int b = 0; b < count; ++b) {
         for (int di = 0; di < dynOfsPairCount; ++di) {
             const uint binding = dynOfsPairs[2 * di];
-            if (binding == startBinding + b) {
+            if (binding == startBinding + UINT(b)) {
                 const uint offsetInConstants = dynOfsPairs[2 * di + 1];
                 (*offsets)[b] = offsetInConstants;
                 break;
@@ -1877,37 +1877,37 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
 {
     if (!offsetOnlyChange) {
         for (const auto &batch : srbD->vssamplers.batches)
-            context->VSSetSamplers(batch.startBinding, batch.resources.count(), batch.resources.constData());
+            context->VSSetSamplers(batch.startBinding, UINT(batch.resources.count()), batch.resources.constData());
 
         for (const auto &batch : srbD->vsshaderresources.batches) {
-            context->VSSetShaderResources(batch.startBinding, batch.resources.count(), batch.resources.constData());
+            context->VSSetShaderResources(batch.startBinding, UINT(batch.resources.count()), batch.resources.constData());
             contextState.vsHighestActiveSrvBinding = qMax<int>(contextState.vsHighestActiveSrvBinding,
-                                                               batch.startBinding + batch.resources.count() - 1);
+                                                               int(batch.startBinding) + batch.resources.count() - 1);
         }
 
         for (const auto &batch : srbD->fssamplers.batches)
-            context->PSSetSamplers(batch.startBinding, batch.resources.count(), batch.resources.constData());
+            context->PSSetSamplers(batch.startBinding, UINT(batch.resources.count()), batch.resources.constData());
 
         for (const auto &batch : srbD->fsshaderresources.batches) {
-            context->PSSetShaderResources(batch.startBinding, batch.resources.count(), batch.resources.constData());
+            context->PSSetShaderResources(batch.startBinding, UINT(batch.resources.count()), batch.resources.constData());
             contextState.fsHighestActiveSrvBinding = qMax<int>(contextState.fsHighestActiveSrvBinding,
-                                                               batch.startBinding + batch.resources.count() - 1);
+                                                               int(batch.startBinding) + batch.resources.count() - 1);
         }
 
         for (const auto &batch : srbD->cssamplers.batches)
-            context->CSSetSamplers(batch.startBinding, batch.resources.count(), batch.resources.constData());
+            context->CSSetSamplers(batch.startBinding, UINT(batch.resources.count()), batch.resources.constData());
 
         for (const auto &batch : srbD->csshaderresources.batches) {
-            context->CSSetShaderResources(batch.startBinding, batch.resources.count(), batch.resources.constData());
+            context->CSSetShaderResources(batch.startBinding, UINT(batch.resources.count()), batch.resources.constData());
             contextState.csHighestActiveSrvBinding = qMax<int>(contextState.csHighestActiveSrvBinding,
-                                                               batch.startBinding + batch.resources.count() - 1);
+                                                               int(batch.startBinding) + batch.resources.count() - 1);
         }
     }
 
     for (int i = 0, ie = srbD->vsubufs.batches.count(); i != ie; ++i) {
         if (!dynOfsPairCount) {
             context->VSSetConstantBuffers1(srbD->vsubufs.batches[i].startBinding,
-                                           srbD->vsubufs.batches[i].resources.count(),
+                                           UINT(srbD->vsubufs.batches[i].resources.count()),
                                            srbD->vsubufs.batches[i].resources.constData(),
                                            srbD->vsubufoffsets.batches[i].resources.constData(),
                                            srbD->vsubufsizes.batches[i].resources.constData());
@@ -1915,7 +1915,7 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
             QVarLengthArray<UINT, 4> offsets;
             applyDynamicOffsets(&offsets, i, &srbD->vsubufs, &srbD->vsubufoffsets, dynOfsPairs, dynOfsPairCount);
             context->VSSetConstantBuffers1(srbD->vsubufs.batches[i].startBinding,
-                                           srbD->vsubufs.batches[i].resources.count(),
+                                           UINT(srbD->vsubufs.batches[i].resources.count()),
                                            srbD->vsubufs.batches[i].resources.constData(),
                                            offsets.constData(),
                                            srbD->vsubufsizes.batches[i].resources.constData());
@@ -1925,7 +1925,7 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
     for (int i = 0, ie = srbD->fsubufs.batches.count(); i != ie; ++i) {
         if (!dynOfsPairCount) {
             context->PSSetConstantBuffers1(srbD->fsubufs.batches[i].startBinding,
-                                           srbD->fsubufs.batches[i].resources.count(),
+                                           UINT(srbD->fsubufs.batches[i].resources.count()),
                                            srbD->fsubufs.batches[i].resources.constData(),
                                            srbD->fsubufoffsets.batches[i].resources.constData(),
                                            srbD->fsubufsizes.batches[i].resources.constData());
@@ -1933,7 +1933,7 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
             QVarLengthArray<UINT, 4> offsets;
             applyDynamicOffsets(&offsets, i, &srbD->fsubufs, &srbD->fsubufoffsets, dynOfsPairs, dynOfsPairCount);
             context->PSSetConstantBuffers1(srbD->fsubufs.batches[i].startBinding,
-                                           srbD->fsubufs.batches[i].resources.count(),
+                                           UINT(srbD->fsubufs.batches[i].resources.count()),
                                            srbD->fsubufs.batches[i].resources.constData(),
                                            offsets.constData(),
                                            srbD->fsubufsizes.batches[i].resources.constData());
@@ -1943,7 +1943,7 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
     for (int i = 0, ie = srbD->csubufs.batches.count(); i != ie; ++i) {
         if (!dynOfsPairCount) {
             context->CSSetConstantBuffers1(srbD->csubufs.batches[i].startBinding,
-                                           srbD->csubufs.batches[i].resources.count(),
+                                           UINT(srbD->csubufs.batches[i].resources.count()),
                                            srbD->csubufs.batches[i].resources.constData(),
                                            srbD->csubufoffsets.batches[i].resources.constData(),
                                            srbD->csubufsizes.batches[i].resources.constData());
@@ -1951,7 +1951,7 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
             QVarLengthArray<UINT, 4> offsets;
             applyDynamicOffsets(&offsets, i, &srbD->csubufs, &srbD->csubufoffsets, dynOfsPairs, dynOfsPairCount);
             context->CSSetConstantBuffers1(srbD->csubufs.batches[i].startBinding,
-                                           srbD->csubufs.batches[i].resources.count(),
+                                           UINT(srbD->csubufs.batches[i].resources.count()),
                                            srbD->csubufs.batches[i].resources.constData(),
                                            offsets.constData(),
                                            srbD->csubufsizes.batches[i].resources.constData());
@@ -1960,13 +1960,13 @@ void QRhiD3D11::bindShaderResources(QD3D11ShaderResourceBindings *srbD,
 
     for (int i = 0, ie = srbD->csUAVs.batches.count(); i != ie; ++i) {
         const uint startBinding = srbD->csUAVs.batches[i].startBinding;
-        const uint count = srbD->csUAVs.batches[i].resources.count();
+        const uint count = uint(srbD->csUAVs.batches[i].resources.count());
         context->CSSetUnorderedAccessViews(startBinding,
                                            count,
                                            srbD->csUAVs.batches[i].resources.constData(),
                                            nullptr);
         contextState.csHighestActiveUavBinding = qMax<int>(contextState.csHighestActiveUavBinding,
-                                                           startBinding + count - 1);
+                                                           int(startBinding + count - 1));
     }
 }
 
@@ -1990,7 +1990,7 @@ void QRhiD3D11::resetShaderResources()
         QVarLengthArray<UINT, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT> nulloffsets(count);
         for (int i = 0; i < count; ++i)
             nulloffsets[i] = 0;
-        context->IASetVertexBuffers(0, count, nullbufs.constData(), nullstrides.constData(), nulloffsets.constData());
+        context->IASetVertexBuffers(0, UINT(count), nullbufs.constData(), nullstrides.constData(), nulloffsets.constData());
         contextState.vsHighestActiveVertexBufferBinding = -1;
     }
 
@@ -2003,15 +2003,15 @@ void QRhiD3D11::resetShaderResources()
         for (int i = 0; i < nullsrvs.count(); ++i)
             nullsrvs[i] = nullptr;
         if (contextState.vsHighestActiveSrvBinding >= 0) {
-            context->VSSetShaderResources(0, contextState.vsHighestActiveSrvBinding + 1, nullsrvs.constData());
+            context->VSSetShaderResources(0, UINT(contextState.vsHighestActiveSrvBinding + 1), nullsrvs.constData());
             contextState.vsHighestActiveSrvBinding = -1;
         }
         if (contextState.fsHighestActiveSrvBinding >= 0) {
-            context->PSSetShaderResources(0, contextState.fsHighestActiveSrvBinding + 1, nullsrvs.constData());
+            context->PSSetShaderResources(0, UINT(contextState.fsHighestActiveSrvBinding + 1), nullsrvs.constData());
             contextState.fsHighestActiveSrvBinding = -1;
         }
         if (contextState.csHighestActiveSrvBinding >= 0) {
-            context->CSSetShaderResources(0, contextState.csHighestActiveSrvBinding + 1, nullsrvs.constData());
+            context->CSSetShaderResources(0, UINT(contextState.csHighestActiveSrvBinding + 1), nullsrvs.constData());
             contextState.csHighestActiveSrvBinding = -1;
         }
     }
@@ -2022,7 +2022,7 @@ void QRhiD3D11::resetShaderResources()
                 D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT> nulluavs(nulluavCount);
         for (int i = 0; i < nulluavCount; ++i)
             nulluavs[i] = nullptr;
-        context->CSSetUnorderedAccessViews(0, nulluavCount, nulluavs.constData(), nullptr);
+        context->CSSetUnorderedAccessViews(0, UINT(nulluavCount), nulluavs.constData(), nullptr);
         contextState.csHighestActiveUavBinding = -1;
     }
 }
@@ -2044,7 +2044,7 @@ void QRhiD3D11::executeCommandBuffer(QD3D11CommandBuffer *cbD, QD3D11SwapChain *
             // writing the first timestamp only afterwards.
             context->Begin(tsDisjoint);
             QD3D11RenderTargetData *rtD = rtData(&timestampSwapChain->rt);
-            context->OMSetRenderTargets(rtD->colorAttCount, rtD->colorAttCount ? rtD->rtv : nullptr, rtD->dsv);
+            context->OMSetRenderTargets(UINT(rtD->colorAttCount), rtD->colorAttCount ? rtD->rtv : nullptr, rtD->dsv);
             context->End(tsStart); // just record a timestamp, no Begin needed
         }
     }
@@ -2057,7 +2057,7 @@ void QRhiD3D11::executeCommandBuffer(QD3D11CommandBuffer *cbD, QD3D11SwapChain *
         case QD3D11CommandBuffer::Command::SetRenderTarget:
         {
             QD3D11RenderTargetData *rtD = rtData(cmd.args.setRenderTarget.rt);
-            context->OMSetRenderTargets(rtD->colorAttCount, rtD->colorAttCount ? rtD->rtv : nullptr, rtD->dsv);
+            context->OMSetRenderTargets(UINT(rtD->colorAttCount), rtD->colorAttCount ? rtD->rtv : nullptr, rtD->dsv);
         }
             break;
         case QD3D11CommandBuffer::Command::Clear:
@@ -2073,7 +2073,7 @@ void QRhiD3D11::executeCommandBuffer(QD3D11CommandBuffer *cbD, QD3D11SwapChain *
             if (cmd.args.clear.mask & QD3D11CommandBuffer::Command::Stencil)
                 ds |= D3D11_CLEAR_STENCIL;
             if (ds)
-                context->ClearDepthStencilView(rtD->dsv, ds, cmd.args.clear.d, cmd.args.clear.s);
+                context->ClearDepthStencilView(rtD->dsv, ds, cmd.args.clear.d, UINT8(cmd.args.clear.s));
         }
             break;
         case QD3D11CommandBuffer::Command::Viewport:
@@ -2103,8 +2103,8 @@ void QRhiD3D11::executeCommandBuffer(QD3D11CommandBuffer *cbD, QD3D11SwapChain *
             contextState.vsHighestActiveVertexBufferBinding = qMax<int>(
                         contextState.vsHighestActiveVertexBufferBinding,
                         cmd.args.bindVertexBuffers.startSlot + cmd.args.bindVertexBuffers.slotCount - 1);
-            context->IASetVertexBuffers(cmd.args.bindVertexBuffers.startSlot,
-                                        cmd.args.bindVertexBuffers.slotCount,
+            context->IASetVertexBuffers(UINT(cmd.args.bindVertexBuffers.startSlot),
+                                        UINT(cmd.args.bindVertexBuffers.slotCount),
                                         cmd.args.bindVertexBuffers.buffers,
                                         cmd.args.bindVertexBuffers.strides,
                                         cmd.args.bindVertexBuffers.offsets);
@@ -2247,7 +2247,7 @@ static inline uint toD3DBufferUsage(QRhiBuffer::UsageFlags usage)
         u |= D3D11_BIND_CONSTANT_BUFFER;
     if (usage.testFlag(QRhiBuffer::StorageBuffer))
         u |= D3D11_BIND_UNORDERED_ACCESS;
-    return u;
+    return uint(u);
 }
 
 bool QD3D11Buffer::build()
@@ -2270,7 +2270,7 @@ bool QD3D11Buffer::build()
 
     D3D11_BUFFER_DESC desc;
     memset(&desc, 0, sizeof(desc));
-    desc.ByteWidth = roundedSize;
+    desc.ByteWidth = UINT(roundedSize);
     desc.Usage = m_type == Dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
     desc.BindFlags = toD3DBufferUsage(m_usage);
     desc.CPUAccessFlags = m_type == Dynamic ? D3D11_CPU_ACCESS_WRITE : 0;
@@ -2289,10 +2289,10 @@ bool QD3D11Buffer::build()
     }
 
     if (!m_objectName.isEmpty())
-        buffer->SetPrivateData(WKPDID_D3DDebugObjectName, m_objectName.size(), m_objectName.constData());
+        buffer->SetPrivateData(WKPDID_D3DDebugObjectName, UINT(m_objectName.size()), m_objectName.constData());
 
     QRHI_PROF;
-    QRHI_PROF_F(newBuffer(this, roundedSize, m_type == Dynamic ? 2 : 1, m_type == Dynamic ? 1 : 0));
+    QRHI_PROF_F(newBuffer(this, quint32(roundedSize), m_type == Dynamic ? 2 : 1, m_type == Dynamic ? 1 : 0));
 
     generation += 1;
     rhiD->registerResource(this);
@@ -2310,7 +2310,7 @@ ID3D11UnorderedAccessView *QD3D11Buffer::unorderedAccessView()
     desc.Format = DXGI_FORMAT_R32_TYPELESS;
     desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
     desc.Buffer.FirstElement = 0;
-    desc.Buffer.NumElements = aligned(m_size, 4) / 4;
+    desc.Buffer.NumElements = UINT(aligned(m_size, 4) / 4);
     desc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_RAW;
 
     QRHI_RES_RHI(QRhiD3D11);
@@ -2371,8 +2371,8 @@ bool QD3D11RenderBuffer::build()
 
     D3D11_TEXTURE2D_DESC desc;
     memset(&desc, 0, sizeof(desc));
-    desc.Width = m_pixelSize.width();
-    desc.Height = m_pixelSize.height();
+    desc.Width = UINT(m_pixelSize.width());
+    desc.Height = UINT(m_pixelSize.height());
     desc.MipLevels = 1;
     desc.ArraySize = 1;
     desc.SampleDesc = sampleDesc;
@@ -2421,10 +2421,10 @@ bool QD3D11RenderBuffer::build()
     }
 
     if (!m_objectName.isEmpty())
-        tex->SetPrivateData(WKPDID_D3DDebugObjectName, m_objectName.size(), m_objectName.constData());
+        tex->SetPrivateData(WKPDID_D3DDebugObjectName, UINT(m_objectName.size()), m_objectName.constData());
 
     QRHI_PROF;
-    QRHI_PROF_F(newRenderBuffer(this, false, false, sampleDesc.Count));
+    QRHI_PROF_F(newRenderBuffer(this, false, false, int(sampleDesc.Count)));
 
     rhiD->registerResource(this);
     return true;
@@ -2514,7 +2514,7 @@ bool QD3D11Texture::prepareBuild(QSize *adjustedSize)
 
     QRHI_RES_RHI(QRhiD3D11);
     dxgiFormat = toD3DTextureFormat(m_format, m_flags);
-    mipLevelCount = hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1;
+    mipLevelCount = uint(hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1);
     sampleDesc = rhiD->effectiveSampleCount(m_sampleCount);
     if (sampleDesc.Count > 1) {
         if (isCube) {
@@ -2600,8 +2600,8 @@ bool QD3D11Texture::build()
 
     D3D11_TEXTURE2D_DESC desc;
     memset(&desc, 0, sizeof(desc));
-    desc.Width = size.width();
-    desc.Height = size.height();
+    desc.Width = UINT(size.width());
+    desc.Height = UINT(size.height());
     desc.MipLevels = mipLevelCount;
     desc.ArraySize = isCube ? 6 : 1;
     desc.Format = dxgiFormat;
@@ -2621,10 +2621,10 @@ bool QD3D11Texture::build()
         return false;
 
     if (!m_objectName.isEmpty())
-        tex->SetPrivateData(WKPDID_D3DDebugObjectName, m_objectName.size(), m_objectName.constData());
+        tex->SetPrivateData(WKPDID_D3DDebugObjectName, UINT(m_objectName.size()), m_objectName.constData());
 
     QRHI_PROF;
-    QRHI_PROF_F(newTexture(this, true, mipLevelCount, isCube ? 6 : 1, sampleDesc.Count));
+    QRHI_PROF_F(newTexture(this, true, int(mipLevelCount), isCube ? 6 : 1, int(sampleDesc.Count)));
 
     owns = true;
     rhiD->registerResource(this);
@@ -2646,7 +2646,7 @@ bool QD3D11Texture::buildFrom(const QRhiNativeHandles *src)
         return false;
 
     QRHI_PROF;
-    QRHI_PROF_F(newTexture(this, false, mipLevelCount, m_flags.testFlag(CubeMap) ? 6 : 1, sampleDesc.Count));
+    QRHI_PROF_F(newTexture(this, false, int(mipLevelCount), m_flags.testFlag(CubeMap) ? 6 : 1, int(sampleDesc.Count)));
 
     owns = false;
     QRHI_RES_RHI(QRhiD3D11);
@@ -2670,12 +2670,12 @@ ID3D11UnorderedAccessView *QD3D11Texture::unorderedAccessViewForLevel(int level)
     desc.Format = dxgiFormat;
     if (isCube) {
         desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY;
-        desc.Texture2DArray.MipSlice = level;
+        desc.Texture2DArray.MipSlice = UINT(level);
         desc.Texture2DArray.FirstArraySlice = 0;
         desc.Texture2DArray.ArraySize = 6;
     } else {
         desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
-        desc.Texture2D.MipSlice = level;
+        desc.Texture2D.MipSlice = UINT(level);
     }
 
     QRHI_RES_RHI(QRhiD3D11);
@@ -2935,15 +2935,15 @@ bool QD3D11TextureRenderTarget::build()
             rtvDesc.Format = toD3DTextureFormat(texD->format(), texD->flags());
             if (texD->flags().testFlag(QRhiTexture::CubeMap)) {
                 rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
-                rtvDesc.Texture2DArray.MipSlice = colorAttachments[i].level();
-                rtvDesc.Texture2DArray.FirstArraySlice = colorAttachments[i].layer();
+                rtvDesc.Texture2DArray.MipSlice = UINT(colorAttachments[i].level());
+                rtvDesc.Texture2DArray.FirstArraySlice = UINT(colorAttachments[i].layer());
                 rtvDesc.Texture2DArray.ArraySize = 1;
             } else {
                 if (texD->sampleDesc.Count > 1) {
                     rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
                 } else {
                     rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
-                    rtvDesc.Texture2D.MipSlice = colorAttachments[i].level();
+                    rtvDesc.Texture2D.MipSlice = UINT(colorAttachments[i].level());
                 }
             }
             HRESULT hr = rhiD->dev->CreateRenderTargetView(texD->tex, &rtvDesc, &rtv[i]);
@@ -2954,7 +2954,7 @@ bool QD3D11TextureRenderTarget::build()
             ownsRtv[i] = true;
             if (i == 0) {
                 d.pixelSize = texD->pixelSize();
-                d.sampleCount = texD->sampleDesc.Count;
+                d.sampleCount = int(texD->sampleDesc.Count);
             }
         } else if (rb) {
             QD3D11RenderBuffer *rbD = QRHI_RES(QD3D11RenderBuffer, rb);
@@ -2962,7 +2962,7 @@ bool QD3D11TextureRenderTarget::build()
             rtv[i] = rbD->rtv;
             if (i == 0) {
                 d.pixelSize = rbD->pixelSize();
-                d.sampleCount = rbD->sampleDesc.Count;
+                d.sampleCount = int(rbD->sampleDesc.Count);
             }
         }
     }
@@ -2984,7 +2984,7 @@ bool QD3D11TextureRenderTarget::build()
             }
             if (d.colorAttCount == 0) {
                 d.pixelSize = depthTexD->pixelSize();
-                d.sampleCount = depthTexD->sampleDesc.Count;
+                d.sampleCount = int(depthTexD->sampleDesc.Count);
             }
         } else {
             ownsDsv = false;
@@ -2992,7 +2992,7 @@ bool QD3D11TextureRenderTarget::build()
             dsv = depthRbD->dsv;
             if (d.colorAttCount == 0) {
                 d.pixelSize = m_desc.depthStencilBuffer()->pixelSize();
-                d.sampleCount = depthRbD->sampleDesc.Count;
+                d.sampleCount = int(depthRbD->sampleDesc.Count);
             }
         }
         d.dsAttCount = 1;
@@ -3216,9 +3216,9 @@ static inline D3D11_PRIMITIVE_TOPOLOGY toD3DTopology(QRhiGraphicsPipeline::Topol
     }
 }
 
-static inline uint toD3DColorWriteMask(QRhiGraphicsPipeline::ColorMask c)
+static inline UINT8 toD3DColorWriteMask(QRhiGraphicsPipeline::ColorMask c)
 {
-    uint f = 0;
+    UINT8 f = 0;
     if (c.testFlag(QRhiGraphicsPipeline::R))
         f |= D3D11_COLOR_WRITE_ENABLE_RED;
     if (c.testFlag(QRhiGraphicsPipeline::G))
@@ -3353,22 +3353,22 @@ static QByteArray compileHlslShaderSource(const QShader &shader, QShader::Varian
 
     ID3DBlob *bytecode = nullptr;
     ID3DBlob *errors = nullptr;
-    HRESULT hr = d3dCompile(hlslSource.shader().constData(), hlslSource.shader().size(),
+    HRESULT hr = d3dCompile(hlslSource.shader().constData(), SIZE_T(hlslSource.shader().size()),
                             nullptr, nullptr, nullptr,
                             hlslSource.entryPoint().constData(), target, 0, 0, &bytecode, &errors);
     if (FAILED(hr) || !bytecode) {
         qWarning("HLSL shader compilation failed: 0x%x", uint(hr));
         if (errors) {
             *error = QString::fromUtf8(static_cast<const char *>(errors->GetBufferPointer()),
-                                       errors->GetBufferSize());
+                                       int(errors->GetBufferSize()));
             errors->Release();
         }
         return QByteArray();
     }
 
     QByteArray result;
-    result.resize(bytecode->GetBufferSize());
-    memcpy(result.data(), bytecode->GetBufferPointer(), result.size());
+    result.resize(int(bytecode->GetBufferSize()));
+    memcpy(result.data(), bytecode->GetBufferPointer(), size_t(result.size()));
     bytecode->Release();
     return result;
 }
@@ -3400,8 +3400,8 @@ bool QD3D11GraphicsPipeline::build()
     dsDesc.DepthFunc = toD3DCompareOp(m_depthOp);
     dsDesc.StencilEnable = m_stencilTest;
     if (m_stencilTest) {
-        dsDesc.StencilReadMask = m_stencilReadMask;
-        dsDesc.StencilWriteMask = m_stencilWriteMask;
+        dsDesc.StencilReadMask = UINT8(m_stencilReadMask);
+        dsDesc.StencilWriteMask = UINT8(m_stencilWriteMask);
         dsDesc.FrontFace.StencilFailOp = toD3DStencilOp(m_stencilFront.failOp);
         dsDesc.FrontFace.StencilDepthFailOp = toD3DStencilOp(m_stencilFront.depthFailOp);
         dsDesc.FrontFace.StencilPassOp = toD3DStencilOp(m_stencilFront.passOp);
@@ -3478,7 +3478,7 @@ bool QD3D11GraphicsPipeline::build()
 
             switch (shaderStage.type()) {
             case QRhiShaderStage::Vertex:
-                hr = rhiD->dev->CreateVertexShader(bytecode.constData(), bytecode.size(), nullptr, &vs);
+                hr = rhiD->dev->CreateVertexShader(bytecode.constData(), SIZE_T(bytecode.size()), nullptr, &vs);
                 if (FAILED(hr)) {
                     qWarning("Failed to create vertex shader: %s", qPrintable(comErrorMessage(hr)));
                     return false;
@@ -3488,7 +3488,7 @@ bool QD3D11GraphicsPipeline::build()
                 vs->AddRef();
                 break;
             case QRhiShaderStage::Fragment:
-                hr = rhiD->dev->CreatePixelShader(bytecode.constData(), bytecode.size(), nullptr, &fs);
+                hr = rhiD->dev->CreatePixelShader(bytecode.constData(), SIZE_T(bytecode.size()), nullptr, &fs);
                 if (FAILED(hr)) {
                     qWarning("Failed to create pixel shader: %s", qPrintable(comErrorMessage(hr)));
                     return false;
@@ -3513,20 +3513,21 @@ bool QD3D11GraphicsPipeline::build()
             memset(&desc, 0, sizeof(desc));
             // the output from SPIRV-Cross uses TEXCOORD<location> as the semantic
             desc.SemanticName = "TEXCOORD";
-            desc.SemanticIndex = attribute.location();
+            desc.SemanticIndex = UINT(attribute.location());
             desc.Format = toD3DAttributeFormat(attribute.format());
-            desc.InputSlot = attribute.binding();
+            desc.InputSlot = UINT(attribute.binding());
             desc.AlignedByteOffset = attribute.offset();
             const QRhiVertexInputBinding &binding(bindings[attribute.binding()]);
             if (binding.classification() == QRhiVertexInputBinding::PerInstance) {
                 desc.InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
-                desc.InstanceDataStepRate = binding.instanceStepRate();
+                desc.InstanceDataStepRate = UINT(binding.instanceStepRate());
             } else {
                 desc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
             }
             inputDescs.append(desc);
         }
-        hr = rhiD->dev->CreateInputLayout(inputDescs.constData(), inputDescs.count(), vsByteCode, vsByteCode.size(), &inputLayout);
+        hr = rhiD->dev->CreateInputLayout(inputDescs.constData(), UINT(inputDescs.count()),
+                                          vsByteCode, SIZE_T(vsByteCode.size()), &inputLayout);
         if (FAILED(hr)) {
             qWarning("Failed to create input layout: %s", qPrintable(comErrorMessage(hr)));
             return false;
@@ -3579,7 +3580,7 @@ bool QD3D11ComputePipeline::build()
             return false;
         }
 
-        HRESULT hr = rhiD->dev->CreateComputeShader(bytecode.constData(), bytecode.size(), nullptr, &cs);
+        HRESULT hr = rhiD->dev->CreateComputeShader(bytecode.constData(), SIZE_T(bytecode.size()), nullptr, &cs);
         if (FAILED(hr)) {
             qWarning("Failed to create compute shader: %s", qPrintable(comErrorMessage(hr)));
             return false;
@@ -3715,8 +3716,8 @@ bool QD3D11SwapChain::newColorBuffer(const QSize &size, DXGI_FORMAT format, DXGI
 {
     D3D11_TEXTURE2D_DESC desc;
     memset(&desc, 0, sizeof(desc));
-    desc.Width = size.width();
-    desc.Height = size.height();
+    desc.Width = UINT(size.width());
+    desc.Height = UINT(size.height());
     desc.MipLevels = 1;
     desc.ArraySize = 1;
     desc.Format = format;
@@ -3787,8 +3788,8 @@ bool QD3D11SwapChain::buildOrResize()
 
             DXGI_SWAP_CHAIN_DESC1 desc;
             memset(&desc, 0, sizeof(desc));
-            desc.Width = pixelSize.width();
-            desc.Height = pixelSize.height();
+            desc.Width = UINT(pixelSize.width());
+            desc.Height = UINT(pixelSize.height());
             desc.Format = colorFormat;
             desc.SampleDesc.Count = 1;
             desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
@@ -3813,8 +3814,8 @@ bool QD3D11SwapChain::buildOrResize()
 
             DXGI_SWAP_CHAIN_DESC desc;
             memset(&desc, 0, sizeof(desc));
-            desc.BufferDesc.Width = pixelSize.width();
-            desc.BufferDesc.Height = pixelSize.height();
+            desc.BufferDesc.Width = UINT(pixelSize.width());
+            desc.BufferDesc.Height = UINT(pixelSize.height());
             desc.BufferDesc.RefreshRate.Numerator = 60;
             desc.BufferDesc.RefreshRate.Denominator = 1;
             desc.BufferDesc.Format = colorFormat;
@@ -3836,7 +3837,7 @@ bool QD3D11SwapChain::buildOrResize()
     } else {
         releaseBuffers();
         const UINT count = useFlipDiscard ? BUFFER_COUNT : 1;
-        HRESULT hr = swapChain->ResizeBuffers(count, pixelSize.width(), pixelSize.height(),
+        HRESULT hr = swapChain->ResizeBuffers(count, UINT(pixelSize.width()), UINT(pixelSize.height()),
                                               colorFormat, swapChainFlags);
         if (FAILED(hr)) {
             qWarning("Failed to resize D3D11 swapchain: %s", qPrintable(comErrorMessage(hr)));
@@ -3899,13 +3900,13 @@ bool QD3D11SwapChain::buildOrResize()
     QD3D11ReferenceRenderTarget *rtD = QRHI_RES(QD3D11ReferenceRenderTarget, &rt);
     rtD->d.rp = QRHI_RES(QD3D11RenderPassDescriptor, m_renderPassDesc);
     rtD->d.pixelSize = pixelSize;
-    rtD->d.dpr = window->devicePixelRatio();
-    rtD->d.sampleCount = sampleDesc.Count;
+    rtD->d.dpr = float(window->devicePixelRatio());
+    rtD->d.sampleCount = int(sampleDesc.Count);
     rtD->d.colorAttCount = 1;
     rtD->d.dsAttCount = m_depthStencil ? 1 : 0;
 
     QRHI_PROF;
-    QRHI_PROF_F(resizeSwapChain(this, BUFFER_COUNT, sampleDesc.Count > 1 ? BUFFER_COUNT : 0, sampleDesc.Count));
+    QRHI_PROF_F(resizeSwapChain(this, BUFFER_COUNT, sampleDesc.Count > 1 ? BUFFER_COUNT : 0, int(sampleDesc.Count)));
     if (rhiP) {
         D3D11_QUERY_DESC queryDesc;
         memset(&queryDesc, 0, sizeof(queryDesc));
diff --git a/src/gui/rhi/qrhigles2.cpp b/src/gui/rhi/qrhigles2.cpp
index 9ad591a17a..0329acd350 100644
--- a/src/gui/rhi/qrhigles2.cpp
+++ b/src/gui/rhi/qrhigles2.cpp
@@ -654,7 +654,7 @@ static inline GLenum toGlCompressedTextureFormat(QRhiTexture::Format format, QRh
 bool QRhiGles2::isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags) const
 {
     if (isCompressedFormat(format))
-        return supportedCompressedFormats.contains(toGlCompressedTextureFormat(format, flags));
+        return supportedCompressedFormats.contains(GLint(toGlCompressedTextureFormat(format, flags)));
 
     switch (format) {
     case QRhiTexture::D16:
@@ -930,7 +930,7 @@ void QRhiGles2::setShaderResources(QRhiCommandBuffer *cb, QRhiShaderResourceBind
                 uint *p = cmd.args.bindShaderResources.dynamicOffsetPairs;
                 for (int i = 0; i < dynamicOffsetCount; ++i) {
                     const QRhiCommandBuffer::DynamicOffset &dynOfs(dynamicOffsets[i]);
-                    *p++ = dynOfs.first;
+                    *p++ = uint(dynOfs.first);
                     *p++ = dynOfs.second;
                 }
             } else {
@@ -1023,10 +1023,10 @@ void QRhiGles2::setBlendConstants(QRhiCommandBuffer *cb, const QColor &c)
 
     QGles2CommandBuffer::Command cmd;
     cmd.cmd = QGles2CommandBuffer::Command::BlendConstants;
-    cmd.args.blendConstants.r = c.redF();
-    cmd.args.blendConstants.g = c.greenF();
-    cmd.args.blendConstants.b = c.blueF();
-    cmd.args.blendConstants.a = c.alphaF();
+    cmd.args.blendConstants.r = float(c.redF());
+    cmd.args.blendConstants.g = float(c.greenF());
+    cmd.args.blendConstants.b = float(c.blueF());
+    cmd.args.blendConstants.a = float(c.alphaF());
     cbD->commands.append(cmd);
 }
 
@@ -1314,7 +1314,7 @@ void QRhiGles2::enqueueSubresUpload(QGles2Texture *texD, QGles2CommandBuffer *cb
         }
         cmd.args.subImage.target = texD->target;
         cmd.args.subImage.texture = texD->texture;
-        cmd.args.subImage.faceTarget = faceTargetBase + layer;
+        cmd.args.subImage.faceTarget = faceTargetBase + uint(layer);
         cmd.args.subImage.level = level;
         cmd.args.subImage.dx = dp.x();
         cmd.args.subImage.dy = dp.y();
@@ -1333,7 +1333,7 @@ void QRhiGles2::enqueueSubresUpload(QGles2Texture *texD, QGles2CommandBuffer *cb
             cmd.cmd = QGles2CommandBuffer::Command::CompressedSubImage;
             cmd.args.compressedSubImage.target = texD->target;
             cmd.args.compressedSubImage.texture = texD->texture;
-            cmd.args.compressedSubImage.faceTarget = faceTargetBase + layer;
+            cmd.args.compressedSubImage.faceTarget = faceTargetBase + uint(layer);
             cmd.args.compressedSubImage.level = level;
             cmd.args.compressedSubImage.dx = dp.x();
             cmd.args.compressedSubImage.dy = dp.y();
@@ -1348,7 +1348,7 @@ void QRhiGles2::enqueueSubresUpload(QGles2Texture *texD, QGles2CommandBuffer *cb
             cmd.cmd = QGles2CommandBuffer::Command::CompressedImage;
             cmd.args.compressedImage.target = texD->target;
             cmd.args.compressedImage.texture = texD->texture;
-            cmd.args.compressedImage.faceTarget = faceTargetBase + layer;
+            cmd.args.compressedImage.faceTarget = faceTargetBase + uint(layer);
             cmd.args.compressedImage.level = level;
             cmd.args.compressedImage.glintformat = texD->glintformat;
             cmd.args.compressedImage.w = size.width();
@@ -1366,7 +1366,7 @@ void QRhiGles2::enqueueSubresUpload(QGles2Texture *texD, QGles2CommandBuffer *cb
         cmd.cmd = QGles2CommandBuffer::Command::SubImage;
         cmd.args.subImage.target = texD->target;
         cmd.args.subImage.texture = texD->texture;
-        cmd.args.subImage.faceTarget = faceTargetBase + layer;
+        cmd.args.subImage.faceTarget = faceTargetBase + uint(layer);
         cmd.args.subImage.level = level;
         cmd.args.subImage.dx = dp.x();
         cmd.args.subImage.dy = dp.y();
@@ -1394,7 +1394,7 @@ void QRhiGles2::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
         QGles2Buffer *bufD = QRHI_RES(QGles2Buffer, u.buf);
         Q_ASSERT(bufD->m_type == QRhiBuffer::Dynamic);
         if (bufD->m_usage.testFlag(QRhiBuffer::UniformBuffer)) {
-            memcpy(bufD->ubuf.data() + u.offset, u.data.constData(), u.data.size());
+            memcpy(bufD->ubuf.data() + u.offset, u.data.constData(), size_t(u.data.size()));
         } else {
             trackedBufferBarrier(cbD, bufD, QGles2Buffer::AccessUpdate);
             QGles2CommandBuffer::Command cmd;
@@ -1413,7 +1413,7 @@ void QRhiGles2::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
         Q_ASSERT(bufD->m_type != QRhiBuffer::Dynamic);
         Q_ASSERT(u.offset + u.data.size() <= bufD->m_size);
         if (bufD->m_usage.testFlag(QRhiBuffer::UniformBuffer)) {
-            memcpy(bufD->ubuf.data() + u.offset, u.data.constData(), u.data.size());
+            memcpy(bufD->ubuf.data() + u.offset, u.data.constData(), size_t(u.data.size()));
         } else {
             trackedBufferBarrier(cbD, bufD, QGles2Buffer::AccessUpdate);
             QGles2CommandBuffer::Command cmd;
@@ -1458,7 +1458,7 @@ void QRhiGles2::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
             QGles2CommandBuffer::Command cmd;
             cmd.cmd = QGles2CommandBuffer::Command::CopyTex;
 
-            cmd.args.copyTex.srcFaceTarget = srcFaceTargetBase + u.copy.desc.sourceLayer();
+            cmd.args.copyTex.srcFaceTarget = srcFaceTargetBase + uint(u.copy.desc.sourceLayer());
             cmd.args.copyTex.srcTexture = srcD->texture;
             cmd.args.copyTex.srcLevel = u.copy.desc.sourceLevel();
             cmd.args.copyTex.srcX = sp.x();
@@ -1466,7 +1466,7 @@ void QRhiGles2::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
 
             cmd.args.copyTex.dstTarget = dstD->target;
             cmd.args.copyTex.dstTexture = dstD->texture;
-            cmd.args.copyTex.dstFaceTarget = dstFaceTargetBase + u.copy.desc.destinationLayer();
+            cmd.args.copyTex.dstFaceTarget = dstFaceTargetBase + uint(u.copy.desc.destinationLayer());
             cmd.args.copyTex.dstLevel = u.copy.desc.destinationLevel();
             cmd.args.copyTex.dstX = dp.x();
             cmd.args.copyTex.dstY = dp.y();
@@ -1488,7 +1488,7 @@ void QRhiGles2::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
                 cmd.args.readPixels.format = texD->m_format;
                 const GLenum faceTargetBase = texD->m_flags.testFlag(QRhiTexture::CubeMap)
                         ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : texD->target;
-                cmd.args.readPixels.readTarget = faceTargetBase + u.read.rb.layer();
+                cmd.args.readPixels.readTarget = faceTargetBase + uint(u.read.rb.layer());
                 cmd.args.readPixels.level = u.read.rb.level();
             }
             cbD->commands.append(cmd);
@@ -1848,7 +1848,7 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
                 f->glBindVertexArray(0);
             break;
         case QGles2CommandBuffer::Command::Viewport:
-            f->glViewport(cmd.args.viewport.x, cmd.args.viewport.y, cmd.args.viewport.w, cmd.args.viewport.h);
+            f->glViewport(GLint(cmd.args.viewport.x), GLint(cmd.args.viewport.y), GLsizei(cmd.args.viewport.w), GLsizei(cmd.args.viewport.h));
             f->glDepthRangef(cmd.args.viewport.d0, cmd.args.viewport.d1);
             break;
         case QGles2CommandBuffer::Command::Scissor:
@@ -1861,8 +1861,8 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
         {
             QGles2GraphicsPipeline *psD = QRHI_RES(QGles2GraphicsPipeline, cmd.args.stencilRef.ps);
             if (psD) {
-                f->glStencilFuncSeparate(GL_FRONT, toGlCompareOp(psD->m_stencilFront.compareOp), cmd.args.stencilRef.ref, psD->m_stencilReadMask);
-                f->glStencilFuncSeparate(GL_BACK, toGlCompareOp(psD->m_stencilBack.compareOp), cmd.args.stencilRef.ref, psD->m_stencilReadMask);
+                f->glStencilFuncSeparate(GL_FRONT, toGlCompareOp(psD->m_stencilFront.compareOp), GLint(cmd.args.stencilRef.ref), psD->m_stencilReadMask);
+                f->glStencilFuncSeparate(GL_BACK, toGlCompareOp(psD->m_stencilBack.compareOp), GLint(cmd.args.stencilRef.ref), psD->m_stencilReadMask);
             } else {
                 qWarning("No graphics pipeline active for setStencilRef; ignored");
             }
@@ -1882,7 +1882,7 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
                     // we do not support more than one vertex buffer
                     f->glBindBuffer(GL_ARRAY_BUFFER, cmd.args.bindVertexBuffer.buffer);
 
-                    const int stride = bindings[bindingIdx].stride();
+                    const int stride = int(bindings[bindingIdx].stride());
                     int size = 1;
                     GLenum type = GL_FLOAT;
                     bool normalize = false;
@@ -1924,13 +1924,13 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
 
                     const int locationIdx = a.location();
                     quint32 ofs = a.offset() + cmd.args.bindVertexBuffer.offset;
-                    f->glVertexAttribPointer(locationIdx, size, type, normalize, stride,
+                    f->glVertexAttribPointer(GLuint(locationIdx), size, type, normalize, stride,
                                              reinterpret_cast<const GLvoid *>(quintptr(ofs)));
-                    f->glEnableVertexAttribArray(locationIdx);
+                    f->glEnableVertexAttribArray(GLuint(locationIdx));
                     if (bindings[bindingIdx].classification() == QRhiVertexInputBinding::PerInstance
                             && caps.instancing)
                     {
-                        f->glVertexAttribDivisor(locationIdx, bindings[bindingIdx].instanceStepRate());
+                        f->glVertexAttribDivisor(GLuint(locationIdx), GLuint(bindings[bindingIdx].instanceStepRate()));
                     }
                 }
             } else {
@@ -1949,10 +1949,10 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
             QGles2GraphicsPipeline *psD = QRHI_RES(QGles2GraphicsPipeline, cmd.args.draw.ps);
             if (psD) {
                 if (cmd.args.draw.instanceCount == 1 || !caps.instancing) {
-                    f->glDrawArrays(psD->drawMode, cmd.args.draw.firstVertex, cmd.args.draw.vertexCount);
+                    f->glDrawArrays(psD->drawMode, GLint(cmd.args.draw.firstVertex), GLsizei(cmd.args.draw.vertexCount));
                 } else {
-                    f->glDrawArraysInstanced(psD->drawMode, cmd.args.draw.firstVertex, cmd.args.draw.vertexCount,
-                                             cmd.args.draw.instanceCount);
+                    f->glDrawArraysInstanced(psD->drawMode, GLint(cmd.args.draw.firstVertex), GLsizei(cmd.args.draw.vertexCount),
+                                             GLsizei(cmd.args.draw.instanceCount));
                 }
             } else {
                 qWarning("No graphics pipeline active for draw; ignored");
@@ -1968,30 +1968,30 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
                 if (cmd.args.drawIndexed.instanceCount == 1 || !caps.instancing) {
                     if (cmd.args.drawIndexed.baseVertex != 0 && caps.baseVertex) {
                         f->glDrawElementsBaseVertex(psD->drawMode,
-                                                    cmd.args.drawIndexed.indexCount,
+                                                    GLsizei(cmd.args.drawIndexed.indexCount),
                                                     indexType,
                                                     ofs,
                                                     cmd.args.drawIndexed.baseVertex);
                     } else {
                         f->glDrawElements(psD->drawMode,
-                                          cmd.args.drawIndexed.indexCount,
+                                          GLsizei(cmd.args.drawIndexed.indexCount),
                                           indexType,
                                           ofs);
                     }
                 } else {
                     if (cmd.args.drawIndexed.baseVertex != 0 && caps.baseVertex) {
                         f->glDrawElementsInstancedBaseVertex(psD->drawMode,
-                                                             cmd.args.drawIndexed.indexCount,
+                                                             GLsizei(cmd.args.drawIndexed.indexCount),
                                                              indexType,
                                                              ofs,
-                                                             cmd.args.drawIndexed.instanceCount,
+                                                             GLsizei(cmd.args.drawIndexed.instanceCount),
                                                              cmd.args.drawIndexed.baseVertex);
                     } else {
                         f->glDrawElementsInstanced(psD->drawMode,
-                                                   cmd.args.drawIndexed.indexCount,
+                                                   GLsizei(cmd.args.drawIndexed.indexCount),
                                                    indexType,
                                                    ofs,
-                                                   cmd.args.drawIndexed.instanceCount);
+                                                   GLsizei(cmd.args.drawIndexed.instanceCount));
                     }
                 }
             } else {
@@ -2016,7 +2016,7 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
                     const int colorAttCount = cmd.args.bindFramebuffer.colorAttCount;
                     QVarLengthArray<GLenum, 8> bufs;
                     for (int i = 0; i < colorAttCount; ++i)
-                        bufs.append(GL_COLOR_ATTACHMENT0 + i);
+                        bufs.append(GL_COLOR_ATTACHMENT0 + uint(i));
                     f->glDrawBuffers(colorAttCount, bufs.constData());
                 }
             } else {
@@ -2044,7 +2044,7 @@ void QRhiGles2::executeCommandBuffer(QRhiCommandBuffer *cb)
                 f->glClearDepthf(cmd.args.clear.d);
             }
             if (cmd.args.clear.mask & GL_STENCIL_BUFFER_BIT)
-                f->glClearStencil(cmd.args.clear.s);
+                f->glClearStencil(GLint(cmd.args.clear.s));
             f->glClear(cmd.args.clear.mask);
             break;
         case QGles2CommandBuffer::Command::BufferSubData:
@@ -2288,7 +2288,7 @@ void QRhiGles2::bindShaderResources(QRhiGraphicsPipeline *maybeGraphicsPs, QRhiC
             if (dynOfsCount) {
                 for (int j = 0; j < dynOfsCount; ++j) {
                     if (dynOfsPairs[2 * j] == uint(b->binding)) {
-                        viewOffset = dynOfsPairs[2 * j + 1];
+                        viewOffset = int(dynOfsPairs[2 * j + 1]);
                         break;
                     }
                 }
@@ -2379,20 +2379,20 @@ void QRhiGles2::bindShaderResources(QRhiGraphicsPipeline *maybeGraphicsPs, QRhiC
 
             for (QGles2SamplerDescription &sampler : samplers) {
                 if (sampler.binding == b->binding) {
-                    f->glActiveTexture(GL_TEXTURE0 + texUnit);
+                    f->glActiveTexture(GL_TEXTURE0 + uint(texUnit));
                     f->glBindTexture(texD->target, texD->texture);
 
                     if (texD->samplerState != samplerD->d) {
-                        f->glTexParameteri(texD->target, GL_TEXTURE_MIN_FILTER, samplerD->d.glminfilter);
-                        f->glTexParameteri(texD->target, GL_TEXTURE_MAG_FILTER, samplerD->d.glmagfilter);
-                        f->glTexParameteri(texD->target, GL_TEXTURE_WRAP_S, samplerD->d.glwraps);
-                        f->glTexParameteri(texD->target, GL_TEXTURE_WRAP_T, samplerD->d.glwrapt);
+                        f->glTexParameteri(texD->target, GL_TEXTURE_MIN_FILTER, GLint(samplerD->d.glminfilter));
+                        f->glTexParameteri(texD->target, GL_TEXTURE_MAG_FILTER, GLint(samplerD->d.glmagfilter));
+                        f->glTexParameteri(texD->target, GL_TEXTURE_WRAP_S, GLint(samplerD->d.glwraps));
+                        f->glTexParameteri(texD->target, GL_TEXTURE_WRAP_T, GLint(samplerD->d.glwrapt));
                         // 3D textures not supported by GLES 2.0 or by us atm...
                         //f->glTexParameteri(texD->target, GL_TEXTURE_WRAP_R, samplerD->d.glwrapr);
                         if (caps.textureCompareMode) {
                             if (samplerD->d.gltexcomparefunc != GL_NEVER) {
                                 f->glTexParameteri(texD->target, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
-                                f->glTexParameteri(texD->target, GL_TEXTURE_COMPARE_FUNC, samplerD->d.gltexcomparefunc);
+                                f->glTexParameteri(texD->target, GL_TEXTURE_COMPARE_FUNC, GLint(samplerD->d.gltexcomparefunc));
                             } else {
                                 f->glTexParameteri(texD->target, GL_TEXTURE_COMPARE_MODE, GL_NONE);
                             }
@@ -2419,7 +2419,7 @@ void QRhiGles2::bindShaderResources(QRhiGraphicsPipeline *maybeGraphicsPs, QRhiC
                 access = GL_READ_ONLY;
             else if (b->type == QRhiShaderResourceBinding::ImageStore)
                 access = GL_WRITE_ONLY;
-            f->glBindImageTexture(b->binding, texD->texture,
+            f->glBindImageTexture(GLuint(b->binding), texD->texture,
                                   b->u.simage.level, layered, 0,
                                   access, texD->glsizedintformat);
         }
@@ -2432,9 +2432,9 @@ void QRhiGles2::bindShaderResources(QRhiGraphicsPipeline *maybeGraphicsPs, QRhiC
         {
             QGles2Buffer *bufD = QRHI_RES(QGles2Buffer, b->u.sbuf.buf);
             if (b->u.sbuf.offset == 0 && b->u.sbuf.maybeSize == 0)
-                f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, b->binding, bufD->buffer);
+                f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, GLuint(b->binding), bufD->buffer);
             else
-                f->glBindBufferRange(GL_SHADER_STORAGE_BUFFER, b->binding, bufD->buffer,
+                f->glBindBufferRange(GL_SHADER_STORAGE_BUFFER, GLuint(b->binding), bufD->buffer,
                                      b->u.sbuf.offset, b->u.sbuf.maybeSize ? b->u.sbuf.maybeSize : bufD->m_size);
         }
             break;
@@ -2556,10 +2556,10 @@ void QRhiGles2::beginPass(QRhiCommandBuffer *cb,
         clearCmd.args.clear.mask |= GL_COLOR_BUFFER_BIT;
     if (rtD->dsAttCount && wantsDsClear)
         clearCmd.args.clear.mask |= GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
-    clearCmd.args.clear.c[0] = colorClearValue.redF();
-    clearCmd.args.clear.c[1] = colorClearValue.greenF();
-    clearCmd.args.clear.c[2] = colorClearValue.blueF();
-    clearCmd.args.clear.c[3] = colorClearValue.alphaF();
+    clearCmd.args.clear.c[0] = float(colorClearValue.redF());
+    clearCmd.args.clear.c[1] = float(colorClearValue.greenF());
+    clearCmd.args.clear.c[2] = float(colorClearValue.blueF());
+    clearCmd.args.clear.c[3] = float(colorClearValue.alphaF());
     clearCmd.args.clear.d = depthStencilClearValue.depthClearValue();
     clearCmd.args.clear.s = depthStencilClearValue.stencilClearValue();
     cbD->commands.append(clearCmd);
@@ -2597,7 +2597,7 @@ void QRhiGles2::endPass(QRhiCommandBuffer *cb, QRhiResourceUpdateBatch *resource
                 QGles2Texture *colorTexD = QRHI_RES(QGles2Texture, colorAtt.resolveTexture());
                 const GLenum faceTargetBase = colorTexD->m_flags.testFlag(QRhiTexture::CubeMap) ? GL_TEXTURE_CUBE_MAP_POSITIVE_X
                                                                                                 : colorTexD->target;
-                cmd.args.blitFromRb.target = faceTargetBase + colorAtt.resolveLayer();
+                cmd.args.blitFromRb.target = faceTargetBase + uint(colorAtt.resolveLayer());
                 cmd.args.blitFromRb.texture = colorTexD->texture;
                 cmd.args.blitFromRb.dstLevel = colorAtt.resolveLevel();
                 cbD->commands.append(cmd);
@@ -2664,9 +2664,9 @@ void QRhiGles2::dispatch(QRhiCommandBuffer *cb, int x, int y, int z)
 
     QGles2CommandBuffer::Command cmd;
     cmd.cmd = QGles2CommandBuffer::Command::Dispatch;
-    cmd.args.dispatch.x = x;
-    cmd.args.dispatch.y = y;
-    cmd.args.dispatch.z = z;
+    cmd.args.dispatch.x = GLuint(x);
+    cmd.args.dispatch.y = GLuint(y);
+    cmd.args.dispatch.z = GLuint(z);
     cbD->commands.append(cmd);
 }
 
@@ -2818,7 +2818,7 @@ void QRhiGles2::gatherUniforms(GLuint program, const QShaderDescription::Uniform
         uniform.glslLocation = f->glGetUniformLocation(program, name.constData());
         if (uniform.glslLocation >= 0) {
             uniform.binding = ub.binding;
-            uniform.offset = blockMember.offset;
+            uniform.offset = uint(blockMember.offset);
             uniform.size = blockMember.size;
             dst->append(uniform);
         }
@@ -2882,7 +2882,7 @@ bool QGles2Buffer::build()
             return false;
         }
         ubuf.resize(nonZeroSize);
-        QRHI_PROF_F(newBuffer(this, nonZeroSize, 0, 1));
+        QRHI_PROF_F(newBuffer(this, uint(nonZeroSize), 0, 1));
         return true;
     }
 
@@ -2901,7 +2901,7 @@ bool QGles2Buffer::build()
 
     usageState.access = AccessNone;
 
-    QRHI_PROF_F(newBuffer(this, nonZeroSize, 1, 0));
+    QRHI_PROF_F(newBuffer(this, uint(nonZeroSize), 1, 0));
     rhiD->registerResource(this);
     return true;
 }
@@ -3172,13 +3172,13 @@ bool QGles2Texture::build()
                 for (int layer = 0, layerCount = isCube ? 6 : 1; layer != layerCount; ++layer) {
                     for (int level = 0; level != mipLevelCount; ++level) {
                         const QSize mipSize = rhiD->q->sizeForMipLevel(level, size);
-                        rhiD->f->glTexImage2D(faceTargetBase + layer, level, glintformat,
+                        rhiD->f->glTexImage2D(faceTargetBase + uint(layer), level, GLint(glintformat),
                                               mipSize.width(), mipSize.height(), 0,
                                               glformat, gltype, nullptr);
                     }
                 }
             } else {
-                rhiD->f->glTexImage2D(target, 0, glintformat, size.width(), size.height(),
+                rhiD->f->glTexImage2D(target, 0, GLint(glintformat), size.width(), size.height(),
                                       0, glformat, gltype, nullptr);
             }
         } else {
@@ -3381,14 +3381,15 @@ bool QGles2TextureRenderTarget::build()
             QGles2Texture *texD = QRHI_RES(QGles2Texture, texture);
             Q_ASSERT(texD->texture && texD->specified);
             const GLenum faceTargetBase = texD->flags().testFlag(QRhiTexture::CubeMap) ? GL_TEXTURE_CUBE_MAP_POSITIVE_X : texD->target;
-            rhiD->f->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, faceTargetBase + colorAtt.layer(), texD->texture, colorAtt.level());
+            rhiD->f->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + uint(i), faceTargetBase + uint(colorAtt.layer()),
+                                            texD->texture, colorAtt.level());
             if (i == 0) {
                 d.pixelSize = texD->pixelSize();
                 d.sampleCount = 1;
             }
         } else if (renderBuffer) {
             QGles2RenderBuffer *rbD = QRHI_RES(QGles2RenderBuffer, renderBuffer);
-            rhiD->f->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_RENDERBUFFER, rbD->renderbuffer);
+            rhiD->f->glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + uint(i), GL_RENDERBUFFER, rbD->renderbuffer);
             if (i == 0) {
                 d.pixelSize = rbD->pixelSize();
                 d.sampleCount = rbD->samples;
@@ -3538,7 +3539,7 @@ bool QGles2GraphicsPipeline::build()
 
     for (auto inVar : vsDesc.inputVariables()) {
         const QByteArray name = inVar.name.toUtf8();
-        rhiD->f->glBindAttribLocation(program, inVar.location, name.constData());
+        rhiD->f->glBindAttribLocation(program, GLuint(inVar.location), name.constData());
     }
 
     if (!rhiD->linkProgram(program))
@@ -3684,7 +3685,7 @@ bool QGles2SwapChain::buildOrResize()
 
     rt.d.rp = QRHI_RES(QGles2RenderPassDescriptor, m_renderPassDesc);
     rt.d.pixelSize = pixelSize;
-    rt.d.dpr = m_window->devicePixelRatio();
+    rt.d.dpr = float(m_window->devicePixelRatio());
     rt.d.sampleCount = qBound(1, m_sampleCount, 64);
     rt.d.colorAttCount = 1;
     rt.d.dsAttCount = m_depthStencil ? 1 : 0;
diff --git a/src/gui/rhi/qrhimetal.mm b/src/gui/rhi/qrhimetal.mm
index a14ffa7173..3bf95ad676 100644
--- a/src/gui/rhi/qrhimetal.mm
+++ b/src/gui/rhi/qrhimetal.mm
@@ -352,7 +352,8 @@ QRhiMetal::~QRhiMetal()
     delete d;
 }
 
-static inline uint aligned(uint v, uint byteAlign)
+template <class Int>
+inline Int aligned(Int v, Int byteAlign)
 {
     return (v + byteAlign - 1) & ~(byteAlign - 1);
 }
@@ -655,7 +656,7 @@ void QRhiMetal::enqueueShaderResourceBindings(QMetalShaderResourceBindings *srbD
         {
             QMetalBuffer *bufD = QRHI_RES(QMetalBuffer, b->u.ubuf.buf);
             id<MTLBuffer> mtlbuf = bufD->d->buf[bufD->d->slotted ? currentFrameSlot : 0];
-            uint offset = b->u.ubuf.offset;
+            uint offset = uint(b->u.ubuf.offset);
             for (int i = 0; i < dynamicOffsetCount; ++i) {
                 const QRhiCommandBuffer::DynamicOffset &dynOfs(dynamicOffsets[i]);
                 if (dynOfs.first == b->binding) {
@@ -719,7 +720,7 @@ void QRhiMetal::enqueueShaderResourceBindings(QMetalShaderResourceBindings *srbD
         {
             QMetalBuffer *bufD = QRHI_RES(QMetalBuffer, b->u.sbuf.buf);
             id<MTLBuffer> mtlbuf = bufD->d->buf[0];
-            uint offset = b->u.sbuf.offset;
+            uint offset = uint(b->u.sbuf.offset);
             if (b->stage.testFlag(QRhiShaderResourceBinding::VertexStage)) {
                 res[0].buffers.feed(b->binding, mtlbuf);
                 res[0].bufferOffsets.feed(b->binding, offset);
@@ -751,17 +752,17 @@ void QRhiMetal::enqueueShaderResourceBindings(QMetalShaderResourceBindings *srbD
             case 0:
                 [cbD->d->currentRenderPassEncoder setVertexBuffers: bufferBatch.resources.constData()
                   offsets: offsetBatch.resources.constData()
-                  withRange: NSMakeRange(bufferBatch.startBinding, bufferBatch.resources.count())];
+                  withRange: NSMakeRange(bufferBatch.startBinding, NSUInteger(bufferBatch.resources.count()))];
                 break;
             case 1:
                 [cbD->d->currentRenderPassEncoder setFragmentBuffers: bufferBatch.resources.constData()
                   offsets: offsetBatch.resources.constData()
-                  withRange: NSMakeRange(bufferBatch.startBinding, bufferBatch.resources.count())];
+                  withRange: NSMakeRange(bufferBatch.startBinding, NSUInteger(bufferBatch.resources.count()))];
                 break;
             case 2:
                 [cbD->d->currentComputePassEncoder setBuffers: bufferBatch.resources.constData()
                   offsets: offsetBatch.resources.constData()
-                  withRange: NSMakeRange(bufferBatch.startBinding, bufferBatch.resources.count())];
+                  withRange: NSMakeRange(bufferBatch.startBinding, NSUInteger(bufferBatch.resources.count()))];
                 break;
             default:
                 Q_UNREACHABLE();
@@ -780,15 +781,15 @@ void QRhiMetal::enqueueShaderResourceBindings(QMetalShaderResourceBindings *srbD
             switch (idx) {
             case 0:
                 [cbD->d->currentRenderPassEncoder setVertexTextures: batch.resources.constData()
-                  withRange: NSMakeRange(batch.startBinding, batch.resources.count())];
+                  withRange: NSMakeRange(batch.startBinding, NSUInteger(batch.resources.count()))];
                 break;
             case 1:
                 [cbD->d->currentRenderPassEncoder setFragmentTextures: batch.resources.constData()
-                  withRange: NSMakeRange(batch.startBinding, batch.resources.count())];
+                  withRange: NSMakeRange(batch.startBinding, NSUInteger(batch.resources.count()))];
                 break;
             case 2:
                 [cbD->d->currentComputePassEncoder setTextures: batch.resources.constData()
-                  withRange: NSMakeRange(batch.startBinding, batch.resources.count())];
+                  withRange: NSMakeRange(batch.startBinding, NSUInteger(batch.resources.count()))];
                 break;
             default:
                 Q_UNREACHABLE();
@@ -800,15 +801,15 @@ void QRhiMetal::enqueueShaderResourceBindings(QMetalShaderResourceBindings *srbD
             switch (idx) {
             case 0:
                 [cbD->d->currentRenderPassEncoder setVertexSamplerStates: batch.resources.constData()
-                  withRange: NSMakeRange(batch.startBinding, batch.resources.count())];
+                  withRange: NSMakeRange(batch.startBinding, NSUInteger(batch.resources.count()))];
                 break;
             case 1:
                 [cbD->d->currentRenderPassEncoder setFragmentSamplerStates: batch.resources.constData()
-                  withRange: NSMakeRange(batch.startBinding, batch.resources.count())];
+                  withRange: NSMakeRange(batch.startBinding, NSUInteger(batch.resources.count()))];
                 break;
             case 2:
                 [cbD->d->currentComputePassEncoder setSamplerStates: batch.resources.constData()
-                  withRange: NSMakeRange(batch.startBinding, batch.resources.count())];
+                  withRange: NSMakeRange(batch.startBinding, NSUInteger(batch.resources.count()))];
                 break;
             default:
                 Q_UNREACHABLE();
@@ -1006,7 +1007,7 @@ void QRhiMetal::setVertexInput(QRhiCommandBuffer *cb,
             [cbD->d->currentRenderPassEncoder setVertexBuffers:
                 bufferBatch.resources.constData()
               offsets: offsetBatch.resources.constData()
-              withRange: NSMakeRange(firstVertexBinding + bufferBatch.startBinding, bufferBatch.resources.count())];
+              withRange: NSMakeRange(uint(firstVertexBinding) + bufferBatch.startBinding, NSUInteger(bufferBatch.resources.count()))];
         }
     }
 
@@ -1067,21 +1068,21 @@ void QRhiMetal::setViewport(QRhiCommandBuffer *cb, const QRhiViewport &viewport)
         return;
 
     MTLViewport vp;
-    vp.originX = x;
-    vp.originY = y;
-    vp.width = w;
-    vp.height = h;
-    vp.znear = viewport.minDepth();
-    vp.zfar = viewport.maxDepth();
+    vp.originX = double(x);
+    vp.originY = double(y);
+    vp.width = double(w);
+    vp.height = double(h);
+    vp.znear = double(viewport.minDepth());
+    vp.zfar = double(viewport.maxDepth());
 
     [cbD->d->currentRenderPassEncoder setViewport: vp];
 
     if (!QRHI_RES(QMetalGraphicsPipeline, cbD->currentGraphicsPipeline)->m_flags.testFlag(QRhiGraphicsPipeline::UsesScissor)) {
         MTLScissorRect s;
-        s.x = x;
-        s.y = y;
-        s.width = w;
-        s.height = h;
+        s.x = NSUInteger(x);
+        s.y = NSUInteger(y);
+        s.width = NSUInteger(w);
+        s.height = NSUInteger(h);
         [cbD->d->currentRenderPassEncoder setScissorRect: s];
     }
 }
@@ -1099,10 +1100,10 @@ void QRhiMetal::setScissor(QRhiCommandBuffer *cb, const QRhiScissor &scissor)
         return;
 
     MTLScissorRect s;
-    s.x = x;
-    s.y = y;
-    s.width = w;
-    s.height = h;
+    s.x = NSUInteger(x);
+    s.y = NSUInteger(y);
+    s.width = NSUInteger(w);
+    s.height = NSUInteger(h);
 
     [cbD->d->currentRenderPassEncoder setScissorRect: s];
 }
@@ -1112,7 +1113,8 @@ void QRhiMetal::setBlendConstants(QRhiCommandBuffer *cb, const QColor &c)
     QMetalCommandBuffer *cbD = QRHI_RES(QMetalCommandBuffer, cb);
     Q_ASSERT(cbD->recordingPass == QMetalCommandBuffer::RenderPass);
 
-    [cbD->d->currentRenderPassEncoder setBlendColorRed: c.redF() green: c.greenF() blue: c.blueF() alpha: c.alphaF()];
+    [cbD->d->currentRenderPassEncoder setBlendColorRed: float(c.redF())
+      green: float(c.greenF()) blue: float(c.blueF()) alpha: float(c.alphaF())];
 }
 
 void QRhiMetal::setStencilRef(QRhiCommandBuffer *cb, quint32 refValue)
@@ -1144,7 +1146,7 @@ void QRhiMetal::drawIndexed(QRhiCommandBuffer *cb, quint32 indexCount,
         return;
 
     const quint32 indexOffset = cbD->currentIndexOffset + firstIndex * (cbD->currentIndexFormat == QRhiCommandBuffer::IndexUInt16 ? 2 : 4);
-    Q_ASSERT(indexOffset == aligned(indexOffset, 4));
+    Q_ASSERT(indexOffset == aligned<quint32>(indexOffset, 4));
 
     QMetalBuffer *ibufD = QRHI_RES(QMetalBuffer, cbD->currentIndexBuffer);
     id<MTLBuffer> mtlbuf = ibufD->d->buf[ibufD->d->slotted ? currentFrameSlot : 0];
@@ -1402,7 +1404,7 @@ MTLRenderPassDescriptor *QRhiMetalData::createDefaultRenderPass(bool hasDepthSte
     MTLClearColor c = MTLClearColorMake(colorClearValue.redF(), colorClearValue.greenF(), colorClearValue.blueF(),
                                         colorClearValue.alphaF());
 
-    for (int i = 0; i < colorAttCount; ++i) {
+    for (uint i = 0; i < uint(colorAttCount); ++i) {
         rp.colorAttachments[i].loadAction = MTLLoadActionClear;
         rp.colorAttachments[i].storeAction = MTLStoreActionStore;
         rp.colorAttachments[i].clearColor = c;
@@ -1413,7 +1415,7 @@ MTLRenderPassDescriptor *QRhiMetalData::createDefaultRenderPass(bool hasDepthSte
         rp.depthAttachment.storeAction = MTLStoreActionDontCare;
         rp.stencilAttachment.loadAction = MTLLoadActionClear;
         rp.stencilAttachment.storeAction = MTLStoreActionDontCare;
-        rp.depthAttachment.clearDepth = depthStencilClearValue.depthClearValue();
+        rp.depthAttachment.clearDepth = double(depthStencilClearValue.depthClearValue());
         rp.stencilAttachment.clearStencil = depthStencilClearValue.stencilClearValue();
     }
 
@@ -1426,7 +1428,7 @@ qsizetype QRhiMetal::subresUploadByteSize(const QRhiTextureSubresourceUploadDesc
     const qsizetype imageSizeBytes = subresDesc.image().isNull() ?
                 subresDesc.data().size() : subresDesc.image().sizeInBytes();
     if (imageSizeBytes > 0)
-        size += aligned(imageSizeBytes, QRhiMetalData::TEXBUF_ALIGN);
+        size += aligned<qsizetype>(imageSizeBytes, QRhiMetalData::TEXBUF_ALIGN);
     return size;
 }
 
@@ -1454,31 +1456,31 @@ void QRhiMetal::enqueueSubresUpload(QMetalTexture *texD, void *mp, void *blitEnc
                 h = subresDesc.sourceSize().height();
             }
             if (img.depth() == 32) {
-                memcpy(reinterpret_cast<char *>(mp) + *curOfs, img.constBits(), fullImageSizeBytes);
+                memcpy(reinterpret_cast<char *>(mp) + *curOfs, img.constBits(), size_t(fullImageSizeBytes));
                 srcOffset = sy * bpl + sx * 4;
                 // bpl remains set to the original image's row stride
             } else {
                 img = img.copy(sx, sy, w, h);
                 bpl = img.bytesPerLine();
                 Q_ASSERT(img.sizeInBytes() <= fullImageSizeBytes);
-                memcpy(reinterpret_cast<char *>(mp) + *curOfs, img.constBits(), img.sizeInBytes());
+                memcpy(reinterpret_cast<char *>(mp) + *curOfs, img.constBits(), size_t(img.sizeInBytes()));
             }
         } else {
-            memcpy(reinterpret_cast<char *>(mp) + *curOfs, img.constBits(), fullImageSizeBytes);
+            memcpy(reinterpret_cast<char *>(mp) + *curOfs, img.constBits(), size_t(fullImageSizeBytes));
         }
 
         [blitEnc copyFromBuffer: texD->d->stagingBuf[currentFrameSlot]
-                                 sourceOffset: *curOfs + srcOffset
-                                 sourceBytesPerRow: bpl
+                                 sourceOffset: NSUInteger(*curOfs + srcOffset)
+                                 sourceBytesPerRow: NSUInteger(bpl)
                                  sourceBytesPerImage: 0
-                                 sourceSize: MTLSizeMake(w, h, 1)
+                                 sourceSize: MTLSizeMake(NSUInteger(w), NSUInteger(h), 1)
           toTexture: texD->d->tex
-          destinationSlice: layer
-          destinationLevel: level
-          destinationOrigin: MTLOriginMake(dp.x(), dp.y(), 0)
+          destinationSlice: NSUInteger(layer)
+          destinationLevel: NSUInteger(level)
+          destinationOrigin: MTLOriginMake(NSUInteger(dp.x()), NSUInteger(dp.y()), 0)
           options: MTLBlitOptionNone];
 
-        *curOfs += aligned(fullImageSizeBytes, QRhiMetalData::TEXBUF_ALIGN);
+        *curOfs += aligned<qsizetype>(fullImageSizeBytes, QRhiMetalData::TEXBUF_ALIGN);
     } else if (!rawData.isEmpty() && isCompressedFormat(texD->m_format)) {
         const QSize subresSize = q->sizeForMipLevel(level, texD->m_pixelSize);
         const int subresw = subresSize.width();
@@ -1503,17 +1505,17 @@ void QRhiMetal::enqueueSubresUpload(QMetalTexture *texD, void *mp, void *blitEnc
         if (dy + h != subresh)
             h = aligned(h, blockDim.height());
 
-        memcpy(reinterpret_cast<char *>(mp) + *curOfs, rawData.constData(), rawData.size());
+        memcpy(reinterpret_cast<char *>(mp) + *curOfs, rawData.constData(), size_t(rawData.size()));
 
         [blitEnc copyFromBuffer: texD->d->stagingBuf[currentFrameSlot]
-                                 sourceOffset: *curOfs
+                                 sourceOffset: NSUInteger(*curOfs)
                                  sourceBytesPerRow: bpl
                                  sourceBytesPerImage: 0
-                                 sourceSize: MTLSizeMake(w, h, 1)
+                                 sourceSize: MTLSizeMake(NSUInteger(w), NSUInteger(h), 1)
           toTexture: texD->d->tex
-          destinationSlice: layer
-          destinationLevel: level
-          destinationOrigin: MTLOriginMake(dx, dy, 0)
+          destinationSlice: NSUInteger(layer)
+          destinationLevel: NSUInteger(level)
+          destinationOrigin: MTLOriginMake(NSUInteger(dx), NSUInteger(dy), 0)
           options: MTLBlitOptionNone];
 
         *curOfs += aligned(rawData.size(), QRhiMetalData::TEXBUF_ALIGN);
@@ -1532,17 +1534,17 @@ void QRhiMetal::enqueueSubresUpload(QMetalTexture *texD, void *mp, void *blitEnc
 
         quint32 bpl = 0;
         textureFormatInfo(texD->m_format, QSize(w, h), &bpl, nullptr);
-        memcpy(reinterpret_cast<char *>(mp) + *curOfs, rawData.constData(), rawData.size());
+        memcpy(reinterpret_cast<char *>(mp) + *curOfs, rawData.constData(), size_t(rawData.size()));
 
         [blitEnc copyFromBuffer: texD->d->stagingBuf[currentFrameSlot]
-                                 sourceOffset: *curOfs
+                                 sourceOffset: NSUInteger(*curOfs)
                                  sourceBytesPerRow: bpl
                                  sourceBytesPerImage: 0
-                                 sourceSize: MTLSizeMake(w, h, 1)
+                                 sourceSize: MTLSizeMake(NSUInteger(w), NSUInteger(h), 1)
           toTexture: texD->d->tex
-          destinationSlice: layer
-          destinationLevel: level
-          destinationOrigin: MTLOriginMake(dp.x(), dp.y(), 0)
+          destinationSlice: NSUInteger(layer)
+          destinationLevel: NSUInteger(level)
+          destinationOrigin: MTLOriginMake(NSUInteger(dp.x()), NSUInteger(dp.y()), 0)
           options: MTLBlitOptionNone];
 
         *curOfs += aligned(rawData.size(), QRhiMetalData::TEXBUF_ALIGN);
@@ -1596,9 +1598,9 @@ void QRhiMetal::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
 
             ensureBlit();
             Q_ASSERT(!utexD->d->stagingBuf[currentFrameSlot]);
-            utexD->d->stagingBuf[currentFrameSlot] = [d->dev newBufferWithLength: stagingSize
+            utexD->d->stagingBuf[currentFrameSlot] = [d->dev newBufferWithLength: NSUInteger(stagingSize)
                         options: MTLResourceStorageModeShared];
-            QRHI_PROF_F(newTextureStagingArea(utexD, currentFrameSlot, stagingSize));
+            QRHI_PROF_F(newTextureStagingArea(utexD, currentFrameSlot, quint32(stagingSize)));
 
             void *mp = [utexD->d->stagingBuf[currentFrameSlot] contents];
             qsizetype curOfs = 0;
@@ -1628,14 +1630,14 @@ void QRhiMetal::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
 
             ensureBlit();
             [blitEnc copyFromTexture: srcD->d->tex
-                                      sourceSlice: u.copy.desc.sourceLayer()
-                                      sourceLevel: u.copy.desc.sourceLevel()
-                                      sourceOrigin: MTLOriginMake(sp.x(), sp.y(), 0)
-                                      sourceSize: MTLSizeMake(size.width(), size.height(), 1)
+                                      sourceSlice: NSUInteger(u.copy.desc.sourceLayer())
+                                      sourceLevel: NSUInteger(u.copy.desc.sourceLevel())
+                                      sourceOrigin: MTLOriginMake(NSUInteger(sp.x()), NSUInteger(sp.y()), 0)
+                                      sourceSize: MTLSizeMake(NSUInteger(size.width()), NSUInteger(size.height()), 1)
                                       toTexture: dstD->d->tex
-                                      destinationSlice: u.copy.desc.destinationLayer()
-                                      destinationLevel: u.copy.desc.destinationLevel()
-                                      destinationOrigin: MTLOriginMake(dp.x(), dp.y(), 0)];
+                                      destinationSlice: NSUInteger(u.copy.desc.destinationLayer())
+                                      destinationLevel: NSUInteger(u.copy.desc.destinationLevel())
+                                      destinationOrigin: MTLOriginMake(NSUInteger(dp.x()), NSUInteger(dp.y()), 0)];
 
             srcD->lastActiveFrameSlot = dstD->lastActiveFrameSlot = currentFrameSlot;
         } else if (u.type == QRhiResourceUpdateBatchPrivate::TextureOp::Read) {
@@ -1675,16 +1677,16 @@ void QRhiMetal::enqueueResourceUpdates(QRhiCommandBuffer *cb, QRhiResourceUpdate
             textureFormatInfo(aRb.format, aRb.pixelSize, &bpl, &aRb.bufSize);
             aRb.buf = [d->dev newBufferWithLength: aRb.bufSize options: MTLResourceStorageModeShared];
 
-            QRHI_PROF_F(newReadbackBuffer(quint64(quintptr(aRb.buf)),
+            QRHI_PROF_F(newReadbackBuffer(qint64(qintptr(aRb.buf)),
                                           texD ? static_cast<QRhiResource *>(texD) : static_cast<QRhiResource *>(swapChainD),
                                           aRb.bufSize));
 
             ensureBlit();
             [blitEnc copyFromTexture: src
-                                      sourceSlice: u.read.rb.layer()
-                                      sourceLevel: u.read.rb.level()
+                                      sourceSlice: NSUInteger(u.read.rb.layer())
+                                      sourceLevel: NSUInteger(u.read.rb.level())
                                       sourceOrigin: MTLOriginMake(0, 0, 0)
-                                      sourceSize: MTLSizeMake(srcSize.width(), srcSize.height(), 1)
+                                      sourceSize: MTLSizeMake(NSUInteger(srcSize.width()), NSUInteger(srcSize.height()), 1)
                                       toBuffer: aRb.buf
                                       destinationOffset: 0
                                       destinationBytesPerRow: bpl
@@ -1722,14 +1724,14 @@ void QRhiMetal::executeBufferHostWritesForCurrentFrame(QMetalBuffer *bufD)
     int changeEnd = -1;
     for (const QRhiResourceUpdateBatchPrivate::DynamicBufferUpdate &u : updates) {
         Q_ASSERT(bufD == QRHI_RES(QMetalBuffer, u.buf));
-        memcpy(static_cast<char *>(p) + u.offset, u.data.constData(), u.data.size());
+        memcpy(static_cast<char *>(p) + u.offset, u.data.constData(), size_t(u.data.size()));
         if (changeBegin == -1 || u.offset < changeBegin)
             changeBegin = u.offset;
         if (changeEnd == -1 || u.offset + u.data.size() > changeEnd)
             changeEnd = u.offset + u.data.size();
     }
     if (changeBegin >= 0 && bufD->d->managed)
-        [bufD->d->buf[idx] didModifyRange: NSMakeRange(changeBegin, changeEnd - changeBegin)];
+        [bufD->d->buf[idx] didModifyRange: NSMakeRange(NSUInteger(changeBegin), NSUInteger(changeEnd - changeBegin))];
 
     updates.clear();
 }
@@ -1786,7 +1788,7 @@ void QRhiMetal::beginPass(QRhiCommandBuffer *cb,
         rtD = rtTex->d;
         cbD->d->currentPassRpDesc = d->createDefaultRenderPass(rtD->dsAttCount, colorClearValue, depthStencilClearValue, rtD->colorAttCount);
         if (rtTex->m_flags.testFlag(QRhiTextureRenderTarget::PreserveColorContents)) {
-            for (int i = 0; i < rtD->colorAttCount; ++i)
+            for (uint i = 0; i < uint(rtD->colorAttCount); ++i)
                 cbD->d->currentPassRpDesc.colorAttachments[i].loadAction = MTLLoadActionLoad;
         }
         if (rtD->dsAttCount && rtTex->m_flags.testFlag(QRhiTextureRenderTarget::PreserveDepthStencilContents)) {
@@ -1813,15 +1815,15 @@ void QRhiMetal::beginPass(QRhiCommandBuffer *cb,
         break;
     }
 
-    for (int i = 0; i < rtD->colorAttCount; ++i) {
+    for (uint i = 0; i < uint(rtD->colorAttCount); ++i) {
         cbD->d->currentPassRpDesc.colorAttachments[i].texture = rtD->fb.colorAtt[i].tex;
-        cbD->d->currentPassRpDesc.colorAttachments[i].slice = rtD->fb.colorAtt[i].layer;
-        cbD->d->currentPassRpDesc.colorAttachments[i].level = rtD->fb.colorAtt[i].level;
+        cbD->d->currentPassRpDesc.colorAttachments[i].slice = NSUInteger(rtD->fb.colorAtt[i].layer);
+        cbD->d->currentPassRpDesc.colorAttachments[i].level = NSUInteger(rtD->fb.colorAtt[i].level);
         if (rtD->fb.colorAtt[i].resolveTex) {
             cbD->d->currentPassRpDesc.colorAttachments[i].storeAction = MTLStoreActionMultisampleResolve;
             cbD->d->currentPassRpDesc.colorAttachments[i].resolveTexture = rtD->fb.colorAtt[i].resolveTex;
-            cbD->d->currentPassRpDesc.colorAttachments[i].resolveSlice = rtD->fb.colorAtt[i].resolveLayer;
-            cbD->d->currentPassRpDesc.colorAttachments[i].resolveLevel = rtD->fb.colorAtt[i].resolveLevel;
+            cbD->d->currentPassRpDesc.colorAttachments[i].resolveSlice = NSUInteger(rtD->fb.colorAtt[i].resolveLayer);
+            cbD->d->currentPassRpDesc.colorAttachments[i].resolveLevel = NSUInteger(rtD->fb.colorAtt[i].resolveLevel);
         }
     }
 
@@ -1903,7 +1905,7 @@ void QRhiMetal::dispatch(QRhiCommandBuffer *cb, int x, int y, int z)
     Q_ASSERT(cbD->recordingPass == QMetalCommandBuffer::ComputePass);
     QMetalComputePipeline *psD = QRHI_RES(QMetalComputePipeline, cbD->currentComputePipeline);
 
-    [cbD->d->currentComputePassEncoder dispatchThreadgroups: MTLSizeMake(x, y, z)
+    [cbD->d->currentComputePassEncoder dispatchThreadgroups: MTLSizeMake(NSUInteger(x), NSUInteger(y), NSUInteger(z))
       threadsPerThreadgroup: psD->d->localSize];
 }
 
@@ -1971,12 +1973,12 @@ void QRhiMetal::finishActiveReadbacks(bool forced)
         if (forced || currentFrameSlot == aRb.activeFrameSlot || aRb.activeFrameSlot < 0) {
             aRb.result->format = aRb.format;
             aRb.result->pixelSize = aRb.pixelSize;
-            aRb.result->data.resize(aRb.bufSize);
+            aRb.result->data.resize(int(aRb.bufSize));
             void *p = [aRb.buf contents];
             memcpy(aRb.result->data.data(), p, aRb.bufSize);
             [aRb.buf release];
 
-            QRHI_PROF_F(releaseReadbackBuffer(quint64(quintptr(aRb.buf))));
+            QRHI_PROF_F(releaseReadbackBuffer(qint64(qintptr(aRb.buf))));
 
             if (aRb.result->completed)
                 completedCallbacks.append(aRb.result->completed);
@@ -2035,8 +2037,8 @@ bool QMetalBuffer::build()
         return false;
     }
 
-    const int nonZeroSize = m_size <= 0 ? 256 : m_size;
-    const int roundedSize = m_usage.testFlag(QRhiBuffer::UniformBuffer) ? aligned(nonZeroSize, 256) : nonZeroSize;
+    const uint nonZeroSize = m_size <= 0 ? 256 : uint(m_size);
+    const uint roundedSize = m_usage.testFlag(QRhiBuffer::UniformBuffer) ? aligned<uint>(nonZeroSize, 256) : nonZeroSize;
 
     d->managed = false;
     MTLResourceOptions opts = MTLResourceStorageModeShared;
@@ -2123,10 +2125,10 @@ bool QMetalRenderBuffer::build()
 
     MTLTextureDescriptor *desc = [[MTLTextureDescriptor alloc] init];
     desc.textureType = samples > 1 ? MTLTextureType2DMultisample : MTLTextureType2D;
-    desc.width = m_pixelSize.width();
-    desc.height = m_pixelSize.height();
+    desc.width = NSUInteger(m_pixelSize.width());
+    desc.height = NSUInteger(m_pixelSize.height());
     if (samples > 1)
-        desc.sampleCount = samples;
+        desc.sampleCount = NSUInteger(samples);
     desc.resourceOptions = MTLResourceStorageModePrivate;
     desc.usage = MTLTextureUsageRenderTarget;
 
@@ -2393,11 +2395,11 @@ bool QMetalTexture::build()
     else
         desc.textureType = samples > 1 ? MTLTextureType2DMultisample : MTLTextureType2D;
     desc.pixelFormat = d->format;
-    desc.width = size.width();
-    desc.height = size.height();
-    desc.mipmapLevelCount = mipLevelCount;
+    desc.width = NSUInteger(size.width());
+    desc.height = NSUInteger(size.height());
+    desc.mipmapLevelCount = NSUInteger(mipLevelCount);
     if (samples > 1)
-        desc.sampleCount = samples;
+        desc.sampleCount = NSUInteger(samples);
     desc.resourceOptions = MTLResourceStorageModePrivate;
     desc.storageMode = MTLStorageModePrivate;
     desc.usage = MTLTextureUsageShaderRead;
@@ -2463,7 +2465,7 @@ id<MTLTexture> QMetalTextureData::viewForLevel(int level)
     const MTLTextureType type = [tex textureType];
     const bool isCube = q->m_flags.testFlag(QRhiTexture::CubeMap);
     id<MTLTexture> view = [tex newTextureViewWithPixelFormat: format textureType: type
-            levels: NSMakeRange(level, 1) slices: NSMakeRange(0, isCube ? 6 : 1)];
+            levels: NSMakeRange(NSUInteger(level), 1) slices: NSMakeRange(0, isCube ? 6 : 1)];
 
     perLevelViews[level] = view;
     return view;
@@ -2673,13 +2675,13 @@ QRhiRenderPassDescriptor *QMetalTextureRenderTarget::newCompatibleRenderPassDesc
     for (int i = 0, ie = colorAttachments.count(); i != ie; ++i) {
         QMetalTexture *texD = QRHI_RES(QMetalTexture, colorAttachments[i].texture());
         QMetalRenderBuffer *rbD = QRHI_RES(QMetalRenderBuffer, colorAttachments[i].renderBuffer());
-        rpD->colorFormat[i] = texD ? texD->d->format : rbD->d->format;
+        rpD->colorFormat[i] = int(texD ? texD->d->format : rbD->d->format);
     }
 
     if (m_desc.depthTexture())
-        rpD->dsFormat = QRHI_RES(QMetalTexture, m_desc.depthTexture())->d->format;
+        rpD->dsFormat = int(QRHI_RES(QMetalTexture, m_desc.depthTexture())->d->format);
     else if (m_desc.depthStencilBuffer())
-        rpD->dsFormat = QRHI_RES(QMetalRenderBuffer, m_desc.depthStencilBuffer())->d->format;
+        rpD->dsFormat = int(QRHI_RES(QMetalRenderBuffer, m_desc.depthStencilBuffer())->d->format);
 
     return rpD;
 }
@@ -3079,7 +3081,7 @@ id<MTLLibrary> QRhiMetalData::createMetalLib(const QShader &shader, QShader::Var
     QShaderCode mtllib = shader.shader({ QShader::MetalLibShader, 12, shaderVariant });
     if (!mtllib.shader().isEmpty()) {
         dispatch_data_t data = dispatch_data_create(mtllib.shader().constData(),
-                                                    mtllib.shader().size(),
+                                                    size_t(mtllib.shader().size()),
                                                     dispatch_get_global_queue(0, 0),
                                                     DISPATCH_DATA_DESTRUCTOR_DEFAULT);
         NSError *err = nil;
@@ -3139,19 +3141,19 @@ bool QMetalGraphicsPipeline::build()
     MTLVertexDescriptor *inputLayout = [MTLVertexDescriptor vertexDescriptor];
     const QVector<QRhiVertexInputAttribute> attributes = m_vertexInputLayout.attributes();
     for (const QRhiVertexInputAttribute &attribute : attributes) {
-        const int loc = attribute.location();
+        const uint loc = uint(attribute.location());
         inputLayout.attributes[loc].format = toMetalAttributeFormat(attribute.format());
-        inputLayout.attributes[loc].offset = attribute.offset();
-        inputLayout.attributes[loc].bufferIndex = firstVertexBinding + attribute.binding();
+        inputLayout.attributes[loc].offset = NSUInteger(attribute.offset());
+        inputLayout.attributes[loc].bufferIndex = NSUInteger(firstVertexBinding + attribute.binding());
     }
     const QVector<QRhiVertexInputBinding> bindings = m_vertexInputLayout.bindings();
     for (int i = 0, ie = bindings.count(); i != ie; ++i) {
         const QRhiVertexInputBinding &binding(bindings[i]);
-        const int layoutIdx = firstVertexBinding + i;
+        const uint layoutIdx = uint(firstVertexBinding + i);
         inputLayout.layouts[layoutIdx].stepFunction =
                 binding.classification() == QRhiVertexInputBinding::PerInstance
                 ? MTLVertexStepFunctionPerInstance : MTLVertexStepFunctionPerVertex;
-        inputLayout.layouts[layoutIdx].stepRate = binding.instanceStepRate();
+        inputLayout.layouts[layoutIdx].stepRate = NSUInteger(binding.instanceStepRate());
         inputLayout.layouts[layoutIdx].stride = binding.stride();
     }
 
@@ -3239,8 +3241,8 @@ bool QMetalGraphicsPipeline::build()
         Q_ASSERT(m_targetBlends.count() == rpD->colorAttachmentCount
                  || (m_targetBlends.isEmpty() && rpD->colorAttachmentCount == 1));
 
-        for (int i = 0, ie = m_targetBlends.count(); i != ie; ++i) {
-            const QRhiGraphicsPipeline::TargetBlend &b(m_targetBlends[i]);
+        for (uint i = 0, ie = uint(m_targetBlends.count()); i != ie; ++i) {
+            const QRhiGraphicsPipeline::TargetBlend &b(m_targetBlends[int(i)]);
             rpDesc.colorAttachments[i].pixelFormat = MTLPixelFormat(rpD->colorFormat[i]);
             rpDesc.colorAttachments[i].blendingEnabled = b.enable;
             rpDesc.colorAttachments[i].sourceRGBBlendFactor = toMetalBlendFactor(b.srcColor);
@@ -3262,7 +3264,7 @@ bool QMetalGraphicsPipeline::build()
             rpDesc.stencilAttachmentPixelFormat = fmt;
     }
 
-    rpDesc.sampleCount = rhiD->effectiveSampleCount(m_sampleCount);
+    rpDesc.sampleCount = NSUInteger(rhiD->effectiveSampleCount(m_sampleCount));
 
     NSError *err = nil;
     d->ps = [rhiD->d->dev newRenderPipelineStateWithDescriptor: rpDesc error: &err];
@@ -3517,7 +3519,7 @@ QSize QMetalSwapChain::surfacePixelSize()
         CAMetalLayer *layer = (CAMetalLayer *) [v layer];
         if (layer) {
             CGSize size = [layer drawableSize];
-            return QSize(size.width, size.height);
+            return QSize(int(size.width), int(size.height));
         }
     }
     return QSize();
@@ -3532,7 +3534,7 @@ QRhiRenderPassDescriptor *QMetalSwapChain::newCompatibleRenderPassDescriptor()
     rpD->colorAttachmentCount = 1;
     rpD->hasDepthStencil = m_depthStencil != nullptr;
 
-    rpD->colorFormat[0] = d->colorFormat;
+    rpD->colorFormat[0] = int(d->colorFormat);
 
     // m_depthStencil may not be built yet so cannot rely on computed fields in it
     rpD->dsFormat = rhiD->d->dev.depth24Stencil8PixelFormatSupported
@@ -3616,7 +3618,7 @@ bool QMetalSwapChain::buildOrResize()
     }
 
     rtWrapper.d->pixelSize = pixelSize;
-    rtWrapper.d->dpr = window->devicePixelRatio();
+    rtWrapper.d->dpr = float(window->devicePixelRatio());
     rtWrapper.d->sampleCount = samples;
     rtWrapper.d->colorAttCount = 1;
     rtWrapper.d->dsAttCount = ds ? 1 : 0;
@@ -3627,9 +3629,9 @@ bool QMetalSwapChain::buildOrResize()
         MTLTextureDescriptor *desc = [[MTLTextureDescriptor alloc] init];
         desc.textureType = MTLTextureType2DMultisample;
         desc.pixelFormat = d->colorFormat;
-        desc.width = pixelSize.width();
-        desc.height = pixelSize.height();
-        desc.sampleCount = samples;
+        desc.width = NSUInteger(pixelSize.width());
+        desc.height = NSUInteger(pixelSize.height());
+        desc.sampleCount = NSUInteger(samples);
         desc.resourceOptions = MTLResourceStorageModePrivate;
         desc.storageMode = MTLStorageModePrivate;
         desc.usage = MTLTextureUsageRenderTarget;
diff --git a/src/gui/rhi/qrhiprofiler.cpp b/src/gui/rhi/qrhiprofiler.cpp
index e74e446a1c..1521c0f36e 100644
--- a/src/gui/rhi/qrhiprofiler.cpp
+++ b/src/gui/rhi/qrhiprofiler.cpp
@@ -319,7 +319,7 @@ void QRhiProfilerPrivate::writeFloat(const char *key, float f)
     Q_ASSERT(key[0] == 'F');
     buf.append(key);
     buf.append(',');
-    buf.append(QByteArray::number(f));
+    buf.append(QByteArray::number(double(f)));
     buf.append(',');
 }
 
@@ -385,7 +385,7 @@ void QRhiProfilerPrivate::newRenderBuffer(QRhiRenderBuffer *rb, bool transientBa
     const QRhiTexture::Format assumedFormat = type == QRhiRenderBuffer::DepthStencil ? QRhiTexture::D32F : QRhiTexture::RGBA8;
     quint32 byteSize = rhiDWhenEnabled->approxByteSizeForTexture(assumedFormat, sz, 1, 1);
     if (sampleCount > 1)
-        byteSize *= sampleCount;
+        byteSize *= uint(sampleCount);
 
     startEntry(QRhiProfiler::NewRenderBuffer, ts.elapsed(), rb);
     writeInt("type", type);
@@ -416,7 +416,7 @@ void QRhiProfilerPrivate::newTexture(QRhiTexture *tex, bool owns, int mipCount,
     const QSize sz = tex->pixelSize();
     quint32 byteSize = rhiDWhenEnabled->approxByteSizeForTexture(format, sz, mipCount, layerCount);
     if (sampleCount > 1)
-        byteSize *= sampleCount;
+        byteSize *= uint(sampleCount);
 
     startEntry(QRhiProfiler::NewTexture, ts.elapsed(), tex);
     writeInt("width", sz.width());
@@ -467,7 +467,7 @@ void QRhiProfilerPrivate::resizeSwapChain(QRhiSwapChain *sc, int bufferCount, in
 
     const QSize sz = sc->currentPixelSize();
     quint32 byteSize = rhiDWhenEnabled->approxByteSizeForTexture(QRhiTexture::BGRA8, sz, 1, 1);
-    byteSize = byteSize * bufferCount + byteSize * msaaBufferCount * sampleCount;
+    byteSize = byteSize * uint(bufferCount) + byteSize * uint(msaaBufferCount) * uint(sampleCount);
 
     startEntry(QRhiProfiler::ResizeSwapChain, ts.elapsed(), sc);
     writeInt("width", sz.width());
@@ -569,7 +569,7 @@ void QRhiProfilerPrivate::swapChainFrameGpuTime(QRhiSwapChain *sc, float gpuTime
     }
 }
 
-void QRhiProfilerPrivate::newReadbackBuffer(quint64 id, QRhiResource *src, quint32 size)
+void QRhiProfilerPrivate::newReadbackBuffer(qint64 id, QRhiResource *src, quint32 size)
 {
     if (!outputDevice)
         return;
@@ -580,7 +580,7 @@ void QRhiProfilerPrivate::newReadbackBuffer(quint64 id, QRhiResource *src, quint
     endEntry();
 }
 
-void QRhiProfilerPrivate::releaseReadbackBuffer(quint64 id)
+void QRhiProfilerPrivate::releaseReadbackBuffer(qint64 id)
 {
     if (!outputDevice)
         return;
@@ -590,7 +590,7 @@ void QRhiProfilerPrivate::releaseReadbackBuffer(quint64 id)
     endEntry();
 }
 
-void QRhiProfilerPrivate::vmemStat(int realAllocCount, int subAllocCount, quint32 totalSize, quint32 unusedSize)
+void QRhiProfilerPrivate::vmemStat(uint realAllocCount, uint subAllocCount, quint32 totalSize, quint32 unusedSize)
 {
     if (!outputDevice)
         return;
diff --git a/src/gui/rhi/qrhiprofiler_p_p.h b/src/gui/rhi/qrhiprofiler_p_p.h
index 49c6bd78ed..7d0f183fb1 100644
--- a/src/gui/rhi/qrhiprofiler_p_p.h
+++ b/src/gui/rhi/qrhiprofiler_p_p.h
@@ -79,10 +79,10 @@ public:
     void endSwapChainFrame(QRhiSwapChain *sc, int frameCount);
     void swapChainFrameGpuTime(QRhiSwapChain *sc, float gpuTimeMs);
 
-    void newReadbackBuffer(quint64 id, QRhiResource *src, quint32 size);
-    void releaseReadbackBuffer(quint64 id);
+    void newReadbackBuffer(qint64 id, QRhiResource *src, quint32 size);
+    void releaseReadbackBuffer(qint64 id);
 
-    void vmemStat(int realAllocCount, int subAllocCount, quint32 totalSize, quint32 unusedSize);
+    void vmemStat(uint realAllocCount, uint subAllocCount, quint32 totalSize, quint32 unusedSize);
 
     void startEntry(QRhiProfiler::StreamOp op, qint64 timestamp, QRhiResource *res);
     void writeInt(const char *key, qint64 v);
diff --git a/src/gui/rhi/qrhivulkan.cpp b/src/gui/rhi/qrhivulkan.cpp
index 4f550c6a90..c4f298dafb 100644
--- a/src/gui/rhi/qrhivulkan.cpp
+++ b/src/gui/rhi/qrhivulkan.cpp
@@ -211,7 +211,8 @@ QT_BEGIN_NAMESPACE
     \brief Holds the Vulkan render pass object backing a QRhiRenderPassDescriptor.
  */
 
-static inline VkDeviceSize aligned(VkDeviceSize v, VkDeviceSize byteAlign)
+template <class Int>
+inline Int aligned(Int v, Int byteAlign)
 {
     return (v + byteAlign - 1) & ~(byteAlign - 1);
 }
@@ -370,7 +371,7 @@ bool QRhiVulkan::create(QRhi::Flags flags)
     auto queryQueueFamilyProps = [this, &queueFamilyProps] {
         uint32_t queueCount = 0;
         f->vkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, nullptr);
-        queueFamilyProps.resize(queueCount);
+        queueFamilyProps.resize(int(queueCount));
         f->vkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, queueFamilyProps.data());
     };
 
@@ -391,7 +392,7 @@ bool QRhiVulkan::create(QRhi::Flags flags)
         int requestedPhysDevIndex = -1;
         if (qEnvironmentVariableIsSet("QT_VK_PHYSICAL_DEVICE_INDEX"))
             requestedPhysDevIndex = qEnvironmentVariableIntValue("QT_VK_PHYSICAL_DEVICE_INDEX");
-        for (uint32_t i = 0; i < physDevCount; ++i) {
+        for (int i = 0; i < int(physDevCount); ++i) {
             f->vkGetPhysicalDeviceProperties(physDevs[i], &physDevProperties);
             qCDebug(QRHI_LOG_INFO, "Physical device %d: '%s' %d.%d.%d", i,
                     physDevProperties.deviceName,
@@ -423,7 +424,7 @@ bool QRhiVulkan::create(QRhi::Flags flags)
                     i, queueFamilyProps[i].queueFlags, queueFamilyProps[i].queueCount);
             if (gfxQueueFamilyIdx == -1
                     && (queueFamilyProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
-                    && (!maybeWindow || inst->supportsPresent(physDev, i, maybeWindow)))
+                    && (!maybeWindow || inst->supportsPresent(physDev, uint32_t(i), maybeWindow)))
             {
                 if (queueFamilyProps[i].queueFlags & VK_QUEUE_COMPUTE_BIT)
                     gfxQueueFamilyIdx = i;
@@ -444,7 +445,7 @@ bool QRhiVulkan::create(QRhi::Flags flags)
         const float prio[] = { 0 };
         memset(queueInfo, 0, sizeof(queueInfo));
         queueInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-        queueInfo[0].queueFamilyIndex = gfxQueueFamilyIdx;
+        queueInfo[0].queueFamilyIndex = uint32_t(gfxQueueFamilyIdx);
         queueInfo[0].queueCount = 1;
         queueInfo[0].pQueuePriorities = prio;
 
@@ -480,9 +481,9 @@ bool QRhiVulkan::create(QRhi::Flags flags)
         devInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
         devInfo.queueCreateInfoCount = 1;
         devInfo.pQueueCreateInfos = queueInfo;
-        devInfo.enabledLayerCount = devLayers.count();
+        devInfo.enabledLayerCount = uint32_t(devLayers.count());
         devInfo.ppEnabledLayerNames = devLayers.constData();
-        devInfo.enabledExtensionCount = requestedDevExts.count();
+        devInfo.enabledExtensionCount = uint32_t(requestedDevExts.count());
         devInfo.ppEnabledExtensionNames = requestedDevExts.constData();
 
         err = f->vkCreateDevice(physDev, &devInfo, nullptr, &dev);
@@ -498,7 +499,7 @@ bool QRhiVulkan::create(QRhi::Flags flags)
         VkCommandPoolCreateInfo poolInfo;
         memset(&poolInfo, 0, sizeof(poolInfo));
         poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
-        poolInfo.queueFamilyIndex = gfxQueueFamilyIdx;
+        poolInfo.queueFamilyIndex = uint32_t(gfxQueueFamilyIdx);
         VkResult err = df->vkCreateCommandPool(dev, &poolInfo, nullptr, &cmdPool);
         if (err != VK_SUCCESS) {
             qWarning("Failed to create command pool: %d", err);
@@ -508,7 +509,7 @@ bool QRhiVulkan::create(QRhi::Flags flags)
 
     if (gfxQueueFamilyIdx != -1) {
         if (!gfxQueue)
-            df->vkGetDeviceQueue(dev, gfxQueueFamilyIdx, 0, &gfxQueue);
+            df->vkGetDeviceQueue(dev, uint32_t(gfxQueueFamilyIdx), 0, &gfxQueue);
 
         if (queueFamilyProps.isEmpty())
             queryQueueFamilyProps();
@@ -691,7 +692,7 @@ bool QRhiVulkan::allocateDescriptorSet(VkDescriptorSetAllocateInfo *allocInfo, V
             df->vkResetDescriptorPool(dev, descriptorPools[i].pool, 0);
             descriptorPools[i].allocedDescSets = 0;
         }
-        if (descriptorPools[i].allocedDescSets + allocInfo->descriptorSetCount <= QVK_DESC_SETS_PER_POOL) {
+        if (descriptorPools[i].allocedDescSets + int(allocInfo->descriptorSetCount) <= QVK_DESC_SETS_PER_POOL) {
             VkResult err = tryAllocate(i);
             if (err == VK_SUCCESS) {
                 descriptorPools[i].allocedDescSets += allocInfo->descriptorSetCount;
@@ -901,8 +902,8 @@ bool QRhiVulkan::createTransientImage(VkFormat format,
         imgInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
         imgInfo.imageType = VK_IMAGE_TYPE_2D;
         imgInfo.format = format;
-        imgInfo.extent.width = pixelSize.width();
-        imgInfo.extent.height = pixelSize.height();
+        imgInfo.extent.width = uint32_t(pixelSize.width());
+        imgInfo.extent.height = uint32_t(pixelSize.height());
         imgInfo.extent.depth = 1;
         imgInfo.mipLevels = imgInfo.arrayLayers = 1;
         imgInfo.samples = samples;
@@ -925,7 +926,7 @@ bool QRhiVulkan::createTransientImage(VkFormat format,
     VkMemoryAllocateInfo memInfo;
     memset(&memInfo, 0, sizeof(memInfo));
     memInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
-    memInfo.allocationSize = aligned(memReq.size, memReq.alignment) * count;
+    memInfo.allocationSize = aligned(memReq.size, memReq.alignment) * VkDeviceSize(count);
 
     uint32_t startIndex = 0;
     do {
@@ -1175,7 +1176,7 @@ bool QRhiVulkan::createOffscreenRenderPass(VkRenderPass *rp,
     VkSubpassDescription subpassDesc;
     memset(&subpassDesc, 0, sizeof(subpassDesc));
     subpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-    subpassDesc.colorAttachmentCount = colorRefs.count();
+    subpassDesc.colorAttachmentCount = uint32_t(colorRefs.count());
     Q_ASSERT(colorRefs.count() == resolveRefs.count());
     subpassDesc.pColorAttachments = !colorRefs.isEmpty() ? colorRefs.constData() : nullptr;
     subpassDesc.pDepthStencilAttachment = hasDepthStencil ? &dsRef : nullptr;
@@ -1184,7 +1185,7 @@ bool QRhiVulkan::createOffscreenRenderPass(VkRenderPass *rp,
     VkRenderPassCreateInfo rpInfo;
     memset(&rpInfo, 0, sizeof(rpInfo));
     rpInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
-    rpInfo.attachmentCount = attDescs.count();
+    rpInfo.attachmentCount = uint32_t(attDescs.count());
     rpInfo.pAttachments = attDescs.constData();
     rpInfo.subpassCount = 1;
     rpInfo.pSubpasses = &subpassDesc;
@@ -1325,7 +1326,7 @@ bool QRhiVulkan::recreateSwapChain(QRhiSwapChain *swapChain)
     }
     if (actualSwapChainBufferCount != reqBufferCount)
         qCDebug(QRHI_LOG_INFO, "Actual swapchain buffer count is %u", actualSwapChainBufferCount);
-    swapChainD->bufferCount = actualSwapChainBufferCount;
+    swapChainD->bufferCount = int(actualSwapChainBufferCount);
 
     VkImage swapChainImages[QVkSwapChain::MAX_BUFFER_COUNT];
     err = vkGetSwapchainImagesKHR(dev, swapChainD->sc, &actualSwapChainBufferCount, swapChainImages);
@@ -1540,12 +1541,12 @@ QRhi::FrameOpResult QRhiVulkan::beginFrame(QRhiSwapChain *swapChain, QRhi::Begin
     // will make B wait for A's frame 0 commands, so if a resource is written
     // in B's frame or when B checks for pending resource releases, that won't
     // mess up A's in-flight commands (as they are not in flight anymore).
-    waitCommandCompletion(swapChainD->currentFrameSlot);
+    waitCommandCompletion(int(swapChainD->currentFrameSlot));
 
     // Now is the time to read the timestamps for the previous frame for this slot.
     if (frame.timestampQueryIndex >= 0) {
         quint64 timestamp[2] = { 0, 0 };
-        VkResult err = df->vkGetQueryPoolResults(dev, timestampQueryPool, frame.timestampQueryIndex, 2,
+        VkResult err = df->vkGetQueryPoolResults(dev, timestampQueryPool, uint32_t(frame.timestampQueryIndex), 2,
                                                  2 * sizeof(quint64), timestamp, sizeof(quint64),
                                                  VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
         timestampQueryPoolMap.clearBit(frame.timestampQueryIndex / 2);
@@ -1585,10 +1586,10 @@ QRhi::FrameOpResult QRhiVulkan::beginFrame(QRhiSwapChain *swapChain, QRhi::Begin
         }
     }
     if (timestampQueryIdx >= 0) {
-        df->vkCmdResetQueryPool(frame.cmdBuf, timestampQueryPool, timestampQueryIdx, 2);
+        df->vkCmdResetQueryPool(frame.cmdBuf, timestampQueryPool, uint32_t(timestampQueryIdx), 2);
         // record timestamp at the start of the command buffer
         df->vkCmdWriteTimestamp(frame.cmdBuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                                timestampQueryPool, timestampQueryIdx);
+                                timestampQueryPool, uint32_t(timestampQueryIdx));
         frame.timestampQueryIndex = timestampQueryIdx;
     }
 
@@ -1598,7 +1599,7 @@ QRhi::FrameOpResult QRhiVulkan::beginFrame(QRhiSwapChain *swapChain, QRhi::Begin
     QVkSwapChain::ImageResources &image(swapChainD->imageRes[swapChainD->currentImageIndex]);
     swapChainD->rtWrapper.d.fb = image.fb;
 
-    currentFrameSlot = swapChainD->currentFrameSlot;
+    currentFrameSlot = int(swapChainD->currentFrameSlot);
     currentSwapChain = swapChainD;
     if (swapChainD->ds)
         swapChainD->ds->lastActiveFrameSlot = currentFrameSlot;
@@ -1653,7 +1654,7 @@ QRhi::FrameOpResult QRhiVulkan::endFrame(QRhiSwapChain *swapChain, QRhi::EndFram
     // record another timestamp, when enabled
     if (frame.timestampQueryIndex >= 0) {
         df->vkCmdWriteTimestamp(frame.cmdBuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-                                timestampQueryPool, frame.timestampQueryIndex + 1);
+                                timestampQueryPool, uint32_t(frame.timestampQueryIndex + 1));
     }
 
     // stop recording and submit to the queue
@@ -1932,8 +1933,8 @@ static inline QRhiPassResourceTracker::UsageState toPassTrackerUsageState(const
 {
     QRhiPassResourceTracker::UsageState u;
     u.layout = 0; // unused with buffers
-    u.access = bufUsage.access;
-    u.stage = bufUsage.stage;
+    u.access = int(bufUsage.access);
+    u.stage = int(bufUsage.stage);
     return u;
 }
 
@@ -1941,8 +1942,8 @@ static inline QRhiPassResourceTracker::UsageState toPassTrackerUsageState(const
 {
     QRhiPassResourceTracker::UsageState u;
     u.layout = texUsage.layout;
-    u.access = texUsage.access;
-    u.stage = texUsage.stage;
+    u.access = int(texUsage.access);
+    u.stage = int(texUsage.stage);
     return u;
 }
 
@@ -2106,8 +2107,8 @@ void QRhiVulkan::beginPass(QRhiCommandBuffer *cb,
     rpBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
     rpBeginInfo.renderPass = rtD->rp->rp;
     rpBeginInfo.framebuffer = rtD->fb;
-    rpBeginInfo.renderArea.extent.width = rtD->pixelSize.width();
-    rpBeginInfo.renderArea.extent.height = rtD->pixelSize.height();
+    rpBeginInfo.renderArea.extent.width = uint32_t(rtD->pixelSize.width());
+    rpBeginInfo.renderArea.extent.height = uint32_t(rtD->pixelSize.height());
 
     QVarLengthArray<VkClearValue, 4> cvs;
     for (int i = 0; i < rtD->colorAttCount; ++i) {
@@ -2127,7 +2128,7 @@ void QRhiVulkan::beginPass(QRhiCommandBuffer *cb,
                        float(colorClearValue.alphaF()) } };
         cvs.append(cv);
     }
-    rpBeginInfo.clearValueCount = cvs.count();
+    rpBeginInfo.clearValueCount = uint32_t(cvs.count());
 
     QVkCommandBuffer::Command cmd;
     cmd.cmd = QVkCommandBuffer::Command::BeginRenderPass;
@@ -2229,7 +2230,7 @@ void QRhiVulkan::dispatch(QRhiCommandBuffer *cb, int x, int y, int z)
     Q_ASSERT(cbD->recordingPass == QVkCommandBuffer::ComputePass);
 
     if (cbD->useSecondaryCb) {
-        df->vkCmdDispatch(cbD->secondaryCbs.last(), x, y, z);
+        df->vkCmdDispatch(cbD->secondaryCbs.last(), uint32_t(x), uint32_t(y), uint32_t(z));
     } else {
         QVkCommandBuffer::Command cmd;
         cmd.cmd = QVkCommandBuffer::Command::Dispatch;
@@ -2245,7 +2246,7 @@ VkShaderModule QRhiVulkan::createShader(const QByteArray &spirv)
     VkShaderModuleCreateInfo shaderInfo;
     memset(&shaderInfo, 0, sizeof(shaderInfo));
     shaderInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-    shaderInfo.codeSize = spirv.size();
+    shaderInfo.codeSize = size_t(spirv.size());
     shaderInfo.pCode = reinterpret_cast<const quint32 *>(spirv.constData());
     VkShaderModule shaderModule;
     VkResult err = df->vkCreateShaderModule(dev, &shaderInfo, nullptr, &shaderModule);
@@ -2292,7 +2293,7 @@ void QRhiVulkan::updateShaderResourceBindings(QRhiShaderResourceBindings *srb, i
             memset(&writeInfo, 0, sizeof(writeInfo));
             writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
             writeInfo.dstSet = srbD->descSets[frameSlot];
-            writeInfo.dstBinding = b->binding;
+            writeInfo.dstBinding = uint32_t(b->binding);
             writeInfo.descriptorCount = 1;
 
             switch (b->type) {
@@ -2306,8 +2307,8 @@ void QRhiVulkan::updateShaderResourceBindings(QRhiShaderResourceBindings *srb, i
                 bd.ubuf.generation = bufD->generation;
                 VkDescriptorBufferInfo bufInfo;
                 bufInfo.buffer = bufD->m_type == QRhiBuffer::Dynamic ? bufD->buffers[frameSlot] : bufD->buffers[0];
-                bufInfo.offset = b->u.ubuf.offset;
-                bufInfo.range = b->u.ubuf.maybeSize ? b->u.ubuf.maybeSize : bufD->m_size;
+                bufInfo.offset = VkDeviceSize(b->u.ubuf.offset);
+                bufInfo.range = VkDeviceSize(b->u.ubuf.maybeSize ? b->u.ubuf.maybeSize : bufD->m_size);
                 // be nice and assert when we know the vulkan device would die a horrible death due to non-aligned reads
                 Q_ASSERT(aligned(bufInfo.offset, ubufAlign) == bufInfo.offset);
                 bufferInfos.append(bufInfo);
@@ -2364,8 +2365,8 @@ void QRhiVulkan::updateShaderResourceBindings(QRhiShaderResourceBindings *srb, i
                 bd.sbuf.generation = bufD->generation;
                 VkDescriptorBufferInfo bufInfo;
                 bufInfo.buffer = bufD->m_type == QRhiBuffer::Dynamic ? bufD->buffers[frameSlot] : bufD->buffers[0];
-                bufInfo.offset = b->u.ubuf.offset;
-                bufInfo.range = b->u.ubuf.maybeSize ? b->u.ubuf.maybeSize : bufD->m_size;
+                bufInfo.offset = VkDeviceSize(b->u.ubuf.offset);
+                bufInfo.range = VkDeviceSize(b->u.ubuf.maybeSize ? b->u.ubuf.maybeSize : bufD->m_size);
                 bufferInfos.append(bufInfo);
                 writeInfo.pBufferInfo = &bufferInfos.last();
             }
@@ -2379,7 +2380,7 @@ void QRhiVulkan::updateShaderResourceBindings(QRhiShaderResourceBindings *srb, i
         ++frameSlot;
     }
 
-    df->vkUpdateDescriptorSets(dev, writeInfos.count(), writeInfos.constData(), 0, nullptr);
+    df->vkUpdateDescriptorSets(dev, uint32_t(writeInfos.count()), writeInfos.constData(), 0, nullptr);
 }
 
 static inline bool accessIsWrite(VkAccessFlags access)
@@ -2487,10 +2488,10 @@ void QRhiVulkan::subresourceBarrier(QVkCommandBuffer *cbD, VkImage image,
     memset(&barrier, 0, sizeof(barrier));
     barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
     barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    barrier.subresourceRange.baseMipLevel = startLevel;
-    barrier.subresourceRange.levelCount = levelCount;
-    barrier.subresourceRange.baseArrayLayer = startLayer;
-    barrier.subresourceRange.layerCount = layerCount;
+    barrier.subresourceRange.baseMipLevel = uint32_t(startLevel);
+    barrier.subresourceRange.levelCount = uint32_t(levelCount);
+    barrier.subresourceRange.baseArrayLayer = uint32_t(startLayer);
+    barrier.subresourceRange.layerCount = uint32_t(layerCount);
     barrier.oldLayout = oldLayout;
     barrier.newLayout = newLayout;
     barrier.srcAccessMask = srcAccess;
@@ -2511,7 +2512,7 @@ VkDeviceSize QRhiVulkan::subresUploadByteSize(const QRhiTextureSubresourceUpload
     const qsizetype imageSizeBytes = subresDesc.image().isNull() ?
                 subresDesc.data().size() : subresDesc.image().sizeInBytes();
     if (imageSizeBytes > 0)
-        size += aligned(imageSizeBytes, texbufAlign);
+        size += aligned(VkDeviceSize(imageSizeBytes), texbufAlign);
     return size;
 }
 
@@ -2528,8 +2529,8 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level,
     memset(&copyInfo, 0, sizeof(copyInfo));
     copyInfo.bufferOffset = *curOfs;
     copyInfo.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    copyInfo.imageSubresource.mipLevel = level;
-    copyInfo.imageSubresource.baseArrayLayer = layer;
+    copyInfo.imageSubresource.mipLevel = uint32_t(level);
+    copyInfo.imageSubresource.baseArrayLayer = uint32_t(layer);
     copyInfo.imageSubresource.layerCount = 1;
     copyInfo.imageExtent.depth = 1;
 
@@ -2544,7 +2545,7 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level,
         // be taken into account for bufferRowLength.
         int bpc = qMax(1, image.depth() / 8);
         // this is in pixels, not bytes, to make it more complicated...
-        copyInfo.bufferRowLength = image.bytesPerLine() / bpc;
+        copyInfo.bufferRowLength = uint32_t(image.bytesPerLine() / bpc);
         if (!subresDesc.sourceSize().isEmpty() || !subresDesc.sourceTopLeft().isNull()) {
             const int sx = subresDesc.sourceTopLeft().x();
             const int sy = subresDesc.sourceTopLeft().y();
@@ -2554,7 +2555,7 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level,
                 // The staging buffer will get the full image
                 // regardless, just adjust the vk
                 // buffer-to-image copy start offset.
-                copyInfo.bufferOffset += sy * image.bytesPerLine() + sx * 4;
+                copyInfo.bufferOffset += VkDeviceSize(sy * image.bytesPerLine() + sx * 4);
                 // bufferRowLength remains set to the original image's width
             } else {
                 image = image.copy(sx, sy, size.width(), size.height());
@@ -2563,13 +2564,13 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level,
                 // space reserved for this mip will be unused.
                 copySizeBytes = image.sizeInBytes();
                 bpc = qMax(1, image.depth() / 8);
-                copyInfo.bufferRowLength = image.bytesPerLine() / bpc;
+                copyInfo.bufferRowLength = uint32_t(image.bytesPerLine() / bpc);
             }
         }
         copyInfo.imageOffset.x = dp.x();
         copyInfo.imageOffset.y = dp.y();
-        copyInfo.imageExtent.width = size.width();
-        copyInfo.imageExtent.height = size.height();
+        copyInfo.imageExtent.width = uint32_t(size.width());
+        copyInfo.imageExtent.height = uint32_t(size.height());
         copyInfos->append(copyInfo);
     } else if (!rawData.isEmpty() && isCompressedFormat(texD->m_format)) {
         copySizeBytes = imageSizeBytes = rawData.size();
@@ -2588,8 +2589,8 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level,
         copyInfo.imageOffset.y = aligned(dp.y(), blockDim.height());
         // width and height must be multiples of the block width and height
         // or x + width and y + height must equal the subresource width and height
-        copyInfo.imageExtent.width = dp.x() + w == subresw ? w : aligned(w, blockDim.width());
-        copyInfo.imageExtent.height = dp.y() + h == subresh ? h : aligned(h, blockDim.height());
+        copyInfo.imageExtent.width = uint32_t(dp.x() + w == subresw ? w : aligned(w, blockDim.width()));
+        copyInfo.imageExtent.height = uint32_t(dp.y() + h == subresh ? h : aligned(h, blockDim.height()));
         copyInfos->append(copyInfo);
     } else if (!rawData.isEmpty()) {
         copySizeBytes = imageSizeBytes = rawData.size();
@@ -2599,15 +2600,15 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level,
             size = subresDesc.sourceSize();
         copyInfo.imageOffset.x = dp.x();
         copyInfo.imageOffset.y = dp.y();
-        copyInfo.imageExtent.width = size.width();
-        copyInfo.imageExtent.height = size.height();
+        copyInfo.imageExtent.width = uint32_t(size.width());
+        copyInfo.imageExtent.height = uint32_t(size.height());
         copyInfos->append(copyInfo);
     } else {
         qWarning("Invalid texture upload for %p layer=%d mip=%d", texD, layer, level);
     }
 
-    memcpy(reinterpret_cast<char *>(mp) + *curOfs, src, copySizeBytes);
-    *curOfs += aligned(imageSizeBytes, texbufAlign);
+    memcpy(reinterpret_cast<char *>(mp) + *curOfs, src, size_t(copySizeBytes));
+    *curOfs += aligned(VkDeviceSize(imageSizeBytes), texbufAlign);
 }
 
 void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdateBatch *resourceUpdates)
@@ -2633,7 +2634,7 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
             bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
             // must cover the entire buffer - this way multiple, partial updates per frame
             // are supported even when the staging buffer is reused (Static)
-            bufferInfo.size = bufD->m_size;
+            bufferInfo.size = VkDeviceSize(bufD->m_size);
             bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
 
             VmaAllocationCreateInfo allocInfo;
@@ -2645,7 +2646,7 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
                                            &bufD->stagingBuffers[currentFrameSlot], &allocation, nullptr);
             if (err == VK_SUCCESS) {
                 bufD->stagingAllocations[currentFrameSlot] = allocation;
-                QRHI_PROF_F(newBufferStagingArea(bufD, currentFrameSlot, bufD->m_size));
+                QRHI_PROF_F(newBufferStagingArea(bufD, currentFrameSlot, quint32(bufD->m_size)));
             } else {
                 qWarning("Failed to create staging buffer of size %d: %d", bufD->m_size, err);
                 continue;
@@ -2659,18 +2660,18 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
             qWarning("Failed to map buffer: %d", err);
             continue;
         }
-        memcpy(static_cast<uchar *>(p) + u.offset, u.data.constData(), u.data.size());
+        memcpy(static_cast<uchar *>(p) + u.offset, u.data.constData(), size_t(u.data.size()));
         vmaUnmapMemory(toVmaAllocator(allocator), a);
-        vmaFlushAllocation(toVmaAllocator(allocator), a, u.offset, u.data.size());
+        vmaFlushAllocation(toVmaAllocator(allocator), a, VkDeviceSize(u.offset), VkDeviceSize(u.data.size()));
 
         trackedBufferBarrier(cbD, bufD, 0,
                              VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
         VkBufferCopy copyInfo;
         memset(&copyInfo, 0, sizeof(copyInfo));
-        copyInfo.srcOffset = u.offset;
-        copyInfo.dstOffset = u.offset;
-        copyInfo.size = u.data.size();
+        copyInfo.srcOffset = VkDeviceSize(u.offset);
+        copyInfo.dstOffset = VkDeviceSize(u.offset);
+        copyInfo.size = VkDeviceSize(u.data.size());
 
         QVkCommandBuffer::Command cmd;
         cmd.cmd = QVkCommandBuffer::Command::CopyBuffer;
@@ -2732,7 +2733,7 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
                 continue;
             }
             utexD->stagingAllocations[currentFrameSlot] = allocation;
-            QRHI_PROF_F(newTextureStagingArea(utexD, currentFrameSlot, stagingSize));
+            QRHI_PROF_F(newTextureStagingArea(utexD, currentFrameSlot, quint32(stagingSize)));
 
             BufferImageCopyList copyInfos;
             size_t curOfs = 0;
@@ -2799,24 +2800,24 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
             memset(&region, 0, sizeof(region));
 
             region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-            region.srcSubresource.mipLevel = u.copy.desc.sourceLevel();
-            region.srcSubresource.baseArrayLayer = u.copy.desc.sourceLayer();
+            region.srcSubresource.mipLevel = uint32_t(u.copy.desc.sourceLevel());
+            region.srcSubresource.baseArrayLayer = uint32_t(u.copy.desc.sourceLayer());
             region.srcSubresource.layerCount = 1;
 
             region.srcOffset.x = u.copy.desc.sourceTopLeft().x();
             region.srcOffset.y = u.copy.desc.sourceTopLeft().y();
 
             region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-            region.dstSubresource.mipLevel = u.copy.desc.destinationLevel();
-            region.dstSubresource.baseArrayLayer = u.copy.desc.destinationLayer();
+            region.dstSubresource.mipLevel = uint32_t(u.copy.desc.destinationLevel());
+            region.dstSubresource.baseArrayLayer = uint32_t(u.copy.desc.destinationLayer());
             region.dstSubresource.layerCount = 1;
 
             region.dstOffset.x = u.copy.desc.destinationTopLeft().x();
             region.dstOffset.y = u.copy.desc.destinationTopLeft().y();
 
             const QSize size = u.copy.desc.pixelSize().isEmpty() ? srcD->m_pixelSize : u.copy.desc.pixelSize();
-            region.extent.width = size.width();
-            region.extent.height = size.height();
+            region.extent.width = uint32_t(size.width());
+            region.extent.height = uint32_t(size.height());
             region.extent.depth = 1;
 
             trackedImageBarrier(cbD, srcD, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
@@ -2883,7 +2884,7 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
             VkResult err = vmaCreateBuffer(toVmaAllocator(allocator), &bufferInfo, &allocInfo, &aRb.buf, &allocation, nullptr);
             if (err == VK_SUCCESS) {
                 aRb.bufAlloc = allocation;
-                QRHI_PROF_F(newReadbackBuffer(quint64(aRb.buf),
+                QRHI_PROF_F(newReadbackBuffer(qint64(aRb.buf),
                                               texD ? static_cast<QRhiResource *>(texD) : static_cast<QRhiResource *>(swapChainD),
                                               aRb.bufSize));
             } else {
@@ -2896,11 +2897,11 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
             memset(&copyDesc, 0, sizeof(copyDesc));
             copyDesc.bufferOffset = 0;
             copyDesc.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-            copyDesc.imageSubresource.mipLevel = u.read.rb.level();
-            copyDesc.imageSubresource.baseArrayLayer = u.read.rb.layer();
+            copyDesc.imageSubresource.mipLevel = uint32_t(u.read.rb.level());
+            copyDesc.imageSubresource.baseArrayLayer = uint32_t(u.read.rb.layer());
             copyDesc.imageSubresource.layerCount = 1;
-            copyDesc.imageExtent.width = aRb.pixelSize.width();
-            copyDesc.imageExtent.height = aRb.pixelSize.height();
+            copyDesc.imageExtent.width = uint32_t(aRb.pixelSize.width());
+            copyDesc.imageExtent.height = uint32_t(aRb.pixelSize.height());
             copyDesc.imageExtent.depth = 1;
 
             if (texD) {
@@ -2953,7 +2954,7 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
             if (!origStage)
                 origStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 
-            for (uint level = 1; level < utexD->mipLevelCount; ++level) {
+            for (int level = 1; level < int(utexD->mipLevelCount); ++level) {
                 if (level == 1) {
                     subresourceBarrier(cbD, utexD->image,
                                        origLayout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
@@ -2981,8 +2982,8 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
                 memset(&region, 0, sizeof(region));
 
                 region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-                region.srcSubresource.mipLevel = level - 1;
-                region.srcSubresource.baseArrayLayer = u.mipgen.layer;
+                region.srcSubresource.mipLevel = uint32_t(level) - 1;
+                region.srcSubresource.baseArrayLayer = uint32_t(u.mipgen.layer);
                 region.srcSubresource.layerCount = 1;
 
                 region.srcOffsets[1].x = qMax(1, w);
@@ -2990,8 +2991,8 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
                 region.srcOffsets[1].z = 1;
 
                 region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-                region.dstSubresource.mipLevel = level;
-                region.dstSubresource.baseArrayLayer = u.mipgen.layer;
+                region.dstSubresource.mipLevel = uint32_t(level);
+                region.dstSubresource.baseArrayLayer = uint32_t(u.mipgen.layer);
                 region.dstSubresource.layerCount = 1;
 
                 region.dstOffsets[1].x = qMax(1, w >> 1);
@@ -3018,13 +3019,13 @@ void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdat
                                    VK_ACCESS_TRANSFER_READ_BIT, origAccess,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, origStage,
                                    u.mipgen.layer, 1,
-                                   0, utexD->mipLevelCount - 1);
+                                   0, int(utexD->mipLevelCount) - 1);
                 subresourceBarrier(cbD, utexD->image,
                                    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, origLayout,
                                    VK_ACCESS_TRANSFER_WRITE_BIT, origAccess,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, origStage,
                                    u.mipgen.layer, 1,
-                                   utexD->mipLevelCount - 1, 1);
+                                   int(utexD->mipLevelCount) - 1, 1);
             }
 
             utexD->lastActiveFrameSlot = currentFrameSlot;
@@ -3055,7 +3056,7 @@ void QRhiVulkan::executeBufferHostWritesForCurrentFrame(QVkBuffer *bufD)
     int changeEnd = -1;
     for (const QRhiResourceUpdateBatchPrivate::DynamicBufferUpdate &u : updates) {
         Q_ASSERT(bufD == QRHI_RES(QVkBuffer, u.buf));
-        memcpy(static_cast<char *>(p) + u.offset, u.data.constData(), u.data.size());
+        memcpy(static_cast<char *>(p) + u.offset, u.data.constData(), size_t(u.data.size()));
         if (changeBegin == -1 || u.offset < changeBegin)
             changeBegin = u.offset;
         if (changeEnd == -1 || u.offset + u.data.size() > changeEnd)
@@ -3063,7 +3064,7 @@ void QRhiVulkan::executeBufferHostWritesForCurrentFrame(QVkBuffer *bufD)
     }
     vmaUnmapMemory(toVmaAllocator(allocator), a);
     if (changeBegin >= 0)
-        vmaFlushAllocation(toVmaAllocator(allocator), a, changeBegin, changeEnd - changeBegin);
+        vmaFlushAllocation(toVmaAllocator(allocator), a, VkDeviceSize(changeBegin), VkDeviceSize(changeEnd - changeBegin));
 
     updates.clear();
 }
@@ -3164,7 +3165,7 @@ void QRhiVulkan::finishActiveReadbacks(bool forced)
         if (forced || currentFrameSlot == aRb.activeFrameSlot || aRb.activeFrameSlot < 0) {
             aRb.result->format = aRb.format;
             aRb.result->pixelSize = aRb.pixelSize;
-            aRb.result->data.resize(aRb.bufSize);
+            aRb.result->data.resize(int(aRb.bufSize));
             void *p = nullptr;
             VmaAllocation a = toVmaAllocation(aRb.bufAlloc);
             VkResult err = vmaMapMemory(toVmaAllocator(allocator), a, &p);
@@ -3176,7 +3177,7 @@ void QRhiVulkan::finishActiveReadbacks(bool forced)
             vmaUnmapMemory(toVmaAllocator(allocator), a);
 
             vmaDestroyBuffer(toVmaAllocator(allocator), aRb.buf, a);
-            QRHI_PROF_F(releaseReadbackBuffer(quint64(aRb.buf)));
+            QRHI_PROF_F(releaseReadbackBuffer(qint64(aRb.buf)));
 
             if (aRb.result->completed)
                 completedCallbacks.append(aRb.result->completed);
@@ -3266,7 +3267,7 @@ void QRhiVulkan::recordPrimaryCommandBuffer(QVkCommandBuffer *cbD)
         case QVkCommandBuffer::Command::CopyBufferToImage:
             df->vkCmdCopyBufferToImage(cbD->cb, cmd.args.copyBufferToImage.src, cmd.args.copyBufferToImage.dst,
                                        cmd.args.copyBufferToImage.dstLayout,
-                                       cmd.args.copyBufferToImage.count,
+                                       uint32_t(cmd.args.copyBufferToImage.count),
                                        cbD->pools.bufferImageCopy.constData() + cmd.args.copyBufferToImage.bufferImageCopyIndex);
             break;
         case QVkCommandBuffer::Command::CopyImage:
@@ -3315,13 +3316,13 @@ void QRhiVulkan::recordPrimaryCommandBuffer(QVkCommandBuffer *cbD)
             df->vkCmdBindDescriptorSets(cbD->cb, cmd.args.bindDescriptorSet.bindPoint,
                                         cmd.args.bindDescriptorSet.pipelineLayout,
                                         0, 1, &cmd.args.bindDescriptorSet.descSet,
-                                        cmd.args.bindDescriptorSet.dynamicOffsetCount,
+                                        uint32_t(cmd.args.bindDescriptorSet.dynamicOffsetCount),
                                         offsets);
         }
             break;
         case QVkCommandBuffer::Command::BindVertexBuffer:
-            df->vkCmdBindVertexBuffers(cbD->cb, cmd.args.bindVertexBuffer.startBinding,
-                                       cmd.args.bindVertexBuffer.count,
+            df->vkCmdBindVertexBuffers(cbD->cb, uint32_t(cmd.args.bindVertexBuffer.startBinding),
+                                       uint32_t(cmd.args.bindVertexBuffer.count),
                                        cbD->pools.vertexBuffer.constData() + cmd.args.bindVertexBuffer.vertexBufferIndex,
                                        cbD->pools.vertexBufferOffset.constData() + cmd.args.bindVertexBuffer.vertexBufferOffsetIndex);
             break;
@@ -3367,7 +3368,7 @@ void QRhiVulkan::recordPrimaryCommandBuffer(QVkCommandBuffer *cbD)
             recordTransitionPassResources(cbD, cbD->passResTrackers[cmd.args.transitionResources.trackerIndex]);
             break;
         case QVkCommandBuffer::Command::Dispatch:
-            df->vkCmdDispatch(cbD->cb, cmd.args.dispatch.x, cmd.args.dispatch.y, cmd.args.dispatch.z);
+            df->vkCmdDispatch(cbD->cb, uint32_t(cmd.args.dispatch.x), uint32_t(cmd.args.dispatch.y), uint32_t(cmd.args.dispatch.z));
             break;
         case QVkCommandBuffer::Command::ExecuteSecondary:
             df->vkCmdExecuteCommands(cbD->cb, 1, &cmd.args.executeSecondary.cb);
@@ -3421,8 +3422,8 @@ static inline VkPipelineStageFlags toVkPipelineStage(QRhiPassResourceTracker::Bu
 static inline QVkBuffer::UsageState toVkBufferUsageState(QRhiPassResourceTracker::UsageState usage)
 {
     QVkBuffer::UsageState u;
-    u.access = usage.access;
-    u.stage = usage.stage;
+    u.access = VkAccessFlags(usage.access);
+    u.stage = VkPipelineStageFlags(usage.stage);
     return u;
 }
 
@@ -3494,8 +3495,8 @@ static inline QVkTexture::UsageState toVkTextureUsageState(QRhiPassResourceTrack
 {
     QVkTexture::UsageState u;
     u.layout = VkImageLayout(usage.layout);
-    u.access = usage.access;
-    u.stage = usage.stage;
+    u.access = VkAccessFlags(usage.access);
+    u.stage = VkPipelineStageFlags(usage.stage);
     return u;
 }
 
@@ -3603,7 +3604,7 @@ QRhiBuffer *QRhiVulkan::createBuffer(QRhiBuffer::Type type, QRhiBuffer::UsageFla
 
 int QRhiVulkan::ubufAlignment() const
 {
-    return ubufAlign; // typically 256 (bytes)
+    return int(ubufAlign); // typically 256 (bytes)
 }
 
 bool QRhiVulkan::isYUpInFramebuffer() const
@@ -3711,9 +3712,9 @@ int QRhiVulkan::resourceLimit(QRhi::ResourceLimit limit) const
     case QRhi::TextureSizeMin:
         return 1;
     case QRhi::TextureSizeMax:
-        return physDevProperties.limits.maxImageDimension2D;
+        return int(physDevProperties.limits.maxImageDimension2D);
     case QRhi::MaxColorAttachments:
-        return physDevProperties.limits.maxColorAttachments;
+        return int(physDevProperties.limits.maxColorAttachments);
     case QRhi::FramesInFlight:
         return QVK_FRAMES_IN_FLIGHT;
     default:
@@ -3736,7 +3737,7 @@ void QRhiVulkan::sendVMemStatsToProfiler()
     VmaStats stats;
     vmaCalculateStats(toVmaAllocator(allocator), &stats);
     QRHI_PROF_F(vmemStat(stats.total.blockCount, stats.total.allocationCount,
-                         stats.total.usedBytes, stats.total.unusedBytes));
+                         quint32(stats.total.usedBytes), quint32(stats.total.unusedBytes)));
 }
 
 void QRhiVulkan::makeThreadLocalNativeContextCurrent()
@@ -4008,7 +4009,7 @@ void QRhiVulkan::setShaderResources(QRhiCommandBuffer *cb, QRhiShaderResourceBin
                                         gfxPsD ? VK_PIPELINE_BIND_POINT_GRAPHICS : VK_PIPELINE_BIND_POINT_COMPUTE,
                                         gfxPsD ? gfxPsD->layout : compPsD->layout,
                                         0, 1, &srbD->descSets[descSetIdx],
-                                        dynOfs.count(),
+                                        uint32_t(dynOfs.count()),
                                         dynOfs.count() ? dynOfs.constData() : nullptr);
         } else {
             QVkCommandBuffer::Command cmd;
@@ -4078,8 +4079,8 @@ void QRhiVulkan::setVertexInput(QRhiCommandBuffer *cb,
         }
 
         if (cbD->useSecondaryCb) {
-            df->vkCmdBindVertexBuffers(cbD->secondaryCbs.last(), startBinding,
-                                       bufs.count(), bufs.constData(), ofs.constData());
+            df->vkCmdBindVertexBuffers(cbD->secondaryCbs.last(), uint32_t(startBinding),
+                                       uint32_t(bufs.count()), bufs.constData(), ofs.constData());
         } else {
             QVkCommandBuffer::Command cmd;
             cmd.cmd = QVkCommandBuffer::Command::BindVertexBuffer;
@@ -4160,10 +4161,10 @@ void QRhiVulkan::setViewport(QRhiCommandBuffer *cb, const QRhiViewport &viewport
 
     if (!QRHI_RES(QVkGraphicsPipeline, cbD->currentGraphicsPipeline)->m_flags.testFlag(QRhiGraphicsPipeline::UsesScissor)) {
         VkRect2D *s = &cmd.args.setScissor.scissor;
-        s->offset.x = x;
-        s->offset.y = y;
-        s->extent.width = w;
-        s->extent.height = h;
+        s->offset.x = int32_t(x);
+        s->offset.y = int32_t(y);
+        s->extent.width = uint32_t(w);
+        s->extent.height = uint32_t(h);
         if (cbD->useSecondaryCb) {
             df->vkCmdSetScissor(cbD->secondaryCbs.last(), 0, 1, s);
         } else {
@@ -4189,8 +4190,8 @@ void QRhiVulkan::setScissor(QRhiCommandBuffer *cb, const QRhiScissor &scissor)
     VkRect2D *s = &cmd.args.setScissor.scissor;
     s->offset.x = x;
     s->offset.y = y;
-    s->extent.width = w;
-    s->extent.height = h;
+    s->extent.width = uint32_t(w);
+    s->extent.height = uint32_t(h);
 
     if (cbD->useSecondaryCb) {
         df->vkCmdSetScissor(cbD->secondaryCbs.last(), 0, 1, s);
@@ -4211,10 +4212,10 @@ void QRhiVulkan::setBlendConstants(QRhiCommandBuffer *cb, const QColor &c)
     } else {
         QVkCommandBuffer::Command cmd;
         cmd.cmd = QVkCommandBuffer::Command::SetBlendConstants;
-        cmd.args.setBlendConstants.c[0] = c.redF();
-        cmd.args.setBlendConstants.c[1] = c.greenF();
-        cmd.args.setBlendConstants.c[2] = c.blueF();
-        cmd.args.setBlendConstants.c[3] = c.alphaF();
+        cmd.args.setBlendConstants.c[0] = float(c.redF());
+        cmd.args.setBlendConstants.c[1] = float(c.greenF());
+        cmd.args.setBlendConstants.c[2] = float(c.blueF());
+        cmd.args.setBlendConstants.c[3] = float(c.alphaF());
         cbD->commands.append(cmd);
     }
 }
@@ -4843,7 +4844,7 @@ bool QVkBuffer::build()
     VkBufferCreateInfo bufferInfo;
     memset(&bufferInfo, 0, sizeof(bufferInfo));
     bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-    bufferInfo.size = nonZeroSize;
+    bufferInfo.size = uint32_t(nonZeroSize);
     bufferInfo.usage = toVkBufferUsage(m_usage);
 
     VmaAllocationCreateInfo allocInfo;
@@ -4890,7 +4891,7 @@ bool QVkBuffer::build()
     }
 
     QRHI_PROF;
-    QRHI_PROF_F(newBuffer(this, nonZeroSize, m_type != Dynamic ? 1 : QVK_FRAMES_IN_FLIGHT, 0));
+    QRHI_PROF_F(newBuffer(this, uint(nonZeroSize), m_type != Dynamic ? 1 : QVK_FRAMES_IN_FLIGHT, 0));
 
     lastActiveFrameSlot = -1;
     generation += 1;
@@ -5081,7 +5082,7 @@ bool QVkTexture::prepareBuild(QSize *adjustedSize)
     const bool isCube = m_flags.testFlag(CubeMap);
     const bool hasMipMaps = m_flags.testFlag(MipMapped);
 
-    mipLevelCount = hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1;
+    mipLevelCount = uint(hasMipMaps ? rhiD->q->mipLevelsForSize(size) : 1);
     const int maxLevels = QRhi::MAX_LEVELS;
     if (mipLevelCount > maxLevels) {
         qWarning("Too many mip levels (%d, max is %d), truncating mip chain", mipLevelCount, maxLevels);
@@ -5160,8 +5161,8 @@ bool QVkTexture::build()
     imageInfo.flags = isCube ? VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0;
     imageInfo.imageType = VK_IMAGE_TYPE_2D;
     imageInfo.format = vkformat;
-    imageInfo.extent.width = size.width();
-    imageInfo.extent.height = size.height();
+    imageInfo.extent.width = uint32_t(size.width());
+    imageInfo.extent.height = uint32_t(size.height());
     imageInfo.extent.depth = 1;
     imageInfo.mipLevels = mipLevelCount;
     imageInfo.arrayLayers = isCube ? 6 : 1;
@@ -5202,7 +5203,7 @@ bool QVkTexture::build()
     rhiD->setObjectName(uint64_t(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, m_objectName);
 
     QRHI_PROF;
-    QRHI_PROF_F(newTexture(this, true, mipLevelCount, isCube ? 6 : 1, samples));
+    QRHI_PROF_F(newTexture(this, true, int(mipLevelCount), isCube ? 6 : 1, samples));
 
     owns = true;
     rhiD->registerResource(this);
@@ -5224,7 +5225,7 @@ bool QVkTexture::buildFrom(const QRhiNativeHandles *src)
         return false;
 
     QRHI_PROF;
-    QRHI_PROF_F(newTexture(this, false, mipLevelCount, m_flags.testFlag(CubeMap) ? 6 : 1, samples));
+    QRHI_PROF_F(newTexture(this, false, int(mipLevelCount), m_flags.testFlag(CubeMap) ? 6 : 1, samples));
 
     usageState.layout = h->layout;
 
@@ -5260,7 +5261,7 @@ VkImageView QVkTexture::imageViewForLevel(int level)
     viewInfo.components.b = VK_COMPONENT_SWIZZLE_B;
     viewInfo.components.a = VK_COMPONENT_SWIZZLE_A;
     viewInfo.subresourceRange.aspectMask = isDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
-    viewInfo.subresourceRange.baseMipLevel = level;
+    viewInfo.subresourceRange.baseMipLevel = uint32_t(level);
     viewInfo.subresourceRange.levelCount = 1;
     viewInfo.subresourceRange.baseArrayLayer = 0;
     viewInfo.subresourceRange.layerCount = isCube ? 6 : 1;
@@ -5501,9 +5502,9 @@ bool QVkTextureRenderTarget::build()
             viewInfo.components.b = VK_COMPONENT_SWIZZLE_B;
             viewInfo.components.a = VK_COMPONENT_SWIZZLE_A;
             viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-            viewInfo.subresourceRange.baseMipLevel = colorAttachments[i].level();
+            viewInfo.subresourceRange.baseMipLevel = uint32_t(colorAttachments[i].level());
             viewInfo.subresourceRange.levelCount = 1;
-            viewInfo.subresourceRange.baseArrayLayer = colorAttachments[i].layer();
+            viewInfo.subresourceRange.baseArrayLayer = uint32_t(colorAttachments[i].layer());
             viewInfo.subresourceRange.layerCount = 1;
             VkResult err = rhiD->df->vkCreateImageView(rhiD->dev, &viewInfo, nullptr, &rtv[i]);
             if (err != VK_SUCCESS) {
@@ -5565,9 +5566,9 @@ bool QVkTextureRenderTarget::build()
             viewInfo.components.b = VK_COMPONENT_SWIZZLE_B;
             viewInfo.components.a = VK_COMPONENT_SWIZZLE_A;
             viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-            viewInfo.subresourceRange.baseMipLevel = colorAttachments[i].resolveLevel();
+            viewInfo.subresourceRange.baseMipLevel = uint32_t(colorAttachments[i].resolveLevel());
             viewInfo.subresourceRange.levelCount = 1;
-            viewInfo.subresourceRange.baseArrayLayer = colorAttachments[i].resolveLayer();
+            viewInfo.subresourceRange.baseArrayLayer = uint32_t(colorAttachments[i].resolveLayer());
             viewInfo.subresourceRange.layerCount = 1;
             VkResult err = rhiD->df->vkCreateImageView(rhiD->dev, &viewInfo, nullptr, &resrtv[i]);
             if (err != VK_SUCCESS) {
@@ -5588,10 +5589,10 @@ bool QVkTextureRenderTarget::build()
     memset(&fbInfo, 0, sizeof(fbInfo));
     fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
     fbInfo.renderPass = d.rp->rp;
-    fbInfo.attachmentCount = d.colorAttCount + d.dsAttCount + d.resolveAttCount;
+    fbInfo.attachmentCount = uint32_t(d.colorAttCount + d.dsAttCount + d.resolveAttCount);
     fbInfo.pAttachments = views.constData();
-    fbInfo.width = d.pixelSize.width();
-    fbInfo.height = d.pixelSize.height();
+    fbInfo.width = uint32_t(d.pixelSize.width());
+    fbInfo.height = uint32_t(d.pixelSize.height());
     fbInfo.layers = 1;
 
     VkResult err = rhiD->df->vkCreateFramebuffer(rhiD->dev, &fbInfo, nullptr, &d.fb);
@@ -5675,7 +5676,7 @@ bool QVkShaderResourceBindings::build()
         const QRhiShaderResourceBindingPrivate *b = QRhiShaderResourceBindingPrivate::get(&binding);
         VkDescriptorSetLayoutBinding vkbinding;
         memset(&vkbinding, 0, sizeof(vkbinding));
-        vkbinding.binding = b->binding;
+        vkbinding.binding = uint32_t(b->binding);
         vkbinding.descriptorType = toVkDescriptorType(b);
         vkbinding.descriptorCount = 1; // no array support yet
         vkbinding.stageFlags = toVkShaderStageFlags(b->stage);
@@ -5792,7 +5793,7 @@ bool QVkGraphicsPipeline::build()
             shaderStageCreateInfos.append(shaderInfo);
         }
     }
-    pipelineInfo.stageCount = shaderStageCreateInfos.count();
+    pipelineInfo.stageCount = uint32_t(shaderStageCreateInfos.count());
     pipelineInfo.pStages = shaderStageCreateInfos.constData();
 
     const QVector<QRhiVertexInputBinding> bindings = m_vertexInputLayout.bindings();
@@ -5833,15 +5834,15 @@ bool QVkGraphicsPipeline::build()
     VkPipelineVertexInputStateCreateInfo vertexInputInfo;
     memset(&vertexInputInfo, 0, sizeof(vertexInputInfo));
     vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
-    vertexInputInfo.vertexBindingDescriptionCount = vertexBindings.count();
+    vertexInputInfo.vertexBindingDescriptionCount = uint32_t(vertexBindings.count());
     vertexInputInfo.pVertexBindingDescriptions = vertexBindings.constData();
-    vertexInputInfo.vertexAttributeDescriptionCount = vertexAttributes.count();
+    vertexInputInfo.vertexAttributeDescriptionCount = uint32_t(vertexAttributes.count());
     vertexInputInfo.pVertexAttributeDescriptions = vertexAttributes.constData();
     VkPipelineVertexInputDivisorStateCreateInfoEXT divisorInfo;
     if (!nonOneStepRates.isEmpty()) {
         memset(&divisorInfo, 0, sizeof(divisorInfo));
         divisorInfo.sType = VkStructureType(1000190001); // VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT
-        divisorInfo.vertexBindingDivisorCount = nonOneStepRates.count();
+        divisorInfo.vertexBindingDivisorCount = uint32_t(nonOneStepRates.count());
         divisorInfo.pVertexBindingDivisors = nonOneStepRates.constData();
         vertexInputInfo.pNext = &divisorInfo;
     }
@@ -5858,7 +5859,7 @@ bool QVkGraphicsPipeline::build()
     VkPipelineDynamicStateCreateInfo dynamicInfo;
     memset(&dynamicInfo, 0, sizeof(dynamicInfo));
     dynamicInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
-    dynamicInfo.dynamicStateCount = dynEnable.count();
+    dynamicInfo.dynamicStateCount = uint32_t(dynEnable.count());
     dynamicInfo.pDynamicStates = dynEnable.constData();
     pipelineInfo.pDynamicState = &dynamicInfo;
 
@@ -5930,7 +5931,7 @@ bool QVkGraphicsPipeline::build()
                 | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
         vktargetBlends.append(blend);
     }
-    blendInfo.attachmentCount = vktargetBlends.count();
+    blendInfo.attachmentCount = uint32_t(vktargetBlends.count());
     blendInfo.pAttachments = vktargetBlends.constData();
     pipelineInfo.pColorBlendState = &blendInfo;
 
@@ -6131,11 +6132,11 @@ QSize QVkSwapChain::surfacePixelSize()
     QRHI_RES_RHI(QRhiVulkan);
     rhiD->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(rhiD->physDev, surface, &surfaceCaps);
     VkExtent2D bufferSize = surfaceCaps.currentExtent;
-    if (bufferSize.width == quint32(-1)) {
-        Q_ASSERT(bufferSize.height == quint32(-1));
+    if (bufferSize.width == uint32_t(-1)) {
+        Q_ASSERT(bufferSize.height == uint32_t(-1));
         return m_window->size() * m_window->devicePixelRatio();
     }
-    return QSize(bufferSize.width, bufferSize.height);
+    return QSize(int(bufferSize.width), int(bufferSize.height));
 }
 
 QRhiRenderPassDescriptor *QVkSwapChain::newCompatibleRenderPassDescriptor()
@@ -6203,7 +6204,7 @@ bool QVkSwapChain::ensureSurface()
 
     QRHI_RES_RHI(QRhiVulkan);
     if (rhiD->gfxQueueFamilyIdx != -1) {
-        if (!rhiD->inst->supportsPresent(rhiD->physDev, rhiD->gfxQueueFamilyIdx, m_window)) {
+        if (!rhiD->inst->supportsPresent(rhiD->physDev, uint32_t(rhiD->gfxQueueFamilyIdx), m_window)) {
             qWarning("Presenting not supported on this window");
             return false;
         }
@@ -6232,7 +6233,7 @@ bool QVkSwapChain::ensureSurface()
         rhiD->vkGetPhysicalDeviceSurfaceFormatsKHR(rhiD->physDev, surface, &formatCount, formats.data());
 
     const bool srgbRequested = m_flags.testFlag(sRGB);
-    for (quint32 i = 0; i < formatCount; ++i) {
+    for (int i = 0; i < int(formatCount); ++i) {
         if (formats[i].format != VK_FORMAT_UNDEFINED && srgbRequested == isSrgbFormat(formats[i].format)) {
             colorFormat = formats[i].format;
             colorSpace = formats[i].colorSpace;
@@ -6293,7 +6294,7 @@ bool QVkSwapChain::buildOrResize()
     Q_ASSERT(rtWrapper.d.rp && rtWrapper.d.rp->rp);
 
     rtWrapper.d.pixelSize = pixelSize;
-    rtWrapper.d.dpr = window->devicePixelRatio();
+    rtWrapper.d.dpr = float(window->devicePixelRatio());
     rtWrapper.d.sampleCount = samples;
     rtWrapper.d.colorAttCount = 1;
     if (m_depthStencil) {
@@ -6320,10 +6321,10 @@ bool QVkSwapChain::buildOrResize()
         memset(&fbInfo, 0, sizeof(fbInfo));
         fbInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
         fbInfo.renderPass = rtWrapper.d.rp->rp;
-        fbInfo.attachmentCount = rtWrapper.d.colorAttCount + rtWrapper.d.dsAttCount + rtWrapper.d.resolveAttCount;
+        fbInfo.attachmentCount = uint32_t(rtWrapper.d.colorAttCount + rtWrapper.d.dsAttCount + rtWrapper.d.resolveAttCount);
         fbInfo.pAttachments = views;
-        fbInfo.width = pixelSize.width();
-        fbInfo.height = pixelSize.height();
+        fbInfo.width = uint32_t(pixelSize.width());
+        fbInfo.height = uint32_t(pixelSize.height());
         fbInfo.layers = 1;
 
         VkResult err = rhiD->df->vkCreateFramebuffer(rhiD->dev, &fbInfo, nullptr, &image.fb);