7.7 LookAt na prática

Nesta seção, seguiremos o passo a passo de desenvolvimento de uma aplicação que renderiza uma cena 3D do ponto de vista de uma câmera LookAt.

A cena 3D será composta por quatro instâncias do modelo “Stanford Bunny” dispostos sobre o plano \(y=0\). A câmera LookAt simulará um observador em primeira pessoa. A figura 7.32 mostra o posicionamento dos objetos no plano e mostra a localização inicial da câmera.

Objetos e elementos de cena dispostos no espaço do mundo.

Figura 7.32: Objetos e elementos de cena dispostos no espaço do mundo.

Na figura acima, os vetores \(\hat{\mathbf{i}}\),\(\hat{\mathbf{j}}\),\(\hat{\mathbf{k}}\) correspondem às direções dos eixos \(x\),\(y\),\(z\) do espaço euclidiano, e \(\hat{\mathbf{u}}\),\(\hat{\mathbf{v}}\),\(\hat{\mathbf{n}}\) são os vetores do frame da câmera. A câmera está localizada em \((0, 0.5, 2.5)\) e está olhando na direção do eixo \(z\) negativo.

  • O coelho vermelho está na posição \((0,0,0)\) e tem escala de \(10\%\) do tamanho original.
  • O coelho cinza está na posição \((-1,0,0)\) e está rodado em \(90^{\circ}\) em torno de seu eixo \(y\) local.
  • O coelho azul está na posição \((1,0,0)\) e está rodado em \(-90^{\circ}\) em torno de seu eixo \(y\) local.
  • O coelho amarelo está na posição \((0,0,-1)\) e está com sua orientação original.

A câmera pode ser movida através do teclado:

  • As setas para cima/baixo (ou W/S) fazem a câmera ir para a frente/trás ao longo da direção de visão (direção de \(\pm\hat{\mathbf{n}}\)). No jargão da cinematografia, esse movimento de câmera é chamado de dolly.
  • As setas para os lados (ou A/D) fazem a câmera girar em torno de seu eixo \(y\) (vetor \(\hat{\mathbf{v}}\)). Esse movimento é chamado de pan.
  • As teclas Q/E fazem a câmera deslizar para os lados (direção de \(\pm\hat{\mathbf{u}}\)). Esse movimento é chamado de truck ou dolly lateral.

O chão da cena não é renderizado, e os objetos parecem flutuar no espaço. Entretanto, a câmera sempre mantém a mesma altura \(y=0.5\). O resultado é como se o observador estivesse se deslocando sobre um chão invisível.

O resultado ficará como a seguir:

Observação

Para controlar a câmera usando o teclado, abra o link original e clique na área de desenho para a aplicação ter o foco do teclado.

Configuração inicial

  • No arquivo abcg/examples/CMakeLists.txt, inclua a linha:

    add_subdirectory(lookat)

  • Crie o subdiretório abcg/examples/lookat e o arquivo abcg/examples/lookat/CMakeLists.txt com o seguinte conteúdo:

    project(lookat)
add_executable(${PROJECT_NAME} camera.cpp main.cpp openglwindow.cpp)
enable_abcg(${PROJECT_NAME})

  • Crie os arquivos camera.cpp, camera.hpp, main.cpp, openglwindow.cpp e openglwindow.hpp.

  • Crie o subdiretório abcg/examples/lookat/assets. Dentro dele, crie os arquivos lookat.frag e lookat.vert. Além disso, baixe o arquivo bunny.zip e descompacte-o em assets.

A estrutura de abcg/examples/lookat ficará assim:

lookat/
│   CMakeLists.txt
│   camera.hpp
│   camera.cpp
│   main.cpp
│   openglwindow.hpp
│   openglwindow.cpp
│
└───assets/
    │   bunny.obj
    │   lookat.frag    
    └   lookat.vert

main.cpp

