GPU Display: Many minor fixes suggested by Claude

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -500,7 +500,7 @@ AddOption(camYUp, bool, false, "", 0, "Orient the camera such that the y-axis is
 AddOption(cameraMode, int32_t, 0, "", 0, "Camera mode")
 AddOption(fullScreen, bool, false, "", 0, "Full Screen")
 AddOption(maximized, bool, true, "", 0, "Maximized window")
-AddOption(rendererCompatSmoothing, bool, false, "", 0, "Use compat smoothing (if available) of instad of shader for smooth lines / points")
+AddOption(rendererCompatSmoothing, bool, false, "", 0, "Use compat smoothing (if available) instead of shader for smooth lines / points")
 AddOption(drawQualityMSAA, int32_t, 0, "", 0, "MultiSample Anti Aliasing")
 AddOption(drawQualityDownsampleFSAA, int32_t, 0, "", 0, "Downsampling Anti Aliasing")
 AddOption(drawQualityVSync, bool, true, "", 0, "Enable Vertical Sync")

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -674,7 +674,9 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
   nextViewMatrix = nextViewMatrix * *mModelMatrix;
   const float zFar = ((mParam->par.continuousTracking ? (mMaxClusterZ * GL_SCALE_FACTOR) : 8.f) + 50.f) * 2.f;
   const hmm_mat4 proj = HMM_Perspective(mCfgR.fov, (float)mBackend->mRenderWidth / (float)mBackend->mRenderHeight, 0.1f, zFar);
-  mBackend->prepareDraw(proj, nextViewMatrix, doScreenshot || mRequestScreenshot, renderToMixBuffer, mixSlaveImage);
+  if (!mBackend->prepareDraw(proj, nextViewMatrix, doScreenshot || mRequestScreenshot, renderToMixBuffer, mixSlaveImage)) {
+    return; // No image available (e.g. hidden window), retry with the next frame
+  }
   mBackend->pointSizeFactor(1);
   mBackend->lineWidthFactor(1);
 

GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx

@@ -119,7 +119,8 @@ void GPUDisplayBackend::loadFont()
     return;
   }
   if (FT_New_Face(ft, fontName.c_str(), 0, &face)) {
-    GPUError("Error loading freetypoe font");
+    GPUError("Error loading freetype font");
+    FT_Done_FreeType(ft);
     return;
   }
 
@@ -134,6 +135,8 @@ void GPUDisplayBackend::loadFont()
   for (uint32_t i = 0; i < 128; i++) {
     if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
       GPUError("Error loading freetype symbol");
+      FT_Done_Face(face);
+      FT_Done_FreeType(ft);
       return;
     }
     const auto& glyph = face->glyph;

GPU/GPUTracking/display/backend/GPUDisplayBackend.h

@@ -90,7 +90,7 @@ class GPUDisplayBackend
   void updateFontScale(float scale); // Rasterize the font again if the display (HiDPI) scale changed
   void ExitBackend();
   virtual void loadDataToGPU(size_t totalVertizes) = 0;
-  virtual void prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot = false, bool toMixBuffer = false, float includeMixImage = 0.f) = 0;
+  virtual bool prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot = false, bool toMixBuffer = false, float includeMixImage = 0.f) = 0; // Returns false if the frame must be skipped (no swapchain image available)
   virtual void finishDraw(bool doScreenshot, bool toMixBuffer = false, float includeMixImage = 0.f) = 0;
   virtual void finishFrame(bool doScreenshot, bool toMixBuffer = false, float includeMixImage = 0.f) = 0;
   virtual void prepareText() = 0;

GPU/GPUTracking/display/backend/GPUDisplayBackendNone.h

@@ -33,7 +33,7 @@ class GPUDisplayBackendNone : public GPUDisplayBackend
   int32_t InitBackendA() override;
   void ExitBackendA() override {}
   void loadDataToGPU(size_t totalVertizes) override {}
