DiarioOpenGL

• 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.