O conteúdo de main.cpp é o mesmo do projeto anterior. Só muda o título da janela:

#include <fmt/core.h>

#include "abcg.hpp"
#include "openglwindow.hpp"

int main(int argc, char **argv) {
  try {
    abcg::Application app(argc, argv);

    auto window{std::make_unique<OpenGLWindow>()};
    window->setOpenGLSettings({.samples = 4});
    window->setWindowSettings(
        {.width = 600, .height = 600, .title = "LookAt Camera"});

    app.run(window);
  } catch (abcg::Exception &exception) {
    fmt::print(stderr, "{}\n", exception.what());
    return -1;
  }
  return 0;
}

lookat.vert

O vertex shader ficará como a seguir:

#version 410

layout(location = 0) in vec3 inPosition;

uniform vec4 color;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projMatrix;

out vec4 fragColor;

void main() {
  vec4 posEyeSpace = viewMatrix * modelMatrix * vec4(inPosition, 1);

  float i = 1.0 - (-posEyeSpace.z / 5.0);
  fragColor = vec4(i, i, i, 1) * color;

  gl_Position = projMatrix * posEyeSpace;
}

O atributo de entrada, inPosition, é a posição \((x,y,z)\) do vértice no espaço do objeto.

O atributo de saída, fragColor, é uma cor RGBA.

As variáveis uniformes (linhas 5 a 8) são utilizadas para determinar a cor do objeto (color) e as matrizes \(4 \times 4\) de transformação geométrica:

  • Matriz de modelo: modelMatrix;
  • Matriz de visão: viewMatrix;
  • Matriz de projeção: projMatrix.

Embora ainda não tenha sido abordada a teoria de como criar a matriz de projeção, vamos utilizá-la desde já para obter o efeito de perspectiva necessário para manter a ilusão de que a câmera LookAt é um observador dentro de um cenário 3D.

No código de main, a linha 13 transforma a posição de entrada pelas matrizes de modelo e visão. Para entender a ordem das transformações, temos de ler a linha 13 da direita para a esquerda:

  vec4 posEyeSpace = viewMatrix * modelMatrix * vec4(inPosition, 1);

Primeiro, vec4(inPosition, 1) produz a posição \((x,y,z,1)\), isto é, um ponto em coordenadas homogêneas. Essa posição é multiplicada (isto é, transformada) pela matriz de modelo modelMatrix para converter as coordenadas do espaço do objeto para o espaço do mundo. Em seguida há uma transformação pela matriz de visão viewMatrix, que converte as coordenadas do espaço do mundo para coordenadas do espaço da câmera. É esse o resultado armazenado em posEyeSpace: a posição do vértice no espaço da câmera.

Na linha 15, calculamos um valor i de intensidade de cor com base na coordenada \(z\) no espaço da câmera:

  float i = 1.0 - (-posEyeSpace.z / 5.0);

Lembre-se que, no espaço da câmera, a câmera está olhando na direção de seu eixo \(z\) negativo. Logo, do ponto de vista da câmera, todos os objetos à sua frente têm valor \(z\) negativo. Ao fazer -PosEyeSpace.z, tornamos esse valor positivo, correspondendo à distância entre o ponto e a câmera ao longo do eixo \(z\). A ideia aqui é transformar essa distância em um valor de intensidade de cor. A intensidade será máxima (1) se o objeto estiver na mesma posição da câmera, e mínima (0) se estiver a uma distância de 5 unidades. Na linha 16, esse valor é utilizado para multiplicar as componentes RGB da cor color.

  fragColor = vec4(i, i, i, 1) * color;

Assim, quanto mais longe o objeto estiver da câmera, mais escuro ele ficará. A partir da distância 5, a intensidade fica negativa, mas nesse caso o OpenGL fixa automaticamente o valor de cor para zero (não existe intensidade negativa de cor).

