path: root/source/main.cpp

#include <stdio.h>
#include <SDL2/SDL.h>
#include <glad/glad.h>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <vector>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

/* @lookup:
*  - I do not understand how floating point numbers work, so I should probably look into that.
*	 - The normal matrix calculation in the fragment shader for the object affected by light has been mainly copied.
*		 I have tried to understand the formula, and whilst it made some sense, it is not fully clear to me, and I cannot picture it yet.
*		 Revisit the derivation for the normal matrix some time in the future.
*  - Lookup the derivation of the formula for reflecting a vector about a normal. I am doing that for specular lighting, but the learnopengl tutorial
*		 just uses a glsl reflect formula, and at the time of writing it is also very late so I am not in the mood or position to look into it at present.
*  - One of the things I have observed with specular lights is that the circle/specular highlight follows the camera (me) when I move. I would like to figure
*		 out a way by which this does not happen and it remains fixed on the object, at the angle at which it hits. All of this will be made complicated by the fact
*		 that ofcourse everything is actually happening from the cameras' perspective. I would still love to figure this out.
*/

typedef uint8_t   u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef int8_t    s8;
typedef int16_t  s16;
typedef int32_t  s32;
typedef int64_t  s64;

typedef float    r32;
typedef double   r64;

typedef u8        b8;

#include "math.h"

// =========== Shader Loading =============

unsigned int gl_create_vertex_shader(char* vertex_shader_source)
{
	unsigned int vertex_shader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertex_shader, 1, &vertex_shader_source, NULL);
	glCompileShader(vertex_shader);
    
	int success;
	char info_log[512];
	glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		glGetShaderInfoLog(vertex_shader, 512, NULL, info_log);
		printf("================================\n");
		printf("vertex shader compilation failed:\n%s\n", info_log);
	}
    
	return vertex_shader;
}

unsigned int gl_create_fragment_shader(char* fragment_shader_source)
{
	unsigned int fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
	glCompileShader(fragment_shader);
    
	int success;
	char info_log[512];
	glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		glGetShaderInfoLog(fragment_shader, 512, NULL, info_log);
		printf("================================\n");
		printf("fragment shader compilation failed:\n%s\n", info_log);
	}
    
	return fragment_shader;
}

unsigned int gl_create_shader_program(unsigned int vertex_shader, unsigned int fragment_shader)
{
	unsigned int shader_program = glCreateProgram();
    
	glAttachShader(shader_program, vertex_shader);
	glAttachShader(shader_program, fragment_shader);
	glLinkProgram(shader_program);
    
	int success;
	char info_log[512];
	glGetProgramiv(shader_program, GL_LINK_STATUS, &success);
	if (!success)
	{
		glGetProgramInfoLog(shader_program, 512, NULL, info_log);
		printf("================================\n");
		printf("shader program linking failed:\n%s\n", info_log);
	}
    
	glDeleteShader(vertex_shader);
	glDeleteShader(fragment_shader);
    
	return shader_program;
}

unsigned int gl_shader_program(char* vertex_shader_source, char* fragment_shader_source)
{
  unsigned int vertex_shader = gl_create_vertex_shader(vertex_shader_source);
  unsigned int fragment_shader = gl_create_fragment_shader(fragment_shader_source);
  unsigned int shader_program = gl_create_shader_program(vertex_shader, fragment_shader);

  return shader_program;
}

Mat4 camera_create4m(Vec3 camera_pos, Vec3 camera_look, Vec3 camera_up)
{
	// @note: We do this because this allows the camera to have the axis it looks at
	// inwards be the +z axis.
	// If we did not do this, then the inward axis the camera looks at would be negative. 
	// I am still learning from learnopengl.com but I imagine that this was done for conveniences' sake.
	Vec3 camera_forward_dir = normalize3v(subtract3v(camera_pos, camera_look));
	Vec3 camera_right_dir   = normalize3v(cross_multiply3v(camera_up, camera_forward_dir));
	Vec3 camera_up_dir      = normalize3v(cross_multiply3v(camera_forward_dir, camera_right_dir));
    
	Mat4 res = lookat4m(camera_up_dir, camera_forward_dir, camera_right_dir, camera_pos);
    
	return res;
}

