Wrong assert was used when including glm

CMakeLists.txt

 
 # Flags for Debug build
 set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -DDEBUG")
-set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -DEXPERIMENTAL")
-set (OpenRaider_CXX_FLAGS_DEBUG "${OpenRaider_CXX_FLAGS_DEBUG} -DMULTITEXTURE")
 
 # Flags for Releasae builds
-set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -DNDEBUG")
+set (OpenRaider_CXX_FLAGS_RELEASE "${OpenRaider_CXX_FLAGS_RELEASE} -DNODEBUG")
 
 #################################################################
 

ChangeLog.md

 
     [ 20140107 ]
     * Fixed problems with FontTTFs Glyph Baseline
+    * No longer using wrong assert() when glm is included
 
     [ 20150106 ]
     * Removed SDL2-TTF Font implementation

include/Camera.h

 #ifndef _CAMERA_H_
 #define _CAMERA_H_
 
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <glm/mat4x4.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/type_precision.hpp>
 

include/Log.h

 #include <string>
 #include <sstream>
 #include <vector>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
+
 #include <glm/gtc/type_precision.hpp>
 
 class Log {

include/Mesh.h

 #define _MESH_H_
 
 #include <vector>
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
 
 #include "system/Shader.h"
 

include/Render.h

 #define _RENDER_H_
 
 #include <vector>
-#include <glm/vec2.hpp>
-#include <glm/vec4.hpp>
+
 #include <glm/gtc/type_precision.hpp>
 
 #include "Room.h"

include/Room.h

 
 #include <memory>
 #include <vector>
-#include <glm/mat4x4.hpp>
-#include <glm/vec3.hpp>
 
 #include "Sprite.h"
 #include "RoomData.h"

include/RoomData.h

 
 #include <memory>
 #include <vector>
-#include <glm/mat4x4.hpp>
-#include <glm/vec3.hpp>
 
 class BoundingBox {
   public:

include/RoomMesh.h

 #define _ROOM_MESH_H_
 
 #include <vector>
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
 
 #include "Mesh.h"
 #include "system/Shader.h"

include/TextureManager.h

 #ifndef _TEXTURE_MANAGER_H
 #define _TEXTURE_MANAGER_H
 
-#include <cstdint>
 #include <vector>
-#include <glm/vec2.hpp>
 
 // These are loaded into TextureStorage::SYSTEM by initialize()!
 #define TEXTURE_WHITE 0
 
 class TextureTileVertex {
   public:
-    TextureTileVertex(uint8_t xc, uint8_t xp, uint8_t yc, uint8_t yp)
+    TextureTileVertex(int xc, int xp, int yc, int yp)
         : xCoordinate(xc), xPixel(xp), yCoordinate(yc), yPixel(yp) { }
 
-    uint8_t xCoordinate, xPixel;
-    uint8_t yCoordinate, yPixel;
+    int xCoordinate, xPixel;
+    int yCoordinate, yPixel;
 };
 
 class TextureTile {

include/UI.h

 #include <list>
 #include <memory>
 #include <tuple>
-#include <glm/vec2.hpp>
+
 #include <glm/gtc/type_precision.hpp>
 
 #include "system/Shader.h"

include/global.h

 #include <GL/glext.h>
 #endif // __APPLE__
 
+/*! \todo Is there a better way to handle this?
+ * We wan't to use our own assert(). Unfortunately, glm includes
+ * <cassert> in its headers. So we need to define NDEBUG here.
+ * To avoid a conflict, our flag is now called NODEBUG instead.
+ */
+#define NDEBUG
+#include <glm/glm.hpp>
+
 // If available, use our own assert that prints the call stack
 #if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)
 
-#ifndef NDEBUG
+#ifndef NODEBUG
 
 #include <iostream>
 #include <execinfo.h>
         assertNotEqualImplementation(#x " != " #y, assertEvalTemp, assertEvalTemp2, __FILE__, __LINE__, true); \
 }
 
-#else // NDEBUG
+#else // NODEBUG
 
 #define assert(x)
 #define assertEqual(x, y)
 #define assertNotEqual(x, y)
 
-#endif // NDEBUG
+#endif // NODEBUG
 
 #else // EXECINFO
 

include/system/FontTRLE.h

 #define _FONT_TRLE_H_
 
 #include <vector>
-#include <glm/vec2.hpp>
 
 #include "system/Shader.h"
 

include/system/Shader.h

 #define _SHADER_H_
 
 #include <vector>
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec4.hpp>
 
 #include "TextureManager.h"
 

include/system/Window.h

 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
-#include <vector>
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <glm/vec4.hpp>
 #include <glm/gtc/type_precision.hpp>
 
 class Window {

include/system/WindowGLFW.h

 #ifndef _WINDOW_GLFW_H_
 #define _WINDOW_GLFW_H_
 
-#include <glm/vec2.hpp>
 #include <glm/gtc/type_precision.hpp>
 
 #include <GLFW/glfw3.h>

include/system/WindowSDL.h

 #ifndef _WINDOW_SDL_H_
 #define _WINDOW_SDL_H_
 
-#include <glm/vec2.hpp>
 #include <glm/gtc/type_precision.hpp>
 
 #include "SDL.h"

src/Camera.cpp

  */
 
 #include <limits>
-#include <glm/gtc/epsilon.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/quaternion.hpp>
 
 #include "global.h"
 #include "RunTime.h"
 #include "system/Window.h"
 #include "Camera.h"
 
+#include <glm/gtc/epsilon.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/quaternion.hpp>
+
 static bool equal(float a, float b) {
     return glm::epsilonEqual(a, b, std::numeric_limits<float>::epsilon());
 }

src/Entity.cpp

  * \author xythobuz
  */
 
-#include <glm/glm.hpp>
-
 #include "global.h"
 #include "Log.h"
 #include "World.h"

src/Render.cpp

 
 #include <algorithm>
 #include <sstream>
-#include <glm/gtc/matrix_transform.hpp>
-
-#include "imgui/imgui.h"
-#include "stb/stb_image_write.h"
 
 #include "global.h"
 #include "Camera.h"
 #include "utils/strings.h"
 #include "Render.h"
 
+#include <glm/gtc/matrix_transform.hpp>
+
+#include "imgui/imgui.h"
+#include "stb/stb_image_write.h"
+
 RenderMode Render::mode = RenderMode::LoadScreen;
 std::vector<Room*> Render::roomList;
 bool Render::displayViewFrustum = false;

src/Room.cpp

  */
 
 #include <algorithm>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/intersect.hpp>
 
 #include "global.h"
 #include "Game.h"
 #include "Room.h"
 #include "TextureManager.h"
 
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/intersect.hpp>
+
 Room::Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f,
            int a, int x, int z) : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f),
                                   alternateRoom(a), numXSectors(x), numZSectors(z) {

src/RoomData.cpp

  * \author xythobuz
  */
 
-#include <glm/gtc/matrix_transform.hpp>
-
 #include "global.h"
 #include "SkeletalModel.h"
 #include "World.h"
 #include "system/Shader.h"
 #include "RoomData.h"
 
+#include <glm/gtc/matrix_transform.hpp>
+
 void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {
     std::vector<glm::vec3> verts;
     std::vector<glm::vec3> cols;

src/Sprite.cpp

  * \author xythobuz
  */
 
-#include <glm/glm.hpp>
-
 #include "global.h"
 #include "Camera.h"
 #include "Game.h"

src/commands/CommandSet.cpp

  * \author xythobuz
  */
 
-#include <glm/glm.hpp>
-
 #include "global.h"
 #include "Camera.h"
 #include "Log.h"
             getLog() << "set-size-Error: Invalid value(s)" << Log::endl;
             return -2;
         }
-        Window::setSize(glm::vec2(w, h));
+        Window::setSize(glm::i32vec2(w, h));
     } else if (var.compare("fullscreen") == 0) {
         bool fullscreen = false;
         if (!(args >> fullscreen)) {

src/loader/LoaderTR2.cpp

  */
 
 #include <vector>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
 
 #include "global.h"
 #include "Game.h"
 #include "utils/pixel.h"
 #include "loader/LoaderTR2.h"
 
+#include <glm/gtc/matrix_transform.hpp>
+
 LoaderTR2::LoaderTR2() {
 }
 

src/main.cpp

 }
 
 #if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)
-#ifndef NDEBUG
+#ifndef NODEBUG
 
 #include <exception>
 #include <execinfo.h>
         char** strs = backtrace_symbols(callstack, frames);
 
         std::cout << std::endl;
-        for (int i = 0; i < frames; i++)
-            std::cout << strs[i] << std::endl;
+        for (int i = frames; i > 0; i++)
+            std::cout << strs[i - 1] << std::endl;
 
         delete [] strs;
 
     std::terminate_handler oldTerminateHandler = std::set_terminate(terminateHandler);
 }
 
-#endif // NDEBUG
+#endif // NODEBUG
 #endif // HAVE_EXECINFO_H && HAVE_BACKTRACE && HAVE_BACKTRACE_SYMBOLS