Inserted OpenGL Error checking

src/dawnshared/assert/assert.cpp

@@ -7,64 +7,60 @@
 
 #include "assert.hpp"
 
-#if ASSERTS_ENABLED == 0
-
-#elif ASSERTS_ENABLED == 1
-  void assertTrue(bool_t x, const char message[]) {
-    if(x != true) {
-      std::cout << message << std::endl;
-      throw message;
-      free(0);
-    }
-    assert(x == true);
+void assertTrue(bool_t x, const char message[]) {
+  if(x != true) {
+    std::cout << message << std::endl;
+    throw message;
+    free(0);
   }
+  assert(x == true);
+}
 
-  void assertTrue(bool_t x, std::string message) {
-    assertTrue(x, message.c_str());
-  }
-  
-
-  void assertFalse(bool_t x, const char message[]) {
-    assertTrue(!x, message);
-  }
-
-  void assertFalse(bool_t x, std::string message) {
-    assertFalse(x, message.c_str());
-  }
+void assertTrue(bool_t x, std::string message) {
+  assertTrue(x, message.c_str());
+}
 
 
-  void assertUnreachable(const char message[]) {
-    assertTrue(false, message);
-  }
+void assertFalse(bool_t x, const char message[]) {
+  assertTrue(!x, message);
+}
 
-  void assertUnreachable(std::string message) {
-    assertUnreachable(message.c_str());
-  }
+void assertFalse(bool_t x, std::string message) {
+  assertFalse(x, message.c_str());
+}
 
 
-  void assertNotNull(void *pointer, const char message[]) {
-    assertTrue(pointer != nullptr && pointer != NULL, message);
-  }
+void assertUnreachable(const char message[]) {
+  assertTrue(false, message);
+}
 
-  void assertNotNull(void *pointer, std::string message) {
-    assertNotNull(pointer, message.c_str());
-  }
+void assertUnreachable(std::string message) {
+  assertUnreachable(message.c_str());
+}
 
 
-  void assertNull(void *pointer, const char message[]) {
-    assertTrue(pointer == NULL || pointer == nullptr, message);
-  }
+void assertNotNull(void *pointer, const char message[]) {
+  assertTrue(pointer != nullptr && pointer != NULL, message);
+}
 
-  void assertNull(void *pointer, std::string message) {
-    assertNull(pointer, message.c_str());
-  }
+void assertNotNull(void *pointer, std::string message) {
+  assertNotNull(pointer, message.c_str());
+}
 
 
-  void assertDeprecated(const char message[]) {
-    assertUnreachable(message);
-  }
+void assertNull(void *pointer, const char message[]) {
+  assertTrue(pointer == NULL || pointer == nullptr, message);
+}
 
-  void assertDeprecated(std::string message) {
-    assertDeprecated(message.c_str());
-  }
-#endif
+void assertNull(void *pointer, std::string message) {
+  assertNull(pointer, message.c_str());
+}
+
+
+void assertDeprecated(const char message[]) {
+  assertUnreachable(message);
+}
+
+void assertDeprecated(std::string message) {
+  assertDeprecated(message.c_str());
+}

src/dawnshared/assert/assert.hpp

@@ -8,86 +8,73 @@
 #pragma once
 #include "dawnsharedlibs.hpp"
 
-#define ASSERTS_ENABLED 1
+/**
+ * Assert a given value to be true.
+ * @param x Value to assert as true.
+ * @param message Message to throw against assertion failure.
+ */
+void assertTrue(bool_t x, const char message[]);
+void assertTrue(bool_t x, std::string message);
 
-#if ASSERTS_ENABLED == 0
+/**
+ * Asserts a given statement to be false.
+ * @param x Value to assert as false.
+ * @param message Message to throw against assertion failure.
+ */
+void assertFalse(bool_t x, const char message[]);
+void assertFalse(bool_t x, std::string message);
 
-static inline void assertTrue(bool_t x) {}
+/**
+ * Asserts that a given line of code is unreachable. Essentially a forced
+ * assertion failure, good for "edge cases"
+ * @param message Message to throw against assertion failure.
+ */
+void assertUnreachable(const char message[]);
+void assertUnreachable(std::string message);
 
-#elif ASSERTS_ENABLED == 1
+/**
+ * Assert a given pointer to not point to a null pointer.
+ * @param pointer Pointer to assert is not a null pointer.
+ * @param message Message to throw against assertion failure.
+ */
+void assertNotNull(void *pointer, const char message[]);
+void assertNotNull(void *pointer, std::string message);
 
-  /**
-   * Assert a given value to be true.
-   * @param x Value to assert as true.
-   * @param message Message to throw against assertion failure.
-   */
-  void assertTrue(bool_t x, const char message[]);
-  void assertTrue(bool_t x, std::string message);
+/**
+ * Asserts a given pointer to be a nullptr.
+ * @param pointer Pointer to assert is nullptr.
+ * @param message Message to throw against assertion failure.
+ */
+void assertNull(void *pointer, const char message[]);
+void assertNull(void *pointer, std::string message);
 
-  /**
-   * Asserts a given statement to be false.
-   * @param x Value to assert as false.
-   * @param message Message to throw against assertion failure.
-   */
-  void assertFalse(bool_t x, const char message[]);
-  void assertFalse(bool_t x, std::string message);
+/**
+ * Asserts a function as being deprecated.
+ * @param message Message to throw against assertion failure.
+ */
+void assertDeprecated(const char message[]);
+void assertDeprecated(std::string message);
 
-  /**
-   * Asserts that a given line of code is unreachable. Essentially a forced
-   * assertion failure, good for "edge cases"
-   * @param message Message to throw against assertion failure.
-   */
-  void assertUnreachable(const char message[]);
-  void assertUnreachable(std::string message);
+/**
+ * Asserts that a given map has a key.
+ * 
+ * @param map Map to check.
+ * @param key Key to try and assert exists.
+ * @param message Message to throw against assertion failure.
+ */
+template<typename K, typename V>
+void assertMapHasKey(std::map<K,V> map, K key, const char message[]) {
+  assertTrue(map.find(key) != map.end(), message);
+}
 
-  /**
-   * Assert a given pointer to not point to a null pointer.
-   * @param pointer Pointer to assert is not a null pointer.
-   * @param message Message to throw against assertion failure.
-   */
-  void assertNotNull(void *pointer, const char message[]);
-  void assertNotNull(void *pointer, std::string message);
-
-  /**
-   * Asserts a given pointer to be a nullptr.
-   * @param pointer Pointer to assert is nullptr.
-   * @param message Message to throw against assertion failure.
-   */
-  void assertNull(void *pointer, const char message[]);
-  void assertNull(void *pointer, std::string message);
-
-  /**
-   * Asserts a function as being deprecated.
-   * @param message Message to throw against assertion failure.
-   */
-  void assertDeprecated(const char message[]);
-  void assertDeprecated(std::string message);
-
-  /**
-   * Asserts that a given map has a key.
-   * 
-   * @param map Map to check.
-   * @param key Key to try and assert exists.
-   * @param message Message to throw against assertion failure.
-   */
-  template<typename K, typename V>
-  void assertMapHasKey(std::map<K,V> map, K key, const char message[]) {
-    assertTrue(map.find(key) != map.end(), message);
-  }
-
-  /**
-   * Asserts that a given map has a key.
-   * 
-   * @param map Map to check.
-   * @param key Key to try and assert exists.
-   * @param message Message to throw against assertion failure.
-   */
-  template<typename K, typename V>
-  void assertMapHasKey(std::map<K,V> map, K key, std::string message) {
-    assertMapHasKey(map, key, message.c_str());
-  }
-#else
-
-  #define assertTrue assert
-
-#endif
+/**
+ * Asserts that a given map has a key.
+ * 
+ * @param map Map to check.
+ * @param key Key to try and assert exists.
+ * @param message Message to throw against assertion failure.
+ */
+template<typename K, typename V>
+void assertMapHasKey(std::map<K,V> map, K key, std::string message) {
+  assertMapHasKey(map, key, message.c_str());
+}