-  void prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage) override {}
+  bool prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage) override { return true; }
   void finishDraw(bool doScreenshot, bool toMixBuffer, float includeMixImage) override {}
   void finishFrame(bool doScreenshot, bool toMixBuffer, float includeMixImage) override {}
   void prepareText() override {}

GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx

@@ -61,6 +61,11 @@ int32_t GPUDisplayBackendOpenGL::ExtInit()
 #endif
 }
 
+bool GPUDisplayBackendOpenGL::canLimitToVSync() const
+{
+  return mDisplay->frontend()->canSetVSync();
+}
+
 bool GPUDisplayBackendOpenGL::CoreProfile()
 {
 #ifdef GPUCA_DISPLAY_OPENGL_CORE
@@ -471,11 +476,14 @@ void GPUDisplayBackendOpenGL::loadDataToGPU(size_t totalVertizes)
   }
 }
 
-void GPUDisplayBackendOpenGL::prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage)
+bool GPUDisplayBackendOpenGL::prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage)
 {
   if (mDisplay->updateRenderPipeline() || mDownsampleFactor != getDownsampleFactor(requestScreenshot)) {
     updateRenderer(requestScreenshot);
   }
+  if (toMixBuffer && !mMixBuffer.created) { // Only allocated when mixing is used, freed with the other offscreen buffers
+    createFB(mMixBuffer, true, true, false, mRenderWidth, mRenderHeight);
+  }
   if (mOffscreenBufferMSAA.created) {
     setFrameBuffer(mOffscreenBufferMSAA.fb_id);
   } else if (toMixBuffer) {
@@ -543,6 +551,7 @@ void GPUDisplayBackendOpenGL::prepareDraw(const hmm_mat4& proj, const hmm_mat4&
       CHKERR(glNamedBufferSubData(mFieldModelViewBuffer, 0, sizeof(modelViewProj), &modelViewProj));
     }
   }
+  return true;
 }
 
 void GPUDisplayBackendOpenGL::finishDraw(bool doScreenshot, bool toMixBuffer, float includeMixImage)
@@ -557,7 +566,7 @@ void GPUDisplayBackendOpenGL::finishDraw(bool doScreenshot, bool toMixBuffer, fl
     CHKERR(glUseProgram(0));
   }
 