Na linha 18, projMatrix * posEyeSpace faz com que as coordenadas no espaço da câmera sejam convertidas para o espaço de recorte. É esse o resultado final em gl_Position:

  gl_Position = projMatrix * posEyeSpace;

lookat.frag

O conteúdo do fragment shader ficará assim:

#version 410

in vec4 fragColor;
out vec4 outColor;

void main() {
  if (gl_FrontFacing) {
    outColor = fragColor;
  } else {
    outColor = fragColor * 0.5;
  }
}

Se o triângulo estiver orientado de frente para a câmera, a cor final do fragmento será a cor de entrada (fragColor). Caso contrário, a cor terá metade da intensidade original. Assim, se a câmera estiver dentro de um objeto, os triângulos serão desenhados com uma cor mais escura, pois estaremos vendo o lado de trás da malha triangular.

camera.hpp

Neste arquivo definiremos a classe Camera que gerenciará a câmera LookAt. O conteúdo ficará assim:

#ifndef CAMERA_HPP_
#define CAMERA_HPP_

#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>

class OpenGLWindow;

class Camera {
 public:
  void computeViewMatrix();
  void computeProjectionMatrix(int width, int height);

  void dolly(float speed);
  void truck(float speed);
  void pan(float speed);

 private:
  friend OpenGLWindow;

  glm::vec3 m_eye{glm::vec3(0.0f, 0.5f, 2.5f)};  // Camera position
  glm::vec3 m_at{glm::vec3(0.0f, 0.5f, 0.0f)};   // Look-at point
  glm::vec3 m_up{glm::vec3(0.0f, 1.0f, 0.0f)};   // "up" direction

  // Matrix to change from world space to camera soace
  glm::mat4 m_viewMatrix;

  // Matrix to change from camera space to clip space
  glm::mat4 m_projMatrix;
};

#endif

Observe, nas linhas 21 a 23, que a classe tem os atributos necessários para criar o frame de uma câmera LookAt:

  • m_eye é a posição da câmera: \((0, 0.5, 2.5)\).
  • m_at é a posição para onde a câmera está olhando: \((0, 0.5, 0)\).
  • m_up é o vetor de direção para cima: \((0, 1, 0)\).

Na linha 26 temos a matriz de visão (m_viewMatrix), calculada pelo método Camera::computeViewMatrix (linha 11).

Na linha 29 temos a matriz de projeção (m_projMatrix), calculada pelo método Camera::computeProjectionMatrix (linha 12).

Os métodos Camera::dolly, Camera::truck e Camera::pan serão chamados a partir de OpenGLWindow, em resposta à entrada do teclado. Internamente, esses métodos modificarão as variáveis m_eye e m_at, fazendo a câmera mudar de posição e orientação.

camera.cpp

A definição dos métodos de Camera ficará como a seguir:

#include "camera.hpp"

#include <glm/gtc/matrix_transform.hpp>

void Camera::computeProjectionMatrix(int width, int height) {
  m_projMatrix = glm::mat4(1.0f);
  auto aspect{static_cast<float>(width) / static_cast<float>(height)};
  m_projMatrix = glm::perspective(glm::radians(70.0f), aspect, 0.1f, 5.0f);
}

void Camera::computeViewMatrix() {
  m_viewMatrix = glm::lookAt(m_eye, m_at, m_up);
}

void Camera::dolly(float speed) {
  // Compute forward vector (view direction)
  glm::vec3 forward = glm::normalize(m_at - m_eye);

  // Move eye and center forward (speed > 0) or backward (speed < 0)
  m_eye += forward * speed;
  m_at += forward * speed;

  computeViewMatrix();
}

void Camera::truck(float speed) {
  // Compute forward vector (view direction)
  glm::vec3 forward = glm::normalize(m_at - m_eye);
  // Compute vector to the left
  glm::vec3 left = glm::cross(m_up, forward);

  // Move eye and center to the left (speed < 0) or to the right (speed > 0)
  m_at -= left * speed;
  m_eye -= left * speed;

  computeViewMatrix();
}

