main.cpp

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <bits/stdc++.h>

using namespace std;

int WIDTH = 500;
int HEIGHT = 500;
vector<pair<int,int>> nbours = {{-1,0},{1,0},{0,1},{0,-1}};
// vector<pair<int,int>> nbours = {{-1,0},{1,0},{0,1},{0,-1},{1,1},{-1,-1},{-1,1},{1,-1}};
// --- Funções base ---
GLFWwindow* initOpenGL(int w, int h, const char* title) {
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    GLFWwindow* window = glfwCreateWindow(w, h, title, NULL, NULL);
    if (!window) return nullptr;
    glfwMakeContextCurrent(window);
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) return nullptr;
    glViewport(0, 0, w, h);
    return window;
}

// Atualiza a textura com novos pixels
void updateTexture(GLuint texture, vector<unsigned char>& pixels) {
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, WIDTH, HEIGHT, GL_RGB, GL_UNSIGNED_BYTE, pixels.data());
}

// Cria textura inicial
GLuint createTexture(vector<unsigned char>& pixels) {
    GLuint tex;
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, WIDTH, HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels.data());
    return tex;
}
// Lineariza coorenada
int lin(int i,int j){
  return 3 * (j*WIDTH + i);
}
pair<int,int> deslin(int idx){
    int pixelIndex = idx / 3;
    int j = pixelIndex / WIDTH;
    int i = pixelIndex % WIDTH;
    return {i, j};
}
bool check(int i,int j){
  return !(i < 0 || i >= WIDTH || j < 0 || j >= HEIGHT);
}

int main() {
    // --- Matriz de pixels (RGB linearizada) ---
    int n,m;
    cin>>n>>m;
    HEIGHT = n;
    WIDTH = m;
    int from,to;
    vector<unsigned char> pixels(WIDTH*HEIGHT*3);
    for(int i =0;i<n;i++)
    {
      for(int j =0;j<m;j++)
      {
        char aux;
        cin>>aux;
        int coord = lin(i,j);
        if(aux == '#') pixels[coord] = 0;
        if(aux == '.') pixels[coord] = 255;
        if(aux == 'A') pixels[coord] = 200,from = coord;
        if(aux == 'B') pixels[coord] = 124,to = coord;
      }
    }
    GLFWwindow* window = initOpenGL(1000, 1000, "Pixel Matrix");
    if (!window) return -1;

    GLuint texture = createTexture(pixels);

    // --- Quad cobrindo a tela ---
    float quadVertices[] = {
        // pos     // tex
        -1,-1,    0,0,
         1,-1,    1,0,
         1, 1,    1,1,
        -1,-1,    0,0,
         1, 1,    1,1,
        -1, 1,    0,1
    };

    GLuint VAO, VBO;
    glGenVertexArrays(1,&VAO);
    glGenBuffers(1,&VBO);
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER,VBO);
    glBufferData(GL_ARRAY_BUFFER,sizeof(quadVertices),quadVertices,GL_STATIC_DRAW);
    glVertexAttribPointer(0,2,GL_FLOAT,GL_FALSE,4*sizeof(float),(void*)0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,4*sizeof(float),(void*)(2*sizeof(float)));
    glEnableVertexAttribArray(1);

    // --- Shaders ---
    const char* vertexShaderSrc = R"(
        #version 330 core
        layout(location=0) in vec2 aPos;
        layout(location=1) in vec2 aTex;
        out vec2 TexCoord;
        void main() { TexCoord = aTex; gl_Position = vec4(aPos,0,1); }
    )";
    const char* fragmentShaderSrc = R"(
        #version 330 core
        out vec4 FragColor;
        in vec2 TexCoord;
        uniform sampler2D tex;
        void main() { FragColor = texture(tex, TexCoord); }
        )";
        
        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vs,1,&vertexShaderSrc,nullptr); glCompileShader(vs);
        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fs,1,&fragmentShaderSrc,nullptr); glCompileShader(fs);
        GLuint shaderProgram = glCreateProgram();
        glAttachShader(shaderProgram,vs);
        glAttachShader(shaderProgram,fs);
        glLinkProgram(shaderProgram);
        glDeleteShader(vs); glDeleteShader(fs);
        
        int c = 0;
    // fill(pixels.begin(),pixels.end(),0);
    queue<int> open;
    int current;
    open.push(from);
    pixels[from] = 124;
    vector<int> parent(3*n*m+1);
    bool found = false;
    while(!glfwWindowShouldClose(window)) {
        glClear(GL_COLOR_BUFFER_BIT);
        // std::this_thread::sleep_for(std::chrono::milliseconds(500));
        c++;
        if (glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS) {
          double xpos, ypos;
          glfwGetCursorPos(window, &xpos, &ypos);

          int pixel_x = (int)(xpos / 500.0 * WIDTH);
          int pixel_y = (int)((500.0 - ypos) / 500.0 * HEIGHT);

          if (pixel_x >= 0 && pixel_x < WIDTH && pixel_y >= 0 && pixel_y < HEIGHT) {
              int idx = lin(pixel_x,pixel_y);
              pixels[idx + 0] = 255;
              // pixels[idx + 1] = 255;
              // pixels[idx + 2] = 255;
          }
        } 
        if(!open.empty() && !found){
        for(int aa =0;aa<2000;aa++){
          if(!open.empty()){
            current = open.front();
            open.pop();
            if(current == to) {found = true;break;}
            for (int k = 0; k < 4; k++)
            {

              auto [x, y] = nbours[k];
              auto [i, j] = deslin(current);
              i += x;
              j += y;
              if (check(i, j) && (pixels[lin(i, j)] == 255 || pixels[lin(i, j)] == 124) )
              {
                pixels[lin(i, j)] = 120;
                // pixels[lin(i, j)+1] = 120;
                pixels[lin(i, j)+2] = 120;
                open.push(lin(i, j));
                parent[lin(i,j)] = current;
              }
            }
          }
        }
    }
    else if(found){
      if(current!= from)              
      {
        
        c++;
        int nxt = parent[current];
        pixels[current] = 255;pixels[current+1] = 255;pixels[current+2] = 255;
        current = nxt;
      }
    }

        // for(int i =0;i<WIDTH;i++)
        //   for(int j =0;j<HEIGHT;j++)
        //   {
        //     int ncount = 0;
        //     unsigned char* pixelPtr = &pixels[lin(i,j)];
        //     auto r = &pixelPtr[0];
        //     auto g = &pixelPtr[1];
        //     auto b = &pixelPtr[2];
            // if(*r >= 20){
              
            //   for(auto [a,b] : nbours)
            //   {
            //     if(i + a < 0 || i + a >= WIDTH || j + b < 0 || j + b >= HEIGHT) continue;

            //     int linCoord = lin(i+a,j+b);
            //     pixels[linCoord]++;
            //     *r--;
            //   }
            // }
            
          // }
        // Atualiza a textura
        updateTexture(texture,pixels);
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);
        glBindTexture(GL_TEXTURE_2D, texture);
        glDrawArrays(GL_TRIANGLES, 0, 6);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }


    glfwTerminate();
}