-  if (mDisplay->cfgR().drawQualityMSAA) {
+  if (mOffscreenBufferMSAA.created) {
     uint32_t dstId = toMixBuffer ? mMixBuffer.fb_id : (mDownsampleFactor != 1 ? mOffscreenBuffer.fb_id : 0);
     CHKERR(glBlitNamedFramebuffer(mOffscreenBufferMSAA.fb_id, dstId, 0, 0, mRenderWidth, mRenderHeight, 0, 0, mRenderWidth, mRenderHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR));
   }
@@ -788,8 +797,8 @@ void GPUDisplayBackendOpenGL::OpenGLPrint(const char* s, float x, float y, float
   if (smoothFont()) {
     scale *= 0.25f; // Font size is 48 to have nice bitmap, scale to size 12
   }
-  for (const char* c = s; *c; c++) {
-    if ((int32_t)*c > (int32_t)mFontSymbols.size()) {
+  for (const unsigned char* c = (const unsigned char*)s; *c; c++) {
+    if ((int32_t)*c >= (int32_t)mFontSymbols.size()) {
       GPUError("Trying to draw unsupported symbol: %d > %d\n", (int32_t)*c, (int32_t)mFontSymbols.size());
       continue;
     }
@@ -838,20 +847,6 @@ void GPUDisplayBackendOpenGL::resizeScene(uint32_t width, uint32_t height)
   mScreenHeight = height;
 
   updateRenderer(false);
-
-  float vertices[6][4] = {
-    {0, (float)mRenderHeight, 0.0f, 1.0f},
-    {0, 0, 0.0f, 0.0f},
-    {(float)mRenderWidth, 0, 1.0f, 0.0f},
-    {0, (float)mRenderHeight, 0.0f, 1.0f},
-    {(float)mRenderWidth, 0, 1.0f, 0.0f},
-    {(float)mRenderWidth, (float)mRenderHeight, 1.0f, 1.0f}};
-  CHKERR(glBindBuffer(GL_ARRAY_BUFFER, VBO_texture));
-  CHKERR(glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices));
-  CHKERR(glBindBuffer(GL_ARRAY_BUFFER, 0));
-  if (!mDisplay->useMultiVBO()) {
-    CHKERR(glBindBuffer(GL_ARRAY_BUFFER, mVBOId[0])); // If we don't use multiple buffers, we keep the default buffer bound
-  }
 }
 
 void GPUDisplayBackendOpenGL::updateRenderer(bool withScreenshot)
@@ -866,6 +861,16 @@ void GPUDisplayBackendOpenGL::updateRenderer(bool withScreenshot)
   if (mDownsampleFactor != 1) {
     createFB(mOffscreenBuffer, mDownsampleFactor != 2, true, false, mRenderWidth, mRenderHeight); // Texture for shader downsampling (factor != 2), screenshot downsampling uses the shader only if this factor is != 2 as well
   }
-  createFB(mMixBuffer, true, true, false, mRenderWidth, mRenderHeight);
   setQuality();
+
+  float vertices[6][4] = {// Mix quad at render size
+                          {0, (float)mRenderHeight, 0.0f, 1.0f},
+                          {0, 0, 0.0f, 0.0f},
+                          {(float)mRenderWidth, 0, 1.0f, 0.0f},
+                          {0, (float)mRenderHeight, 0.0f, 1.0f},
+                          {(float)mRenderWidth, 0, 1.0f, 0.0f},
+                          {(float)mRenderWidth, (float)mRenderHeight, 1.0f, 1.0f}};
+  CHKERR(glBindBuffer(GL_ARRAY_BUFFER, VBO_texture));
+  CHKERR(glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices));
+  CHKERR(glBindBuffer(GL_ARRAY_BUFFER, mDisplay->useMultiVBO() ? 0 : mVBOId[0])); // If we don't use multiple buffers, we keep the default buffer bound (also called from prepareDraw before the vertex pointers are set)
 }

GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.h

@@ -35,7 +35,7 @@ class GPUDisplayBackendOpenGL : public GPUDisplayBackend
   ~GPUDisplayBackendOpenGL() override = default;
   int32_t ExtInit() override;
   bool CoreProfile() override;
-  bool canLimitToVSync() const override { return true; } // Buffer swap blocks with VSync
+  bool canLimitToVSync() const override; // Buffer swap blocks with VSync, if the frontend can set the swap interval
   uint32_t DepthBits() override;
 
  protected:
@@ -57,7 +57,7 @@ class GPUDisplayBackendOpenGL : public GPUDisplayBackend
   static int32_t checkProgramStatus(uint32_t program);
   void clearScreen(bool alphaOnly = false);
   void loadDataToGPU(size_t totalVertizes) override;
-  void prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage) override;
+  bool prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage) override;
   void resizeScene(uint32_t width, uint32_t height) override;
   void updateRenderer(bool withScreenshot);
   void ClearOffscreenBuffers();
@@ -101,9 +101,9 @@ class GPUDisplayBackendOpenGL : public GPUDisplayBackend
   uint32_t mFragmentShaderDownsample;
   uint32_t mGeometryShader;
   uint32_t mShaderProgram;
-  uint32_t mShaderProgramSmoothPoint; // Points with fragmentSmoothPoint.frag, for smoothPoints in the core profile (no GL_POINT_SMOOTH)
+  uint32_t mShaderProgramSmoothPoint; // Points with fragmentSmoothPoint.frag, for smoothPoints with the shader path (not rendererCompatSmoothing / GL_POINT_SMOOTH)
   bool mUseSmoothPointShader = false;
