rwengine: iwyu: reduce warnings in render subdirectory

openrw_iwyu.imp

@@ -13,6 +13,7 @@
     { "include": [ "@<glm/gtx/norm\\.inl>", "private", "<glm/gtx/norm.hpp>", "public"] },
     { "include": [ "@<glm/gtx/\\.\\./gtc/quaternion\\.hpp>", "public", "<glm/gtc/quaternion.hpp>", "public"] },
     { "include": [ "@<glm/gtx/\\.\\./gtx/quaternion\\.hpp>", "public", "<glm/gtx/quaternion.hpp>", "public"] },
+    { "symbol": [ "glm::value_ptr", "private", "<glm/gtc/type_ptr.hpp>", "public"] },
 # Boost filesystem:
     { "include": [ "@<boost/filesystem/.*>", "private", "<boost/filesystem.hpp>", "public"] },
 # Boost iterator:

rwengine/src/engine/GameData.cpp

@@ -5,6 +5,7 @@
 #include <cmath>
 #include <cstdlib>
 #include <fstream>
+#include <iostream>
 #include <iterator>
 #include <stdexcept>
 

rwengine/src/engine/SaveGame.cpp

@@ -5,9 +5,7 @@
 #include <cstring>
 #include <cstdio>
 
-#if RW_DEBUG
 #include <iostream>
-#endif
 
 #include <rw/filesystem.hpp>
 

rwengine/src/render/DebugDraw.cpp

@@ -1,11 +1,18 @@
 #include "render/DebugDraw.hpp"
 
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
 #include <iostream>
 
