Build world model in engine

.clang-format

@@ -1,5 +1,5 @@
 {
-    ColumnLimit: 80,
+    ColumnLimit: 100,
     TabWidth: 4,
     IndentWidth: 4, # 1 tab
     UseTab: ForIndentation,

.gitignore

@@ -4,6 +4,7 @@
 # Custom
 *.swp
 *.opendb
+data/textures/SrcAssets/
 
 # User-specific files
 *.suo

Dengine.vcxproj

@@ -122,9 +122,10 @@
   <ItemGroup>
     <ClCompile Include="src\AssetManager.cpp" />
     <ClCompile Include="src\dengine.cpp" />
-    <ClCompile Include="src\Game.cpp" />
+    <ClCompile Include="src\Entity.cpp" />
     <ClCompile Include="src\Renderer.cpp" />
     <ClCompile Include="src\Shader.cpp" />
+    <ClCompile Include="src\WorldTraveller.cpp" />
     <ClCompile Include="src\Texture.cpp" />
     <ClCompile Include="src\Tutorial.cpp" />
   </ItemGroup>
@@ -138,10 +139,12 @@
     <ClInclude Include="src\include\Dengine\AssetManager.h" />
     <ClInclude Include="src\include\Dengine\Common.h" />
     <ClInclude Include="src\include\Breakout\Game.h" />
+    <ClInclude Include="src\include\Dengine\Entity.h" />
     <ClInclude Include="src\include\Dengine\OpenGL.h" />
     <ClInclude Include="src\include\Dengine\Renderer.h" />
     <ClInclude Include="src\include\Dengine\Shader.h" />
     <ClInclude Include="src\include\Dengine\Texture.h" />
+    <ClInclude Include="src\include\WorldTraveller\WorldTraveller.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Dengine.vcxproj.filters

@@ -27,15 +27,18 @@
     <ClCompile Include="src\AssetManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\Game.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\Tutorial.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\Renderer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\WorldTraveller.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Entity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="data\shaders\default.vert.glsl" />
@@ -65,5 +68,11 @@
     <ClInclude Include="src\include\Dengine\Renderer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\include\WorldTraveller\WorldTraveller.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\include\Dengine\Entity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

src/AssetManager.cpp

@@ -21,24 +21,22 @@ Texture *AssetManager::getTexture(const std::string name)
 	return nullptr;
 }
 
