Code restructuring, Input (WIP)

src/kekengine/cpp/engine.cpp

@@ -1,7 +1,4 @@
-#include "kekengine.h"
+#include "engine.h"
-#include "errordialog.h"
-#include "objparser.h"
-#include "resource.h"
 
 #include <iostream>
 #include <cstring>
@@ -10,18 +7,23 @@
 #include <GLFW/glfw3.h>
 #include <glm/gtc/type_ptr.hpp>
 
-namespace kek {
+#include "internal.h"
+#include "errordialog.h"
+#include "objparser.h"
+#include "resource.h"
+#include "camera.h"
+#include "constants.h"
+#include "gameobject.h"
+#include "scene.h"
 
-static GLFWwindow *window;
+kek::KekData kek::kekData;
-static Camera *cam;
 
-static int screenWidth = 800.0f;
+namespace kek::Engine {
-static int screenHeight = 600.0f;
 
 static void framebufferSizeCallback(GLFWwindow *window, int w, int h) {
 	glViewport(0, 0, w, h);
-	screenWidth = w;
+	kekData.screenWidth = w;
-	screenHeight = h;
+	kekData.screenHeight = h;
 }
 
 static void glDebugOutput(GLenum source, GLenum type, unsigned int id, GLenum severity, GLsizei length, const char *message, const void *userParam) {
@@ -47,8 +49,8 @@ void onCursorPosCallback(GLFWwindow *window, double x, double y) {
 	xoff *= 0.1f;
 	yoff *= 0.1f;
 
-	cam->rotateYaw(xoff);
+	kekData.activeCamera->rotateYaw(xoff);
-	cam->rotatePitch(yoff);
+	kekData.activeCamera->rotatePitch(yoff);
 }
 
 int init() {
@@ -76,8 +78,10 @@ int init() {
 	glfwWindowHint(GLFW_MAXIMIZED, GL_TRUE);
 	glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
 
-	window = glfwCreateWindow(screenWidth, screenHeight, "KekEngine", NULL, NULL);
+	kekData.screenWidth = 800.0f;
-	if(window == NULL) {
+	kekData.screenHeight = 600.0f;
+	kekData.window = glfwCreateWindow(kekData.screenWidth, kekData.screenHeight, "KekEngine", NULL, NULL);
+	if(!kekData.window) {
 		const char *errorMsg;
 		int code = glfwGetError(&errorMsg);
 		if(code != GLFW_NO_ERROR) {
@@ -90,7 +94,7 @@ int init() {
 		return KEK_ERROR;
 	}
 
-	glfwMakeContextCurrent(window);
+	glfwMakeContextCurrent(kekData.window);
 
 	std::cout << "Initialized window" << std::endl;
 
@@ -113,9 +117,9 @@ int init() {
 		glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 	}
 
-	glViewport(0, 0, screenWidth, screenHeight);
+	glViewport(0, 0, kekData.screenWidth, kekData.screenHeight);
 
-	glfwSetFramebufferSizeCallback(window, framebufferSizeCallback);
+	glfwSetFramebufferSizeCallback(kekData.window, framebufferSizeCallback);
 
 	glEnable(GL_DEPTH_TEST);
 	glEnable(GL_MULTISAMPLE);
@@ -127,74 +131,84 @@ int init() {
 		return KEK_ERROR;
 	}
 
-	glfwSetCursorPosCallback(window, onCursorPosCallback);
+	glfwSetCursorPosCallback(kekData.window, onCursorPosCallback);
-	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+	glfwSetInputMode(kekData.window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
 
 	glClearColor(0.1f, 0.3f, 0.1f, 0.0f);
 
-	cam = new Camera();
+	kekData.activeCamera = new Camera();
+	kekData.shader = new Shader("shader/mesh/vertex.glsl", "shader/mesh/fragment.glsl");
 
-	MemoryBuffer *buf = Resource::loadResource("object/sphere/Sphere.obj");
+	return KEK_SUCCESS;
-	Mesh *mesh = ObjParser::parse(buf);
+}
-	Shader *shader = new Shader("shader/mesh/vertex.glsl", "shader/mesh/fragment.glsl");
+
-	while(1) {
+int start() {
+	while(!glfwWindowShouldClose(kekData.window)) {
 		// Clear the screen
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-		glViewport(0, 0, screenWidth, screenHeight);
+		glViewport(0, 0, kekData.screenWidth, kekData.screenHeight);
 
-		if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
+		for(std::pair<InputListener, PeriodicCallback> cb : kekData.periodicCallbacks) {
-			cam->translate(cam->direction * 0.1f);
+			cb.second(kekData.window);
 		}
 
-		if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
+		if(glfwGetKey(kekData.window, GLFW_KEY_W) == GLFW_PRESS) {
-			cam->translate(cam->direction * -0.1f);
+			kekData.activeCamera->translate(kekData.activeCamera->direction * 0.1f);
 		}
 
-		if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
+		if(glfwGetKey(kekData.window, GLFW_KEY_S) == GLFW_PRESS) {
-			glm::vec3 camRight = glm::normalize(glm::cross(cam->direction, glm::vec3(0.0f, 1.0f, 0.0f)));
+			kekData.activeCamera->translate(kekData.activeCamera->direction * -0.1f);
-			cam->translate(-camRight * 0.1f);
 		}
 
-		if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
+		if(glfwGetKey(kekData.window, GLFW_KEY_A) == GLFW_PRESS) {
-			glm::vec3 camRight = glm::normalize(glm::cross(cam->direction, glm::vec3(0.0f, 1.0f, 0.0f)));
+			glm::vec3 camRight = glm::normalize(glm::cross(kekData.activeCamera->direction, glm::vec3(0.0f, 1.0f, 0.0f)));
-			cam->translate(camRight * 0.1f);
+			kekData.activeCamera->translate(-camRight * 0.1f);
 		}
 
-		if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) {
+		if(glfwGetKey(kekData.window, GLFW_KEY_D) == GLFW_PRESS) {
-			cam->translateY(0.1f);
+			glm::vec3 camRight = glm::normalize(glm::cross(kekData.activeCamera->direction, glm::vec3(0.0f, 1.0f, 0.0f)));
+			kekData.activeCamera->translate(camRight * 0.1f);
 		}
 
-		if(glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) {
+		if(glfwGetKey(kekData.window, GLFW_KEY_SPACE) == GLFW_PRESS) {
-			cam->translateY(-0.1f);
+			kekData.activeCamera->translateY(0.1f);
 		}
 
-		if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
+		if(glfwGetKey(kekData.window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS) {
+			kekData.activeCamera->translateY(-0.1f);
+		}
+
+		if(glfwGetKey(kekData.window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
 			break;
 		}
 
-		shader->use();
+		kekData.shader->use();
 
-		glm::mat4 view = cam->transformationMatrix();
+		glm::mat4 view = kekData.activeCamera->transformationMatrix();
 
 		glm::mat4 projection;
-		projection = glm::perspective(glm::radians(90.0f), screenWidth / (float) screenHeight, KEK_CAMERA_NEAR, KEK_CAMERA_FAR);
+		projection = glm::perspective(glm::radians(90.0f), kekData.screenWidth / (float) kekData.screenHeight, KEK_CAMERA_NEAR, KEK_CAMERA_FAR);
 
-		glm::vec3 position = cam->getPosition();
+		glm::vec3 position = kekData.activeCamera->getPosition();
 
-		glUniformMatrix4fv(glGetUniformLocation(shader->id, "view"), 1, GL_FALSE, glm::value_ptr(view));
+		glUniformMatrix4fv(glGetUniformLocation(kekData.shader->id, "view"), 1, GL_FALSE, glm::value_ptr(view));
-		glUniformMatrix4fv(glGetUniformLocation(shader->id, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
+		glUniformMatrix4fv(glGetUniformLocation(kekData.shader->id, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
-		glUniform3fv(glGetUniformLocation(shader->id, "cameraPos"), 1, glm::value_ptr(position));
+		glUniform3fv(glGetUniformLocation(kekData.shader->id, "cameraPos"), 1, glm::value_ptr(position));
 		glm::mat4 model = glm::mat4(1.0f);
-		glUniformMatrix4fv(glGetUniformLocation(shader->id, "model"), 1, GL_FALSE, glm::value_ptr(model));
+		glUniformMatrix4fv(glGetUniformLocation(kekData.shader->id, "model"), 1, GL_FALSE, glm::value_ptr(model));
 
-		mesh->draw(shader);
+		if(kekData.activeScene) kekData.activeScene->draw(kekData.shader);
 
 		// Swap buffers and poll window events
-		glfwSwapBuffers(window);
+		glfwSwapBuffers(kekData.window);
 		glfwPollEvents();
 	}
 
 	return KEK_SUCCESS;
 }
 
+void setActiveScene(Scene *scene) {
+	kekData.activeScene = scene;
+}
+
 }

src/kekengine/cpp/gameobject.cpp

@@ -0,0 +1,25 @@
+#include "gameobject.h"
+
+namespace kek {
+
+GameObject::GameObject() {
+
+}
+
+GameObject::~GameObject() {
+	for(Mesh *mesh : meshes) {
+		delete mesh;
+	}
+}
+
+void GameObject::addMesh(Mesh *mesh) {
+	meshes.push_back(mesh);
+}
+
+void GameObject::draw(Shader *shader) {
+	for(Mesh *mesh : meshes) {
+		mesh->draw(shader);
+	}
+}
+
+}

src/kekengine/cpp/input.cpp

@@ -0,0 +1,41 @@
+#include "input.h"
+
+#include <map>
+
+#include "internal.h"
+
+namespace kek::Input {
+
+static InputListener nextID = 0;
+
+InputListener addPeriodicCallback(PeriodicCallback callback) {
+	InputListener id = nextID++;
+	kekData.periodicCallbacks.emplace(id, callback);
+	return id;
+}
+
+void removePeriodicCallback(InputListener listener) {
+	kekData.periodicCallbacks.erase(listener);
+}
+
+InputListener addKeyListener(KeyCallback callback) {
+	InputListener id = nextID++;
+	kekData.keyCallbacks.emplace(id, callback);
+	return id;
+}
+
+void removeKeyListener(InputListener listener) {
+	kekData.keyCallbacks.erase(listener);
+}
+
+InputListener addMouseListener(MouseCallback callback) {
+	InputListener id = nextID++;
+	kekData.mouseCallbacks.emplace(id, callback);
+	return id;
+}
+
+void removeMouseListener(InputListener listener) {
+	kekData.mouseCallbacks.erase(listener);
+}
+
+}

src/kekengine/cpp/mesh.cpp

@@ -59,7 +59,7 @@ void Mesh::draw(Shader *shader) {
 	glBindBuffer(GL_ARRAY_BUFFER, vbo);
 	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
 
-	/*if(!light) {
+	/*if(!light) { // TODO: check if props exist
 		material->diffuse->use(GL_TEXTURE0);
 		glUniform1i(glGetUniformLocation(shader->id, "material.diffuse"), 0);
 

src/kekengine/cpp/objparser.cpp

@@ -4,7 +4,6 @@
 #include <string>
 #include <sstream>
 #include <glm/glm.hpp>
-#include <memory>
 
 #include "types.h"
 

src/kekengine/cpp/scene.cpp

@@ -0,0 +1,33 @@
+#include "scene.h"
+
+namespace kek {
+
+Scene::Scene() {
+
+}
+
+Scene::~Scene() {
+	for(GameObject *obj : objects) delete obj;
+}
+
+void Scene::addObject(GameObject *object) {
+	objects.push_back(object);
+}
+
+void Scene::removeObject(GameObject *object) {
+	for(auto it = objects.begin(); it < objects.end(); it++) {
+		if(*it == object) {
+			objects.erase(it);
+			delete object;
+			break;
+		}
+	}
+}
+
+void Scene::draw(Shader *shader) {
+	for(GameObject *obj : objects) {
+		obj->draw(shader);
+	}
+}
+
+}

src/kekengine/cpp/shader.cpp

@@ -13,10 +13,25 @@ static GLuint compileShader(GLenum type, std::string path) {
 		throw std::exception();
 	}
 
+	std::istream inStream(buf);
 	std::ostringstream stream;
-	stream << buf;
+	std::string line;
-	std::string code = stream.str();
+	while(std::getline(inStream, line)) {
+		if(line.find("!include ") == 0) {
+			std::string includePath = line.substr(9);
+			MemoryBuffer *includeBuf = Resource::loadResource("shader/include/" + includePath);
+			if(!includeBuf) {
+				std::cerr << "Include error: Failed to find path '" << includePath << "'" << std::endl;
+				throw std::exception();
+			}
+			stream << includeBuf;
+			delete includeBuf;
+		}else {
+			stream << line << '\n';
+		}
+	}
 
+	std::string code = stream.str();
 	delete buf;
 
 	const char *src = code.c_str();

src/kekengine/include/engine.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "scene.h"
+
+namespace kek::Engine {
+
+int init();
+
+int start();
+
+void setActiveScene(Scene *scene);
+
+}

src/kekengine/include/gameobject.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "object.h"
+#include "mesh.h"
+
+namespace kek {
+
+class GameObject: public DefaultRotateableObject {
+
+protected:
+	std::vector<Mesh *> meshes;
+
+public:
+	GameObject();
+
+	~GameObject();
+
+	// Adds a mesh to the GameObject. The GameObject takes ownership of the Mesh, so don't use Meshes in multiple GameObjects
+	void addMesh(Mesh *mesh);
+
+	void draw(Shader *shader);
+
+};
+
+}

src/kekengine/include/input.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <GLFW/glfw3.h>
+
+#include "utils.h"
+
+namespace kek {
+
+typedef generic_callable_t<GLFWwindow *> PeriodicCallback;
+typedef generic_callable_t<GLFWwindow *> KeyCallback;
+typedef generic_callable_t<GLFWwindow *, double, double> MouseCallback;
+
+typedef unsigned int InputListener;
+
+}
+
+namespace kek::Input {
+
+InputListener addPeriodicCallback(PeriodicCallback callback);
+
+void removePeriodicCallback(InputListener listener);
+
+InputListener addKeyListener(KeyCallback callback);
+
+void removeKeyListener(InputListener listener);
+
+InputListener addMouseListener(MouseCallback callback);
+
+void removeMouseListener(InputListener listener);
+
+}

src/kekengine/include/internal.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "input.h"
+#include "camera.h"
+#include "scene.h"
+
+#include <map>
+
+namespace kek {
+
+struct KekData {
+	std::map<InputListener, PeriodicCallback> periodicCallbacks;
+	std::map<InputListener, KeyCallback> keyCallbacks;
+	std::map<InputListener, MouseCallback> mouseCallbacks;
+
+	GLFWwindow *window;
+	Shader *shader;
+
+	Camera *activeCamera;
+	Scene *activeScene;
+
+	int screenWidth;
+	int screenHeight;
+};
+
+extern KekData kekData;
+
+}

src/kekengine/include/kekengine.h

@@ -2,17 +2,14 @@
 
 #include "camera.h"
 #include "constants.h"
+#include "engine.h"
 #include "errordialog.h"
+#include "gameobject.h"
 #include "mesh.h"
 #include "object.h"
 #include "objparser.h"
 #include "resource.h"
+#include "scene.h"
 #include "shader.h"
 #include "types.h"
 #include "utils.h"
-
-namespace kek {
-
-int init();
-
-}

src/kekengine/include/scene.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <vector>
+
+#include "gameobject.h"
+
+namespace kek {
+
+class Scene {
+
+protected:
+	std::vector<GameObject *> objects;
+
+public:
+	Scene();
+
+	~Scene();
+
+	// Adds an object to the scene. The scene will take ownership of the object
+	void addObject(GameObject *object);
+
+	// Removes an object from the scene. The object will be deleted
+	void removeObject(GameObject *object);
+
+	// Draws the scene
+	void draw(Shader *shader);
+
+};
+
+}

src/kekengine/res/shader/include/types.glsl

@@ -0,0 +1,44 @@
+struct Material {
+	sampler2D diffuse;
+	sampler2D specular;
+	float shininess;
+};
+
+struct PointLight {
+	vec3 position;
+
+	vec3 ambient;
+	vec3 diffuse;
+	vec3 specular;
+
+	float constant;
+	float linear;
+	float quadratic;
+};
+
+struct DirectionalLight {
+	vec3 direction;
+
+	vec3 ambient;
+	vec3 diffuse;
+	vec3 specular;
+
+	mat4 lightSpaceMatrix;
+};
+
+struct SpotLight {
+	vec3 position;
+	vec3 direction;
+	float innerCutOff;
+	float outerCutOff;
+
+	vec3 ambient;
+	vec3 diffuse;
+	vec3 specular;
+
+	float constant;
+	float linear;
+	float quadratic;
+
+	mat4 lightSpaceMatrix;
+};

src/kekengine/res/shader/mesh/fragment.glsl

@@ -1,5 +1,7 @@
 #version 330 core
 
+!include types.glsl
+
 in VS_OUT {
 	vec3 fragmentPosition;
 	vec2 textureCoordinate;

src/kekengine/res/shader/mesh/vertex.glsl

@@ -1,5 +1,7 @@
 #version 330 core
 
+!include types.glsl
+
 layout (location = 0) in vec3 position;
 layout (location = 1) in vec3 normal;
 layout (location = 2) in vec2 texCoord;

src/kekgame/cpp/kekgame.cpp

@@ -4,6 +4,21 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 
+using namespace kek;
+
 int main(int argc, char **argv) {
-	kek::init();
+	Engine::init();
+
+	MemoryBuffer *buf = Resource::loadResource("object/sphere/Sphere.obj");
+	Mesh *mesh = ObjParser::parse(buf);
+	delete buf;
+
+	GameObject *test = new GameObject();
+	test->addMesh(mesh);
+
+	Scene *scene = new Scene();
+	scene->addObject(test);
+	Engine::setActiveScene(scene);
+
+	Engine::start();
 }