+#include <glm/glm.hpp>
+#include <LinearMath/btVector3.h>
+
+#include <data/Clump.hpp>
+#include <gl/DrawBuffer.hpp>
+#include <gl/GeometryBuffer.hpp>
+#include <gl/gl_core_3_3.h>
+#include <rw/defines.hpp>
+
+#include "render/GameRenderer.hpp"
+
 DebugDraw::DebugDraw() : shaderProgram(nullptr) {
     lineBuff = new GeometryBuffer;
     dbuff = new DrawBuffer;

rwengine/src/render/DebugDraw.hpp

@@ -1,8 +1,21 @@
-#pragma once
+#ifndef _RWENGINE_DEBUGDRAW_HPP_
+#define _RWENGINE_DEBUGDRAW_HPP_
+
+#include <cstddef>
+#include <vector>
 
 #include <LinearMath/btIDebugDraw.h>
+#include <LinearMath/btScalar.h>
+
 #include <data/Clump.hpp>
-#include <render/GameRenderer.hpp>
+#include <gl/gl_core_3_3.h>
+
+#include "render/OpenGLRenderer.hpp"
+
+class btVector3;
+class DrawBuffer;
+class GameRenderer;
+class GeometryBuffer;
 
 class DebugDraw : public btIDebugDraw {
 public:
@@ -38,3 +51,5 @@ protected:
 
     GLuint texture;
 };
+
+#endif

rwengine/src/render/GameRenderer.cpp

@@ -1,31 +1,29 @@
-#include <data/Clump.hpp>
+#include "render/GameRenderer.hpp"
-#include <engine/Animator.hpp>
-#include <engine/GameState.hpp>
-#include <engine/GameWorld.hpp>
-#include <render/GameRenderer.hpp>
 
-#include <objects/CharacterObject.hpp>
+#include <algorithm>
-#include <objects/InstanceObject.hpp>
+#include <cstdint>
-#include <objects/PickupObject.hpp>
+#include <cmath>
-#include <objects/ProjectileObject.hpp>
+#include <string>
-#include <objects/VehicleObject.hpp>
+#include <vector>
 
-#include <ai/CharacterController.hpp>
-#include <data/ModelData.hpp>
-
-#include <data/CutsceneData.hpp>
-#include <objects/CutsceneObject.hpp>
-#include <render/ObjectRenderer.hpp>
-
-#include <core/Logger.hpp>
-#include <render/GameShaders.hpp>
-
-#include <deque>
 #include <glm/gtc/constants.hpp>
 #include <glm/gtc/type_ptr.hpp>
-#include <glm/gtx/string_cast.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
 
-#include <core/Profiler.hpp>
+#include <gl/TextureData.hpp>
+#include <rw/types.hpp>
+
+#include "core/Logger.hpp"
+#include "core/Profiler.hpp"
+#include "engine/GameData.hpp"
+#include "engine/GameState.hpp"
+#include "engine/GameWorld.hpp"
+#include "loaders/WeatherLoader.hpp"
+#include "objects/GameObject.hpp"
+#include "render/ObjectRenderer.hpp"
+#include "render/GameShaders.hpp"
+#include "render/VisualFX.hpp"
 
 const size_t skydomeSegments = 8, skydomeRows = 10;
 constexpr uint32_t kMissingTextureBytes[] = {

rwengine/src/render/GameRenderer.hpp

@@ -1,39 +1,27 @@
-#ifndef _GAMERENDERER_HPP_
+#ifndef _RWENGINE_GAMERENDERER_HPP_
-#define _GAMERENDERER_HPP_
+#define _RWENGINE_GAMERENDERER_HPP_
-#include <rw/defines.hpp>
 
-class Logger;
+#include <cstddef>
+#include <memory>
 
+#include <glm/glm.hpp>
+
+#include <gl/DrawBuffer.hpp>
+#include <gl/GeometryBuffer.hpp>
 #include <gl/gl_core_3_3.h>
 
-#include <memory>
+#include <rw/forward.hpp>
-#include <vector>
-
-#include <render/ViewCamera.hpp>
 
 #include <render/OpenGLRenderer.hpp>
-#include "MapRenderer.hpp"
+#include <render/MapRenderer.hpp>
-#include "TextRenderer.hpp"
+#include <render/TextRenderer.hpp>
-#include "WaterRenderer.hpp"
+#include <render/ViewCamera.hpp>
+#include <render/WaterRenderer.hpp>
 
-class Clump;
+class Logger;
-class ModelFrame;
+class GameData;
 class GameWorld;
-class GameObject;
+class TextureData;
-
-struct AreaIndicatorInfo;
-
-/// @todo migrate to some other way of rendering each object type.
-class CharacterObject;
-class VehicleObject;
-class InstanceObject;
-class PickupObject;
-class ProjectileObject;
-class CutsceneObject;
-
-class Animator;
-
-class Renderer;
 
 /**
  * @brief Implements high level drawing logic and low level draw commands

rwengine/src/render/GameShaders.cpp

@@ -1,4 +1,4 @@
-#include <render/GameShaders.hpp>
+#include "render/GameShaders.hpp"
 
 namespace GameShaders {
 
@@ -44,17 +44,17 @@ vec3 planeIntercept( vec3 start, vec3 dir, float height )
 void main()
 {
 	TexCoords = position * vec2(0.5,0.5) + vec2(0.5);
-	
+
 	mat4 vp = projection * view;
 	mat4 projector = inverseVP;
-	
+
 	mat3 rot = mat3(view);
 	vec3 ray = vec3(-position.x, -position.y, projection[0][0] ) * rot;
-	
+
 	float plane = texture( data, TexCoords ).r;
-	
+
 	vec3 ws = planeIntercept( campos.xyz, ray, plane );
-	
+
 	ws.z = ws.z + (-1.0+(sin(time + (ws.x + ws.y) * waveParams.x)) * waveParams.y);
 	TexCoords = ws.xy / 5.0;
 	gl_Position = vp * vec4(ws, 1.0);

rwengine/src/render/GameShaders.hpp

@@ -1,6 +1,5 @@
-#pragma once
+#ifndef _RWENGINE_GAMESHADERS_HPP_
-#ifndef _GAMESHADERS_HPP_
+#define _RWENGINE_GAMESHADERS_HPP_
-#define _GAMESHADERS_HPP_
 
 #define SHADER_VF(Name)                    \
     struct Name {                          \

rwengine/src/render/MapRenderer.cpp

@@ -1,10 +1,19 @@
-#include <ai/PlayerController.hpp>
+#include "render/MapRenderer.hpp"
-#include <engine/GameData.hpp>
+
-#include <engine/GameState.hpp>
+#include <cstdint>
-#include <engine/GameWorld.hpp>
+#include <cmath>
-#include <objects/CharacterObject.hpp>
+#include <vector>
-#include <render/GameShaders.hpp>
+
-#include <render/MapRenderer.hpp>
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+#include <gl/gl_core_3_3.h>
+#include <gl/TextureData.hpp>
+
+#include "engine/GameData.hpp"
+#include "engine/GameState.hpp"
+#include "engine/GameWorld.hpp"
+#include "objects/GameObject.hpp"
 
 const char* MapVertexShader = R"(
 #version 330

rwengine/src/render/MapRenderer.hpp

@@ -1,6 +1,16 @@
-#pragma once
+#ifndef _RWENGINE_MAPRENDERER_HPP_
+#define _RWENGINE_MAPRENDERER_HPP_
+
+#include <memory>
+#include <string>
+
+#include <glm/glm.hpp>
+
+#include <gl/DrawBuffer.hpp>
+#include <gl/GeometryBuffer.hpp>
+
+#include "render/OpenGLRenderer.hpp"
 
-#include <render/OpenGLRenderer.hpp>
 class GameData;
 class GameWorld;
 
@@ -51,3 +61,5 @@ private:
     void drawBlip(const glm::vec2& coord, const glm::mat4& view,
                   const MapInfo& mi, glm::vec4 colour, float size);
 };
+
+#endif

rwengine/src/render/ObjectRenderer.cpp

@@ -1,19 +1,27 @@
+#include "render/ObjectRenderer.hpp"
+
+#include <cstdint>
+
 #include <BulletDynamics/Vehicle/btRaycastVehicle.h>
+#include <glm/gtc/type_ptr.hpp>
 
 #include <data/Clump.hpp>
-#include <data/CutsceneData.hpp>
+
-#include <engine/GameData.hpp>
+#include "data/CutsceneData.hpp"
-#include <engine/GameState.hpp>
-#include <glm/gtc/type_ptr.hpp>
-#include <render/ObjectRenderer.hpp>
 #include "data/WeaponData.hpp"
+#include "engine/GameData.hpp"
+#include "engine/GameState.hpp"
+#include "engine/GameWorld.hpp"
+#include "render/ViewCamera.hpp"
+
 // Objects that we know how to turn into renderlist entries
-#include <objects/CharacterObject.hpp>
+#include "objects/CharacterObject.hpp"
-#include <objects/CutsceneObject.hpp>
+#include "objects/CutsceneObject.hpp"
-#include <objects/InstanceObject.hpp>
+#include "objects/InstanceObject.hpp"
-#include <objects/PickupObject.hpp>
+#include "objects/PickupObject.hpp"
-#include <objects/ProjectileObject.hpp>
+#include "objects/ProjectileObject.hpp"
-#include <objects/VehicleObject.hpp>
+#include "objects/VehicleObject.hpp"
+
 #ifdef RW_WINDOWS
 #include <rw_mingw.hpp>
 #endif

rwengine/src/render/ObjectRenderer.hpp

@@ -1,16 +1,30 @@
 #ifndef _RWENGINE_OBJECTRENDERER_HPP_
 #define _RWENGINE_OBJECTRENDERER_HPP_
 
-#include <engine/GameWorld.hpp>
+#include <cstddef>
-#include <gl/DrawBuffer.hpp>
-#include <glm/glm.hpp>
-#include <objects/GameObject.hpp>
-#include <render/OpenGLRenderer.hpp>
-#include <render/ViewCamera.hpp>
-#include <rw/types.hpp>
 
-class ProjectileObject;
+#include <gl/gl_core_3_3.h>
+
+//#include <engine/GameWorld.hpp>
+//#include <gl/DrawBuffer.hpp>
+#include <glm/glm.hpp>
+//#include <objects/GameObject.hpp>
+#include <render/OpenGLRenderer.hpp>
+//#include <render/ViewCamera.hpp>
+//#include <rw/types.hpp>
+
+class Atomic;
+class CharacterObject;
+class Clump;
+class CutsceneObject;
+class GameObject;
+class GameWorld;
+class InstanceObject;
 class PickupObject;
+class ProjectileObject;
+class VehicleObject;
+class ViewCamera;
+struct Geometry;
 
 /**
  * @brief The ObjectRenderer class handles object -> renderer transformation

rwengine/src/render/OpenGLRenderer.cpp

@@ -1,9 +1,13 @@
+#include "render/OpenGLRenderer.hpp"
+
+#include <cstring>
+#include <sstream>
+
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
-#include <render/OpenGLRenderer.hpp>
 
-#include <iostream>
+#include <gl/DrawBuffer.hpp>
-#include <sstream>
+#include <rw/defines.hpp>
 
 namespace {
 constexpr GLuint kUBOIndexScene = 1;
@@ -19,7 +23,7 @@ GLuint compileShader(GLenum type, const char* source) {
     glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
 
     if (status != GL_TRUE) {
-        std::cerr << "[OGL] Shader Compilation Failed" << std::endl;
+        RW_ERROR("[OGL] Shader Compilation Failed");
     }
 
     GLint len;
@@ -33,9 +37,9 @@ GLuint compileShader(GLenum type, const char* source) {
         GLchar* sourceBuff = new GLchar[sourceLen];
         glGetShaderSource(shader, sourceLen, nullptr, sourceBuff);
 
-        std::cerr << "[OGL] Shader InfoLog(" << shader << "):\n"
+        RW_ERROR("[OGL] Shader InfoLog(" << shader << "):\n"
                   << buffer << "\nSource:\n"
-                  << sourceBuff << std::endl;
+                  << sourceBuff);
 
         delete[] buffer;
         delete[] sourceBuff;
@@ -68,7 +72,7 @@ GLuint compileProgram(const char* vertex, const char* fragment) {
     glGetProgramiv(prog, GL_LINK_STATUS, &status);
 
     if (status != GL_TRUE) {
-        std::cerr << "[OGL] Program Link Failed" << std::endl;
+        RW_ERROR("[OGL] Program Link Failed");
     }
 
     GLint len;
@@ -77,8 +81,8 @@ GLuint compileProgram(const char* vertex, const char* fragment) {
         GLchar* buffer = new GLchar[len];
         glGetProgramInfoLog(prog, len, NULL, buffer);
 
-        std::cerr << "[OGL] Program InfoLog(" << prog << "):\n"
+        RW_ERROR("[OGL] Program InfoLog(" << prog << "):\n"
-                  << buffer << std::endl;
+                  << buffer);
 
         delete[] buffer;
     }

rwengine/src/render/OpenGLRenderer.hpp

@@ -1,11 +1,19 @@
-#pragma once
+#ifndef _RWENGINE_OPENGLRENDERER_HPP_
-#ifndef _OPENGLRENDERER_HPP_
+#define _RWENGINE_OPENGLRENDERER_HPP_
-#define _OPENGLRENDERER_HPP_
 
-#include <gl/DrawBuffer.hpp>
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <glm/glm.hpp>
+
+#include <gl/gl_core_3_3.h>
 #include <gl/GeometryBuffer.hpp>
-#include <glm/vec2.hpp>
+
-#include <rw/types.hpp>
+class DrawBuffer;
 
 typedef uint64_t RenderKey;
 

rwengine/src/render/TextRenderer.cpp

@@ -1,9 +1,16 @@
 #include "render/TextRenderer.hpp"
-#include <engine/GameWorld.hpp>
-#include <render/GameRenderer.hpp>
 
 #include <algorithm>
 #include <cctype>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <vector>
+
+#include <gl/gl_core_3_3.h>
+
+#include "engine/GameData.hpp"
+#include "render/GameRenderer.hpp"
 
 int charToIndex(uint16_t g) {
     // Correct for the default font maps

rwengine/src/render/TextRenderer.hpp

@@ -1,7 +1,16 @@
-#ifndef RWENGINE_TEXTRENDERER_HPP
+#ifndef _RWENGINE_TEXTRENDERER_HPP_
-#define RWENGINE_TEXTRENDERER_HPP
+#define _RWENGINE_TEXTRENDERER_HPP_
-#include <engine/GameData.hpp>
+
-#include "OpenGLRenderer.hpp"
+#include <memory>
+#include <string>
+
+#include <glm/glm.hpp>
+
+#include <gl/DrawBuffer.hpp>
+#include <gl/GeometryBuffer.hpp>
+
+#include <data/GameTexts.hpp>
+#include <render/OpenGLRenderer.hpp>
 
 #define GAME_FONTS 3
 #define GAME_GLYPHS 192

rwengine/src/render/ViewCamera.hpp

@@ -1,7 +1,8 @@
-#ifndef _VIEWCAMERA_HPP_
+#ifndef _RWENGINE_VIEWCAMERA_HPP_
-#define _VIEWCAMERA_HPP_
+#define _RWENGINE_VIEWCAMERA_HPP_
 #include <glm/gtc/quaternion.hpp>
-#include "ViewFrustum.hpp"
+
+#include "render/ViewFrustum.hpp"
 
 class ViewCamera {
 public:

rwengine/src/render/ViewFrustum.hpp

@@ -1,7 +1,9 @@
-#ifndef _VIEWFRUSTUM_HPP_
+#ifndef _RWENGINE_VIEWFRUSTUM_HPP_
-#define _VIEWFRUSTUM_HPP_
+#define _RWENGINE_VIEWFRUSTUM_HPP_
+
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
+
 #ifdef RW_WINDOWS
 #include <rw_mingw.hpp>
 #endif

rwengine/src/render/VisualFX.cpp

@@ -1,6 +1,6 @@
-#include <render/VisualFX.hpp>
+#include "render/VisualFX.hpp"
 
-#include <memory>
+#include <new>
 
 VisualFX::LightData::~LightData() {
 }

rwengine/src/render/VisualFX.hpp

@@ -1,7 +1,9 @@
-#pragma once
+#ifndef _RWENGINE_VISUALFX_HPP_
+#define _RWENGINE_VISUALFX_HPP_
+
+#include <glm/glm.hpp>
 
 #include <gl/TextureData.hpp>
-#include <glm/glm.hpp>
 
 /**
  * Represents a scene effect: lighting, particles etc.
@@ -80,3 +82,5 @@ public:
 private:
     EffectType type;
 };
+
+#endif

rwengine/src/render/WaterRenderer.cpp

@@ -1,10 +1,18 @@
-#include <engine/GameWorld.hpp>
+#include "render/WaterRenderer.hpp"
-#include <render/GameRenderer.hpp>
+
-#include <render/GameShaders.hpp>
+#include <cmath>
-#include <render/WaterRenderer.hpp>
 
 #include <glm/glm.hpp>
 
+#include <rw/defines.hpp>
+#include <rw/types.hpp>
+
+#include "engine/GameData.hpp"
+#include "engine/GameWorld.hpp"
+#include "render/GameRenderer.hpp"
+#include "render/GameShaders.hpp"
+#include "render/OpenGLRenderer.hpp"
+
 WaterRenderer::WaterRenderer(GameRenderer* renderer) : waterProg(nullptr) {
     maskDraw.setFaceType(GL_TRIANGLES);
     gridDraw.setFaceType(GL_TRIANGLES);

rwengine/src/render/WaterRenderer.hpp

@@ -1,7 +1,15 @@
-#pragma once
+#ifndef _RWENGINE_WATERRENDERER_HPP_
+#define _RWENGINE_WATERRENDERER_HPP_
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include <gl/DrawBuffer.hpp>
+#include <gl/GeometryBuffer.hpp>
+#include <gl/gl_core_3_3.h>
 
 #include <render/OpenGLRenderer.hpp>
-#include <rw/types.hpp>
 
 class GameRenderer;
 class GameWorld;
@@ -47,3 +55,5 @@ private:
     GLuint fbOutput;
     GLuint dataTexture;
 };
+
+#endif

rwgame/DrawUI.cpp

@@ -3,6 +3,7 @@
 #include <engine/GameState.hpp>
 #include <objects/CharacterObject.hpp>
 #include <data/WeaponData.hpp>
+#include <engine/GameData.hpp>
 #include <render/GameRenderer.hpp>
 
 #include <glm/gtc/constants.hpp>

rwgame/GameBase.cpp

@@ -1,12 +1,15 @@
 #include "GameBase.hpp"
 
+//#include <rw/filesystem.hpp>
+
+#include <iostream>
+
+#include <SDL.h>
+
 #include <rw/defines.hpp>
-#include <rw/filesystem.hpp>
 
 #include "GitSHA1.h"
 
-#include "SDL.h"
-
 #include <iostream>
 
 // Use first 8 chars of git hash as the build string

rwgame/MenuSystem.hpp

@@ -2,11 +2,14 @@
 #define _GAME_MENUSYSTEM_HPP_
 #include <algorithm>
 #include <functional>
-#include <glm/glm.hpp>
 #include <memory>
-#include <render/GameRenderer.hpp>
 #include <string>
 
+#include <glm/glm.hpp>
+
+#include <render/GameRenderer.hpp>
+#include <rw/defines.hpp>
+
 /**
  * Default values for menus that should match the look and feel of the original
  */

rwgame/RWGame.cpp

@@ -24,6 +24,7 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <functional>
 #include <iomanip>
+#include <iostream>
 
 std::map<GameRenderer::SpecialModel, std::string> kSpecialModels = {
     {GameRenderer::ZoneCylinderA, "zonecyla.dff"},

rwgame/states/BenchmarkState.cpp

@@ -1,8 +1,10 @@
 #include "BenchmarkState.hpp"
 #include <engine/GameState.hpp>
-#include <fstream>
 #include "RWGame.hpp"
 
+#include <fstream>
+#include <iostream>
+
 BenchmarkState::BenchmarkState(RWGame* game, const std::string& benchfile)
     : State(game), benchfile(benchfile), benchmarkTime(0.f), duration(0.f), frameCounter(0) {
 }

rwgame/states/DebugState.cpp

@@ -8,6 +8,7 @@
 #include <objects/InstanceObject.hpp>
 #include <objects/VehicleObject.hpp>
 #include <sstream>
+#include <iostream>
 #include "RWGame.hpp"
 
 constexpr float kDebugEntryHeight = 14.f;

rwgame/states/IngameState.hpp

@@ -3,6 +3,7 @@
 
 #include "StateManager.hpp"
 
+class GameObject;
 class PlayerController;
 
 class IngameState : public State {

rwgame/states/PauseState.cpp

@@ -1,6 +1,8 @@
 #include "PauseState.hpp"
 #include "RWGame.hpp"
 
+#include <iostream>
+
 PauseState::PauseState(RWGame* game) : State(game) {
     auto& t = game->getGameData().texts;