Added camera

assets/shaders/test.frag

@@ -1,11 +1,6 @@
 #version 330 core
 out vec4 FragColor;
 
-in vec2 TexCoord;
-uniform sampler2D uniform_Texture;
-
 void main() {
-  vec4 color = texture(uniform_Texture, TexCoord);
-  FragColor = color;
-  // FragColor = vec4(1, 1, 1, 1);
+  FragColor = vec4(1, 1, 1, 1);
 }

assets/shaders/test.vert

@@ -1,17 +1,11 @@
-#version 330 core
-#extension GL_ARB_separate_shader_objects : enable
+// #version 330 core
+// #extension GL_ARB_separate_shader_objects : enable
 
-layout (location = 0) in vec3 aPos;
-layout (location = 1) in vec2 aTexCoord;
+// layout (location = 0) in vec3 aPos;
 
-uniform mat4 uniform_MVP;
-uniform mat4 uniform_MP;
-
-out vec2 TexCoord;
+uniform mat4 u_Proj;
+uniform mat4 u_View;
 
 void main() {
-  vec3 pos = aPos;
-
-  gl_Position = uniform_MVP * uniform_MP * vec4(pos, 1);
-  TexCoord = vec2(aTexCoord.x, aTexCoord.y);
+  gl_Position = u_Proj * u_View * gl_Vertex;
 }

src/dawn/dawngame.c

@@ -19,7 +19,7 @@ game_t * gameInit(platform_t *platform) {
     return NULL;
   }
 
-  // Pass to the main game to handle.r
+  // Pass to the main game to handle
   return game;
 }
 

src/engine/display/camera.c

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2021 Dominic Msters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "camera.h"
+
+camera_t * cameraCreate() {
+  camera_t *camera = malloc(sizeof(camera_t));
+  if(!camera) return NULL;
+  return camera;
+}
+
+void cameraDispose(camera_t *camera) {
+  free(camera);
+}
+
+void cameraLookAt(camera_t *camera,
+  float x, float y, float z, float targetX, float targetY, float targetZ
+) {
+  glm_lookat(
+    (vec3){ x, y, z },
+    (vec3){ targetX, targetY, targetZ },
+    (vec3){ 0, 1, 0 },
+    camera->view
+  );
+}
+
+void cameraLook(camera_t *camera,
+  float x, float y, float z,
+  float pitch, float yaw, float roll
+) {
+  glm_look(
+    (vec3){ x, y, z },
+    (vec3){ pitch, yaw, roll },
+    (vec3){ 0, 1, 0 },
+    camera->view
+  );
+}
+
+void cameraPerspective(camera_t *camera,
+  float fov, float aspect, float near, float far
+) {
+  glm_perspective(fov, aspect, near, far, camera->projection);
+}
+
+void cameraOrtho(camera_t *camera,
+  float left, float right, float bottom, float top, float near, float far
+) {
+  glm_ortho(left, right, bottom, top, near, far, camera->projection);
+}

src/engine/display/camera.h

@@ -0,0 +1,90 @@
+// Copyright (c) 2021 Dominic Msters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include <cglm/cglm.h>
+#include <malloc.h>
+
+/** The math for the camera is stored here. */
+typedef struct {
+  /** View Matrix (Where the camera looks) */
+  mat4 view;
+
+  /** Projection Matrix (How the camera looks) */
+  mat4 projection;
+} camera_t;
+
+/**
+ * Create a new camera instance.
+ * 
+ * @return A new camera instance.
+ */
+camera_t * cameraCreate();
+
+/**
+ * Cleanup a previously created camera
+ * 
+ * @param camera Camera instance to dispose.
+ */
+void cameraDispose(camera_t *camera);
+
+/**
+ * Make a camera look at a position in world space while itself being positioned
+ * within world space.
+ * 
+ * @param camera The camera to position.
+ * @param x The X position in world space of the camera.
+ * @param y The Y position in world space of the camera.
+ * @param z The Z position in world space of the camera.
+ * @param targetX The Target X position in world space of the camera.
+ * @param targetY The Target Y position in world space of the camera.
+ * @param targetZ The Target Z position in world space of the camera.
+ */
+void cameraLookAt(camera_t *camera,
+  float x, float y, float z, float targetX, float targetY, float targetZ
+);
+
+/**
+ * Make a camera look in a direction based on a rotation direction.
+ * 
+ * @param camera The camera to position.
+ * @param x The X position in world space of the camera.
+ * @param y The Y position in world space of the camera.
+ * @param z The Z position in world space of the camera.
+ * @param pitch The pitch of the camera.
+ * @param yaw The yaw of the camera.
+ * @param roll The roll of the camera.
+ */
+void cameraLook(camera_t *camera,
+  float x, float y, float z,
+  float pitch, float yaw, float roll
+);
+
+/**
+ * Make a camera's projection be a 3D Perspective view.
+ * 
+ * @param camera The camera to project.
+ * @param fov The field of view of the camera.
+ * @param aspect The aspect ratio of the camera (w / h)
+ * @param near The near plane clip.
+ * @param far the far plane clip.
+ */
+void cameraPerspective(camera_t *camera,
+  float fov, float aspect, float near, float far
+);
+
+/**
+ * Defines an orthorgonal camera matrix.
+ * 
+ * @param camera Camera to position.
+ * @param left The left side of the viewport.
+ * @param right The right side of the viewport.
+ * @param bottom The bottom side of the viewport.
+ * @param near The near plane clip.
+ * @param far the far plane clip.
+ */
+void cameraOrtho(camera_t *camera,
+  float left, float right, float bottom, float top, float near, float far
+);

