/CG.2023.3

Development framework accompanying the course MCTA008-17 Computer Graphics at UFABC, Brazil

Primary LanguageC++MIT LicenseMIT

CG.2023.3

Projeto para a disciplina de Computação Gráfica utilizando a biblioteca ABCg.

Integrantes:

  • Matheus Silvério Oliveira - 11201720810
  • Sonny Yassuaki R. Ganiko - 21050913

Atividade 03:

As funções descritas abaixo foram criadas para à Atividade 3 ou foram alteradas em relação a Atividade 2, as demais funções não listadas neste capítulo permaneceram inalteradas ou sofreram correções mínimas.

Classe Window

Carregamento do Modelo da Nave

A função Window::createSpaceship() é responsável por carregar e configurar o modelo 3D da nave espacial (spaceship) no ambiente do jogo. Ela carrega as texturas difusa e normal, o modelo 3D em si e configura os parâmetros de material necessários para a renderização.

Carregamento do Modelo da Nave Espacial
  • Carregamento do Modelo:
    • Utiliza a classe Model para carregar o modelo 3D da nave espacial a partir de um arquivo obj.
    • Configura o Vertex Array Object (VAO) associado ao modelo.
Carregamento das Texturas
  • Carregamento das Texturas:
    • Carrega a textura difusa da nave espacial a partir de um arquivo de imagem (jpg).
    • Carrega a textura normal da nave espacial a partir de um arquivo de mapa normal (png).
Configuração dos Materiais
  • Configuração dos Materiais:
    • Obtém os coeficientes de reflectância (Ka, Kd, Ks) e a intensidade especular (shininess) associados ao modelo no arquivo mtl correspondente.
Posicionamento Inicial da Nave Espacial
  • Posicionamento Inicial:
    • Define a posição inicial da nave espacial no ambiente.

Carregamento do Modelo de Asteróides

A função Window::createAsteroid() é responsável por carregar e configurar o modelo 3D de um asteroide no ambiente do jogo. Ela carrega a textura do céu (skybox), a textura difusa do asteroide, o modelo 3D em si e configura os parâmetros necessários para a renderização.

Carregamento do Modelo do Asteroide
  • Carregamento do Modelo:
    • Utiliza a classe Model para carregar o modelo 3D do asteroide a partir de um arquivo obj.
    • Configura o Vertex Array Object (VAO) associado ao modelo.
Carregamento das Texturas

  • Carregamento da Textura do Céu (Skybox):

    • Carrega a textura do céu (skybox) a partir de um diretório contendo as imagens correspondentes aos seis lados.

  • Carregamento da Textura Difusa do Asteroide:

    • Carrega a textura difusa (albedo) do asteroide a partir de um arquivo de imagem (jpg).

Carregamento do Skybox

A função Window::createSkybox() é responsável por criar e configurar o céu (skybox) no ambiente do jogo. Ela compila e vincula os shaders específicos para o céu, gera um Vertex Buffer Object (VBO) contendo as posições dos vértices do skybox e configura o Vertex Array Object (VAO) associado ao skybox.

Compilação e Vinculação dos Shaders
  • Programa do Skybox:
    • Compila e vincula shaders vertex e fragment específicos para o skybox.
    • Usa a classe abcg::createOpenGLProgram para gerar o programa do skybox.
Configuração do VBO e VAO

  • Geração do VBO:

    • Gera um VBO para armazenar as posições dos vértices do skybox.
    • Preenche o VBO com as posições predefinidas do skybox.

  • Vinculação do VAO:

    • Gera um VAO para armazenar o estado de configuração do VBO.
    • Vincula o VAO atual.
    • Vincula o VBO ao VAO.
    • Configura o atributo de posição do shader.

Função Window::onCreate()

A função Window::onCreate() é chamada durante a inicialização da janela do OpenGL. Ela configura o ambiente gráfico, compila shaders, cria modelos e configura a câmera. Além disso, a função chama outras funções especializadas para criar elementos específicos do jogo, como a espaçonave, asteroides, estrelas e o céu (skybox).

