hello_xr: clang-tidy

Author: rpavlik

src/tests/hello_xr/common.h

@@ -85,7 +85,7 @@ inline std::string Fmt(const char* fmt, ...) {
 
 // The equivalent of C++17 std::size. A helper to get the dimension for an array.
 template <typename T, size_t Size>
-constexpr size_t ArraySize(const T (&)[Size]) noexcept {
+constexpr size_t ArraySize(const T (&/*unused*/)[Size]) noexcept {
     return Size;
 }
 

src/tests/hello_xr/graphicsplugin_factory.cpp

@@ -1,3 +1,5 @@
+#include <utility>
+
 #include "pch.h"
 #include "common.h"
 #include "options.h"
@@ -32,34 +34,36 @@ using GraphicsPluginFactory = std::function<std::shared_ptr<IGraphicsPlugin>(con
 std::map<std::string, GraphicsPluginFactory, IgnoreCaseStringLess> graphicsPluginMap = {
 // #ifdef XR_USE_GRAPHICS_API_OPENGL_ES
 //     { "OpenGLES", [](const std::shared_ptr<Options>& options, std::shared_ptr<IPlatformPlugin> platformPlugin) {
-//         return CreateGraphicsPlugin_OpenGLES(options, platformPlugin); } },
+//         return CreateGraphicsPlugin_OpenGLES(options, std::move(platformPlugin)); } },
 // #endif
 #ifdef XR_USE_GRAPHICS_API_OPENGL
     {"OpenGL",
      [](const std::shared_ptr<Options>& options, std::shared_ptr<IPlatformPlugin> platformPlugin) {
-         return CreateGraphicsPlugin_OpenGL(options, platformPlugin);
+         return CreateGraphicsPlugin_OpenGL(options, std::move(platformPlugin));
      }},
 #endif
 #ifdef XR_USE_GRAPHICS_API_VULKAN
     {"Vulkan",
      [](const std::shared_ptr<Options>& options, std::shared_ptr<IPlatformPlugin> platformPlugin) {
-         return CreateGraphicsPlugin_Vulkan(options, platformPlugin);
+         return CreateGraphicsPlugin_Vulkan(options, std::move(platformPlugin));
      }},
 #endif
 #ifdef XR_USE_GRAPHICS_API_D3D11
-    {"D3D11", [](const std::shared_ptr<Options>& options,
-                 std::shared_ptr<IPlatformPlugin> platformPlugin) { return CreateGraphicsPlugin_D3D11(options, platformPlugin); }},
+    {"D3D11",
+     [](const std::shared_ptr<Options>& options, std::shared_ptr<IPlatformPlugin> platformPlugin) {
+         return CreateGraphicsPlugin_D3D11(options, std::move(platformPlugin));
+     }},
 #endif
     // #ifdef XR_USE_GRAPHICS_API_D3D12
     //     { "D3D12", [](const std::shared_ptr<Options>& options, std::shared_ptr<IPlatformPlugin> platformPlugin) {
-    //         return CreateGraphicsPlugin_D3D12(options, platformPlugin); } },
+    //         return CreateGraphicsPlugin_D3D12(options, std::move(platformPlugin)); } },
     // #endif
 };
 }  // namespace
 
 std::shared_ptr<IGraphicsPlugin> CreateGraphicsPlugin(const std::shared_ptr<Options>& options,
                                                       std::shared_ptr<IPlatformPlugin> platformPlugin) {
-    if (options->GraphicsPlugin.size() == 0) {
+    if (options->GraphicsPlugin.empty()) {
         throw std::invalid_argument("No graphics API specified");
     }
 
@@ -68,5 +72,5 @@ std::shared_ptr<IGraphicsPlugin> CreateGraphicsPlugin(const std::shared_ptr<Opti
         throw std::invalid_argument(Fmt("Unsupported graphics API '%s'", options->GraphicsPlugin.c_str()));
     }
 
-    return apiIt->second(options, platformPlugin);
+    return apiIt->second(options, std::move(platformPlugin));
 }

src/tests/hello_xr/graphicsplugin_opengl.cpp

@@ -39,7 +39,7 @@ static const char* FragmentShaderGlsl = R"_(
     )_";
 
 struct OpenGLGraphicsPlugin : public IGraphicsPlugin {
-    OpenGLGraphicsPlugin(const std::shared_ptr<Options>&, std::shared_ptr<IPlatformPlugin>){};
+    OpenGLGraphicsPlugin(const std::shared_ptr<Options>& /*unused*/, const std::shared_ptr<IPlatformPlugin> /*unused*/&){};
 
     OpenGLGraphicsPlugin(const OpenGLGraphicsPlugin&) = delete;
     OpenGLGraphicsPlugin& operator=(const OpenGLGraphicsPlugin&) = delete;
@@ -101,7 +101,8 @@ struct OpenGLGraphicsPlugin : public IGraphicsPlugin {
             THROW("Unable to create GL context");
         }
 
-        GLint major = 0, minor = 0;
+        GLint major = 0;
+        GLint minor = 0;
         glGetIntegerv(GL_MAJOR_VERSION, &major);
         glGetIntegerv(GL_MINOR_VERSION, &minor);
 
@@ -179,7 +180,7 @@ struct OpenGLGraphicsPlugin : public IGraphicsPlugin {
         glEnableVertexAttribArray(m_vertexAttribColor);
         glBindBuffer(GL_ARRAY_BUFFER, m_cubeVertexBuffer);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_cubeIndexBuffer);
-        glVertexAttribPointer(m_vertexAttribCoords, 3, GL_FLOAT, GL_FALSE, sizeof(Geometry::Vertex), 0);
+        glVertexAttribPointer(m_vertexAttribCoords, 3, GL_FLOAT, GL_FALSE, sizeof(Geometry::Vertex), nullptr);
         glVertexAttribPointer(m_vertexAttribColor, 3, GL_FLOAT, GL_FALSE, sizeof(Geometry::Vertex),
                               reinterpret_cast<const void*>(sizeof(XrVector3f)));
     }
@@ -253,7 +254,8 @@ struct OpenGLGraphicsPlugin : public IGraphicsPlugin {
 
         // This back-buffer has no cooresponding depth-stencil texture, so create one with matching dimensions.
 
-        GLint width, height;
+        GLint width;
+        GLint height;
         glBindTexture(GL_TEXTURE_2D, colorTexture);
         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
@@ -328,7 +330,7 @@ struct OpenGLGraphicsPlugin : public IGraphicsPlugin {
             glUniformMatrix4fv(m_modelViewProjectionUniformLocation, 1, GL_FALSE, reinterpret_cast<const GLfloat*>(&mvp));
 
             // Draw the cube.
-            glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(ArraySize(Geometry::c_cubeIndices)), GL_UNSIGNED_SHORT, 0);
+            glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(ArraySize(Geometry::c_cubeIndices)), GL_UNSIGNED_SHORT, nullptr);
         }
 
         glBindVertexArray(0);
@@ -337,7 +339,9 @@ struct OpenGLGraphicsPlugin : public IGraphicsPlugin {
 
         // Swap our window every other eye for RenderDoc
         static int everyOther = 0;
-        if (everyOther++ & 1) ksGpuWindow_SwapBuffers(&window);
+        if ((everyOther++ & 1) != 0) {
+            ksGpuWindow_SwapBuffers(&window);
+        }
     }
 
    private: