- Configurar o projeto com CMake.
- Importar a biblioteca GLFW.
- Criar uma janela.
- Importar a biblioteca GLAD.
- Carregar o contexto OpenGL e mudar o fundo da janela de cor.
- Criar uma função de retorno de chamada para o redimensionamento de janela.
- Importar o código-fonte para o Vertex e o Fragment Shader.
- Criar programas para o Vertex e o Fragment Shader e compilar.
- Criar o Shader Program.
- Anexar os Shaders criados ao Shader Program.
- Vincular Shader Program ao OpenGL.
- Verificar se existe algum erro de vinculação.
- Deletar Vertex e Fragment Shader, pois foram anexados ao Shader Program e estão inutilizados.
- Configurar os dados dos vertices do triângulo.
- Criar VBO (Vertex Buffer Object), que de modo simplificado, armazena o buffer na memória da placa de vídeo, para melhorar o desempenho.
- Vincular o VBO ao OpenGL.
- Copiar os dados dos vertices para o VBO.
- Criar um VAO (Vertex Array Object), que de modo simplificado, descreve como os vertices são armazenados no VBO.
- Vincular o VAO ao OpenGL.
- Atribuir ponteiros para os vertices.
- Desvincular o VBO e o VAO para não modificar acidentalmente esses objetos.
- Definir qual Shader Program o OpenGL deve usar.
- Definir a primitiva GL_TRIANGLES.
- Desenhar um triângulo.
- Atualizar e adicionar mais um vertice aos vertices, para desenhar um retângulo, a partir de dois triângulos.
- Criar indices a partir dos vertices, para desenhar os triângulos sem repetir os dados.
- Criar EBO (Element Buffer Object), que de modo simplificado, armazena um buffer com os indices dos vertices dos elementos.
- <Desenhar um retângulo.
- Criar a classe Shader, para ler arquivos no formato glsl.
- Criar arquivos fragment_shader.glsl e vertex_shaders.glsl.
- Instânciar a classe criada e usar os shaders.
- Adicionar três floats na sequência das coordenadas de cada vertice para indicar a cor.
- Configurar os ponteiros de vertices e cores para um tamanho de seis floats, pois os três primeiros indicam o vertice, e os três últimos indicam a cor.
- Importar imagem wall.jpg para servir de textura.
- Importar biblioteca stb_image para carregar o arquivo de imagem da textura.
- Adicionar coordenadas de textura para cada vertice.
- Configurar os ponteiros de vertices, cores e texturas, para um tamanho de oito floats, pois os três primeiros indicam o vertice, os três consequentes, indicam a cor, e os dois últimos, a coordenada da textura.
- Alterar variável ID da classe Shader para public.
- Configurar as texturas nos shaders, ou seja, nos arquivos de código-fonte GLSL.
- Configurar a textura na main.cpp.
- Desenhar um retângulo texturizado.
- Importar GLM, uma biblioteca matemática, para facilitar os cálculos de matrizes e vetores.
- Remover os atributos de cor dos vértices, pois não serão mais usados.
- Criar uma matriz 4x4 para sofrer transformações, e depois, multiplicar ela pela matriz do objeto.
- Alterar a escala e rotacionar o objeto ao longo do tempo.
- Remover a alteração de escala.
- Mover o objeto (transladar) para o canto inferior direito e depois rotacionar.
- Remover a matriz de transformação.
- Criar três matrizes identidades (Model, View e Projection) para realizar a projeção de perspectiva.
- Model Matrix: para transformar as coordenadas do modelo em coordenadas no mundo.
- View Matrix: transformar a visualização.
- Projection Matrix: espaço da câmera, o ângulo de abertura e a distância dos planos de corte de renderização.
- Aplicar rotação de -55° na Model Matrix, em relação ao eixo x. Isso modificará a angulação do objeto.
- Transladar em -3.0f no eixo z a View Matrix, ou seja, mover a visualização para trás. A visualização abrange todos os objetos do mundo.
- Determinar o campo de visão, a proporção de tela e o intervalo de renderização dos objetos no mundo, através da Projection Matrix.
- Importar vertices do cubo.
- Remover o Element Buffer Object.
- Desenhar um cubo.
- Habilitar o teste do buffer de profundidade e limpar o buffer de profundidade.
- Definir uma posição para cada cubo no espaço do mundo.
- Criar um laço de repetição "for" dentro do loop de renderização principal, e dentro dele, criar um cubo para cada posição definida.
- Desenhar múltiplos cubos.
- Definir a Projection Matrix fora do loop de renderização principal.
- Transformar a View Matrix com a função lookAt, para ver as coordenadas dos vertices da perspectiva de uma câmera.
- Criar uma função para processar os comandos do teclado, e chamar essa função dentro do loop de renderização principal.
- Definir um sistema de três variáveis para movimentar a visualização em relação a câmera.
- Movimentar a visualização da perspectiva da câmera, através do teclado.
- Ajustar a velocidade do movimento através do deltaTime.
- O deltaTime pode ser definido como a diferença de tempo entre cada renderização.
- Definir uma função de retorno de chamada para o mouse.
- Movimentar a visualização da perspectiva da câmera, através do mouse.
- Criar uma função de retorno de chamada para o scroll do mouse.
- Definir o FOV como um parâmetro variável na Projection Matrix.
- Mover a Projection Matrix para dentro do loop de renderização principal.
- Aplicar zoom através do scroll do mouse.
- Criar uma classe chamada Camera, para organizar o código, obter e atualizar a View Matrix, e processar os eventos de entrada do teclado e do mouse.
- Importar a biblioteca assimp.
- Remover os vertices, o VBO, VAO e as texturas, da main.cpp.
- Criar classe Mesh, para carregar e configurar as malhas.
- Criar classe Model, para ler o arquivo do modelo, verificar os erros, separar os dados e desenhar o modelo.
- Atualizar os shaders.
- Importar e carregar um modelo de mochila com o formato .obj (Object File Wavefront).
- Nota: por algum motivo, na versão 5.2.0 da assimp existe um bug que faz demorar muito a leitura de malhas complexas. (pelo menos no windows)
- Corrigir o bug alterando o arquivo libs/assimp/code/AssetLib/Obj/ObjFileParser.cpp.
- Desenhar a mochila.
- Renomear os shaders para model_fragment.glsl e model_vertex.glsl.
- Importar e carregar um modelo de cubo.
- Criar shaders para a lâmpada.
- Usar esses shaders e desenhar uma lâmpada com formato de cubo ao lado da mochila.
- Adicionar uma iluminação ambiente na mochila.
- Adicionar normal e fragment position aos shaders.
- Adicionar uma iluninação difusa na mochila.
- Rotacionar a mochila.
- Adicionar uma matriz normal no vertex shader para corrigir a iluminação.
- Remover a rotação da mochila.
- Mover a lâmpada ao redor da mochila ao longo do tempo.
- Adicionar uma iluminação especular.
- Nota: alterar as propriedades do material pode ser muito interessante.
- Adicionar um mapa especular (specular map), para fazer com que determinadas partes do objeto brilhem mais ou menos que outras.
- Adicionar uma atenuação, que diminui a intensidade da luz no objeto com base na distância entre eles.
- Adicionar uma iluminação de lanterna, que basicamente é uma iluminação de holofote com a posição e a direção que a câmera está apontada.
- Adicionar uma configuração de luz direcional no model_fragment.glsl.
- Adicionar uma configuração de ponto de luz no model_fragment.glsl.
- Desenhar várias mochilas com várias lâmpadas.
- Adicionar uma configuração de luz de holofote no model_fragment.glsl e usar como lanterna.
- Remover as lâmpadas e as mochilas, e desenhar apenas uma mochila e uma lâmpada.
- Criar classe WindowManager, refatoração para as funções de inicialização de GLFWwindow e callbacks.
- Criar classe Renderer, refatoração para as configurações de buffer do OpenGL e a lógica de renderização dos modelos.
- Criar classe InputManager, refatoração para gerenciar as entradas de mouse e teclado.
- Criar classe Scene, refatoração para carregar os modelos em uma cena, adicionar, remover ou atualizar eles, a partir de Renderer.
- Atualizar a posição do modelo da lâmpada na renderização, assim como sua posição no shader dos outros objetos, a partir da classe Scene e Renderer.
- Criar classes Object e ObjectManager, refatoração para salvar as informações dos objetos, como o tipo do shader, posição, rotação, escala, assim como carregar os modelos em uma classe separada, para facilitar a reutilização com ponteiros.
- Adicionar opção para alternar a luz da lanterna na tecla F, com um pequeno atraso na hora de ligar e desligar.
- Criar classe Engine, refatoração que visa centralizar o código para simplificar futuras implementações.
- Criar classe LightObject, que herda as caracteristicas de Object, para gerenciar os objetos que possuem luz. Além disso, adicionar um vetor para guardar esses objetos iluminados dentro da classe Scene.
- Mover metodo draw da classe Scene para Renderer com o nome de rendererScene. Refatoração que visa organizar a resposabilidade das classes.
- Adicionar lógica para renderizar os objetos com luz na classe Renderer.
- Remover enum ShaderType. A classificação de objetos em LightObject e Object, melhora a aplicação de seus respectivos shaders.
- Adicionar contador de FPS.
- Simplificar a inclusão dos arquivos de código fonte no CmakeLists.txt, a partir de file(GLOB SOURCES src/*.cpp).
- Adicionar um id aos objetos e luzes inseridos na cena, refere-se ao indice do objeto no vetor.
- Adicionar sistema para remover os objetos da cena a partir do id.
- Adicionar dois pontos de luz que interagem com a iluminação dos objetos na cena.
-
Notifications
You must be signed in to change notification settings - Fork 0
DiarioOpenGL
License
luk4w/DiarioOpenGL
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Folders and files
Name | Name | Last commit message | Last commit date | |
---|---|---|---|---|
Repository files navigation
About
DiarioOpenGL
Topics
Resources
License
Stars
Watchers
Forks
Releases
No releases published
Packages 0
No packages published