Configuração Inicial do OpenGL

  • Limpeza de Buffer:

    • Define a cor de limpeza do buffer de cor para preto.
    • Ativa o teste de profundidade.

  • Compilação e Vinculação de Shaders:

    • Compila e vincula shaders vertex e fragment para normal mapping.
    • Utiliza a classe abcg::createOpenGLProgram para gerar o programa.
Criação de Objetos 3D

  • Espaçonave (Spaceship):

    • Chama a função createSpaceship() para carregar e configurar a modelagem 3D da espaçonave.
    • Configura materiais (Ka, Kd, Ks, brilho) da espaçonave.

  • Asteroides:

    • Chama a função createAsteroid() para carregar e configurar a modelagem 3D de asteroides.
    • Configura texturas e materiais dos asteroides.

  • Skybox:

    • Chama a função createSkybox() para criar e configurar o céu (skybox).
Configuração da Câmera
  • Matriz de Visualização (View Matrix):
    • Configura a matriz de visualização usando a função glm::lookAt para definir a posição da câmera (eye), o ponto de visão (at) e a direção "para cima" (up).
Configuração Inicial do Jogo

  • Rotação Inicial da Espaçonave:

    • Configura a rotação inicial da espaçonave.

  • Configuração Inicial das Estrelas:

    • Chama a função randomizeStar para inicializar as posições e orientações iniciais das estrelas.

Renderização do Skybox

A função Window::renderSkybox() é responsável por renderizar o céu (skybox) na cena. Ela configura e utiliza shaders específicos para renderização do skybox, aplicando uma textura de mapa de cubo para criar um ambiente imersivo ao redor da cena principal.

Renderização do Skybox

  • Uso do Programa do Skybox:

    • Ativa o programa do skybox usando abcg::glUseProgram(m_skyProgram).

  • Localização de Uniformes:

    • Obtém as localizações das variáveis uniformes no programa do skybox, incluindo as matrizes viewMatrix, projMatrix e a textura do mapa de cubo (skyTex).
    • viewMatrixLoc: Localização da matriz de visualização.
    • projMatrixLoc: Localização da matriz de projeção.
    • skyTexLoc: Localização da textura do mapa de cubo.

  • Configuração das Matrizes de Visualização e Projeção:

    • Configura uma matriz projView (100.0f) para a matriz de visualização.
    • Atualiza as variáveis uniformes viewMatrix e projMatrix com as matrizes de visualização e projeção.

  • Vinculação e Ativação de Texturas:

    • Ativa a textura do mapa de cubo, que foi carregada previamente durante a inicialização.
    • A textura é vinculada à unidade de textura GL_TEXTURE0.

  • Renderização do Skybox:

    • Habilita o teste de profundidade e a face traseira do skybox.
    • Configura a função de teste de profundidade para GL_LEQUAL.
    • Desenha os triângulos do skybox usando abcg::glDrawArrays(GL_TRIANGLES, 0, m_skyPositions.size()).
    • Restaura a função de teste de profundidade para GL_LESS após a renderização.

  • Desativação de Atributos e Programa:

    • Desabilita a matriz de atributos do VAO do skybox.
    • Desativa o programa do skybox usando abcg::glUseProgram(0).

Função Window::onPaint()

A função Window::onPaint() é chamada para realizar a renderização principal da cena. Nesta função, objetos 3D, como a nave espacial, asteroides e o skybox, são renderizados usando shaders e técnicas de iluminação.

Configuração Inicial

  • Limpeza de Buffers:

    • Limpa os buffers de cor e profundidade usando abcg::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT).

  • Configuração do Viewport:

    • Configura a visualização usando abcg::glViewport(0, 0, m_viewportSize.x, m_viewportSize.y).

  • Uso do Programa Principal:

    • Ativa o programa principal da aplicação usando abcg::glUseProgram(m_program).
Uniformes e Localizações
  • Obtenção de Localizações Uniformes:
    • Obtém as localizações das variáveis uniformes necessárias para a renderização do modelo 3D.
    • Localizações incluem matrizes de visão (viewMatrix), projeção (projMatrix), modelo (modelMatrix) e normal (normalMatrix).
    • Localizações de texturas e modos de mapeamento também são obtidas.