void Camera::pan(float speed) {
  glm::mat4 transform{glm::mat4(1.0f)};

  // Rotate camera around its local y axis
  transform = glm::translate(transform, m_eye);
  transform = glm::rotate(transform, -speed, m_up);
  transform = glm::translate(transform, -m_eye);

  m_at = transform * glm::vec4(m_at, 1.0f);

  computeViewMatrix();
}

Por enquanto vamos ignorar a definição do método Camera::computeProjectionMatrix. Retomaremos no próximo capítulo quando tivermos visto a teoria sobre matrizes de projeção.

Em Camera::computeViewMatrix, chamamos a função lookAt da GLM usando os atributos da câmera:

void Camera::computeViewMatrix() {
  m_viewMatrix = glm::lookAt(m_eye, m_at, m_up);
}

Esse método será chamado sempre que houver alguma alteração em m_eye ou m_at.

Em Camera::dolly, os pontos m_eye e m_at são movidos para a frente ou para trás na direção de visão (vetor forward):

void Camera::dolly(float speed) {
  // Compute forward vector (view direction)
  glm::vec3 forward = glm::normalize(m_at - m_eye);

  // Move eye and center forward (speed > 0) or backward (speed < 0)
  m_eye += forward * speed;
  m_at += forward * speed;

  computeViewMatrix();
}

Veja que, ao final, Camera::computeViewMatrix é chamado para reconstruir a matriz de visão.

Camera::truck funciona de forma parecida ao Camera::dolly. Os pontos m_eye e m_at são movidos para os lados na direção do vetor left, que é o produto vetorial entre o vetor up e o vetor forward.

void Camera::truck(float speed) {
  // Compute forward vector (view direction)
  glm::vec3 forward = glm::normalize(m_at - m_eye);
  // Compute vector to the left
  glm::vec3 left = glm::cross(m_up, forward);

  // Move eye and center to the left (speed < 0) or to the right (speed > 0)
  m_at -= left * speed;
  m_eye -= left * speed;

  computeViewMatrix();
}

Camera::pan faz o movimento de rodar a câmera em torno de seu eixo \(y\). Isso é feito alterando apenas o ponto m_at:

void Camera::pan(float speed) {
  glm::mat4 transform{glm::mat4(1.0f)};

  // Rotate camera around its local y axis
  transform = glm::translate(transform, m_eye);
  transform = glm::rotate(transform, -speed, m_up);
  transform = glm::translate(transform, -m_eye);

  m_at = transform * glm::vec4(m_at, 1.0f);

  computeViewMatrix();
}

A matriz transform é uma concatenção de transformações na forma:

\[ \mathbf{M}=\mathbf{I}.\mathbf{T}(\mathbf{p}_{\textrm{eye}}).\mathbf{R}_y(\theta).\mathbf{T}(-\mathbf{p}_{\textrm{eye}}). \]

A ordem de aplicação das transformações é obtida lendo a expressão da direita para a esquerda (no código, lemos de baixo para cima, da linha 45 à linha 40):

  1. \(\mathbf{T}(-\mathbf{p}_{\textrm{eye}})\) (linha 45) tem o efeito de transladar a câmera para a origem do mundo, isto é, faz o ponto \(\mathbf{p}_{\textrm{eye}}\) virar a origem \(O\).
  2. \(\mathbf{R}_y(\theta)\) (linha 44) roda a câmera em torno do eixo \(y\) do mundo. Como a câmera agora está na origem, é como se a câmera fosse rodada em torno de seu próprio eixo \(y\).
  3. \(\mathbf{T}(\mathbf{p}_{\textrm{eye}})\) (linha 43) é a transformação inversa da primeira, e faz a câmera voltar à sua posição original.
  4. \(\mathbf{I}\) é a matriz identidade criada na linha 40.