-const i32 AssetManager::loadTextureImage(const std::string path,
+const i32 AssetManager::loadTextureImage(const std::string path, const std::string name)
-                                         const std::string name)
 {
 	/* Open the texture image */
 	i32 imgWidth, imgHeight, bytesPerPixel;
 	stbi_set_flip_vertically_on_load(TRUE);
-	u8 *image =
+	u8 *image = stbi_load(path.c_str(), &imgWidth, &imgHeight, &bytesPerPixel, 0);
-	    stbi_load(path.c_str(), &imgWidth, &imgHeight, &bytesPerPixel, 0);
 
 	if (!image)
 	{
-		std::cerr << "stdbi_load() failed: " << stbi_failure_reason()
+		std::cerr << "stdbi_load() failed: " << stbi_failure_reason() << std::endl;
-		          << std::endl;
 		return -1;
 	}
 
 	Texture tex;
-	tex.generate(imgWidth, imgHeight, image);
+	tex.generate(static_cast<GLuint>(imgWidth), static_cast<GLuint>(imgHeight),
+	             static_cast<GLint>(bytesPerPixel), image);
 	stbi_image_free(image);
 
 	textures[name] = tex;
@@ -99,13 +97,11 @@ INTERNAL GLuint createShaderFromPath(std::string path, GLuint shadertype)
 }
 
 const i32 AssetManager::loadShaderFiles(const std::string vertexPath,
-                                        const std::string fragmentPath,
+                                        const std::string fragmentPath, const std::string name)
-                                        const std::string name)
 {
 
 	GLuint vertexShader   = createShaderFromPath(vertexPath, GL_VERTEX_SHADER);
-	GLuint fragmentShader =
+	GLuint fragmentShader = createShaderFromPath(fragmentPath, GL_FRAGMENT_SHADER);
-	    createShaderFromPath(fragmentPath, GL_FRAGMENT_SHADER);
 
 	Shader shader;
 	i32 result = shader.loadProgram(vertexShader, fragmentShader);

src/Entity.cpp

@@ -0,0 +1,40 @@
+#include <Dengine/Entity.h>
+#include <Dengine/AssetManager.h>
+
+namespace Dengine
+{
+
+Entity::Entity()
+: pos(glm::vec2(0, 0))
+, size(glm::vec2(0, 0))
+, tex(nullptr)
+{
+}
+
+Entity::Entity(const glm::vec2 pos, const Texture *tex)
+{
+	this->pos  = pos;
+	this->tex  = tex;
+	this->size = glm::vec2(tex->getWidth(), tex->getHeight());
+}
+
+Entity::Entity(const glm::vec2 pos, glm::vec2 size, const Texture *tex)
+{
+	this->pos  = pos;
+	this->tex  = tex;
+	this->size = size;
+}
+
+Entity::Entity(const glm::vec2 pos, const std::string texName)
+{
+	Texture *tex = AssetManager::getTexture(texName);
+	this->pos  = pos;
+	this->tex  = tex;
+	this->size = glm::vec2(tex->getWidth(), tex->getHeight());
+
+}
+
+Entity::~Entity()
+{
+}
+}

src/Game.cpp

@@ -1,66 +0,0 @@
-#include <Breakout\Game.h>
-#include <glm/glm.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-namespace Breakout
-{
-Game::Game(i32 width, i32 height)
-{
-	this->width = width;
-	this->height = height;
-	glCheckError();
-}
-
-Game::~Game()
-{
-	delete this->renderer;
-}
-
-void Game::init()
-{
-	/* Initialise assets */
-	Dengine::AssetManager::loadShaderFiles("data/shaders/sprite.vert.glsl",
-	                                       "data/shaders/sprite.frag.glsl",
-	                                       "sprite");
-
-	Dengine::AssetManager::loadTextureImage("data/textures/container.jpg",
-	                                        "container");
-	Dengine::AssetManager::loadTextureImage("data/textures/wall.jpg", "wall");
-	Dengine::AssetManager::loadTextureImage("data/textures/awesomeface.png",
-	                                        "awesomeface");
-	Dengine::AssetManager::loadTextureImage("data/textures/plain_terrain.jpg",
-	                                        "plain_terrain");
-
-	this->shader = Dengine::AssetManager::getShader("sprite");
-	this->shader->use();
-
-	glm::mat4 projection =
-	    glm::ortho(0.0f, static_cast<GLfloat>(this->width), 0.0f,
-	               static_cast<GLfloat>(this->height), 0.0f, 1.0f);
-	this->shader->uniformSetMat4fv("projection", projection);
-
-	GLuint projectionLoc = glGetUniformLocation(this->shader->id, "projection");
-	glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
-
-	/* Init game state */
-	this->state = GAME_ACTIVE;
-	this->renderer = new Dengine::Renderer(this->shader);
-}
-
-void Game::processInput(const f32 dt) {}
-void Game::update(const f32 dt) {}
-void Game::render()
-{
-	const Dengine::Texture *tex =
-	    Dengine::AssetManager::getTexture("plain_terrain");
-	glm::vec2 pos  = glm::vec2(0, 0);
-	glm::vec2 size = glm::vec2(1280.0f, 720.0f);
-	this->renderer->drawSprite(tex, pos, size);
-
-	tex  = Dengine::AssetManager::getTexture("container");
-	pos  = glm::vec2(200, 200);
-	size = glm::vec2(250.0f, 250.0f);
-	this->renderer->drawSprite(tex, pos, size);
-}
-}

src/Renderer.cpp

@@ -1,8 +1,8 @@
-#include <Dengine/Renderer.h>
 #include <Dengine/OpenGL.h>
+#include <Dengine/Renderer.h>
 
-#include <glm/gtx/transform.hpp>
 #include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/transform.hpp>
 
 namespace Dengine
 {
@@ -12,20 +12,15 @@ Renderer::Renderer(Shader *shader)
 	this->initRenderData();
 }
 
-Renderer::~Renderer()
+Renderer::~Renderer() { glDeleteVertexArrays(1, &this->quadVAO); }
-{
+void Renderer::drawEntity(Entity *entity, GLfloat rotate, glm::vec3 color)
-	glDeleteVertexArrays(1, &this->quadVAO);
-}
-void Renderer::drawSprite(const Texture *texture, glm::vec2 position,
-                          glm::vec2 size, GLfloat rotate, glm::vec3 color)
 {
 	this->shader->use();
-	glm::mat4 transMatrix  = glm::translate(glm::vec3(position, 0.0f));
+	glm::mat4 transMatrix  = glm::translate(glm::vec3(entity->pos, 0.0f));
 	glm::mat4 rotateMatrix = glm::rotate(rotate, glm::vec3(0.0f, 0.0f, 1.0f));
 
-
 	// NOTE(doyle): We draw everything as a unit square in OGL. Scale it to size
-	glm::mat4 scaleMatrix  = glm::scale(glm::vec3(size, 1.0f));
+	glm::mat4 scaleMatrix = glm::scale(glm::vec3(entity->size, 1.0f));
 
 	glm::mat4 model = transMatrix * rotateMatrix * scaleMatrix;
 
@@ -35,7 +30,7 @@ void Renderer::drawSprite(const Texture *texture, glm::vec2 position,
 	// this->shader->uniformSetVec3f("spriteColor", color);
 
 	glActiveTexture(GL_TEXTURE0);
-	texture->bind();
+	entity->tex->bind();
 	this->shader->uniformSet1i("tex", 0);
 
 	glBindVertexArray(this->quadVAO);
@@ -73,8 +68,7 @@ void Renderer::initRenderData()
 	const GLuint vertexSize        = sizeof(glm::vec4);
 
 	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, numVertexElements, GL_FLOAT, GL_FALSE, vertexSize,
+	glVertexAttribPointer(0, numVertexElements, GL_FLOAT, GL_FALSE, vertexSize, (GLvoid *)0);
-	                      (GLvoid *)0);
 
 	/* Unbind */
 	glBindBuffer(GL_ARRAY_BUFFER, 0);

src/Shader.cpp

@@ -14,8 +14,7 @@ Shader::Shader()
 
 Shader::~Shader() {}
 
-const i32 Shader::loadProgram(const GLuint vertexShader,
+const i32 Shader::loadProgram(const GLuint vertexShader, const GLuint fragmentShader)
-                              const GLuint fragmentShader)
 {
 	this->id = glCreateProgram();
 	glAttachShader(this->id, vertexShader);
@@ -36,7 +35,6 @@ const i32 Shader::loadProgram(const GLuint vertexShader,
 	}
 
 	return 0;
-
 }
 
 void Shader::uniformSet1i(const GLchar *name, const GLuint data)

src/Texture.cpp

@@ -6,7 +6,7 @@ Texture::Texture()
 : id(0)
 , width(0)
 , height(0)
-, internalFormat(GL_RGB)
+, internalFormat(GL_RGBA)
 , imageFormat(GL_RGB)
 , wrapS(GL_REPEAT)
 , wrapT(GL_REPEAT)
@@ -44,7 +44,7 @@ INTERNAL GLint getGLFormat(BytesPerPixel bytesPerPixel, b32 srgb)
 	}
 }
 