Iluminação e Materiais
  • Configuração de Iluminação e Materiais:
    • Configura as propriedades de iluminação e materiais, incluindo a direção da luz (lightDirWorldSpace), intensidades de luz ambiente (Ia), difusa (Id) e especular (Is), e coeficientes de material (Ka, Kd, Ks).
    • Define a rugosidade do material (shininess).
Renderização da Nave Espacial
  • Renderização da Nave Espacial:
    • Configura a matriz de modelo para a nave espacial.
    • Aplica as transformações de translação, escala e rotação.
    • Renderiza a nave espacial usando m_additionalModel.render().
Renderização dos Asteroides
  • Renderização dos Asteroides:
    • Para cada asteroide na lista, calcula a matriz de modelo e renderiza o asteroide usando m_model.render().
Renderização do Skybox
  • Renderização do Skybox:
    • Chama a função renderSkybox() para renderizar o skybox.
Limpeza e Desativação
  • Limpeza e Desativação:
    • Desativa o programa principal usando abcg::glUseProgram(0).

Função Window::onPaintUI()

A função Window::onPaintUI() é responsável por renderizar a interface gráfica do usuário (GUI) durante o processo de pintura. Ela utiliza a biblioteca ImGui para criar elementos interativos, como sliders e janelas de configuração, que permitem ao usuário ajustar parâmetros em tempo real.

Janela de Propriedades de Luz
  • Controles de Luz:
    • Utiliza sliders de cores para ajustar as propriedades de luz ambiente (Ia), difusa (Id), e especular (Is).
    • Os controles permitem ao usuário interagir diretamente com as propriedades de luz.
Janela de Configuração Geral

  • Seleção de Projeção:

    • Oferece uma caixa de combinação para escolher entre projeção perspectiva e ortográfica (Perspective e Orthographic).
    • Atualiza a matriz de projeção com base na escolha do usuário.

  • Ajuste do Campo de Visão (FOV):

    • Se a projeção perspectiva estiver selecionada, exibe um slider para ajustar o campo de visão (FOV) em graus.
    • Atualiza a matriz de projeção conforme o usuário ajusta o slider.

Função Window::onDestroy()

A função Window::onDestroy() é responsável por liberar os recursos alocados durante a execução do programa, garantindo uma limpeza adequada e prevenindo vazamentos de memória.

Liberação de Modelos e Texturas
  • m_model.destroy(): Libera os recursos associados ao modelo principal (asteroide). Isso inclui buffers, texturas e objetos de array de vértices (VAO).
  • m_additionalModel.destroy(): Libera os recursos associados ao modelo adicional (espaçonave). Semelhante ao modelo principal, isso inclui buffers, texturas e VAO.

Liberação do Programa da Skybox

  • abcg::glDeleteProgram(m_skyProgram): Deleta o programa OpenGL associado à renderização da Skybox. Isso inclui os shaders de vértice e fragmento.
  • abcg::glDeleteBuffers(1, &m_skyVBO): Deleta o buffer de vértices (VBO) usado para armazenar as posições da Skybox.
  • abcg::glDeleteVertexArrays(1, &m_skyVAO): Deleta o objeto de array de vértices (VAO) associado à Skybox.

Liberação do Programa Principal

  • abcg::glDeleteProgram(m_program): Deleta o programa OpenGL associado à renderização principal. Isso inclui os shaders de vértice e fragmento.

Classe Model

Somente as funções que sofreram alterações ou foram adicionadas para a atividade atual serão documentadas, as demais funções seguem a documentação da Atividade 02.

Função Model::computeNormals()

A função Model::computeNormals() é responsável por calcular as normais dos vértices do modelo com base nas normais das faces.

Limpeza das Normais Anteriores
  • for (auto &vertex : m_vertices): Itera sobre todos os vértices do modelo.
    • vertex.normal = glm::vec3(0.0f);: Inicializa as normais dos vértices com vetores nulos.
