chore: initial commit

2025-12-12 11:12:29 +00:00 · 2023-01-02 13:17:18 -06:00 · 2023-01-02 13:17:18 -06:00 · 70b00c5c38
commit 70b00c5c38
965 changed files with 264882 additions and 0 deletions
--- a/src/gx/gll/GLVertexArray.cpp
+++ b/src/gx/gll/GLVertexArray.cpp
@ -0,0 +1,189 @@
+#include "gx/gll/GLVertexArray.h"
+#include "gx/gll/GLDevice.h"
+
+bool GLVertexArray::s_VertexArrayEnable = false;
+
+GLVertexArray::GLVertexArray(bool a2) {
+    // TODO
+}
+
+void GLVertexArray::FindVertexArray(GLDevice* a1, GLVertexArray& a2) {
+    if (GLVertexArray::s_VertexArrayEnable) {
+        // TODO
+    }
+
+    a2.ApplyVertexFormat(a1);
+}
+
+void GLVertexArray::ApplyGLStates(GLStates::VertexArrayObject& vao) {
+    GLDevice* device = GLDevice::Get();
+
+    device->BindVertexArray(this);
+
+    for (int32_t i = 0; i < kMAX_VERTEX_ATTRIBS; i++) {
+        auto& attrib = vao.vertexAttribs[i];
+
+        if (attrib.enable) {
+            glBindBuffer(attrib.buffer->m_Type, attrib.buffer->m_BufferID);
+
+            glVertexAttribPointerARB(
+                i,
+                attrib.size,
+                attrib.type,
+                attrib.normalized,
+                attrib.stride,
+                reinterpret_cast<void*>(attrib.offset)
+            );
+
+            glEnableVertexAttribArrayARB(i);
+        } else {
+            glDisableVertexAttribArrayARB(i);
+        }
+    }
+
+    if (vao.position.enable) {
+        glBindBuffer(vao.position.buffer->m_Type, vao.position.buffer->m_BufferID);
+        glVertexPointer(vao.position.size, vao.position.type, vao.position.stride, vao.position.offset);
+        glEnableClientState(GL_VERTEX_ARRAY);
+    } else {
+        glDisableClientState(GL_VERTEX_ARRAY);
+    }
+
+    if (vao.normal.enable) {
+        glBindBuffer(vao.normal.buffer->m_Type, vao.normal.buffer->m_BufferID);
+        glNormalPointer(vao.normal.type, vao.normal.stride, vao.normal.offset);
+        glEnableClientState(GL_NORMAL_ARRAY);
+    } else {
+        glDisableClientState(GL_NORMAL_ARRAY);
+    }
+
+    if (vao.color0.enable) {
+        glBindBuffer(vao.color0.buffer->m_Type, vao.color0.buffer->m_BufferID);
+        glColorPointer(vao.color0.size, vao.color0.type, vao.color0.stride, vao.color0.offset);
+        glEnableClientState(GL_COLOR_ARRAY);
+    } else {
+        glDisableClientState(GL_COLOR_ARRAY);
+    }
+
+    if (vao.color1.enable) {
+        glBindBuffer(vao.color1.buffer->m_Type, vao.color1.buffer->m_BufferID);
+        glColorPointer(vao.color1.size, vao.color1.type, vao.color1.stride, vao.color1.offset);
+        glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
+    } else {
+        glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
+    }
+
+    for (int32_t i = 0; i < 8; i++) {
+        glClientActiveTextureARB(GL_TEXTURE0 + i);
+
+        if (vao.texCoord[i].enable) {
+            glBindBuffer(vao.texCoord[i].buffer->m_Type, vao.texCoord[0].buffer->m_BufferID);
+            glTexCoordPointer(vao.texCoord[i].size, vao.texCoord[i].type, vao.texCoord[i].stride, vao.texCoord[i].offset);
+            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        } else {
+            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        }
+    }
+
+    glBindBuffer(GL_ARRAY_BUFFER, vao.buffers[0]);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vao.buffers[1]);
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, vao.buffers[2]);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, vao.buffers[3]);
+
+    this->m_GLStates = vao;
+}
+
+void GLVertexArray::ApplyVertexFormat(GLDevice* device) {
+    if (GLVertexArray::s_VertexArrayEnable) {
+        device->BindVertexArray(this);
+    }
+
+    auto indexBuffer = this->m_Properties.m_IndexBuffer;
+    uint32_t indexBufferID = indexBuffer ? indexBuffer->m_BufferID : 0;
+
+    if (this->m_GLStates.buffers[1] != indexBufferID) {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
+        this->m_GLStates.buffers[1] = indexBufferID;
+    }
+
+    BLIZZARD_ASSERT(this->GetProperties().m_VertexBufferFormat != nullptr);
+
+    auto& properties = this->GetProperties();
+    bool attribEnable[16] = {};
+
+    bool useVertexShader = device->GetShader(GLShader::eVertexShader) != nullptr;
+
+    for (int32_t index = 0; index < this->GetProperties().m_VertexBufferFormat->m_Size; index++) {
+        BLIZZARD_ASSERT(index < kMAX_VERTEX_ATTRIBS);
+
+        auto& attrib = this->GetProperties().m_VertexBufferFormat->m_Attribs[index];
+
+        BLIZZARD_ASSERT(attrib.type != GLVT_INVALID);
+        BLIZZARD_ASSERT(attrib.type < GLVT_NUM_VERTEX_TYPES);
+
+        auto vertexBuffer = this->GetProperties().m_VertexBuffer[attrib.stream];
+
+        if (useVertexShader || attrib.slot - 1 > 1) {
+            if (this->m_GLStates.buffers[0] != vertexBuffer->m_BufferID) {
+                glBindBuffer(vertexBuffer->m_Type, vertexBuffer->m_BufferID);
+                this->m_GLStates.buffers[0] = vertexBuffer->m_BufferID;
+            }
+
+            attribEnable[attrib.slot] = 1;
+
+            int32_t stride = properties.m_VertexBufferStride[attrib.stream];
+            int32_t offset = attrib.offset
+                + properties.m_VertexBufferOffset[attrib.stream]
+                + properties.m_VertexBase * stride;
+
+            if (useVertexShader) {
+                glVertexAttribPointerARB(
+                    attrib.slot,
+                    k_VertexTypeInfo[attrib.type].m_Size,
+                    k_VertexTypeInfo[attrib.type].m_Type,
+                    k_VertexTypeInfo[attrib.type].m_Normalized,
+                    stride,
+                    reinterpret_cast<void*>(offset)
+                );
+            } else {
+                // TODO
+            }
+        }
+    }
+
+    for (int32_t s = 0; s < 16; s++) {
+        bool* prevAttribEnable;
+
+        if (useVertexShader) {
+            prevAttribEnable = &this->m_GLStates.vertexAttribs[s].enable;
+        } else {
+            // TODO
+        }
+
+        if (*prevAttribEnable != attribEnable[s]) {
+            if (attribEnable[s]) {
+                if (useVertexShader) {
+                   glEnableVertexAttribArrayARB(s);
+                } else {
+                    // TODO
+                }
+            } else {
+                if (useVertexShader) {
+                    glDisableVertexAttribArrayARB(s);
+                } else {
+                    // TODO
+                }
+            }
+
+            *prevAttribEnable = attribEnable[s];
+        }
+    }
+}
+
+GLVertexArray::Properties& GLVertexArray::GetProperties() {
+    return this->m_Properties;
+}
+
+void GLVertexArray::ReleaseObject() {
+    // TODO
+}