src/engine/display/render.c

@@ -27,15 +27,17 @@ render_t * renderInit(char *name) {
 void renderFrame(render_t *render) {
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
+  float z = 0.0f;
+
   glBegin(GL_TRIANGLES);
     glColor3f(1, 0, 0);
-    glVertex3f(-1, -1, 0);
+    glVertex3f(-1, -1, z);
 
     glColor3f(0, 1, 0);
-    glVertex3f(0, 1, 0);
+    glVertex3f(0, 1, z);
 
     glColor3f(0, 0, 1);
-    glVertex3f(1, -1, 0);
+    glVertex3f(1, -1, z);
   glEnd();
 }
 

src/engine/display/shader.c

@@ -75,6 +75,9 @@ shader_t * shaderCompile(char *vertexShaderSource, char* fragmentShaderSource) {
   shader->shaderFrag = shaderFragment;
   shader->shaderProgram = shaderProgram;
 
+  shader->uniProj = glGetUniformLocation(shader->shaderProgram, SHADER_UNI_PROJ);
+  shader->uniView = glGetUniformLocation(shader->shaderProgram, SHADER_UNI_VIEW);
+
   // Bind the shader
   shaderUse(shader);
 
@@ -92,4 +95,9 @@ bool shaderDipose(shader_t *shader) {
 
 void shaderUse(shader_t *shader) {
   glUseProgram(shader->shaderProgram);
+}
+
+void shaderUseCamera(shader_t *shader, camera_t *camera) {
+  glUniformMatrix4fv(shader->uniView, 1, GL_FALSE, (float*)camera->view);
+  glUniformMatrix4fv(shader->uniProj, 1, GL_FALSE, (float*)camera->projection);
 }

src/engine/display/shader.h

@@ -11,6 +11,10 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <malloc.h>
+#include "camera.h"
+
+#define SHADER_UNI_VIEW "u_View"
+#define SHADER_UNI_PROJ "u_Proj"
 
 /**
  * Structure containing information about an OpenGL Shader. For simplicity sake
@@ -25,6 +29,12 @@ typedef struct {
 
   /** Pointer to an uploaded shader program linked */
   GLuint shaderProgram;
+
+  /** Matrix for the view matrix */
+  GLint uniView;
+
+  /** Matrix for the projection matrix */
+  GLint uniProj;
 } shader_t;
 
 /**
@@ -48,4 +58,7 @@ bool shaderDipose(shader_t *shader);
  * Attaches the supplied shader as the current shader.
  * @param shader The shader to attach
  */
-void shaderUse(shader_t *shader);
+void shaderUse(shader_t *shader);
+
+
+void shaderUseCamera(shader_t *shader, camera_t *camera);

src/engine/engine.c

@@ -7,6 +7,9 @@
 
 #include "engine.h"
 
+camera_t *camera;
+shader_t *shader;
+
 engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
   // Create the engine instance.
   engine_t *engine = malloc(sizeof(engine_t));
@@ -30,10 +33,21 @@ engine_t * engineInit(platform_t *platform, char *name, uint32_t inputCount) {
     return NULL;
   }
 
+  shader = assetShaderLoad("shaders/test.vert", "shaders/test.frag");
+
+  camera = cameraCreate();
+  cameraLookAt(camera,
+    3, 3, 3,
+    0, 0, 0
+  );
+  cameraPerspective(camera, 45.0f, 1920.0f/1080.0f, 3.0f, 100.0f);
+  shaderUseCamera(shader, camera);
+
   return engine;
 }
 
 uint32_t engineUpdate(engine_t *engine) {
+  shaderUse(shader);
   renderFrame(engine->render);
   inputUpdate(engine->input);
 

src/engine/engine.h

@@ -6,10 +6,13 @@
 #pragma once
 #include <stdbool.h>
 #include "display/render.h"
-#include "file/asset.h"
 #include "input/input.h"
 #include "./platform.h"
 
+#include "file/asset.h"
+#include "display/shader.h"
+#include "display/camera.h"
+
 /** Information about the current engine context. */
 typedef struct {
   /** Name of the game running. */