Cálculo das Normais das Faces
  • for (auto const offset : iter::range(0UL, m_indices.size(), 3UL)): Itera sobre os índices do modelo em incrementos de 3, representando triângulos.
    • auto &a{m_vertices.at(m_indices.at(offset + 0))};: Obtém o primeiro vértice do triângulo.
    • auto &b{m_vertices.at(m_indices.at(offset + 1))};: Obtém o segundo vértice do triângulo.
    • auto &c{m_vertices.at(m_indices.at(offset + 2))};: Obtém o terceiro vértice do triângulo.
    • auto const edge1{b.position - a.position};: Calcula o vetor da aresta 1.
    • auto const edge2{c.position - b.position};: Calcula o vetor da aresta 2.
    • auto const normal{glm::cross(edge1, edge2)};: Calcula a normal da face usando o produto vetorial das arestas.
    • a.normal += normal;, b.normal += normal;, c.normal += normal;: Acumula as normais nas estruturas de vértices correspondentes.
Normalização das Normais dos Vértices
  • for (auto &vertex : m_vertices): Itera sobre todos os vértices do modelo.
    • vertex.normal = glm::normalize(vertex.normal);: Normaliza as normais dos vértices.
Atualização do Estado das Normais
  • m_hasNormals = true;: Atualiza a flag m_hasNormals para indicar que o modelo agora possui informações de normais.

Função Model::loadCubeTexture(std::string const &path)

A função Model::loadCubeTexture é responsável por carregar uma textura de cubemap no modelo.

Funcionamento
  • m_cubeTexture = abcg::loadOpenGLCubemap({.paths = {path + "posx.jpg", path + "negx.jpg", path + "posy.jpg", path + "negy.jpg", path + "posz.jpg", path + "negz.jpg"}});: Carrega uma nova textura de cubemap usando a função abcg::loadOpenGLCubemap. Os caminhos das seis imagens são construídos com base no caminho fornecido, e os identificadores da textura resultantes são armazenados em m_cubeTexture.
Observações Adicionais
  • A função presume que as imagens do cubemap estão nomeadas seguindo a convenção de nomenclatura padrão, com sufixos indicando as direções dos eixos: "posx" (positivo x), "negx" (negativo x), "posy" (positivo y), "negy" (negativo y), "posz" (positivo z) e "negz" (negativo z).
  • A função é projetada para ser utilizada em conjunto com modelos que requerem um cubemap para efeitos visuais ou de iluminação específicos.

Função Model::loadDiffuseTexture(std::string_view path)

A função Model::loadDiffuseTexture é responsável por carregar uma textura difusa (textura de cor) para o modelo.

Funcionamento
  • m_diffuseTexture = abcg::loadOpenGLTexture({.path = path});: Carrega uma nova textura difusa usando a função abcg::loadOpenGLTexture. O identificador da textura resultante é armazenado em m_diffuseTexture.

Função Model::loadNormalTexture(std::string_view path)

A função Model::loadNormalTexture é responsável por carregar uma textura normal para o modelo.

Funcionamento
  • m_normalTexture = abcg::loadOpenGLTexture({.path = path});: Carrega uma nova textura normal usando a função abcg::loadOpenGLTexture. O identificador da textura resultante é armazenado em m_normalTexture.

Função Model::loadObj(std::string_view path, bool standardize)

A função Model::loadObj é responsável por carregar um modelo 3D no formato OBJ, incluindo suas informações de vértices, índices, normais, coordenadas de textura e materiais associados.

Funcionamento

  • auto const basePath{std::filesystem::path{path}.parent_path().string() + "/"};: Calcula o caminho base para o arquivo do modelo, que será usado como o caminho para os arquivos de materiais (MTL).

  • tinyobj::ObjReaderConfig readerConfig;: Configuração do leitor de arquivo OBJ.

    • readerConfig.mtl_search_path = basePath;: Define o caminho de pesquisa para arquivos de materiais.

  • tinyobj::ObjReader reader;: Objeto de leitura do arquivo OBJ.

  • if (!reader.ParseFromFile(path.data(), readerConfig)) { ... }: Analisa o arquivo OBJ especificado usando o leitor configurado. Lança uma exceção se a análise falhar.

  • auto const &attrib{reader.GetAttrib()};: Obtém os atributos do modelo (vértices, normais, coordenadas de textura).

  • auto const &shapes{reader.GetShapes()};: Obtém as formas do modelo.

  • auto const &materials{reader.GetMaterials()};: Obtém os materiais do modelo.

  • Limpa as listas de vértices e índices do modelo (m_vertices e m_indices).

  • Inicializa o indicador de presença de normais e coordenadas de textura como falso (m_hasNormals e m_hasTexCoords).

  • Um loop sobre as formas e índices é realizado para extrair as informações do modelo.

  • Um mapa hash é utilizado para armazenar vértices únicos e seus índices correspondentes.

  • As propriedades do primeiro material, se disponíveis, são usadas para definir propriedades do modelo, como coeficientes de reflexão e textura difusa.

  • Se o modelo deve ser padronizado (standardize é verdadeiro), a função Model::standardize é chamada para ajustar a escala e centralizar o modelo na origem.

  • Se o modelo não possui informações de normais, a função Model::computeNormals é chamada para calcular as normais dos vértices.

  • Finalmente, a função Model::createBuffers é chamada para criar os buffers de vértices e índices utilizados para renderizar o modelo.

