Improve thread safety.

include/JGL/types/VRamList.h

@@ -16,6 +16,8 @@ private:
     GLuint list_handle = 0;
     long num_elements = 0;
     bool element_array_buffer = false;
+    /// "Spin Locking" fix for multi-threading.
+    bool spin_lock = false;
     void load(const GLfloat* data, const long& size);
     void load(const GLuint* data, const long& size);
     void SetData(void* data, const long& length);

src/types/VRamList.cpp

@@ -3,6 +3,9 @@
 #include <cstring>
 
 void JGL::VRamList::load(const GLfloat* data, const long& size) {
+    while (spin_lock) {}
+    spin_lock = true;
+
     GLint current_array_buffer = 0;
     glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &current_array_buffer);
     glGenBuffers(1, &list_handle);
@@ -11,9 +14,14 @@ void JGL::VRamList::load(const GLfloat* data, const long& size) {
     glBindBuffer(GL_ARRAY_BUFFER, current_array_buffer);
     element_array_buffer = false;
     num_elements = size / sizeof(GLfloat);
+
+    spin_lock = false;
 }
 
 void JGL::VRamList::load(const GLuint* data, const long& size) {
+    while (spin_lock) {}
+    spin_lock = true;
+
     GLint current_element_array_buffer = 0;
     glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &current_element_array_buffer);
     glGenBuffers(1, &list_handle);
@@ -22,12 +30,17 @@ void JGL::VRamList::load(const GLuint* data, const long& size) {
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, current_element_array_buffer);
     element_array_buffer = true;
     num_elements = size / sizeof(GLuint);
+
+    spin_lock = false;
 }
 
 void JGL::VRamList::Erase() {
     if (list_handle == 0)
         return;
 
+    while (spin_lock) {}
+    spin_lock = true;
+
     GLint current_element_array_buffer = 0;
     glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &current_element_array_buffer);
     GLint current_array_buffer = 0;
@@ -41,6 +54,8 @@ void JGL::VRamList::Erase() {
 
     glDeleteBuffers(1, &list_handle);
     list_handle = 0;
+
+    spin_lock = false;
 }
 
 GLuint JGL::VRamList::GetHandle() const {
@@ -62,11 +77,14 @@ size_t JGL::VRamList::GetDataSize() const {
 }
 
 void JGL::VRamList::SetData(void* data, const long& length) {
-    bool should_resize = (this->num_elements != length);
+    while (spin_lock) {}
+    spin_lock = true;
 
+    bool should_resize = (this->num_elements != length);
     if (should_resize) {
         glDeleteBuffers(1, &list_handle);
         list_handle = 0;
+        spin_lock = false;
         element_array_buffer ? load((GLuint*) data, sizeof(GLuint) * length) : load((GLfloat*) data, sizeof(GLfloat) * length);
         return;
     }
@@ -92,9 +110,13 @@ void JGL::VRamList::SetData(void* data, const long& length) {
         JGL::Logger::Fatal("We couldn't unmap the buffer?");
 
     glBindBuffer(buffer_type, current_buffer);
+
+    spin_lock = false;
 }
 
 void JGL::VRamList::UpdateData(void* data, const long& offset, const long& length) {
+    while (spin_lock) {}
+    spin_lock = true;
 
     if (offset + length > num_elements) {
         JGL::Logger::Warning("Using UpdateData to out-of-bounds write the VRamList? I'll resize it for you, But this is slow.");
@@ -104,6 +126,7 @@ void JGL::VRamList::UpdateData(void* data, const long& offset, const long& lengt
             auto list_data = GetDataUI();
             list_data.resize(list_data.size() + oob_delta);
             memcpy(list_data.data() + (offset * sizeof(GLuint)), data, length * sizeof(GLuint));
+            spin_lock = false; // This is going unlock and relock really fast, But this code fixes something considered wrong anyway - Redacted.
             return SetData(list_data.data(), list_data.size());
         }
 
@@ -111,6 +134,7 @@ void JGL::VRamList::UpdateData(void* data, const long& offset, const long& lengt
         auto list_data = GetDataF();
         list_data.resize(list_data.size() + oob_delta);
         memcpy(list_data.data() + (offset * sizeof(GLfloat)), data, length * sizeof(GLfloat));
+        spin_lock = false;
         return SetData(list_data.data(), list_data.size());
     }
 
@@ -136,9 +160,13 @@ void JGL::VRamList::UpdateData(void* data, const long& offset, const long& lengt
         JGL::Logger::Fatal("We couldn't unmap the buffer?");
 
     glBindBuffer(buffer_type, current_buffer);
+
+    spin_lock = false;
 }
 
 std::vector<GLfloat> JGL::VRamList::GetDataF() const {
+    while (spin_lock) {}
+
     if (element_array_buffer)
         JGL::Logger::Warning("Getting data as GLfloat but the buffer data is GLuint?");
 
@@ -160,6 +188,8 @@ std::vector<GLfloat> JGL::VRamList::GetDataF() const {
 }
 
 std::vector<GLuint> JGL::VRamList::GetDataUI() const {
+    while (spin_lock) {}
+
     if (!element_array_buffer)
         JGL::Logger::Warning("Getting data as GLuint but the buffer data is GLfloat?");
 
@@ -254,6 +284,8 @@ JGL::VRamList::~VRamList() {
 }
 
 JGL::VRamList::VRamList(const JGL::VRamList& rhs) {
+    while (rhs.spin_lock) {}
+
     if (rhs.element_array_buffer) {
         auto data_array = rhs.GetDataUI();
         this->load(data_array.data(), data_array.size());