Vec3 camera_look_around(r32 angle_pitch, r32 angle_yaw)
{
    Vec3 camera_look = {0.0};
    camera_look.x = cosf(angle_yaw) * cosf(angle_pitch);
    camera_look.y = sinf(angle_pitch);
    camera_look.z = sinf(angle_yaw) * cosf(angle_pitch);
    camera_look = normalize3v(camera_look);
    
    return camera_look;
}

s32 gl_load_texture(u32 texture_id, const char* path)
{
  s32 width, height, nrChannels;
  unsigned char *data = stbi_load(path, &width, &height, &nrChannels, 0);
  if (data)
  {
    GLenum format;
    if (nrChannels == 1)
      format = GL_RED;
    else if (nrChannels == 3)
      format = GL_RGB;
    else if (nrChannels == 4)
      format = GL_RGBA;

    glBindTexture(GL_TEXTURE_2D, texture_id);
    glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
    glGenerateMipmap(GL_TEXTURE_2D);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    stbi_image_free(data);
  }
  else
  {
    printf("failed to load image texture at path: %s", path);
    stbi_image_free(data);
  }

  return texture_id;
}

// =================== Model Loading ========================
// This section contains a whole host of things:
// 1. classes
// 2. std::vectors
// 3. std::strings
// that I have only used as a glue for I did not know if I had the model loading setup properly.
// @todo: replace these things eventually. For now the goal is to complete learnopengl

s32 TextureFromFile(const char* filepath, std::string directory)
{
  std::string filename = std::string(filepath);
  filename = directory + '/' + filename;

  u32 texid;
  glGenTextures(1, &texid);

  s32 width, height, nrChannels;
  unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrChannels, 0);
  if (data)
  {
    GLenum format;
    if (nrChannels == 1)
      format = GL_RED;
    else if (nrChannels == 3)
      format = GL_RGB;
    else if (nrChannels == 4)
      format = GL_RGBA;

    glBindTexture(GL_TEXTURE_2D, texid);
    glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
    glGenerateMipmap(GL_TEXTURE_2D);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    stbi_image_free(data);
  }
  else
  {
    printf("failed to load image texture at path: %s", filepath);
    stbi_image_free(data);
  }

  return texid;
}

enum TextureType { TextureDiffuse=0, TextureSpecular };

struct Vertex {
  Vec3 position;
  Vec3 normal;
  Vec2 texture;
};

struct Texture {
  u32 id;
  enum TextureType type;
  std::string fname;
};

class Mesh {
  public:
  std::vector<Vertex>  vertices;
  std::vector<u32> indices;
  std::vector<Texture> textures;

  u32 vao;
  u32 vbo;
  u32 ebo;

  Mesh(std::vector<Vertex> vertices, std::vector<u32> indices, std::vector<Texture> textures)
  {
    this->vertices = vertices;
    this->indices = indices;
    this->textures = textures;

    // setup mesh shader stuff
    glGenVertexArrays(1, &vao);
    glGenBuffers(1, &vbo);
    glGenBuffers(1, &ebo);

    glBindVertexArray(vao);

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(struct Vertex), &(this->vertices[0]), GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->indices.size() * sizeof(u32), &(this->indices[0]), GL_STATIC_DRAW);