Observações Adicionais
  • Essa função utiliza a biblioteca TinyObjLoader para analisar arquivos OBJ e extrair informações sobre o modelo.
  • As informações de material do primeiro material são usadas para definir as propriedades do modelo, se disponíveis.
  • A função também suporta o carregamento de texturas difusas associadas aos materiais do modelo.

Atividade 02:

O projeto, desenvolvido utilizando a estrutura leve em C++ chamada ABCg, é um simulador espacial em 3D. Nele, uma nave espacial navega pelo espaço sideral evitando asteroides que se aproximam. A nave tem a capacidade de se mover para a direita, esquerda, acelerar, dar ré e ajustar seu zoom (Setas, WASD e scroll do mouse), oferecendo uma experiência interativa e imersiva. Desenvolvido para a disciplina de Computação Gráfica da UFABC, o projeto utiliza as capacidades do OpenGL para criar uma aplicação em WebAssembly.

Classe Window

Tratamento de Eventos do Teclado e Mouse

A função Window::onEvent é responsável por lidar com eventos do teclado e do mouse e direciona para a rotação e movimentação da nave espacial.

Funcionamento Principal
  • Teclas de Direção (Setas e 'W', 'A', 'S', 'D'):
    • O código trata as teclas de seta (cima, baixo, esquerda, direita) e as teclas 'W', 'A', 'S' e 'D' como comandos de entrada do jogador.
    • Dependendo da tecla pressionada, a função ajusta a rotação, a inclinação da nave espacial e outros parâmetros, controlando sua direção e movimento.
  • Mouse:
    • A função monitora a posição do mouse e a rolagem da roda do mouse.
    • A rolagem da roda do mouse é usada para controlar o nível de zoom da visualização.
    • A posição do mouse é capturada para fins de interação do jogador.
Atualizações e Limites
  • A função atualiza várias variáveis, como ângulo de rotação, rotação e zoom, com base nos eventos do teclado e do mouse.
  • Os valores são limitados dentro de faixas específicas para garantir que permaneçam dentro de limites aceitáveis durante o jogo.
  • O zoom é feito através da manipulação dos eixos da câmera LookAt.

Configuração Inicial da Janela

A função Window::onCreate() é responsável por inicializar e configurar diversos elementos essenciais ao iniciar a janela de renderização. Isso inclui a definição da cor de fundo, configurações de profundidade, carregamento de modelos 3D, configuração da câmera e preparação dos elementos do jogo.

Carregamento de Modelos 3D
  • Asteroides:
    • Carrega o modelo de asteroides (asteroid.obj) para a visualização no jogo.
    • Prepara o Vertex Array Object (VAO) associado ao programa OpenGL.
  • Nave Espacial (Starship):
    • Carrega o modelo da nave espacial (starship.obj) para a visualização no jogo.
    • Configura o Vertex Array Object (VAO) associado ao programa OpenGL.
    • Define a posição inicial da nave espacial.
Configuração da Câmera
  • Posição e Orientação da Câmera:
    • Configura a câmera para posicionar-se em (0, 0.035, 0.01) e apontar na direção negativa do eixo Z.
    • Define o vetor "up" para garantir a orientação correta da câmera.
Rotação Inicial da Nave
  • Inicialização da Rotação da Nave Espacial:
    • Define a rotação inicial da nave espacial como 0 graus, armazenada em radianos.
    • Configura a rotação para a direção (1.0, 1.0, 1.0) nos eixos x, y e z.