A linha 47 transforma m_at por transform. O resultado é rodar m_at em torno de m_eye.

Observação

As operações da linha 40 até a linha 45 em Camera::pan são equivalentes ao pseudocódigo:

transform = I;
transform = transform * T(m_eye);
transform = transform * Ry(-speed);
transform = transform * T(-m_eye);

que é o mesmo que

transform = I * T(m_eye) * Ry(-speed) * T(-m_eye);

onde I, Ry e T são as matrizes de transformação identidade, rotação em \(y\), e translação.

openglwindow.hpp

A definição da classe OpenGLWindow ficará assim:

#ifndef OPENGLWINDOW_HPP_
#define OPENGLWINDOW_HPP_

#include "abcg.hpp"
#include "camera.hpp"

struct Vertex {
  glm::vec3 position;

  bool operator==(const Vertex& other) const {
    return position == other.position;
  }
};

class OpenGLWindow : public abcg::OpenGLWindow {
 protected:
  void handleEvent(SDL_Event& ev) override;
  void initializeGL() override;
  void paintGL() override;
  void paintUI() override;
  void resizeGL(int width, int height) override;
  void terminateGL() override;

 private:
  GLuint m_VAO{};
  GLuint m_VBO{};
  GLuint m_EBO{};
  GLuint m_program{};

  int m_viewportWidth{};
  int m_viewportHeight{};

  Camera m_camera;
  float m_dollySpeed{0.0f};
  float m_truckSpeed{0.0f};
  float m_panSpeed{0.0f};

  std::vector<Vertex> m_vertices;
  std::vector<GLuint> m_indices;

  void loadModelFromFile(std::string_view path);
  void update();
};

#endif

Primeiro, observe a estrutura Vertex definida nas linhas 8 a 14:

struct Vertex {
  glm::vec3 position;

  bool operator==(const Vertex& other) const {
    return position == other.position;
  }
};

O código é semelhante ao do projeto loadmodel. As diferenças são:

  • Linha 5: inclusão do cabeçalho camera.hpp;
  • Linha 17: declaração do método handleEvent, para tratar os eventos do teclado;
  • Linha 33: definição da instância de Camera;
  • Linhas 34 a 36: definição de variáveis de controle de velocidade de dolly, truck e pan;
  • Linha 42: definição de um método update que será chamado em paintGL.

Algumas coisas foram removidas em relação ao projeto anterior, como a variável que controlava o número de triângulos exibidos. Também deixamos de usar o método OpenGLWindow::standardize, que normalizava e centralizava o modelo no NDC. Dessa vez, o modelo armazenado no VBO será o modelo sem modificações, isto é, o modelo lido diretamente do arquivo. Para mudar a escala e posição do modelo, usaremos a matriz de modelo.

openglwindow.cpp

O início de openglwindow.cpp é exatamente o mesmo do projeto anterior:

#include "openglwindow.hpp"

#include <fmt/core.h>
#include <imgui.h>
#include <tiny_obj_loader.h>

#include <cppitertools/itertools.hpp>
#include <glm/gtx/fast_trigonometry.hpp>
#include <glm/gtx/hash.hpp>
#include <unordered_map>

// Custom specialization of std::hash injected in namespace std
namespace std {
template <>
struct hash<Vertex> {
  size_t operator()(Vertex const& vertex) const noexcept {
    std::size_t h1{std::hash<glm::vec3>()(vertex.position)};
    return h1;
  }
};
}  // namespace std

A definição de OpenGLWindow::handleEvent vem a seguir:

