void ScenePostProcessSimple::renderScene(double delta)
{
m_shadingProg->use();
glClearColor(.5f, .5f, .5f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
m_sceneCam->update();
m_shadingProg->setUniform("Light.lightPos_CAM",
(m_sceneCam->getViewMatrix() * m_light->getWorldTransform()) * m_light->getPosition());
// Render plane
{
m_shadingProg->setUniform("MainTex", 0);
SceneObject* obj = m_sceneObjects[1];
obj->update(delta);
mat4 mvp, mv;
mat3 normal;
mv = m_sceneCam->getViewMatrix() * obj->getWorldTransform();
mvp = m_sceneCam->getMVP(obj->getWorldTransform());
normal = mat3(vec3(mv[0]), vec3(mv[1]), vec3(mv[2]));
m_shadingProg->setUniform("MODELVIEW", mv);
m_shadingProg->setUniform("MVP", mvp);
m_shadingProg->setUniform("NORMAL", normal);
obj->getMesh()->uploadMaterialProperties(m_shadingProg);
obj->render();
}
// Render box
{
m_shadingProg->setUniform("MainTex", 1);
SceneObject* obj = m_sceneObjects[0];
obj->rotate(25 * delta, vec3(0, 1, 0));
obj->update(delta);
mat4 mvp, mv;
mat3 normal;
mv = m_sceneCam->getViewMatrix() * obj->getWorldTransform();
mvp = m_sceneCam->getMVP(obj->getWorldTransform());
normal = mat3(vec3(mv[0]), vec3(mv[1]), vec3(mv[2]));
m_shadingProg->setUniform("MODELVIEW", mv);
m_shadingProg->setUniform("MVP", mvp);
m_shadingProg->setUniform("NORMAL", normal);
obj->getMesh()->uploadMaterialProperties(m_shadingProg);
obj->render();
}
}
void SceneNormalMapping::update(double delta)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_program->use();
m_sceneCam->update();
//m_sceneLight->rotate(200 * delta, vec3(.5, 1, -1));
m_program->setUniform("Light.lightPos_CAM",
(m_sceneCam->getViewMatrix() * m_sceneLight->getWorldTransform()) * m_sceneLight->getPosition());
{
SceneObject* obj = m_sceneObjects.at(0);
//obj->rotate(75 * delta, vec3(.75, .5, -1));
//obj->rotate(75 * delta, vec3(0, 1, 0));
obj->update(delta);
mat4 mvp, mv;
mat3 normal;
mv = m_sceneCam->getViewMatrix() * obj->getWorldTransform();
mvp = m_sceneCam->getMVP(obj->getWorldTransform());
normal = mat3(vec3(mv[0]), vec3(mv[1]), vec3(mv[2]));
m_program->setUniform("MODELVIEW", mv);
m_program->setUniform("MVP", mvp);
m_program->setUniform("NORMAL", normal);
obj->getMesh()->uploadMaterialProperties(m_program);
obj->render();
}
}
// THE PROBLEM PROBABLY COMES FROM HERE
void VertexShader( const vec3& v, Pixel& p ){
//It should take the 3D position of a vertex v and compute its 2D image position and store it in the given 2D
//integer vector p. glm::ivec2 is a data type for 2D integer vectors, i.e. a pixel position will be represented by two
//integers.
cout << "in function VertexShader _ 1\n";
vec3 newV = v-cameraPos;
float cosYaw = cos(yaw);
float sinYaw = sin(yaw);
vec3 firstColumn = vec3(cosYaw, 0.0, -sinYaw);
vec3 secondColumn = vec3(0.0, 1.0, 0.0);
vec3 thirdColumn = vec3(sinYaw, 0.0, cosYaw);
R = mat3(firstColumn,secondColumn,thirdColumn);
// WE CHANGED d IN ORDER TO DO A ROTATION
newV=R*newV;
//cout << "newV:("<<newV.x<<","<<newV.y<<","<<newV.z<<")\n";
p.x = focal_length * (newV.x/newV.z) + SCREEN_WIDTH/2.f;
p.y = focal_length * (newV.y/newV.z) +SCREEN_HEIGHT/2.f;
// PROBLEM: DOUBT ABOUT THIS PART
p.zinv = 1/newV.z;
/*
if (p.zinv>depthBuffer[p.x][p.y])
depthBuffer[p.x][p.y]=p.zinv;
*/
//cout <<"pixel p:("<<p.x<<","<<p.y<<","<<p.zinv<<")\n";
//cout <<"depthBuffer["<<p.x<<","<<p.y<<"]: "<<depthBuffer[p.x][p.y]<<"\n";
}
void GLFrame::rotate_local_z(float angle)
{
mat4 rot_mat4;
mat3 rot_mat;
// Only the up vector needs to be rotated
rot_mat = mat3(glm::rotate(rot_mat4, angle, forward));
up = rot_mat * up;
}
// Rotate in world coordinates...
//Rotates in place around a vector in world coordinates
//Does NOT rotate the frame itself around the world origin (ie the pos of the frame doesn't change)
void GLFrame::rotate_world(float angle, float x, float y, float z)
{
mat4 rot_mat4;
mat3 rot_mat;
// Create the Rotation matrix
rot_mat = mat3(glm::rotate(rot_mat4, angle, vec3(x,y,z)));
//transform up and forward axis
up = rot_mat * up;
forward = rot_mat * forward;
}
void GLFrame::rotate_local_y(float angle)
{
mat4 rot_mat4;
mat3 rot_mat;
// Just Rotate around the up vector
// Create a rotation matrix around my Up (Y) vector
rot_mat = mat3(glm::rotate(rot_mat4, angle, up));
// Rotate forward pointing vector
forward = rot_mat * forward;
}
void GuiMeshRender::ProcessEntities(const EntityMap &entities) {
if (entities.empty()) {
//printf("Warning: GuiMeshRender: Entity list is empty\n");
return;
}
EntityMap::const_iterator it, ite;
GuiMeshPtr mesh;
TransformPtr transform;
mat4 model, view, projection, model_view, mvp;
mat3 normal;
// warning: make sure the values here are all floats
projection = glm::ortho(0.0f, 800.0f, 600.0f, 0.0f, -1.0f, 1.0f);
for (it = entities.begin(), ite = entities.end(); it != ite; ++it) {
mesh = gui_mesh_mapper_(it->second);
transform = transform_mapper_(it->second);
model = transform->world();
model_view = model; // camera does not need to effect this
mvp = projection * model_view;
normal = inverse(transpose(mat3(model_view)));
shared_ptr<BasicMaterial> material = boost::dynamic_pointer_cast<BasicMaterial>(mesh->material);
vec4 light_pos = material->light_position_;
// hack to have light move with world
// todo: implement light as entity
material->light_position_ = model_view * light_pos;
// do things like setup colors and lights
// and attach shader program
mesh->material->PreRender();
material->light_position_ = light_pos;
// push matrices up
mesh->material->PushMatrices(model_view, projection, mvp, normal);
// call draw
mesh->geometry->Draw();
// let go of shader program
mesh->material->PostRender();
}
}
void GLFrame::rotate_local_x(float angle)
{
mat3 rot_mat;
mat4 rot_mat4;
vec3 local_x;
//get local x axis
local_x = glm::cross(up, forward);
rot_mat = mat3(glm::rotate(rot_mat4, angle, local_x));
//have to rotate both up and forward vectors
up = rot_mat * up;
forward = rot_mat * forward;
}
// Convert Coordinate Systems
// This is pretty much, do the transformation represented by the rotation
// and position on the point
// Is it better to stick to the convention that the destination always comes
// first, or use the conventions that "sounds" like the function...
vec3 GLFrame::local_to_world(const vec3 local, bool rot_only)
{
vec3 world;
// Create the rotation matrix based on the vectors
mat3 rot_mat = mat3(get_matrix(true));
// Do the rotation
world = rot_mat * local;
// Translate the point
if(!rot_only)
world += origin;
return world;
}
void LegacyMathTest::setUp() {
using glm::quat;
using glm::mat3;
// Data from:
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/eulerToQuaternion/steps/index.htm
// http://www.euclideanspace.com/maths/algebra/matrix/transforms/examples/index.htm
// Identity (no rotation)
addTestData(quat( 1.f, 0.0f, 0.0f, 0.0f), Anglef( 0, 0, 0), mat3( 1, 0, 0, 0, 1, 0, 0, 0, 1));
// 90 degrees about y axis
addTestData(quat(0.7071f, 0.0f, 0.7071f, 0.0f), Anglef( 90, 0, 0), mat3( 0, 0, 1, 0, 1, 0, -1, 0, 0));
// 180 degrees about y axis
addTestData(quat( 0.0f, 0.0f, 1.f, 0.0f), Anglef(180, 0, 0), mat3(-1, 0, 0, 0, 1, 0, 0, 0,-1));
// 270 degrees about y axis
addTestData(quat(0.7071f, 0.0f,-0.7071f, 0.0f), Anglef(-90, 0, 0), mat3( 0, 0,-1, 0, 1, 0, 1, 0, 0));
addTestData(quat(0.7071f, 0.0f, 0.0f, 0.7071f), Anglef( 0, 90, 0), mat3( 0,-1, 0, 1, 0, 0, 0, 0, 1));
addTestData(quat( 0.5f, 0.5f, 0.5f, 0.5f), Anglef( 90, 90, 0), mat3( 0, 0, 1, 1, 0, 0, 0, 1, 0));
addTestData(quat( 0.0f, 0.7071f, 0.7071f, 0.0f), Anglef(180, 90, 0), mat3( 0, 1, 0, 1, 0, 0, 0, 0,-1));
addTestData(quat( 0.5f, -0.5f, -0.5f, 0.5f), Anglef(-90, 90, 0), mat3( 0, 0,-1, 1, 0, 0, 0,-1, 0));
addTestData(quat(0.7071f, 0.0f, 0.0f,-0.7071f), Anglef( 0,-90, 0), mat3( 0, 1, 0, -1, 0, 0, 0, 0, 1));
addTestData(quat( 0.5f, -0.5f, 0.5f, -0.5f), Anglef( 90,-90, 0), mat3( 0, 0, 1, -1, 0, 0, 0,-1, 0));
addTestData(quat( 0.0f,-0.7071f, 0.7071f, 0.0f), Anglef(180,-90, 0), mat3( 0,-1, 0, -1, 0, 0, 0, 0,-1));
addTestData(quat( 0.5f, 0.5f, -0.5f, -0.5f), Anglef(-90,-90, 0), mat3( 0, 0,-1, -1, 0, 0, 0, 1, 0));
addTestData(quat(0.7071f, 0.7071f, 0.0f, 0.0f), Anglef( 0, 0, 90), mat3( 1, 0, 0, 0, 0,-1, 0, 1, 0));
addTestData(quat( 0.5f, 0.5f, 0.5f, -0.5f), Anglef( 90, 0, 90), mat3( 0, 1, 0, 0, 0,-1, -1, 0, 0));
addTestData(quat( 0.0f, 0.0f, 0.7071f,-0.7071f), Anglef(180, 0, 90), mat3(-1, 0, 0, 0, 0,-1, 0,-1, 0));
addTestData(quat( 0.5f, 0.5f, -0.5f, 0.5f), Anglef(-90, 0, 90), mat3( 0,-1, 0, 0, 0,-1, 1, 0, 0));
addTestData(quat( 0.0f, 1.0f, 0.0f, 0.0f), Anglef( 0, 0,180), mat3( 1, 0, 0, 0,-1, 0, 0, 0,-1));
addTestData(quat( 0.0f, 0.7071f, 0.0f,-0.7071f), Anglef( 90, 0,180), mat3( 0, 0,-1, 0,-1, 0, -1, 0, 0));
addTestData(quat( 0.0f, 0.0f, 0.0f, 1.0f), Anglef(180, 0,180), mat3(-1, 0, 0, 0,-1, 0, 0, 0, 1));
addTestData(quat( 0.0f, 0.7071f, 0.0f, 0.7071f), Anglef(-90, 0,180), mat3( 0, 0, 1, 0,-1, 0, 1, 0, 0));
addTestData(quat(0.7071f,-0.7071f, 0.0f, 0.0f), Anglef( 0, 0,-90), mat3( 1, 0, 0, 0, 0, 1, 0,-1, 0));
addTestData(quat( 0.5f, -0.5f, 0.5f, 0.5f), Anglef( 90, 0,-90), mat3( 0,-1, 0, 0, 0, 1, -1, 0, 0));
addTestData(quat( 0.0f, 0.0f, 0.7071f, 0.7071f), Anglef(180, 0,-90), mat3(-1, 0, 0, 0, 0, 1, 0, 1, 0));
addTestData(quat( 0.5f, -0.5f, -0.5f, -0.5f), Anglef(-90, 0,-90), mat3( 0, 1, 0, 0, 0, 1, 1, 0, 0));
}
int main(int argc, char** argv)
{
setup_context();
polygon_mode = 2;
vector<vec3> line_verts;
for (int i=0, j=-FLOOR_SIZE/2; i < 11; ++i, j+=FLOOR_SIZE/10) {
line_verts.push_back(vec3(j, -1, -FLOOR_SIZE/2));
line_verts.push_back(vec3(j, -1, FLOOR_SIZE/2));
line_verts.push_back(vec3(-FLOOR_SIZE/2, -1, j));
line_verts.push_back(vec3(FLOOR_SIZE/2, -1, j));
}
GLuint line_vao, line_buf;
glGenVertexArrays(1, &line_vao);
glBindVertexArray(line_vao);
glGenBuffers(1, &line_buf);
glBindBuffer(GL_ARRAY_BUFFER, line_buf);
glBufferData(GL_ARRAY_BUFFER, line_verts.size()*3*sizeof(float), &line_verts[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
Mesh torus;
Mesh sphere;
generate_torus(torus.verts, torus.tris, torus.texcoords, 0.3, 0.1, 40, 20);
generate_sphere(sphere.verts, sphere.tris, sphere.texcoords, 0.1, 26, 13);
compute_normals(torus.verts, torus.tris, NULL, DEG_TO_RAD(30), torus.normals);
compute_normals(sphere.verts, sphere.tris, NULL, DEG_TO_RAD(30), sphere.normals);
vector<vert_attribs> vert_data;
int v;
for (int i=0, j=0; i<torus.tris.size(); ++i, j+=3) {
v = torus.tris[i].x;
vert_data.push_back(vert_attribs(torus.verts[v], torus.normals[j]));
v = torus.tris[i].y;
vert_data.push_back(vert_attribs(torus.verts[v], torus.normals[j+1]));
v = torus.tris[i].z;
vert_data.push_back(vert_attribs(torus.verts[v], torus.normals[j+2]));
}
for (int i=0, j=0; i<sphere.tris.size(); ++i, j+=3) {
v = sphere.tris[i].x;
vert_data.push_back(vert_attribs(sphere.verts[v], sphere.normals[j]));
v = sphere.tris[i].y;
vert_data.push_back(vert_attribs(sphere.verts[v], sphere.normals[j+1]));
v = sphere.tris[i].z;
vert_data.push_back(vert_attribs(sphere.verts[v], sphere.normals[j+2]));
}
#define NUM_SPHERES 50
vector<vec3> instance_pos;
vec2 rand_pos;
for (int i=0; i<NUM_SPHERES+1; ++i) {
rand_pos = glm::diskRand(FLOOR_SIZE/2.0f);
if (i)
instance_pos.push_back(vec3(rand_pos.x, 0.4, rand_pos.y));
else
instance_pos.push_back(vec3());
}
GLuint vao, buffer;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
size_t total_size = (torus.tris.size()*3 + sphere.tris.size()*3) * sizeof(vert_attribs);
size_t sphere_offset = torus.tris.size()*3;
glBufferData(GL_ARRAY_BUFFER, total_size, &vert_data[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(vert_attribs), 0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vert_attribs), (void*)sizeof(vec3));
GLuint inst_buf;
glGenBuffers(1, &inst_buf);
glBindBuffer(GL_ARRAY_BUFFER, inst_buf);
glBufferData(GL_ARRAY_BUFFER, instance_pos.size()*3*sizeof(float), &instance_pos[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribDivisor(3, 1);
GLuint basic_shader = load_shader_file_pair("../media/shaders/basic_transform.vp", "../media/shaders/uniform_color.fp");
GLuint gouraud_shader = load_shader_file_pair("../media/shaders/gouraud_ads.vp", "../media/shaders/gouraud_ads.fp");
GLuint phong_shader = load_shader_file_pair("../media/shaders/phong_ads.vp", "../media/shaders/phong_ads.fp");
mat4 proj_mat = glm::perspective(DEG_TO_RAD(35.0f), WIDTH/(float)HEIGHT, 0.3f, 100.0f);
mat4 view_mat;
mat4 mvp_mat;
mat3 normal_mat;
mat4 translate_sphere = glm::translate(mat4(1), vec3(0.8f, 0.4f, 0.0f));
vec4 floor_color(0, 1, 0, 1);
vec3 torus_ambient(0.0, 0, 0);
vec3 torus_diffuse(1.0, 0, 0);
vec3 torus_specular(0, 0, 0);
vec3 sphere_ambient(0, 0, 0.2);
vec3 sphere_diffuse(0, 0, 0.7);
vec3 sphere_specular(1, 1, 1);
glUseProgram(basic_shader);
set_uniform4fv(basic_shader, "color", glm::value_ptr(floor_color));
glUseProgram(gouraud_shader);
glUseProgram(phong_shader);
set_uniform1f(phong_shader, "shininess", 128.0f);
vec3 light_direction(0, 10, 5);
glUseProgram(basic_shader);
GLFrame camera(true);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
SDL_SetRelativeMouseMode(SDL_TRUE);
unsigned int old_time = 0, new_time=0, counter = 0, last_time = SDL_GetTicks();
float total_time;
while (1) {
new_time = SDL_GetTicks();
if (handle_events(camera, last_time, new_time))
break;
last_time = new_time;
total_time = new_time/1000.0f;
if (new_time - old_time > 3000) {
printf("%f FPS\n", counter*1000.f/(new_time-old_time));
old_time = new_time;
counter = 0;
}
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
view_mat = camera.get_camera_matrix();
mvp_mat = proj_mat * view_mat;
glUseProgram(basic_shader);
set_uniform_mat4f(basic_shader, "mvp_mat", glm::value_ptr(mvp_mat));
glBindVertexArray(line_vao);
glDrawArrays(GL_LINES, 0, line_verts.size());
glBindVertexArray(vao);
glUseProgram(phong_shader);
vec3 light_dir = mat3(view_mat)*light_direction;
set_uniform3fv(phong_shader, "light_direction", glm::value_ptr(light_dir));
set_uniform_mat4f(phong_shader, "mvp_mat", glm::value_ptr(mvp_mat));
normal_mat = mat3(view_mat);
set_uniform_mat3f(phong_shader, "normal_mat", glm::value_ptr(normal_mat));
set_uniform3fv(phong_shader, "ambient_color", glm::value_ptr(sphere_ambient));
set_uniform3fv(phong_shader, "diffuse_color", glm::value_ptr(sphere_diffuse));
set_uniform3fv(phong_shader, "spec_color", glm::value_ptr(sphere_specular));
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, torus.tris.size()*3, sphere.tris.size()*3, NUM_SPHERES, 1);
mat4 rot_mat = glm::rotate(mat4(1), -1*total_time*DEG_TO_RAD(60.0f), vec3(0, 1, 0));
mvp_mat = mvp_mat * rot_mat * translate_sphere;
normal_mat = mat3(view_mat*rot_mat);
set_uniform_mat3f(phong_shader, "normal_mat", glm::value_ptr(normal_mat));
set_uniform_mat4f(phong_shader, "mvp_mat", glm::value_ptr(mvp_mat));
glDrawArrays(GL_TRIANGLES, torus.tris.size()*3, sphere.tris.size()*3);
//draw rotating torus
mvp_mat = proj_mat * view_mat;
rot_mat = glm::rotate(mat4(1), total_time*DEG_TO_RAD(60.0f), vec3(0, 1, 0));
mvp_mat = mvp_mat * rot_mat;
set_uniform_mat4f(phong_shader, "mvp_mat", glm::value_ptr(mvp_mat));
normal_mat = mat3(view_mat*rot_mat);
set_uniform_mat3f(phong_shader, "normal_mat", glm::value_ptr(normal_mat));
set_uniform3fv(phong_shader, "ambient_color", glm::value_ptr(torus_ambient));
set_uniform3fv(phong_shader, "diffuse_color", glm::value_ptr(torus_diffuse));
set_uniform3fv(phong_shader, "spec_color", glm::value_ptr(torus_specular));
glDrawArrays(GL_TRIANGLES, 0, torus.tris.size()*3);
SDL_GL_SwapWindow(window);
last_time = new_time;
++counter;
}
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &buffer);
glDeleteProgram(basic_shader);
cleanup();
return 0;
}
const int SCREEN_HEIGHT = 500; SDL_Surface* screen; /* Depth buffer*/ float depthBuffer[SCREEN_HEIGHT][SCREEN_WIDTH]; /* Camera */ vec3 cameraPos(0, 0, -3.001); float focalLength = SCREEN_WIDTH; // Rotation angle controlling camera rotation around y-axis float yaw = 0; // Rotation constant - Angle update on the y axis for a rotation float ROTATION = 0.1; float TRANSLATION = 0.5; // Rotation matrix mat3 R = mat3(0, 0, 0, 0, 0, 0, 0, 0, 0); /* Light */ vec3 lightPos(0, -0.5, -0.7); vec3 lightPower = 14.f*vec3(1, 1, 1); vec3 indirectLightPowerPerArea = 0.5f*vec3(1, 1, 1); vec3 currentNormal; vec3 currentReflectance; // ---------------------------------------------------------------------------- // FUNCTIONS void PixelShader(Pixel& p); void DrawPolygon(const vector<Vertex>& vertices); void DrawPolygonRows(const vector<Pixel>& leftPixels, const vector<Pixel>& rightPixels);
void Update()
{
// Compute frame time:
int t2 = SDL_GetTicks();
float dt = float(t2 - t);
t = t2;
cout << "Render time: " << dt << " ms." << endl;
Uint8* keystate = SDL_GetKeyState(0);
if (keystate[SDLK_w]){
lightPos += forwardDir;
}
if (keystate[SDLK_s]){
lightPos -= forwardDir;
}
if (keystate[SDLK_a]){
lightPos -= rightDir;
}
if (keystate[SDLK_d]){
lightPos += rightDir;
}
if (keystate[SDLK_q]){
lightPos -= downDir;
}
if (keystate[SDLK_e]){
lightPos += downDir;
}
if (keystate[SDLK_UP])
{
// Move camera forward
cameraPos += forwardDir;
}
if (keystate[SDLK_DOWN])
{
// Move camera backward
cameraPos -= forwardDir;
}
if (keystate[SDLK_LEFT])
{
/* // Move camera to the left
cameraPos.x--;
*/
// Rotate camera anti-clockwise around y-axis
yaw += dyaw;
cout << yaw;
vec3 col1(cosf(yaw), 0, -sinf(yaw));
vec3 col3(sinf(yaw), 0, cosf(yaw));
R = mat3(col1, vec3(0, 1, 0), col3);
vec3 rightDir(R[0][0], R[0][1], R[0][2]);
vec3 downDir(R[1][0], R[1][1], R[1][2]);
vec3 forwardDir(R[2][0], R[2][1], R[2][2]);
}
if (keystate[SDLK_RIGHT])
{
/*
// Move camera to the right
cameraPos.x++;
*/
// Rotate camera clockwise around y-axis
yaw -= dyaw;
vec3 col1(cosf(yaw), 0, -sinf(yaw));
vec3 col3(sinf(yaw), 0, cosf(yaw));
R = mat3(col1, vec3(0, 1, 0), col3);
vec3 rightDir(R[0][0], R[0][1], R[0][2]);
vec3 downDir(R[1][0], R[1][1], R[1][2]);
vec3 forwardDir(R[2][0], R[2][1], R[2][2]);
}
}