Configuração das Estrelas
  • Configuração Inicial das Estrelas:
    • Para cada estrela na coleção de estrelas (m_stars), a função randomizeStar() é chamada para inicializar suas propriedades.

Randomização das Estrelas

A função Window::randomizeStar(Star &star) é responsável por gerar posições e eixos de rotação aleatórios para as estrelas no jogo. Ela utiliza distribuições uniformes para criar uma variedade de posições e eixos de rotação a fim de aumentar a diversidade visual das estrelas no espaço.

Geração de Posição Aleatória
  • Posição Aleatória no Espaço Tridimensional:
    • Gera aleatoriamente as coordenadas (x, y, z) dentro dos intervalos específicos:
      • x e y no intervalo [-20, 20)
      • z no intervalo [-100, 0)
    • Define a posição da estrela com base nas coordenadas geradas.
Geração de Eixo de Rotação Aleatório
  • Eixo de Rotação Aleatório:
    • Utiliza a função glm::sphericalRand(1.0f) para gerar um vetor de rotação aleatório.
    • Define o eixo de rotação da estrela para o vetor resultante, permitindo uma variedade de orientações no espaço.

Atualização do Ambiente e Estrelas

A função Window::onUpdate() é responsável por atualizar o estado do ambiente e o movimento das estrelas no jogo. Esta função executa a lógica para a nave espacial, a movimentação das estrelas, e as verificações para reposicionamento e realocação das estrelas no espaço tridimensional.

Orientação da Nave Espacial
  • Definição da Orientação da Nave:
    • Define o eixo de rotação da nave espacial com base nas variáveis de rotação (starship_rotation).
Atualização da Câmera
  • Configuração da Matriz de Visualização (View Matrix):
    • Atualiza a matriz de visualização para a câmera com base em variáveis de zoom e posição.
Atualização das Estrelas
  • Movimentação e Verificações das Estrelas:
    • Itera sobre cada estrela e atualiza sua posição ao longo do eixo z com base no tempo.
    • Responde aos inputs do jogador, ajustando a posição das estrelas de acordo com a direção desejada.
    • Verifica se as estrelas ultrapassam certos limites no espaço (eixo z e x), realocando-as para garantir que permaneçam visíveis.
Controle de Movimento das Estrelas
  • Gerenciamento de Posicionamento das Estrelas:
    • Se uma estrela ultrapassa a posição da câmera, é reposicionada aleatoriamente e movida de volta para a posição inicial.
    • Se uma estrela ultrapassa os limites laterais do espaço, é reposicionada aleatoriamente e movida para a extremidade oposta.

Renderização do Ambiente e Objetos

A função Window::onPaint() é responsável por renderizar os elementos do ambiente, incluindo a nave espacial e as estrelas. Esta função configura as variáveis uniformes dos shaders, aplica transformações nos modelos e efetua o processo de renderização dos objetos 3D.

Configuração Inicial
  • Limpeza do Buffer Gráfico:
    • Limpa o buffer de cor e o buffer de profundidade para preparar o contexto gráfico para o desenho dos objetos.
Configuração do Shader
  • Ativação do Programa do Shader:
    • Habilita o uso do programa de shader para realizar as renderizações.
Configuração das Matrizes Uniformes
  • Definição das Matrizes de Visualização e Projeção:
    • Define as matrizes de visualização (viewMatrix) e projeção (projMatrix) no programa de shader para definir a câmera e a perspectiva.
Renderização do Modelo da Nave Espacial
  • Renderização do Modelo da Nave:
    • Aplica as transformações necessárias (escala, translação, rotação) no modelo da nave espacial e o renderiza.
Renderização das Estrelas
  • Renderização das Estrelas:
    • Itera sobre cada estrela, aplica transformações individuais (escala, translação, rotação) e renderiza cada uma no ambiente.
Finalização da Renderização
  • Desativação do Programa do Shader:
    • Finaliza o uso do programa de shader após a renderização dos objetos.

Função Window::onPaintUI()

A função Window::onPaintUI() é responsável por renderizar a interface do usuário (UI) e gerenciar as configurações gráficas relacionadas à projeção do ambiente do jogo.