-void Texture::generate(const GLuint width, const GLuint height,
+void Texture::generate(const GLuint width, const GLuint height, const GLint bytesPerPixel,
                        const u8 *const image)
 {
 	// TODO(doyle): Let us set the parameters gl params as well
@@ -55,17 +55,17 @@ void Texture::generate(const GLuint width, const GLuint height,
 
 	/* Load image into texture */
 	// TODO(doyle) Figure out the gl format
-	glTexImage2D(GL_TEXTURE_2D, 0, this->internalFormat, this->width,
+	this->imageFormat = getGLFormat(static_cast<enum BytesPerPixel>(bytesPerPixel), FALSE);
-	             this->height, 0, this->imageFormat, GL_UNSIGNED_BYTE, image);
+
+	glTexImage2D(GL_TEXTURE_2D, 0, this->internalFormat, this->width, this->height, 0,
+	             this->imageFormat, GL_UNSIGNED_BYTE, image);
 	glGenerateMipmap(GL_TEXTURE_2D);
 
 	/* Set parameter of currently bound texture */
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, this->wrapS);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, this->wrapT);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, this->filterMinification);
-	                this->filterMinification);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, this->filterMagnification);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-	                this->filterMagnification);
 
 	/* Unbind and clean up */
 	glBindTexture(GL_TEXTURE_2D, 0);

src/WorldTraveller.cpp

