XCEngine/tests/RHI/OpenGL/test_shader.cpp

#include "fixtures/OpenGLTestFixture.h"
#include "XCEngine/RHI/OpenGL/OpenGLShader.h"

using namespace XCEngine::RHI;

TEST_F(OpenGLTestFixture, Shader_Compile_VertexFragment) {
    const char* vertexSource = R"(
        #version 330 core
        in vec3 aPosition;
        void main() {
            gl_Position = vec4(aPosition, 1.0);
        }
    )";
    
    const char* fragmentSource = R"(
        #version 330 core
        out vec4 FragColor;
        void main() {
            FragColor = vec4(1.0, 0.0, 0.0, 1.0);
        }
    )";
    
    OpenGLShader shader;
    bool result = shader.Compile(vertexSource, fragmentSource);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(shader.IsValid());
    EXPECT_NE(shader.GetID(), 0u);
    
    shader.Shutdown();
}

TEST_F(OpenGLTestFixture, Shader_Compile_WithGeometry) {
    const char* vertexSource = R"(
        #version 330 core
        void main() {
            gl_Position = vec4(0.0);
        }
    )";
    
    const char* fragmentSource = R"(
        #version 330 core
        void main() {
        }
    )";
    
    const char* geometrySource = R"(
        #version 330 core
        layout(triangles) in;
        layout(triangle_strip, max_vertices = 3) out;
        void main() {
            for(int i = 0; i < 3; i++) {
                gl_Position = gl_in[i].gl_Position;
                EmitVertex();
            }
            EndPrimitive();
        }
    )";
    
    OpenGLShader shader;
    bool result = shader.Compile(vertexSource, fragmentSource, geometrySource);
    
    ASSERT_TRUE(result);
    EXPECT_TRUE(shader.IsValid());
    
    shader.Shutdown();
}

TEST_F(OpenGLTestFixture, Shader_Compile_InvalidSource) {
    const char* invalidSource = R"(
        #version 330 core
        void main() {
            undefined_symbol;
        }
    )";
    
    OpenGLShader shader;
    bool result = shader.Compile(invalidSource, "void main() { }");
    
    EXPECT_FALSE(result);
    EXPECT_FALSE(shader.IsValid());
    
    shader.Shutdown();
}

TEST_F(OpenGLTestFixture, Shader_SetUniforms) {
    const char* vs = R"(
        #version 330 core
        void main() { gl_Position = vec4(0.0); }
    )";
    const char* fs = R"(
        #version 330 core
        uniform int uIntValue;
        uniform float uFloatValue;
        uniform vec3 uVec3Value;
        uniform mat4 uMat4Value;
        out vec4 FragColor;
        void main() { FragColor = vec4(1.0); }
    )";
    
    OpenGLShader shader;
    shader.Compile(vs, fs);
    ASSERT_TRUE(shader.IsValid());
    
    shader.Use();
    
    shader.SetInt("uIntValue", 42);
    shader.SetFloat("uFloatValue", 3.14f);
    shader.SetVec3("uVec3Value", 1.0f, 2.0f, 3.0f);
    
    float mat[16] = {};
    mat[0] = 1.0f; mat[5] = 1.0f; mat[10] = 1.0f; mat[15] = 1.0f;
    shader.SetMat4("uMat4Value", mat);
    
    GLenum error = glGetError();
    EXPECT_EQ(error, GL_NO_ERROR);
    
    shader.Shutdown();
}