Raycasting: Pseudo-3D Rendering

Definir um vetor 2D e representar a posição e direção de um objeto usando vetores.

Realizar operações de soma, subtração e multiplicação por escalar com vetores 2D.

Calcular a magnitude (norma) de um vetor 2D.

Normalizar um vetor para obter um vetor unitário, representando uma direção pura.

Calcular o produto escalar (dot product) de dois vetores e interpretar seu significado geométrico (projeção).

Explicar como imagens digitais são representadas por pixels, resolução e canais de cor.

Definir frame rate (FPS) e explicar sua importância para a interatividade em tempo real.

Descrever as etapas gerais do pipeline de renderização 3D tradicional (transformações de modelo, câmera e projeção).

Diferenciar a renderização baseada em rasterização (polígonos) da renderização baseada em raios (ray tracing/casting).

Explicar o conceito de projeção em perspectiva e sua função na criação da ilusão de profundidade.

Contextualizar o raycasting como uma alternativa computacionalmente eficiente para hardware restrito.

Estruturar um mapa de ambiente 2D usando uma matriz (grid), onde valores distintos representam paredes e espaços vazios.

Definir o estado do jogador usando vetores de posição e direção.

Implementar a lógica de movimentação do jogador (frente/trás) atualizando sua posição com base no vetor de direção.

Implementar a lógica de rotação do jogador (esquerda/direita) alterando seu vetor de direção.

Desenvolver um algoritmo simples de detecção de colisão para impedir que o jogador atravesse as paredes do grid.

Representar matematicamente um raio com um ponto de origem e um vetor de direção normalizado.

Calcular a direção de um raio específico dentro do campo de visão (FOV) do jogador.

Explicar o funcionamento do algoritmo DDA (Digital Differential Analyzer) para travessia incremental de um grid.

Calcular as distâncias iniciais e incrementais (passos delta) para a implementação do DDA.

Aplicar o algoritmo DDA para determinar a sequência de células do grid que um único raio atravessa.

Identificar a primeira célula de parede que o raio intercepta e determinar se a colisão ocorreu em uma face vertical ou horizontal.

Calcular a distância euclidiana entre o jogador e o ponto de colisão do raio na parede.

Explicar a causa do efeito de distorção 'fish-eye' ao usar a distância euclidiana para projeção.

Calcular a distância perpendicular do jogador ao plano da parede para corrigir a distorção 'fish-eye'.

Derivar a fórmula que estabelece a relação inversamente proporcional entre a distância corrigida e a altura da fatia de parede na tela.

Calcular a altura inicial e final (em pixels) de uma coluna vertical na tela com base na distância corrigida.

Descrever como a cena 3D é construída renderizando o chão, a parede e o teto, uma coluna de pixels de cada vez.

Estruturar o loop principal de renderização (game loop) que processa entradas, atualiza o estado e desenha a cena a cada quadro.

Implementar a iteração principal do raycasting, que varre todas as colunas de pixels da tela.

Para cada coluna, traduzir a lógica do DDA em código para encontrar a colisão com a parede.

Implementar o cálculo da distância corrigida e a projeção da altura da parede para cada coluna.

Desenvolver a rotina de desenho que renderiza a coluna de parede calculada, juntamente com o chão e o teto, na tela.

Integrar a lógica de movimento e rotação do jogador ao loop principal para permitir a exploração do ambiente.

Explicar o conceito de mapeamento de texturas para adicionar detalhes visuais às superfícies.

Calcular a coordenada exata (x, y) do ponto de interseção do raio com a parede.

Determinar a coordenada horizontal da textura (coordenada U) com base no ponto de interseção na face da parede.

Mapear a coordenada U da textura para a coluna de pixels correspondente na imagem da textura.

Implementar o desenho de uma coluna de parede texturizada, amostrando pixels da imagem de textura em vez de usar uma cor sólida.

Aplicar um efeito de sombreamento (shading) que escurece as colunas de parede com base em sua distância para simular profundidade.

Definir métricas de desempenho chave para análise de renderização: FPS, tempo de quadro (frametime) e uso de CPU.

Descrever uma metodologia experimental para comparar o desempenho do raycaster com uma abordagem de renderização 3D tradicional.

Construir um cenário de teste equivalente usando uma biblioteca 3D padrão (ex: PyOpenGL, Ursina) para servir como base de comparação.

Instrumentar o código de ambas as implementações para coletar dados de desempenho de forma consistente.

Executar um benchmark para coletar e organizar os dados de desempenho em tabelas e gráficos.

Analisar e interpretar os resultados, articulando as vantagens e desvantagens de cada abordagem em termos de eficiência.

Discutir as limitações do raycasting e os cenários onde sua aplicação é mais vantajosa, fortalecendo a argumentação da tese.