@@ -0,0 +1,116 @@
+#include <WorldTraveller/WorldTraveller.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+#include <cstdlib>
+
+namespace WorldTraveller
+{
+
+// TODO(doyle): Entity list for each world
+// TODO(doyle): Jumping mechanics
+// TODO(doyle): Collision
+
+
+Game::Game(i32 width, i32 height)
+{
+	this->width  = width;
+	this->height = height;
+
+	for (i32 i        = 0; i < NUM_KEYS; i++)
+		this->keys[i] = FALSE;
+}
+
+Game::~Game() { delete this->renderer; }
+
+void Game::init()
+{
+	/* Initialise assets */
+	std::string texFolder = "data/textures/WorldTraveller/";
+	Dengine::AssetManager::loadShaderFiles("data/shaders/sprite.vert.glsl",
+	                                       "data/shaders/sprite.frag.glsl", "sprite");
+
+	Dengine::AssetManager::loadTextureImage(texFolder + "hero.png", "hero");
+	Dengine::AssetManager::loadTextureImage(texFolder + "wall.png", "wall");
+	Dengine::AssetManager::loadTextureImage(texFolder + "hitMarker.png", "hitMarker");
+
+	this->shader = Dengine::AssetManager::getShader("sprite");
+	this->shader->use();
+
+	glm::mat4 projection = glm::ortho(0.0f, static_cast<GLfloat>(this->width), 0.0f,
+	                                  static_cast<GLfloat>(this->height), 0.0f, 1.0f);
+	this->shader->uniformSetMat4fv("projection", projection);
+
+	GLuint projectionLoc = glGetUniformLocation(this->shader->id, "projection");
+	glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
+
+	/* Init game state */
+	this->state    = state_active;
+	this->renderer = new Dengine::Renderer(this->shader);
+
+	/* Init hero */
+	this->hero = Dengine::Entity(glm::vec2(0, 0), "hero");
+
+	glm::vec2 screenCentre       = glm::vec2(this->width / 2.0f, this->height / 2.0f);
+	glm::vec2 heroOffsetToCentre = glm::vec2(-((i32)hero.size.x / 2), -((i32)hero.size.y / 2));
+
+	glm::vec2 heroCentered = screenCentre + heroOffsetToCentre;
+	hero.pos               = heroCentered;
+
+	srand(static_cast<u32>(glfwGetTime()));
+}
+
+void Game::update(const f32 dt)
+{
+	const f32 heroSpeed = static_cast<f32>((3.0f * METERS_TO_PIXEL) * dt);
+
+	if (this->keys[GLFW_KEY_SPACE])
+	{
+#if 0
+		Dengine::Entity hitMarker = Dengine::Entity(glm::vec2(0, 0), "hitMarker");
+		glm::vec2 hitMarkerP =
+		    glm::vec2((hero.pos.x * 1.5f) + hitMarker.tex->getWidth(), hero.pos.y * 1.5f);
+		hitMarker.pos = hitMarkerP;
+		renderer->drawEntity(&hitMarker);
+#endif
+	}
+
+	if (this->keys[GLFW_KEY_RIGHT])
+	{
+		hero.pos.x += heroSpeed;
+	}
+	else if (this->keys[GLFW_KEY_LEFT])
+	{
+		hero.pos.x -= heroSpeed;
+	}
+}
+
+void Game::render()
+{
+
+	Dengine::Renderer *renderer = this->renderer;
+
+	Dengine::Entity wall = Dengine::Entity(glm::vec2(0, 0), "wall");
+	glm::vec2 maxTilesOnScreen =
+	    glm::vec2((this->width / wall.size.x), (this->height / wall.size.y));
+
+	Dengine::Entity hitMarker = Dengine::Entity(glm::vec2(100, 100), "hitMarker");
+
+	for (i32 x = 0; x < maxTilesOnScreen.x; x++)
+	{
+		for (i32 y = 0; y < maxTilesOnScreen.y; y++)
+		{
+			if (x == 0 || x == maxTilesOnScreen.x - 1 || y == 0 || y == maxTilesOnScreen.y - 1)
+			{
+				wall.pos = glm::vec2(x * wall.tex->getWidth(), y * wall.tex->getHeight());
+
+				renderer->drawEntity(&wall);
+			}
+		}
+	}
+	renderer->drawEntity(&hero);
+	renderer->drawEntity(&hitMarker);
+}
+} // namespace Dengine

src/dengine.cpp

@@ -1,33 +1,32 @@
 #if 1
-#include <Dengine/OpenGL.h>
-#include <Dengine/Common.h>
-#include <Dengine/Shader.h>
 #include <Dengine/AssetManager.h>
+#include <Dengine/Common.h>
+#include <Dengine/OpenGL.h>
 #include <Dengine/Renderer.h>
+#include <Dengine/Shader.h>
 
-#include <Breakout/Game.h>
+#include <WorldTraveller/WorldTraveller.h>
 
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
-#include <iostream>
 #include <cstdint>
 #include <fstream>
