More debug output and support for windows compiling.

ChangeLog.md

     * Fix to allow imguifilesystem to compile using Visual Studio 2013.
     * Very simple implementation of solid-mode using white texture.
     * New option to keep camera in a room.
+    * Counting number of OpenGL calls per frame.
+    * Now displaying meaningful error message when no OpenGL lib was found at run-time.
+    * No including gl.h instead of gl33.h where needed.
 
     [ 20150405 ]
     * No longer flipping axis in shaders, now turning camera upside-down.

include/RunTime.h

     static const std::vector<float>& getHistoryFPS() { return history; }
     static float getLastFrameTime() { return lastFrameTime / 1000.0f; }
 
+    static void incrementCallCount() { glCallCount++; }
+    static unsigned long getCallCount() { auto c = glCallCount; glCallCount = 0; return c; }
+
   private:
     static std::string baseDir;
     static std::string pakDir;
     static unsigned long frameTimeSum, frameTimeSum2;
     static unsigned long fps;
     static std::vector<float> history;
+    static unsigned long glCallCount;
 };
 
 #endif

include/system/Shader.h

 
 #include "TextureManager.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 class ShaderBuffer {
   public:

include/system/WindowGLFW.h

     static bool mousegrab;
     static bool textinput;
     static GLFWwindow* window;
-    static int lastMouseX;
-    static int lastMouseY;
+    static int lastMouseX, lastMouseY;
     static bool modShift;
     static bool modControl;
     static bool modAlt;

src/Camera.cpp

 #include "system/Window.h"
 #include "Camera.h"
 
-#include <glbinding/gl/gl33.h>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/quaternion.hpp>

src/Mesh.cpp

 #include "TextureManager.h"
 #include "Mesh.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 Mesh::Mesh(const std::vector<glm::vec3>& vert,
            const std::vector<IndexedRectangle>& rect,

src/Render.cpp

 #include "Render.h"
 
 #include <glm/gtc/matrix_transform.hpp>
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 #include "imgui/imgui.h"
 #include "stb/stb_image_write.h"
     glm::mat4 VP = projection * view;
 
     if (updated || displayVisibilityCheck) {
-        int r = Camera::getRoom();
         clearRoomList();
-        if (r < 0) {
-            buildRoomList(VP);
-        } else {
-            buildRoomList(VP, r);
-        }
+        buildRoomList(VP);
     }
 
     for (int r = roomList.size() - 1; r >= 0; r--) {

src/RoomData.cpp

 
 #include "imgui/imgui.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {

src/RunTime.cpp

 unsigned long RunTime::frameTimeSum2 = 0;
 unsigned long RunTime::fps = 0;
 std::vector<float> RunTime::history;
+unsigned long RunTime::glCallCount = 0;
 
 void RunTime::initialize() {
     baseDir = expandHomeDirectory("~/.OpenRaider");

src/TextureManager.cpp

 #include "utils/strings.h"
 #include "TextureManager.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 glm::vec2 TextureTile::getUV(unsigned int i) {
     glm::vec2 uv(vertices.at(i).xPixel,

src/UI.cpp

 #include "utils/time.h"
 #include "UI.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 Shader UI::imguiShader;
                          ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize
                          | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings
                          | ImGuiWindowFlags_AlwaysAutoResize)) {
+#ifdef DEBUG
+            ImGui::Text("%d FPS  %lu CPF", RunTime::getFPS(), RunTime::getCallCount());
+#else
             ImGui::Text("%d FPS", RunTime::getFPS());
+#endif
+
             ImGui::Text("X: %.1f (%.2f)", Camera::getPosition().x, Camera::getRotation().x);
             ImGui::Text("Y: %.2f (%.2f)", Camera::getPosition().y, Camera::getRotation().y);
             ImGui::Text("Z: %.2f (%d)", Camera::getPosition().z, Camera::getRoom());

src/loader/Loader.cpp

  */
 
 #include "global.h"
+#include "Log.h"
 #include "loader/Loader.h"
 #include "loader/LoaderTR1.h"
 #include "loader/LoaderTR2.h"
             return TR_4;
     }
 
+    Log::get(LOG_ERROR) << "Unknown TR level version: \"" << start << "\"" << Log::endl;
+
     return TR_UNKNOWN;
 }
 

src/main.cpp

 
 #ifdef DEBUG
 static void glErrorCallback(const glbinding::FunctionCall& call) {
+    RunTime::incrementCallCount();
+
     gl::GLenum error = gl::glGetError();
     if (error == gl::GL_NO_ERROR) {
         return;
 
     log << Log::endl;
 }
+
+static void glUnresolvedCallback(const glbinding::AbstractFunction& func) {
+    Log::get(LOG_ERROR) << "Unresolved OpenGL call: \"" << func.name() << "\"!" << Log::endl;
+    orAssert(func.isResolved());
+}
 #endif
 
 int main(int argc, char* argv[]) {
                                      | glbinding::CallbackMask::ParametersAndReturnValue,
                                      { "glGetError" });
     glbinding::setAfterCallback(glErrorCallback);
+    glbinding::setUnresolvedCallback(glUnresolvedCallback);
 #endif
 
     Log::get(LOG_INFO) << "Initializing " << VERSION << Log::endl;

src/system/Shader.cpp

 #include "system/Window.h"
 #include "system/Shader.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 ShaderBuffer::~ShaderBuffer() {
     if (created)

src/system/Window.cpp

 #error "No windowing library selected!"
 #endif
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 int Window::initialize() {
     int res;

src/system/WindowGLFW.cpp

 #include "system/Window.h"
 #include "system/WindowGLFW.h"
 
-#include <glbinding/gl/gl33.h>
+#include <glbinding/gl/gl.h>
 
 glm::i32vec2 WindowGLFW::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 bool WindowGLFW::fullscreen = false;