Seleção do Tipo de Projeção
  • Seleção da Projeção (Perspectiva ou Ortográfica):
    • Cria um combo box para selecionar entre projeção perspectiva e ortográfica.
    • Atualiza a matriz de projeção com base na escolha do usuário.
    • Exibe um slider para ajustar o campo de visão (FOV) no caso da projeção perspectiva.

Função Window::onResize()

A função Window::onResize() é chamada quando a janela do aplicativo é redimensionada. Ela atualiza o tamanho do viewport, que é essencial para garantir que a cena seja renderizada corretamente após a mudança de tamanho da janela.

Função Window::onDestroy()

A função Window::onDestroy() é chamada quando o aplicativo está sendo encerrado. Ela é responsável por liberar recursos, como os programas de shader e os modelos 3D.

Classe Gamedata

A classe GameData representa a estrutura de dados para controlar e armazenar informações de movimentação da nave.

Componentes da Classe

  • m_input: Um objeto std::bitset que armazena as informações de entrada do jogo. Especificamente, são registrados os comandos de direcionais (esquerda, direita, cima, baixo) juntamente com um comando adicional não especificado.

Elementos da Classe

  • enum class Input { Right, Left, Down, Up }: Uma enumeração que representa os diferentes tipos de comandos de entrada. Esses comandos incluem movimento para a direita, esquerda, para baixo e para cima.

Fluxo de Dados

  • A classe GameData é utilizada para manter um registro dos comandos de entrada recebidos durante a execução do jogo.
  • O std::bitset é usado para armazenar informações booleanas de forma compacta, permitindo o registro de diferentes tipos de entrada.

Classe Model

A classe é utilizada para a renderização de objetos 3D.

Funcionalidades

  • createBuffers(): Esta função cria e configura os buffers de vértices e índices para armazenar e renderizar modelos 3D.
  • loadObj(std::string_view path, bool standardize): Carrega um modelo 3D a partir de um arquivo no formato .obj, convertendo suas informações em vértices e índices. O parâmetro standardize normaliza o modelo para caber dentro do intervalo [-1, 1].
  • render(int numTriangles): Renderiza o modelo 3D. O parâmetro numTriangles define a quantidade de triângulos a serem desenhados.
  • setupVAO(GLuint program): Configura o Vertex Array Object (VAO) para o modelo, especificando os atributos dos vértices.
  • standardize(): Normaliza o modelo para caber dentro do intervalo [-1, 1] em todas as dimensões.
  • destroy(): Limpa os buffers e o VAO alocados para o modelo, realizando a limpeza de memória e recursos utilizados.

Principais Funcionalidades

  • A leitura de arquivos .obj é feita utilizando a biblioteca tinyobj para obter as informações do modelo.
  • Os vértices e índices são armazenados em buffers apropriados utilizando funções de baixo nível do OpenGL (GL_ELEMENT_ARRAY_BUFFER e GL_ARRAY_BUFFER).
  • As funções setupVAO e render são usadas para configurar a renderização dos modelos dentro de um contexto OpenGL.
  • A função standardize garante que os modelos renderizados se ajustem a um espaço padronizado para facilitar a renderização e manipulação.

Classe Main

O código apresentado inicializa e gerencia a janela de visualização.

Funcionalidades

  • abcg::Application: Inicializa a aplicação e gere o ciclo de vida do programa.
  • Window: Classe responsável por configurar e controlar as definições da janela de visualização.

Fluxo Principal

  1. Inicialização da Aplicação: Inicia a aplicação e cria a janela de visualização por meio da classe Window.
  2. Configurações da Janela: Define as configurações da janela, como largura, altura, título e configurações específicas do OpenGL, como o número de amostras.
  3. Execução do Aplicativo: Inicia a execução do aplicativo gráfico por meio do método run() da classe abcg::Application.

Assets

  1. Nave espacial: https://www.cgtrader.com/free-3d-models/space/spaceship/free-scifi-fighter
  2. Asteroide: https://free3d.com/3d-model/low-poly-rock-4631.html
  3. Imagem de fundo: https://unblast.com/10-free-space-background-images-jpg/
  4. Imagem para Cubemap: https://jaxry.github.io/panorama-to-cubemap/