void OpenGLWindow::handleEvent(SDL_Event& ev) {
  if (ev.type == SDL_KEYDOWN) {
    if (ev.key.keysym.sym == SDLK_UP || ev.key.keysym.sym == SDLK_w)
      m_dollySpeed = 1.0f;
    if (ev.key.keysym.sym == SDLK_DOWN || ev.key.keysym.sym == SDLK_s)
      m_dollySpeed = -1.0f;
    if (ev.key.keysym.sym == SDLK_LEFT || ev.key.keysym.sym == SDLK_a)
      m_panSpeed = -1.0f;
    if (ev.key.keysym.sym == SDLK_RIGHT || ev.key.keysym.sym == SDLK_d)
      m_panSpeed = 1.0f;
    if (ev.key.keysym.sym == SDLK_q) m_truckSpeed = -1.0f;
    if (ev.key.keysym.sym == SDLK_e) m_truckSpeed = 1.0f;
  }
  if (ev.type == SDL_KEYUP) {
    if ((ev.key.keysym.sym == SDLK_UP || ev.key.keysym.sym == SDLK_w) &&
        m_dollySpeed > 0)
      m_dollySpeed = 0.0f;
    if ((ev.key.keysym.sym == SDLK_DOWN || ev.key.keysym.sym == SDLK_s) &&
        m_dollySpeed < 0)
      m_dollySpeed = 0.0f;
    if ((ev.key.keysym.sym == SDLK_LEFT || ev.key.keysym.sym == SDLK_a) &&
        m_panSpeed < 0)
      m_panSpeed = 0.0f;
    if ((ev.key.keysym.sym == SDLK_RIGHT || ev.key.keysym.sym == SDLK_d) &&
        m_panSpeed > 0)
      m_panSpeed = 0.0f;
    if (ev.key.keysym.sym == SDLK_q && m_truckSpeed < 0) m_truckSpeed = 0.0f;
    if (ev.key.keysym.sym == SDLK_e && m_truckSpeed > 0) m_truckSpeed = 0.0f;
  }
}

Os eventos de teclado são tratados para teclas pressionadas (linhas 24 a 35) e teclas liberadas (linhas 36 a 51).

Quando uma tecla é pressionada (seta ou QWEASD), a velocidade de dolly, pan ou truck é alterada para +1 ou -1. Quando a tecla é solta, a velocidade correspondente volta para 0.

Vamos agora à definição de OpenGLWindow::initializeOpenGL, que também é bem parecida com a do projeto loadmodel:

void OpenGLWindow::initializeGL() {
  glClearColor(0, 0, 0, 1);

  // Enable depth buffering
  glEnable(GL_DEPTH_TEST);

  // Create program
  m_program = createProgramFromFile(getAssetsPath() + "lookat.vert",
                                    getAssetsPath() + "lookat.frag");

  // Load model
  loadModelFromFile(getAssetsPath() + "bunny.obj");

  // Generate VBO
  glGenBuffers(1, &m_VBO);
  glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(m_vertices[0]) * m_vertices.size(),
               m_vertices.data(), GL_STATIC_DRAW);
  glBindBuffer(GL_ARRAY_BUFFER, 0);

  // Generate EBO
  glGenBuffers(1, &m_EBO);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_EBO);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_indices[0]) * m_indices.size(),
               m_indices.data(), GL_STATIC_DRAW);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

  // Create VAO
  glGenVertexArrays(1, &m_VAO);

  // Bind vertex attributes to current VAO
  glBindVertexArray(m_VAO);

  glBindBuffer(GL_ARRAY_BUFFER, m_VBO);
  GLint positionAttribute{glGetAttribLocation(m_program, "inPosition")};
  glEnableVertexAttribArray(positionAttribute);
  glVertexAttribPointer(positionAttribute, 3, GL_FLOAT, GL_FALSE,
                        sizeof(Vertex), nullptr);
  glBindBuffer(GL_ARRAY_BUFFER, 0);

  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_EBO);

  // End of binding to current VAO
  glBindVertexArray(0);

  resizeGL(getWindowSettings().width, getWindowSettings().height);
}

Só modificamos o nomes dos shaders lidos nas linhas 61 a 62, e incluímos a chamada a OpenGLWindow::resizeGL na linha 99.

