zed-playground/new_playground/depth-sensing/test_opengl.cpp

#include <GL/glew.h>
#include <GL/freeglut.h>
#include <iostream>
#include <cmath>

const char* VERTEX_SHADER = 
"#version 330 core\n"
"layout(location = 0) in vec3 position;\n"
"layout(location = 1) in vec3 color;\n"
"uniform mat4 mvp;\n"
"out vec3 fragColor;\n"
"void main() {\n"
"    fragColor = color;\n"
"    gl_Position = mvp * vec4(position, 1.0);\n"
"}\n";

const char* FRAGMENT_SHADER = 
"#version 330 core\n"
"in vec3 fragColor;\n"
"out vec4 outColor;\n"
"void main() {\n"
"    outColor = vec4(fragColor, 1.0);\n"
"}\n";

GLuint shaderProgram;
GLuint vao, vbo_pos, vbo_color;
float angle = 0.0f;

GLuint compileShader(const char* source, GLenum type) {
    GLuint shader = glCreateShader(type);
    glShaderSource(shader, 1, &source, NULL);
    glCompileShader(shader);
    
    GLint success;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        char log[512];
        glGetShaderInfoLog(shader, 512, NULL, log);
        std::cerr << "Shader compilation error: " << log << std::endl;
    }
    return shader;
}

void createShaderProgram() {
    GLuint vertShader = compileShader(VERTEX_SHADER, GL_VERTEX_SHADER);
    GLuint fragShader = compileShader(FRAGMENT_SHADER, GL_FRAGMENT_SHADER);
    
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertShader);
    glAttachShader(shaderProgram, fragShader);
    glLinkProgram(shaderProgram);
    
    GLint success;
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        char log[512];
        glGetProgramInfoLog(shaderProgram, 512, NULL, log);
        std::cerr << "Shader linking error: " << log << std::endl;
    }
    
    glDeleteShader(vertShader);
    glDeleteShader(fragShader);
}

void createGeometry() {
    // Simple triangle vertices
    float vertices[] = {
        // Triangle 1 (large, in front)
         0.0f,  0.5f, 0.0f,
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         
        // Triangle 2 (smaller, behind)
         0.0f,  0.3f, -2.0f,
        -0.3f, -0.3f, -2.0f,
         0.3f, -0.3f, -2.0f
    };
    
    float colors[] = {
        // Triangle 1 colors (RGB at vertices)
        1.0f, 0.0f, 0.0f,  // Red
        0.0f, 1.0f, 0.0f,  // Green
        0.0f, 0.0f, 1.0f,  // Blue
        
        // Triangle 2 colors (Yellow)
        1.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 0.0f
    };
    
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    
    glGenBuffers(1, &vbo_pos);
    glBindBuffer(GL_ARRAY_BUFFER, vbo_pos);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
    
    glGenBuffers(1, &vbo_color);
    glBindBuffer(GL_ARRAY_BUFFER, vbo_color);
    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(1);
    
    glBindVertexArray(0);
}

void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    // Test 1: Draw with identity matrix (no depth)
    static bool testDepth = true;
    
    if (!testDepth) {
        // Identity - everything should be visible
        float mvp[16] = {
            1.0f, 0.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f, 0.0f,
            0.0f, 0.0f, 0.0f, 1.0f
        };
        
        glUseProgram(shaderProgram);
        GLint mvpLoc = glGetUniformLocation(shaderProgram, "mvp");
        glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, mvp);
        
        glBindVertexArray(vao);
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);
    } else {
        // Test depth - draw with simple Z translation only
        glUseProgram(shaderProgram);
        GLint mvpLoc = glGetUniformLocation(shaderProgram, "mvp");
        
        // Draw first triangle (at Z=0)
        float mvp1[16] = {
            1.0f, 0.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f, 0.0f,
            0.0f, 0.0f, 0.0f, 1.0f
        };
        glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, mvp1);
        glBindVertexArray(vao);
        glDrawArrays(GL_TRIANGLES, 0, 3);
        
        // Draw second triangle shifted right and with Z offset
        float mvp2[16] = {
            1.0f, 0.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f, 0.0f,
            0.4f, 0.0f, -0.5f, 1.0f  // Shift right and back in Z
        };
        glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, mvp2);
        glDrawArrays(GL_TRIANGLES, 3, 3);
        
        glBindVertexArray(0);
    }
    
    glutSwapBuffers();
    
    static int frames = 0;
    if (frames++ == 0) {
        std::cout << "\n=== Drawing Test ===" << std::endl;
        std::cout << "You should see TWO triangles:" << std::endl;
        std::cout << "1. RGB triangle on the left (Z=0)" << std::endl;
        std::cout << "2. Yellow triangle on the right (Z=-0.5)" << std::endl;
        std::cout << "\nIf you only see ONE triangle, depth is broken" << std::endl;
        std::cout << "Press 'd' to toggle depth test" << std::endl;
    }
}

void keyboard(unsigned char key, int x, int y) {
    if (key == 'd' || key == 'D') {
        static bool depthEnabled = true;
        depthEnabled = !depthEnabled;
        if (depthEnabled) {
            glEnable(GL_DEPTH_TEST);
            std::cout << "Depth test ENABLED" << std::endl;
        } else {
            glDisable(GL_DEPTH_TEST);
            std::cout << "Depth test DISABLED" << std::endl;
        }
        glutPostRedisplay();
    } else if (key == 27) { // ESC
        exit(0);
    }
}

void init() {
    std::cout << "GL Vendor: " << glGetString(GL_VENDOR) << std::endl;
    std::cout << "GL Renderer: " << glGetString(GL_RENDERER) << std::endl;
    std::cout << "GL Version: " << glGetString(GL_VERSION) << std::endl;
    std::cout << "GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
    
    glClearColor(0.2f, 0.2f, 0.3f, 1.0f);
    glEnable(GL_DEPTH_TEST);
    
    createShaderProgram();
    createGeometry();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("Minimal OpenGL Test");
    
    GLenum err = glewInit();
    if (err != GLEW_OK) {
        std::cerr << "GLEW Init Error: " << glewGetErrorString(err) << std::endl;
        return 1;
    }
    
    init();
    
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    
    std::cout << "\n=== Minimal OpenGL Test ===" << std::endl;
    std::cout << "Controls:" << std::endl;
    std::cout << "  d - Toggle depth test" << std::endl;
    std::cout << "  ESC - Quit" << std::endl;
    
    glutMainLoop();
    
    return 0;
}