-  uint32_t mShaderProgramSmoothLine; // Lines with vertexSmoothLine.vert / fragmentSmoothLine.frag, for smoothLines in the core profile (no GL_LINE_SMOOTH)
+  uint32_t mShaderProgramSmoothLine; // Lines with vertexSmoothLine.vert / fragmentSmoothLine.frag, for smoothLines with the shader path (not rendererCompatSmoothing / GL_LINE_SMOOTH)
   bool mUseSmoothLineShader = false;
   uint32_t mShaderProgramText;
   uint32_t mShaderProgramTexture;

GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx

@@ -571,6 +571,8 @@ void GPUDisplayBackendVulkan::createDevice()
   GPUInfo("Using physical Vulkan device %s", &deviceProperties.deviceName[0]);
   mMaxMSAAsupported = getMaxUsableSampleCount(deviceProperties);
   mStrictLines = deviceProperties.limits.strictLines;
+  mMaxLineWidth = deviceProperties.limits.lineWidthRange[1];
+  mMaxPointSize = deviceProperties.limits.pointSizeRange[1];
   mMaxRenderSize = std::min({deviceProperties.limits.maxImageDimension2D, deviceProperties.limits.maxFramebufferWidth, deviceProperties.limits.maxFramebufferHeight});
   mZSupported = (bool)(depth32FormatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment);
   mStencilSupported = (bool)(depth64FormatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment);
@@ -1196,7 +1198,9 @@ void GPUDisplayBackendVulkan::startFillCommandBuffer(vk::CommandBuffer& commandB
   cmdBeginRendering(commandBuffer, mRenderWidth, mRenderHeight, colorAttachment, mZActive ? &depthAttachment : nullptr);
 
   vk::DeviceSize offsets[] = {0};
-  commandBuffer.bindVertexBuffers(0, 1, &mVBO.buffer, offsets);
+  if (mVBO.size) {
+    commandBuffer.bindVertexBuffers(0, 1, &mVBO.buffer, offsets);
+  }
   cmdPushDescriptors(commandBuffer, mPipelineLayout, mUniformBuffersMat[0][imageIndex]);
   const float viewport[2] = {(float)mRenderWidth, (float)mRenderHeight};
   commandBuffer.pushConstants(mPipelineLayout, vk::ShaderStageFlagBits::eVertex, 6 * sizeof(float), sizeof(viewport), viewport);
@@ -1399,6 +1403,11 @@ void GPUDisplayBackendVulkan::ExitBackendA()
   }
   clearTextureSampler();
   clearDevice();
+  mCommandInfrastructureCreated = false;
+  mImageCount = 0;
+  mLastPresentId = 0;
+  mSwapChainSuboptimal = 0;
+  mFrameSkipped = false;
 }
 
 // ---------------------------- USER CODE ----------------------------