O método Camera::computeProjectioMatrix é chamado dentro de OpenGLWindow::resizeGL para reconstruir a matriz de projeção. Ao chamar OpenGLWindow::resizeGL em OpenGLWindow::initializeGL, garantimos que a aplicação começará com uma matriz de projeção válida (os valores da matriz dependem do tamanho atual da janela).

A definição de OpenGLWindow::loadModelFromFile é a mesma do projeto anterior.

Vamos à definição de OpenGLWindow::paintGL:

void OpenGLWindow::paintGL() {
  update();

  // Clear color buffer and depth buffer
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glViewport(0, 0, m_viewportWidth, m_viewportHeight);

  glUseProgram(m_program);
  glBindVertexArray(m_VAO);

  // Get location of uniform variables (could be precomputed)
  GLint viewMatrixLoc{glGetUniformLocation(m_program, "viewMatrix")};
  GLint projMatrixLoc{glGetUniformLocation(m_program, "projMatrix")};
  GLint modelMatrixLoc{glGetUniformLocation(m_program, "modelMatrix")};
  GLint colorLoc{glGetUniformLocation(m_program, "color")};

  // Set uniform variables for viewMatrix and projMatrix
  // These matrices are used for every scene object
  glUniformMatrix4fv(viewMatrixLoc, 1, GL_FALSE, &m_camera.m_viewMatrix[0][0]);
  glUniformMatrix4fv(projMatrixLoc, 1, GL_FALSE, &m_camera.m_projMatrix[0][0]);

  // Draw white bunny
  glm::mat4 model{1.0f};
  model = glm::translate(model, glm::vec3(-1.0f, 0.0f, 0.0f));
  model = glm::rotate(model, glm::radians(90.0f), glm::vec3(0, 1, 0));
  model = glm::scale(model, glm::vec3(0.5f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

  // Draw yellow bunny
  model = glm::mat4(1.0);
  model = glm::translate(model, glm::vec3(0.0f, 0.0f, -1.0f));
  model = glm::scale(model, glm::vec3(0.5f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 1.0f, 0.8f, 0.0f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

  // Draw blue bunny
  model = glm::mat4(1.0);
  model = glm::translate(model, glm::vec3(1.0f, 0.0f, 0.0f));
  model = glm::rotate(model, glm::radians(-90.0f), glm::vec3(0, 1, 0));
  model = glm::scale(model, glm::vec3(0.5f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 0.0f, 0.8f, 1.0f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

  // Draw red bunny
  model = glm::mat4(1.0);
  model = glm::scale(model, glm::vec3(0.1f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 1.0f, 0.25f, 0.25f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

  glBindVertexArray(0);
  glUseProgram(0);
}

O método OpenGLWindow::update é chamado logo do início, na linha 170, para atualizar a posição e orientação da câmera LookAt.

Nas linhas 188 e 189, o conteúdo das matrizes de visão e projeção é enviado às variáveis uniformes no shader:

  // Set uniform variables for viewMatrix and projMatrix
  // These matrices are used for every scene object
  glUniformMatrix4fv(viewMatrixLoc, 1, GL_FALSE, &m_camera.m_viewMatrix[0][0]);
  glUniformMatrix4fv(projMatrixLoc, 1, GL_FALSE, &m_camera.m_projMatrix[0][0]);

Observe o uso da função glUniformMatrix4fv. Essa função tem a assinatura

void glUniformMatrix4fv(GLint location,
                        GLsizei count,
                        GLboolean transpose,
                        const GLfloat *value);

onde

  • location é o identificador de localização da variável uniforme no shader;
  • count é o número de matrizes que queremos transferir à variável uniforme;
  • transpose é um valor booleano que indica se queremos enviar a transposta da matriz;
  • value é o ponteiro para o primeiro elemento do arranjo de elementos da matriz.

A renderização do coelho branco (cinza na 7.32) é configurada nas linhas 191 a 199:

  // Draw white bunny
  glm::mat4 model{1.0f};
  model = glm::translate(model, glm::vec3(-1.0f, 0.0f, 0.0f));
  model = glm::rotate(model, glm::radians(90.0f), glm::vec3(0, 1, 0));
  model = glm::scale(model, glm::vec3(0.5f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

Nas linhas 192 a 195 é criada a concatenação de transformações que formam a matriz de modelo (model). Para o coelho branco, essa concatenação é

\[ \mathbf{M}_{\textrm{model}}=\mathbf{I}.\mathbf{T}(-1,0,0).\mathbf{R}_y\left(\frac{\pi}{2}\right).\mathbf{S}(0.5, 0.5, 0.5). \] Essas transformações servem para posicionar o coelho no mundo. Inicialmente o modelo está na posição e orientação definida no arquivo bunny.obj: na origem, sobre o plano \(y=0\), como vimos na figura 7.17. As transformações são aplicadas da seguinte forma:

  • Transformação de escala para reduzir o tamanho do coelho para \(50\%\) de seu tamanho original (linha 195);
  • Rotação em \(90^{\circ}\) em torno do eixo \(y\) do espaço do objeto, que é o mesmo eixo \(y\) do espaço do mundo (linha 194);
  • Translação pelo vetor \((-1,0,0)\), que posiciona o coelho em sua posição final na cena (linha 193);
  • Transformação identidade (linha 192).

Na linha 197, a matriz de modelo é enviada à variável uniforme m_modelMatrix no vertex shader.

Na linha 198, a variável uniforme color é definida com \((1,1,1,1)\) (cor branca) no vertex shader.

Finalmente, na linha 199 é feita a chamada ao comando de renderização.

Observe como um procedimento semelhante é feito para os outros coelhos. Mudam apenas as transformações que serão usadas para criar a matriz model, e o valor de cor definido na variável uniforme color.

Para o coelho amarelo:

  // Draw yellow bunny
  model = glm::mat4(1.0);
  model = glm::translate(model, glm::vec3(0.0f, 0.0f, -1.0f));
  model = glm::scale(model, glm::vec3(0.5f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 1.0f, 0.8f, 0.0f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

Para o coelho azul:

  // Draw blue bunny
  model = glm::mat4(1.0);
  model = glm::translate(model, glm::vec3(1.0f, 0.0f, 0.0f));
  model = glm::rotate(model, glm::radians(-90.0f), glm::vec3(0, 1, 0));
  model = glm::scale(model, glm::vec3(0.5f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 0.0f, 0.8f, 1.0f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

Para o coelho vermelho:

  // Draw red bunny
  model = glm::mat4(1.0);
  model = glm::scale(model, glm::vec3(0.1f));

  glUniformMatrix4fv(modelMatrixLoc, 1, GL_FALSE, &model[0][0]);
  glUniform4f(colorLoc, 1.0f, 0.25f, 0.25f, 1.0f);
  glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, nullptr);

Note que todos os modelos foram renderizados com o mesmo VAO (linha 178), pois todos os coelhos compartilham o mesmo VBO. É a matriz de modelo que faz com que cada coelho tenha uma transformação diferente no cenário 3D.

A definição de OpenGLWindow::update ficará como a seguir:

void OpenGLWindow::update() {
  float deltaTime{static_cast<float>(getDeltaTime())};

  // Update LookAt camera
  m_camera.dolly(m_dollySpeed * deltaTime);
  m_camera.truck(m_truckSpeed * deltaTime);
  m_camera.pan(m_panSpeed * deltaTime);
}

Aqui, os métodos de movimentação da câmera são chamados usando as variáveis de velocidade que tiveram seus valores determinados em OpenGLWindow::handleEvent de acordo com as teclas pressionadas.

O conteúdo restante de openglwindow.cpp é similar ao utilizado nos projetos anteriores.

Baixe o código completo do projeto a partir deste link.