    // position
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
    // normal
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, normal));
    // texture
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texture));

    glBindVertexArray(0);
  }

  void draw(u32 shader_program)
  {
    glUseProgram(shader_program);

    u32 diffuse_num = 1;
    u32 specular_num = 1;
    char tex_unit_name[64];
    // set shininess
    s32 mat_shine_loc = glGetUniformLocation(shader_program, "material.shininess");
    glUniform1f(mat_shine_loc, 32.0f);

    for (u32 i=0; i<textures.size(); i++)
    {
      struct Texture curr_tex = textures[i];
      if (curr_tex.type == TextureDiffuse)
      {
        sprintf(tex_unit_name, "material.diffuse[%i]", diffuse_num);
      }
      else if (curr_tex.type == TextureSpecular)
      {
        sprintf(tex_unit_name, "material.diffuse[%i]", specular_num);
      }

      glActiveTexture(GL_TEXTURE0 + i);
      s32 tex_unit_loc = glGetUniformLocation(shader_program, tex_unit_name);
      glUniform1i(tex_unit_loc, i);
      glBindTexture(GL_TEXTURE_2D, curr_tex.id);
    }
    glActiveTexture(GL_TEXTURE0);

    glBindVertexArray(vao);
    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
  }
};

class Model
{
  public:
    Model(std::string path)
    {
      load_model(path);
    }
    void draw(u32 shader_program);
  private:
    std::vector<Texture> loaded_textures;
    std::vector<Mesh> meshes;
    std::string directory;

    void load_model(std::string path);
    void process_node(aiNode *node, const aiScene *scene);
    Mesh process_mesh(aiMesh *mesh, const aiScene *scene);
    std::vector<Texture> load_material_textures(aiMaterial *mat, aiTextureType type, TextureType type_name);
};

void Model::draw(u32 shader_program)
{
  for (int i=0; i < meshes.size(); i++)
  {
    meshes[i].draw(shader_program);
  }
}

void Model::load_model(std::string path)
{
  Assimp::Importer import;
  const aiScene *scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs);

  if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)
  {
    printf("error loading model :%s\n", import.GetErrorString());
    return;
  }

  directory = path.substr(0, path.find_last_of('/'));
  process_node(scene->mRootNode, scene);
}

void Model::process_node(aiNode *node, const aiScene *scene)
{
  for (int i=0; i < node->mNumMeshes; i++)
  {
    aiMesh *mesh = scene->mMeshes[node->mMeshes[i]];
    meshes.push_back(process_mesh(mesh, scene));
  }

  for (int i=0; i<node->mNumChildren; i++)
  {
    process_node(node->mChildren[i], scene);
  }
}

Mesh Model::process_mesh(aiMesh *mesh, const aiScene *scene)
{
  std::vector<Vertex> vertices;
  std::vector<u32> indices;
  std::vector<Texture> textures;

  for (u32 i=0; i < mesh->mNumVertices; i++)
  {
    Vec3 position;
    position.x = mesh->mVertices[i].x;
    position.y = mesh->mVertices[i].y;
    position.z = mesh->mVertices[i].z;

    Vec3 normal;
    normal.x = mesh->mNormals[i].x;
    normal.y = mesh->mNormals[i].y;
    normal.z = mesh->mNormals[i].z;

    Vec2 texture = {0, 0};
    if (mesh->mTextureCoords[0])
    {
      texture.x = mesh->mTextureCoords[0][i].x;
      texture.y = mesh->mTextureCoords[0][i].y;
    }

    struct Vertex vertex;
    vertex.position = position;
    vertex.normal = normal;
    vertex.texture = texture;

    vertices.push_back(vertex);
  }
  // process indices
  for (u32 i = 0; i < mesh->mNumFaces; i++)
  {
    aiFace face = mesh->mFaces[i];
    for(u32 j = 0; j < face.mNumIndices; j++)
    {
      indices.push_back(face.mIndices[j]);
    }
  }
  // process material
  if (mesh->mMaterialIndex >= 0)
  {
    aiMaterial *material = scene->mMaterials[mesh->mMaterialIndex];
    std::vector<Texture> diffuse_maps = load_material_textures(material, aiTextureType_DIFFUSE, TextureDiffuse);
    textures.insert(textures.end(), diffuse_maps.begin(), diffuse_maps.end());
    std::vector<Texture> specular_maps = load_material_textures(material, aiTextureType_SPECULAR, TextureSpecular);
    textures.insert(textures.end(), specular_maps.begin(), specular_maps.end());
  }

  return Mesh(vertices, indices, textures);
}