+#include <iostream>
 #include <string>
 
-void key_callback(GLFWwindow *window, int key, int scancode, int action,
+void key_callback(GLFWwindow *window, int key, int scancode, int action, int mode)
-                  int mode)
 {
-	Breakout::Game *game =
+	WorldTraveller::Game *game =
-	    static_cast<Breakout::Game *>(glfwGetWindowUserPointer(window));
+	    static_cast<WorldTraveller::Game *>(glfwGetWindowUserPointer(window));
 
 	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
 	{
 		glfwSetWindowShouldClose(window, GL_TRUE);
 	}
 
-	if (key >= 0 && key < Breakout::NUM_KEYS)
+	if (key >= 0 && key < WorldTraveller::NUM_KEYS)
 	{
 		if (action == GLFW_PRESS)
 			game->keys[key] = TRUE;
@@ -36,13 +35,9 @@ void key_callback(GLFWwindow *window, int key, int scancode, int action,
 	}
 }
 
-void mouse_callback(GLFWwindow *window, double xPos, double yPos)
+void mouse_callback(GLFWwindow *window, double xPos, double yPos) {}
-{
-}
 
-void scroll_callback(GLFWwindow *window, double xOffset, double yOffset)
+void scroll_callback(GLFWwindow *window, double xOffset, double yOffset) {}
-{
-}
 
 int main()
 {
@@ -54,13 +49,11 @@ int main()
 
 	glm::ivec2 windowSize = glm::ivec2(1280, 720);
 
-	GLFWwindow *window = glfwCreateWindow(windowSize.x, windowSize.y,
+	GLFWwindow *window = glfwCreateWindow(windowSize.x, windowSize.y, "Breakout", nullptr, nullptr);
-	                                      "Breakout", nullptr, nullptr);
 
 	if (!window)
 	{
-		std::cout << "glfwCreateWindow() failed: Failed to create window"
+		std::cout << "glfwCreateWindow() failed: Failed to create window" << std::endl;
-		          << std::endl;
 		glfwTerminate();
 		return -1;
 	}
@@ -71,8 +64,7 @@ int main()
 	glewExperimental = GL_TRUE;
 	if (glewInit() != GLEW_OK)
 	{
-		std::cout << "glewInit() failed: Failed to initialise GLEW"
+		std::cout << "glewInit() failed: Failed to initialise GLEW" << std::endl;
-		          << std::endl;
 		return -1;
 	}
 	// NOTE(doyle): glewInit() bug that sets the gl error flag after init
@@ -94,7 +86,7 @@ int main()
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	glCullFace(GL_BACK);
 
-	Breakout::Game game = Breakout::Game(frameBufferSize.x, frameBufferSize.y);
+	WorldTraveller::Game game = WorldTraveller::Game(frameBufferSize.x, frameBufferSize.y);
 	game.init();
 
 	glfwSetWindowUserPointer(window, static_cast<void *>(&game));
@@ -112,7 +104,6 @@ int main()
 		/* Check and call events */
 		glfwPollEvents();
 
-		game.processInput(deltaTime);
 		game.update(deltaTime);
 
 		/* Rendering commands here*/

src/include/Dengine/AssetManager.h

@@ -1,13 +1,13 @@
 #ifndef DENGINE_ASSET_MANAGER_H
 #define DENGINE_ASSET_MANAGER_H
 
-#include <Dengine\Common.h>
+#include <Dengine/Common.h>
-#include <Dengine\Texture.h>
+#include <Dengine/Shader.h>
-#include <Dengine\Shader.h>
+#include <Dengine/Texture.h>
 
+#include <iostream>
 #include <map>
 #include <string>
-#include <iostream>
 
 namespace Dengine
 {
@@ -23,8 +23,7 @@ public:
 
 	/* Shaders */
 	static Shader *getShader(const std::string name);
-	static const i32 loadShaderFiles(const std::string vertexPath,
+	static const i32 loadShaderFiles(const std::string vertexPath, const std::string fragmentPath,
-	                          const std::string fragmentPath,
 	                                 const std::string name);
 };
 }

src/include/Dengine/Entity.h

@@ -0,0 +1,25 @@
+#ifndef DENGINE_ENTITY_H
+#define DENGINE_ENTITY_H
+
+#include <Dengine/Common.h>
+#include <Dengine/Texture.h>
+
+#include <glm/glm.hpp>
+
+namespace Dengine
+{
+class Entity
+{
+public:
+	Entity();
+	Entity(const glm::vec2 pos, const Texture *tex);
+	Entity(const glm::vec2 pos, const glm::vec2 size, const Texture *tex);
+	Entity(const glm::vec2 pos, const std::string texName);
+	~Entity();
+
+	glm::vec2 pos;
+	glm::vec2 size;
+	const Texture *tex;
+};
+}
+#endif

src/include/Dengine/OpenGL.h

@@ -5,8 +5,8 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 
-#include <string>
 #include <iostream>
+#include <string>
 
 inline GLenum glCheckError_(const char *file, int line)
 {

src/include/Dengine/Renderer.h

@@ -2,8 +2,10 @@
 #define DENGINE_RENDERER_H
 
 #include <Dengine/Common.h>
-#include <Dengine/Texture.h>
+#include <Dengine/Entity.h>
 #include <Dengine/Shader.h>
+#include <Dengine/Texture.h>
+
 #include <GLM/glm.hpp>
 
 namespace Dengine
@@ -14,9 +16,7 @@ public:
 	Renderer(Shader *shader);
 	~Renderer();
 
-	void drawSprite(const Texture *texture, glm::vec2 position,
+	void drawEntity(Entity *entity, GLfloat rotate = 0.0f, glm::vec3 color = glm::vec3(1.0f));
-	                glm::vec2 size = glm::vec2(10, 10), GLfloat rotate = 0.0f,
-	                glm::vec3 color = glm::vec3(1.0f));
 
 private:
 	Shader *shader;

src/include/Dengine/Shader.h

@@ -18,8 +18,7 @@ public:
 	Shader();
 	~Shader();
 
-	const i32 loadProgram(const GLuint vertexShader,
+	const i32 loadProgram(const GLuint vertexShader, const GLuint fragmentShader);
-	                      const GLuint fragmentShader);
 
 	void uniformSet1i(const GLchar *name, const GLuint data);
 	void uniformSetMat4fv(const GLchar *name, const glm::mat4 data);

src/include/Dengine/Texture.h

@@ -1,8 +1,8 @@
 #ifndef DENGINE_TEXTURE_H
 #define DENGINE_TEXTURE_H
 
-#include <Dengine/OpenGL.h>
 #include <Dengine/Common.h>
+#include <Dengine/OpenGL.h>
 
 namespace Dengine
 {
@@ -13,7 +13,7 @@ public:
 	Texture();
 
 	// Generates texture from image data
-	void generate(const GLuint width, const GLuint height,
+	void generate(const GLuint width, const GLuint height, const GLint bytesPerPixel,
 	              const u8 *const image);
 
 	// Binds the texture as the current active GL_TEXTURE_2D texture object
@@ -44,7 +44,6 @@ private:
 	GLuint filterMinification;
 	// Filtering mode if texture pixels > screen pixels
 	GLuint filterMagnification;
-
 };
 }
 #endif

src/include/WorldTraveller/WorldTraveller.h

@@ -1,27 +1,40 @@
-#ifndef BREAKOUT_GAME_H
+#ifndef WORLDTRAVELLER_GAME_H
-#define BREAKOUT_GAME_H
+#define WORLDTRAVELLER_GAME_H
 
 #include <Dengine/OpenGL.h>
 #include <Dengine/Common.h>
 #include <Dengine/Renderer.h>
 #include <Dengine/Shader.h>
 #include <Dengine/AssetManager.h>
+#include <Dengine/Entity.h>
 
-namespace Breakout
+namespace WorldTraveller
 {
 GLOBAL_VAR const i32 NUM_KEYS = 1024;
+GLOBAL_VAR const i32 METERS_TO_PIXEL = 100;
 
-enum GameState
+enum Cardinal
 {
-	GAME_ACTIVE,
+	cardinal_north = 0,
-	GAME_MENU,
+	cardinal_west  = 1,
-	GAME_WIN
+	cardinal_south = 2,
+	cardinal_east  = 3,
+	cardinal_num,
+	cardinal_null
+
+};
+
+enum State
+{
+	state_active,
+	state_menu,
+	state_win
 };
 
 class Game
 {
 public:
-	GameState state;
+	State state;
 	GLboolean keys[NUM_KEYS];
 	i32 width, height;
 
@@ -30,12 +43,12 @@ public:
 
 	void init();
 
-	void processInput(const f32 dt);
 	void update(const f32 dt);
 	void render();
 private:
 	Dengine::Shader *shader;
 	Dengine::Renderer *renderer;
+	Dengine::Entity hero;
 };
 }