@@ -1419,10 +1428,14 @@ void GPUDisplayBackendVulkan::loadDataToGPU(size_t totalVertizes)
 {
   mDevice.waitIdle();
   clearVertexBuffers();
-  mVBO = createBuffer(totalVertizes * sizeof(mDisplay->vertexBuffer()[0][0]), mDisplay->vertexBuffer()[0].data(), vk::BufferUsageFlagBits::eVertexBuffer, 1);
+  if (totalVertizes) { // Zero-size buffers are invalid (empty event)
+    mVBO = createBuffer(totalVertizes * sizeof(mDisplay->vertexBuffer()[0][0]), mDisplay->vertexBuffer()[0].data(), vk::BufferUsageFlagBits::eVertexBuffer, 1);
+  }
   if (mDisplay->cfgR().useGLIndirectDraw) {
     fillIndirectCmdBuffer();
-    mIndirectCommandBuffer = createBuffer(mCmdBuffer.size() * sizeof(mCmdBuffer[0]), mCmdBuffer.data(), vk::BufferUsageFlagBits::eIndirectBuffer, 1);
+    if (mCmdBuffer.size()) {
+      mIndirectCommandBuffer = createBuffer(mCmdBuffer.size() * sizeof(mCmdBuffer[0]), mCmdBuffer.data(), vk::BufferUsageFlagBits::eIndirectBuffer, 1);
+    }
     mCmdBuffer.clear();
   }
   needRecordCommandBuffers();
@@ -1456,25 +1469,27 @@ uint32_t GPUDisplayBackendVulkan::drawVertices(const vboList& v, const drawType
   return count;
 }
 
-void GPUDisplayBackendVulkan::prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage)
+bool GPUDisplayBackendVulkan::prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage)
 {
   if (mDisplay->updateDrawCommands() || toMixBuffer || includeMixImage > 0) {
     needRecordCommandBuffers();
   }
 
+  if (includeMixImage > 0.f && mFrameSkipped) {
+    return false; // The render to the mix buffer of this frame did not get an image
+  }
   if (includeMixImage == 0.f) {
     mCurrentFrame = (mCurrentFrame + 1) % mFramesInFlight;
     waitTimeline(mFrameTimelineValue[mCurrentFrame]);
     if (mLastPresentId > 1 && fpsLimitMode() == FPS_LIMIT_VSYNC) { // Refresh rate limit (FIFO): at most one frame queued (wait for the second-last present), keeps the rate if a frame misses the deadline, timeout in case the window is hidden
       const vk::Result retVal = (vk::Result)VULKAN_HPP_DEFAULT_DISPATCHER.vkWaitForPresentKHR(static_cast<VkDevice>(mDevice), static_cast<VkSwapchainKHR>(mSwapChain), mLastPresentId - 1, 100'000'000);
-      if (retVal == vk::Result::eErrorOutOfDateKHR || retVal == vk::Result::eSuboptimalKHR) {
-        mMustUpdateSwapChain = true;
-      } else if (retVal != vk::Result::eTimeout) {
+      handleSwapChainResult(retVal, 1);
+      if (retVal != vk::Result::eTimeout && retVal != vk::Result::eErrorOutOfDateKHR) {
         CHKERR(retVal);
       }
     }
-    auto getImage = [&]() {
-      return mDevice.acquireNextImageKHR(mSwapChain, UINT64_MAX, mImageAvailableSemaphore[mCurrentFrame], VkFence(VK_NULL_HANDLE), &mCurrentImageIndex);
+    auto getImage = [&]() { // Timeout so that a hidden window cannot block the thread (which may also dispatch the window system events) forever
+      return mDevice.acquireNextImageKHR(mSwapChain, 100'000'000, mImageAvailableSemaphore[mCurrentFrame], VkFence(VK_NULL_HANDLE), &mCurrentImageIndex);
     };
 
     vk::Result retVal = vk::Result::eSuccess;
@@ -1491,8 +1506,13 @@ void GPUDisplayBackendVulkan::prepareDraw(const hmm_mat4& proj, const hmm_mat4&
     if (mustUpdateSwapChain) {
       recreateRendering(requestScreenshot, toMixBuffer);
       retVal = getImage();
+      mMustUpdateSwapChain = false;
+    }
+    handleSwapChainResult(retVal, 2);
+    mFrameSkipped = retVal == vk::Result::eTimeout || retVal == vk::Result::eNotReady || retVal == vk::Result::eErrorOutOfDateKHR;
+    if (mFrameSkipped) {
+      return false;
     }
-    mMustUpdateSwapChain = retVal == vk::Result::eSuboptimalKHR;
     CHKERR(retVal);
     waitTimeline(mImageTimelineValue[mCurrentImageIndex]);                                        // Previous frame using this image's resources (command buffers, uniform buffer, ...) finished
     if (mPresentFences.size()) {                                                                  // Previous present of this image done, its present semaphore can be signaled again
@@ -1519,6 +1539,20 @@ void GPUDisplayBackendVulkan::prepareDraw(const hmm_mat4& proj, const hmm_mat4&
   if (!mCommandBufferUpToDate[mCurrentImageIndex]) {
     startFillCommandBuffer(mCurrentCommandBuffer, mCurrentImageIndex, toMixBuffer);
   }
+  return true;
+}
+
+void GPUDisplayBackendVulkan::handleSwapChainResult(vk::Result retVal, uint8_t suboptimalBit)
+{
+  if (retVal == vk::Result::eErrorOutOfDateKHR || (retVal == vk::Result::eSuboptimalKHR && !(mSwapChainSuboptimal & suboptimalBit))) {
+    mMustUpdateSwapChain = true;
+    if (retVal == vk::Result::eSuboptimalKHR) {
+      mSwapChainSuboptimal |= suboptimalBit;
+    }
+  }
+  if (retVal == vk::Result::eSuccess && !mMustUpdateSwapChain) {
+    mSwapChainSuboptimal &= ~suboptimalBit;
+  }
 }
 
 void GPUDisplayBackendVulkan::finishDraw(bool doScreenshot, bool toMixBuffer, float includeMixImage)
@@ -1588,10 +1622,13 @@ void GPUDisplayBackendVulkan::finishFrame(bool doScreenshot, bool toMixBuffer, f
       presentFenceInfo = vk::SwapchainPresentFenceInfoKHR{1, &mPresentFences[mCurrentImageIndex], presentInfo.pNext};
       presentInfo.pNext = &presentFenceInfo;
     }
-    vk::Result retVal = mGraphicsQueue.presentKHR(&presentInfo);
-    if (retVal == vk::Result::eErrorOutOfDateKHR || retVal == vk::Result::eSuboptimalKHR) {
-      mMustUpdateSwapChain = true;
-    } else {
+    vk::Result retVal;
+    {
+      std::lock_guard<std::mutex> guard(mQueueMutex);
+      retVal = mGraphicsQueue.presentKHR(&presentInfo);
+    }
+    handleSwapChainResult(retVal, 4);
+    if (retVal != vk::Result::eErrorOutOfDateKHR) {
       CHKERR(retVal);
     }
   }
@@ -1740,7 +1777,7 @@ void GPUDisplayBackendVulkan::pointSizeFactor(float factor)
   if (mCommandBufferUpToDate[mCurrentImageIndex]) {
     return;
   }
-  float size = mDisplay->cfgL().pointSize * mDownsampleFactor * factor + (mDisplay->cfgL().smoothPoints ? SMOOTH_POINT_EXTRA_SIZE : 0.f);
+  float size = std::min(mDisplay->cfgL().pointSize * mDownsampleFactor * factor + (mDisplay->cfgL().smoothPoints ? SMOOTH_POINT_EXTRA_SIZE : 0.f), mMaxPointSize);
   mCurrentCommandBuffer.pushConstants(mPipelineLayout, vk::ShaderStageFlagBits::eVertex, sizeof(std::array<float, 4>), sizeof(size), &size);
 }
 
@@ -1761,11 +1798,12 @@ void GPUDisplayBackendVulkan::lineWidthFactor(float factor)
   }
   float width = mDisplay->cfgL().lineWidth * mDownsampleFactor * factor;
   if (useSmoothLineShader()) {
-    width += SMOOTH_LINE_EXTRA_WIDTH;
+    const float expand = mStrictLines ? 1.f : 1.4143f;                         // Non-strict wide lines may be parallelograms, widen so that the perpendicular width is covered
+    width = std::min(width + SMOOTH_LINE_EXTRA_WIDTH, mMaxLineWidth / expand); // The shader must see the width that is actually rasterized
     mCurrentCommandBuffer.pushConstants(mPipelineLayout, vk::ShaderStageFlagBits::eVertex, 5 * sizeof(float), sizeof(width), &width);
-    width *= mStrictLines ? 1.f : 1.4143f; // Non-strict wide lines may be parallelograms, widen so that the perpendicular width is covered
+    width *= expand;
   }
-  mCurrentCommandBuffer.setLineWidth(width);
+  mCurrentCommandBuffer.setLineWidth(std::min(width, mMaxLineWidth));
 }
 
 void GPUDisplayBackendVulkan::needRecordCommandBuffers()