std::vector<Texture> Model::load_material_textures(aiMaterial *mat, aiTextureType type, TextureType tex_type)
{
  std::vector<Texture> textures;
  for(u32 i=0; i<mat->GetTextureCount(type); i++)
  {
    bool load_texture = true;
    aiString str;
    mat->GetTexture(type, i, &str);
    const char* fname = str.C_Str();

    for (s32 j=0; j<loaded_textures.size();  j++)
    {
      if (std::strcmp(loaded_textures[j].fname.data(), fname) == 0)
      {
        load_texture = false;
        textures.push_back(loaded_textures[j]);
        break;
      }
    }
    if (load_texture)
    {
      Texture texture;
      texture.id = TextureFromFile(fname, directory);
      texture.type = tex_type;
      texture.fname = std::string(fname);
      textures.push_back(texture);
      loaded_textures.push_back(texture);
    }
  }

  return textures;
}

int main(int argc, char* argv[])
{

  // ============ END ============
	int width = 1024;
	int height = 768;
    
	if (SDL_Init(SDL_INIT_VIDEO) != 0)
	{
		printf("Error initialising SDL2: %s\n", SDL_GetError());
		return 0;
	};
    
	// set opengl version and profile
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
  SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 8 );
    
	// initialise window with opengl flag
	SDL_Window* window = SDL_CreateWindow("SDL Test",
                                          50,
                                          50,
                                          width,
                                          height,
                                          SDL_WINDOW_OPENGL);
    
    SDL_SetRelativeMouseMode(SDL_TRUE);
   
	// create an opengl context
	SDL_GLContext context = SDL_GL_CreateContext(window);
	if (!context)
	{
		printf("OpenGL context creation failed: %s\n", SDL_GetError());
		return -1;
	}
    
    
	// load glad
	if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) {
		printf("Failed to initialize Glad\n");
		return 1;
	}
    
  // filesystem playground stuff
  size_t read_count;
  char* vertex_source = (char*)SDL_LoadFile("./source/shaders/depth_test.vs.glsl", &read_count);
  char* fragment_source = (char*)SDL_LoadFile("./source/shaders/depth_test.fs.glsl", &read_count);
  char* outline_shader_source = (char*)SDL_LoadFile("./source/shaders/stencil_outline.fs.glsl", &read_count);
    
  u32 shader_program = gl_shader_program(vertex_source, fragment_source);
	u32 outline_shader_program = gl_shader_program(vertex_source, outline_shader_source);

	printf("Successfully compiled shaders.\n");
    
  float cubeVertices[] = {
				// positions          // texture Coords
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
         0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
         0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
         0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
         0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
        -0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
        -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
    };
    float planeVertices[] = {
        // positions          // texture Coords (note we set these higher than 1 (together with GL_REPEAT as texture wrapping mode). this will cause the floor texture to repeat)
         5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
        -5.0f, -0.5f,  5.0f,  0.0f, 0.0f,
        -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,

         5.0f, -0.5f,  5.0f,  2.0f, 0.0f,
        -5.0f, -0.5f, -5.0f,  0.0f, 2.0f,
         5.0f, -0.5f, -5.0f,  2.0f, 2.0f								
    };

  stbi_set_flip_vertically_on_load(1);
  
	u32 cube_vao, cube_vbo, plane_vao, plane_vbo;
	
	glGenVertexArrays(1, &cube_vao);
	glGenBuffers(1, &cube_vbo);

	glBindVertexArray(cube_vao);
  glBindBuffer(GL_ARRAY_BUFFER, cube_vbo);
  glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
  glEnableVertexAttribArray(1);
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
  glBindVertexArray(0);

	glGenVertexArrays(1, &plane_vao);
	glGenBuffers(1, &plane_vbo);

	glBindVertexArray(plane_vao);
  glBindBuffer(GL_ARRAY_BUFFER, plane_vbo);
  glBufferData(GL_ARRAY_BUFFER, sizeof(planeVertices), &planeVertices, GL_STATIC_DRAW);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
  glEnableVertexAttribArray(1);
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
  glBindVertexArray(0);

  u32 cube_tex_id;
  glGenTextures(1, &cube_tex_id);
  glActiveTexture(GL_TEXTURE0);
  gl_load_texture(cube_tex_id, "assets/container.jpg");

  u32 plane_tex_id;
  glGenTextures(1, &plane_tex_id);
  glActiveTexture(GL_TEXTURE1);
  gl_load_texture(plane_tex_id, "assets/smiling.png");

	// objects
	Vec3 model_translations[] = {
		Vec3{  0.0, 0.0,  0.0},
		Vec3{ -1.0, 0.0,  -2.0},
		Vec3{ -1.0, 0.0,  -2.0},
		Vec3{ -3.0,  5.0, -6.0},
		Vec3{  3.0, -7.0, -6.0},
	};
    
	r32 FOV = 90.0;
	r32 time_curr;
	r32 time_prev = SDL_GetTicks64() / 100.0;
	// camera stuff
	Vec3 camera_pos  = Vec3{ 0.0, 0.0, 10.0f};
	Vec3 preset_up_dir = Vec3{ 0.0, 1.0, 0.0 };
    
  r32 angle_yaw, angle_pitch, angle_roll;
  angle_pitch = (r32)To_Radian(0.0f);
  angle_yaw = (r32)-To_Radian(90.0f);
  
  Vec3 camera_look = camera_look_around(angle_pitch, angle_yaw);
  
  // @todo: remove this, I dont like this and think that this is unnecessary
  Vec3 camera_look_increment;
	r32 camera_speed = 0.5f;
    
	Mat4 view = camera_create4m(camera_pos, camera_look, preset_up_dir);
	
	Mat4 proj = perspective4m((r32)To_Radian(90.0), (r32)width / (r32)height, 0.1f, 100.0f);
  // needs this
  glUseProgram(shader_program);
	uint32_t proj_loc = glGetUniformLocation(shader_program, "Projection");
	glUniformMatrix4fv(proj_loc, 1, GL_TRUE, proj.buffer);

  glUseProgram(outline_shader_program);
	proj_loc = glGetUniformLocation(outline_shader_program, "Projection");
	glUniformMatrix4fv(proj_loc, 1, GL_TRUE, proj.buffer);
	
	glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LESS);
  glEnable(GL_STENCIL_TEST);

	u8 game_running = true;
    
  u8 hold_lshift = false;
	u8 move_w = false;
	u8 move_a = false;
	u8 move_s = false;
	u8 move_d = false;
    
	while(game_running)
	{
		
		// frame delta
		time_curr = SDL_GetTicks64() / 100.0;
		r32 time_delta = time_curr - time_prev;
		
		r32 camera_speed_adjusted = time_delta * camera_speed;
		camera_look_increment = scaler_multiply3v(camera_look, camera_speed_adjusted);
        
		SDL_Event ev;
		while(SDL_PollEvent(&ev))
		{
            
			// INPUT
			switch (ev.type)
			{
				case (SDL_QUIT):
				{
					game_running = false;
				} break;
				case (SDL_KEYDOWN):
				{
          if (ev.key.keysym.sym == SDLK_LSHIFT)
          {
              hold_lshift = true;
          }
					if (ev.key.keysym.sym == SDLK_w)
					{
						move_w = true;
					}
					if (ev.key.keysym.sym == SDLK_s)
					{
						move_s = true;
					}
					if (ev.key.keysym.sym == SDLK_a)
					{
						move_a = true;
					}
					if (ev.key.keysym.sym == SDLK_d)
					{
						move_d = true;
					}
				} break;
				case (SDL_KEYUP):
				{
          if (ev.key.keysym.sym == SDLK_LSHIFT)
          {
              hold_lshift = false;
          }
					if (ev.key.keysym.sym == SDLK_w)
					{
						move_w = false;
					}
					if (ev.key.keysym.sym == SDLK_s)
					{
						move_s = false;
					}
					if (ev.key.keysym.sym == SDLK_a)
					{
						move_a = false;
					}
					if (ev.key.keysym.sym == SDLK_d)
					{
						move_d = false;
					}
				} break;
        case (SDL_MOUSEMOTION):
        {
          SDL_MouseMotionEvent mouse_event = ev.motion;
          r32 x_motion = (r32)mouse_event.xrel;
          r32 y_motion = (r32)mouse_event.yrel;
					if (x_motion != 0.0 || y_motion != 0.0)
					{
						angle_yaw = angle_yaw + To_Radian(x_motion * 0.1f);
						angle_pitch = clampf(angle_pitch + To_Radian(-y_motion * 0.1f), To_Radian(-89.0f), To_Radian(89.0f));
						
						camera_look = camera_look_around(angle_pitch, angle_yaw);
					}
        } break;
				default:
				{
					break;
				}
			}
		}
        
		// PROCESS
		if (move_w)
		{
			camera_pos = add3v(camera_pos, camera_look_increment);
		}
		if (move_s)
		{
			camera_pos = subtract3v(camera_pos, camera_look_increment);
		}
		if (move_a)
		{
			Vec3 camera_right = normalize3v(cross_multiply3v(preset_up_dir, camera_look));
			Vec3 camera_right_scaled = scaler_multiply3v(camera_right, camera_speed_adjusted);
			camera_pos = add3v(camera_pos, camera_right_scaled);
		}
		if (move_d)
		{
			Vec3 camera_right = normalize3v(cross_multiply3v(preset_up_dir, camera_look));
			Vec3 camera_right_scaled = scaler_multiply3v(camera_right, camera_speed_adjusted);
			camera_pos = subtract3v(camera_pos, camera_right_scaled);
		}
    view = camera_create4m(camera_pos, add3v(camera_pos, camera_look), preset_up_dir);
        
		// object shader program stuff
    glUseProgram(shader_program);
    uint32_t view_loc = glGetUniformLocation(shader_program, "View");
		glUniformMatrix4fv(view_loc, 1, GL_TRUE, view.buffer);
    
    glUseProgram(outline_shader_program);
    view_loc = glGetUniformLocation(outline_shader_program, "View");
		glUniformMatrix4fv(view_loc, 1, GL_TRUE, view.buffer);
		
		time_prev = time_curr;
		
		// OUTPUT
    glEnable(GL_DEPTH_TEST);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
    glStencilFunc(GL_ALWAYS, 1, 0xFF);

		glClearColor(1.0f, 0.6f, .6f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

    // if no outline
    // @note: if we do not disable writing to the stencil buffer here, the data from the plane fills the stencil buffer.
    // That gets treated as part of whatever fragments we are trying to outline
    glStencilMask(0x00);
    {
      glUseProgram(shader_program);
      s32 tex_id_loc = glGetUniformLocation(shader_program, "TexId");
      glUniform1i(tex_id_loc, 1);
      Vec3 translation_iter = model_translations[1];
      Mat4 model = init_value4m(1.0);
      Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z);
      model = multiply4m(model_translation, model);
      uint32_t model_loc = glGetUniformLocation(shader_program, "Model");
      glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer);
      glBindVertexArray(plane_vao);
      glDrawArrays(GL_TRIANGLES, 0, 6);
    }

    // always pass stencil test so the stencil buffer is loaded wherever fragment exists
    glStencilMask(0xFF);
    glStencilFunc(GL_ALWAYS, 1, 0xFF);
    {
      glUseProgram(shader_program);
      s32 tex_id_loc = glGetUniformLocation(shader_program, "TexId");
      glUniform1i(tex_id_loc, 0);
      Vec3 translation_iter = model_translations[0];
      Mat4 model = init_value4m(1.0);
      Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z);
      model = multiply4m(model_translation, model);
      uint32_t model_loc = glGetUniformLocation(shader_program, "Model");
      glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer);
      glBindVertexArray(cube_vao);
      glDrawArrays(GL_TRIANGLES, 0, 36);
    }
    {
      glUseProgram(shader_program);
      s32 tex_id_loc = glGetUniformLocation(shader_program, "TexId");
      glUniform1i(tex_id_loc, 0);
      Vec3 translation_iter = model_translations[2];
      Mat4 model = init_value4m(1.0);
      Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z);
      model = multiply4m(model_translation, model);
      uint32_t model_loc = glGetUniformLocation(shader_program, "Model");
      glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer);
      glBindVertexArray(cube_vao);
      glDrawArrays(GL_TRIANGLES, 0, 36);
    }

    // drawing the outline
    // @note: if we don't disable the depth buffer, then the objects will not be highlighted if something is in the 
    // view i.e, at a lower depth value
    glDisable(GL_DEPTH_TEST);
    // @note: im not entirely sure why we need to disable writing to the stencil buffer here
    // based on my testing, if we don't disable this, the highlight color that gets drawn infront
    // will cover the stencil values whereever it is. There is a subtle difference when this happens
    // but from what I have seen it just looks better and makes more sense when we have don't write to the 
    // stencil mask because. I guess it also means that we donot want the highlights we draw to affect other
    // highlights
    glStencilMask(0x00);
    glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
    {
      glUseProgram(outline_shader_program);
      s32 tex_id_loc = glGetUniformLocation(outline_shader_program, "TexId");
      glUniform1i(tex_id_loc, 0);
      s32 hlt_loc = glGetUniformLocation(outline_shader_program, "hlt_color");
      glUniform4f(hlt_loc, 1.0f, 0.0f, 0.0f, 1.0f);
      Vec3 translation_iter = model_translations[0];
      Mat4 model = init_value4m(1.0);
      Mat4 model_scale = scaling_matrix4m(1.1f, 1.1f, 1.1f);
      model = multiply4m(model_scale, model);
      Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z);
      model = multiply4m(model_translation, model);
      uint32_t model_loc = glGetUniformLocation(outline_shader_program, "Model");
      glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer);
      glBindVertexArray(cube_vao);
      glDrawArrays(GL_TRIANGLES, 0, 36);
    }
    {
      glUseProgram(outline_shader_program);
      s32 tex_id_loc = glGetUniformLocation(outline_shader_program, "TexId");
      glUniform1i(tex_id_loc, 0);
      s32 hlt_loc = glGetUniformLocation(outline_shader_program, "hlt_color");
      glUniform4f(hlt_loc, 0.0f, 1.0f, 0.0f, 1.0f);
      Vec3 translation_iter = model_translations[2];
      Mat4 model = init_value4m(1.0);
      Mat4 model_scale = scaling_matrix4m(1.1f, 1.1f, 1.1f);
      model = multiply4m(model_scale, model);
      Mat4 model_translation = translation_matrix4m(translation_iter.x, translation_iter.y, translation_iter.z);
      model = multiply4m(model_translation, model);
      uint32_t model_loc = glGetUniformLocation(outline_shader_program, "Model");
      glUniformMatrix4fv(model_loc, 1, GL_TRUE, model.buffer);
      glBindVertexArray(cube_vao);
      glDrawArrays(GL_TRIANGLES, 0, 36);
    }
    // re-enable the depth buffer and stencil buffer state and ops
    glEnable(GL_DEPTH_TEST);
    glStencilMask(0xFF);
    glStencilFunc(GL_ALWAYS, 1, 0xFF);

		SDL_GL_SwapWindow(window);
	}
	
	// opengl free calls
	//glDeleteVertexArrays(1, &VAO);
	//glDeleteBuffers(1, &VBO);
	glDeleteProgram(shader_program);
	glDeleteProgram(outline_shader_program);
	
	// sdl free calls
	SDL_GL_DeleteContext(context);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}