OpenGL error checking.

ChangeLog.md

 
 ## OpenRaider (0.1.4) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150408 ]
+    * Now checking for errors after every OpenGL call.
+    * Slightly tweaked portal visibility checks.
+    * Fix to allow imguifilesystem to compile using Visual Studio 2013.
+    * Very simple implementation of solid-mode using white texture.
+
     [ 20150405 ]
     * No longer flipping axis in shaders, now turning camera upside-down.
     * Mostly fixed portal-to-portal 2D visibility checks.

src/Camera.cpp

     for (int i = 0; i < 6; i++) {
         int out = 0, in = 0;
         for (int c = 0; (c < 8) && ((in == 0) || (out == 0)); c++) {
-            if (planes[i].distance(b.getCorner(c)) > 0)
+            if (planes[i].distance(b.getCorner(c)) >= 0)
                 out++;
             else
                 in++;

src/Render.cpp

             // Display the visibility test for the portal to this room
             BoundingBox debugBox(glm::vec3(min, 0.0f), glm::vec3(max, 0.0f));
             debugBox.display(glm::mat4(1.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 1.0f, 0.0f));
-
-            ImGui::Text("   Min: %.3f %.3f", min.x, min.y);
-            ImGui::Text("   Max: %.3f %.3f", max.x, max.y);
         }
 
         // Check all portals leading from this room to somewhere else
         for (int i = 0; i < World::getRoom(room).sizePortals(); i++) {
             auto& portal = World::getRoom(room).getPortal(i);
+            auto& room = World::getRoom(portal.getAdjoiningRoom());
 
-            // Calculate the 2D window of this portal
+            // Calculate the 2D screen-space bounding box of this portal
             glm::vec3 newMin, newMax;
             for (int c = 0; c < 4; c++) {
                 glm::vec3 vert = portal.getVertex(c);
                 glm::vec4 result = VP * glm::vec4(vert, 1.0f);
                 vert = glm::vec3(result) / result.w;
 
-                if (displayVisibilityCheck) {
-                    ImGui::Text("Test %d: %.3f %.3f %.3f", c, vert.x, vert.y, vert.z);
-                }
-
                 if (c == 0) {
                     newMin = vert;
                     newMax = vert;
                 }
             }
 
-            if (displayVisibilityCheck) {
-                ImGui::Text("NewMin: %.3f %.3f %.3f", newMin.x, newMin.y, newMin.z);
-                ImGui::Text("NewMax: %.3f %.3f %.3f", newMax.x, newMax.y, newMax.z);
-            }
-
             //! \fixme Currently also checking behind player, because Z is always 1.0f?!
             //if ((newMin.z > 0.0f) || (newMin.z < -1.0f) || (newMax.z > 0.0f) || (newMax.z < -1.0f)) {
             //    continue;
                 continue;
             }
 
+            // Check if the connected room is in our view frustum (could be visible)
+            if (!Camera::boxInFrustum(room.getBoundingBox())) {
+                continue;
+            }
+
             // Check if this room is already in the list...
             bool found = false;
             for (int n = 0; n < roomList.size(); n++) {
-                if (roomList.at(n) == &World::getRoom(portal.getAdjoiningRoom())) {
+                if (roomList.at(n) == &room) {
                     found = true;
                     break;
                 }

src/deps/imguifilesystem/imguifilesystem.cpp

     static struct stat stat1;
     static struct stat stat2;
     static SorterSignature sorter;
-#   ifdef MSC_VER
+#   ifdef _MSC_VER
     // Never tested (I've just been told that cl.exe does not have strcasecmp: please search the web for other possible alternative implementations)
     inline static int strcasecmp( const char *s1, const char *s2 )  {
         return _stricmp(s1,s2);
         //return lstrcmpiA(s1,s2);  // Not sure this is better
     }
-#   endif //MSC_VER
+#   endif //_MSC_VER
     // Possible problem: sorting is in ASCII with these methods
     static int Alphasort(const struct dirent **e1,const struct dirent **e2)    {
         return strcasecmp((*e1)->d_name,(*e2)->d_name);

src/main.cpp

 
 #include <glbinding/Binding.h>
 
+#ifdef DEBUG
+#include <glbinding/callbacks.h>
+#include <glbinding/Meta.h>
+#endif
+
 static std::string configFileToUse;
 
+#ifdef DEBUG
+static void glErrorCallback(const glbinding::FunctionCall& call) {
+    gl::GLenum error = gl::glGetError();
+    if (error == gl::GL_NO_ERROR) {
+        return;
+    }
+
+    auto& log = Log::get(LOG_DEBUG);
+    if (glbinding::Meta::stringsByGL()) {
+        log << "OpenGL Error: " << glbinding::Meta::getString(error) << Log::endl;
+    } else {
+        log << "OpenGL Error: "
+            << static_cast<std::underlying_type<gl::GLenum>::type>(error)
+            << Log::endl;
+    }
+    log << call.function->name() << "(";
+
+    for (int i = 0; i < call.parameters.size(); i++) {
+        log << call.parameters[i]->asString();
+        if (i < (call.parameters.size() - 1)) {
+            log << ", ";
+        }
+    }
+
+    log << ")";
+
+    if (call.returnValue) {
+        log << " -> " << call.returnValue->asString();
+    }
+
+    log << Log::endl;
+}
+#endif
+
 int main(int argc, char* argv[]) {
     command_t cmd;
     command_init(&cmd, argv[0], VERSION);
     glbinding::Binding::initialize();
     Log::initialize();
     RunTime::initialize(); // RunTime is required by other constructors
-
     Command::fillCommandList();
 
+#ifdef DEBUG
+    // Register global OpenGL after-callback for all GL functions except glGetError
+    glbinding::setCallbackMaskExcept(glbinding::CallbackMask::After
+                                     | glbinding::CallbackMask::ParametersAndReturnValue,
+                                     { "glGetError" });
+    glbinding::setAfterCallback(glErrorCallback);
+#endif
+
     Log::get(LOG_INFO) << "Initializing " << VERSION << Log::endl;
 
     // Initialize Windowing

src/system/Shader.cpp

 
 #include "global.h"
 #include "Log.h"
+#include "Render.h"
 #include "system/Window.h"
 #include "system/Shader.h"
 
 }
 
 void Shader::loadUniform(int uni, int texture, TextureStorage store) {
-    gl::glUniform1i(getUniform(uni), TextureManager::bindTexture(texture, store));
+    if ((Render::getMode() == RenderMode::Solid)
+        && (store == TextureStorage::GAME)) {
+        gl::glUniform1i(getUniform(uni), TextureManager::bindTexture(TEXTURE_SPLASH, TextureStorage::SYSTEM));
+    } else {
+        gl::glUniform1i(getUniform(uni), TextureManager::bindTexture(texture, store));
+    }
 }
 
 void Shader::use() {