Merge branch 'SArpnt-master' #1 #2 #3 #4 #5 #6 #7 #8 #9 #10

README.md

@@ -65,8 +65,8 @@ Pull requests are welcome. For major changes, please open an issue first to disc
  - [x] 3D Cube
  - [x] 3D Transforms
  - [x] WASD
- - [x] basic input handling
- - [x] Mouse controlled camers
+ - [x] Basic input handling
+ - [x] Mouse controlled camera
  - [x] Window Class
  - [x] Resize context on window resize
  - [x] Time Class
@@ -92,4 +92,4 @@ Pull requests are welcome. For major changes, please open an issue first to disc
  - [ ] Scene Graph
  - [ ] XML based scene graph import
  - [ ] Test ON Windows
- - [ ] Port to Emscripten
+ - [ ] Port to Emscripten

engine/ce_assets.h

@@ -1,5 +1,4 @@
-#ifndef _CE_ASSETS_H_
-#define _CE_ASSETS_H_
+#pragma once
 
 #include <string>
 #include <ce_math.h>
@@ -31,6 +30,4 @@ namespace ce {
 			specularTex = "missing.png",
 			shader = "";
 	};
-}
-
-#endif // !_CE_ASSETS_H_
+}

engine/core/time.cpp

@@ -5,7 +5,8 @@
 float ce::Time::getTime() {
 	return SDL_GetTicks() / 1000.0f;
 }
-ce::Time::Time() : m_last(getTime()), m_now(0), m_dt(0), m_fps(0) {}
+ce::Time::Time()
+	: m_last(getTime()), m_now(0), m_dt(0), m_fps(0) {}
 
 ce::Time::~Time() {}
 
@@ -14,4 +15,4 @@ void ce::Time::update() {
 	m_dt = m_now - m_last;
 	m_fps = 1 / m_dt;
 	m_last = m_now;
-}
+}

engine/core/tpnt_log.h

@@ -24,7 +24,7 @@
 #define TPNT_LOGGER_FORMAT "[%s][%s:%d|%s]: %s\n"
 #define TPNT_LOGGER_FILE strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__
 #define TPNT_LOGGER_CONTEXT TPNT_LOGGER_FILE, __LINE__, __FUNCTION__
-#define TPNT_LOG(L, X) printf(TPNT_LOGGER_FORMAT, TPNT_LOGGER_STR(L), TPNT_LOGGER_CONTEXT,TPNT_LOGGER_STR(X))
+#define TPNT_LOG(L, X) printf(TPNT_LOGGER_FORMAT, TPNT_LOGGER_STR(L), TPNT_LOGGER_CONTEXT, TPNT_LOGGER_STR(X))
 #define TPNT_LOG_RESET "\033[0m"
 #define TPNT_LOG_SUCCESS "\033[1;32m"
 #define TPNT_LOG_WARN "\033[1;33m"
@@ -33,4 +33,4 @@
 #define LOG_INFO(X) TPNT_LOG("INFO", X)
 #define LOG_WARN(X) TPNT_LOG(TPNT_LOG_WARN + "WARN" + TPNT_LOG_RESET, X)
 #define LOG_ERROR(X) TPNT_LOG(TPNT_LOG_ERROR + "ERROR" + TPNT_LOG_RESET, X)
-#define LOG_SUCCESS(X) TPNT_LOG(TPNT_LOG_SUCCESS + "SUCCESS" + TPNT_LOG_RESET, X)
+#define LOG_SUCCESS(X) TPNT_LOG(TPNT_LOG_SUCCESS + "SUCCESS" + TPNT_LOG_RESET, X)

engine/main.cpp

@@ -91,18 +91,18 @@ int main(int argc, char* argv[]) {
 	ce::RenderingEngine* renderingEngine = new ce::RenderingEngine();
 	renderingEngine->setFOV(75.0f);
 	renderingEngine->setSize(window->getWindowSize());
-	renderingEngine->setClipRange(0.1f,100.0f);
+	renderingEngine->setClipRange(0.1f, 100.0f);
 
 	ce::Transform* transform = new ce::Transform();
 	ce::Mesh* mesh = new ce::Mesh(vertices, vertexCount, indices, indexCount);
 	ce::Shader* shader = new ce::Shader("basic");
 	ce::Material* material = new ce::Material(shader);
-	ce::Material* planeMaterial = new ce::Material(shader);
 	material->setTexture(new ce::Texture("uv-map.png"));
-
-	ce::Mesh* plane = new ce::Mesh(planeVertices,planeIndexCount,planeIndices,planeVertexCount);
+
+	ce::Material* planeMaterial = new ce::Material(shader);
+	ce::Mesh* plane = new ce::Mesh(planeVertices, planeIndexCount, planeIndices, planeVertexCount);
 	ce::Transform* planeTransform = new ce::Transform();
-	
+
 	float mouseSensitivity = 0.1f;
 	ce::Camera* camera = new ce::Camera();
 	// Seperate so i can put in a player class later
@@ -159,10 +159,8 @@ int main(int argc, char* argv[]) {
 					if ((event.key.keysym.sym == SDLK_a && cameraVelocity.x < 0) ||
 						 (event.key.keysym.sym == SDLK_d && cameraVelocity.x > 0))
 						cameraVelocity.x = 0;
-					if ((event.key.keysym.sym == SDLK_SPACE &&
-							 cameraVelocity.y > 0) ||
-						 (event.key.keysym.sym == SDLK_LSHIFT &&
-							 cameraVelocity.y < 0))
+					if ((event.key.keysym.sym == SDLK_SPACE && cameraVelocity.y > 0) ||
+						 (event.key.keysym.sym == SDLK_LSHIFT && cameraVelocity.y < 0))
 						cameraVelocity.y = 0;
 					break;
 				}
@@ -180,7 +178,7 @@ int main(int argc, char* argv[]) {
 		transform->roll(25.0f * time->getDeltaTime());
 		transform->yaw(50.0f * time->getDeltaTime());
 		transform->pitch(100.0f * time->getDeltaTime());
-		
+
 		// Camera
 		glm::vec3
 			cameraFront = camera->getTransform()->getForward(),
@@ -190,10 +188,10 @@ int main(int argc, char* argv[]) {
 			(cameraFront * cameraVelocity.z) +
 			(cameraRight * cameraVelocity.x) +
 			(cameraUp * cameraVelocity.y));
-		
+
 		/* Render */
 		renderingEngine->registerCommand({transform, material, mesh, mesh->GetIndexCount()});
-		renderingEngine->registerCommand({planeTransform,planeMaterial,plane,plane->GetIndexCount()});
+		renderingEngine->registerCommand({planeTransform, planeMaterial, plane, plane->GetIndexCount()});
 		renderingEngine->render();
 
 		window->swapBuffers();

engine/managers/asset_manager.cpp

@@ -25,8 +25,7 @@ std::string ce::AssetManager::load_text_file(std::string path) {
 		text = filestream.str();
 		LOG_SUCCESS("LOADED_FILE: " + path);
 	} catch (std::fstream::failure e) {
-		LOG_ERROR(
-			"FILE_NOT_SUCCESSFULLY_READ: (" + path + ") " + std::string(e.what()));
+		LOG_ERROR("FILE_NOT_SUCCESSFULLY_READ: (" + path + ") " + std::string(e.what()));
 	}
 	return text;
 }
@@ -65,4 +64,4 @@ ce::TextureFile ce::AssetManager::getTextureFile(std::string filename) {
 
 void ce::AssetManager::freeTextureFile(ce::TextureFile textureFile) {
 	stbi_image_free(textureFile.data);
-}
+}

engine/managers/asset_manager.h

@@ -7,8 +7,9 @@
 namespace ce {
 	class AssetManager {
 	 private:
-		inline static const std::string SHADER_FOLDER = "shaders",
-												  TEXTURE_FOLDER = "textures";
+		inline static const std::string
+			SHADER_FOLDER = "shaders",
+			TEXTURE_FOLDER = "textures";
 
 		static std::string load_text_file(std::string file);
 

engine/math/transform.cpp

@@ -31,15 +31,13 @@ void ce::Transform::sendToShader(ce::Shader* shader) {
 	shader->setMat4("transform.model", getMatrix());
 }
 
-glm::vec3 ce::Transform::getForward()
-{
+glm::vec3 ce::Transform::getForward() {
 	float
 		yaw = glm::radians(getYaw()),
 		pitch = glm::radians(getPitch());
 	glm::vec3 dir(
-		cos(yaw)*cos(pitch),
+		cos(yaw) * cos(pitch),
 		sin(pitch),
-		sin(yaw)*cos(pitch)
-	);
+		sin(yaw) * cos(pitch));
 	return glm::normalize(dir);
 }

engine/math/transform.h

@@ -15,19 +15,15 @@ namespace ce {
 		glm::vec3 m_pos, m_rot, m_scale;
 
 	 public:
-		static glm::vec3 GetGlobalUp(){return glm::vec3(0.0f,1.0f,0.0f);}
-		 
+		static glm::vec3 GetGlobalUp() { return glm::vec3(0.0f, 1.0f, 0.0f); }
+
 		Transform();
 		~Transform();
 		glm::vec3 getPosition() { return m_pos; }
 		void setPosition(glm::vec3 pos) { m_pos = pos; }
-		void setPosition(float x, float y, float z) {
-			setPosition(glm::vec3(x, y, z));
-		}
+		void setPosition(float x, float y, float z) { setPosition(glm::vec3(x, y, z)); }
 		void translate(glm::vec3 delta) { m_pos += delta; }
-		void translate(float x, float y, float z) {
-			translate(glm::vec3(x, y, z));
-		}
+		void translate(float x, float y, float z) { translate(glm::vec3(x, y, z)); }
 
 		void setPitch(float pitch) { m_rot.x = pitch; }
 		void pitch(float delta) { m_rot.x += delta; }
@@ -43,9 +39,7 @@ namespace ce {
 
 		glm::vec3 getRotation() { return m_rot; }
 		void setRotation(glm::vec3 rot) { m_rot = rot; }
-		void setRotation(float x, float y, float z) {
-			setRotation(glm::vec3(x, y, z));
-		}
+		void setRotation(float x, float y, float z) { setRotation(glm::vec3(x, y, z)); }
 		void rotate(glm::vec3 delta) { m_rot += delta; }
 		void rotate(float x, float y, float z) { rotate(glm::vec3(x, y, z)); }
 

engine/rendering/camera.cpp

@@ -1,44 +1,37 @@
 #include "camera.h"
 
 ce::Camera::Camera()
-:m_transform(NULL)
-{
+	: m_transform(NULL) {
 	m_transform = new Transform();
 }
 
-ce::Camera::~Camera()
-{
+ce::Camera::~Camera() {
 	delete m_transform;
 }
 
-glm::mat4 ce::Camera::getView()
-{
+glm::mat4 ce::Camera::getView() {
 	glm::vec3
 		pos = m_transform->getPosition(),
 		forward = m_transform->getForward();
-	return glm::lookAt(pos,pos+forward,ce::Transform::GetGlobalUp());
+	return glm::lookAt(pos, pos + forward, ce::Transform::GetGlobalUp());
 }
 
-glm::vec3 ce::Camera::getRight()
-{
+glm::vec3 ce::Camera::getRight() {
 	glm::vec3
 		forward = m_transform->getForward(),
 		up = ce::Transform::GetGlobalUp();
-	return glm::normalize(glm::cross(forward,up));
+	return glm::normalize(glm::cross(forward, up));
 }
 
-void ce::Camera::sendToShader(ce::Shader* shader)
-{
-	shader->setMat4("transform.view",getView());
+void ce::Camera::sendToShader(ce::Shader* shader) {
+	shader->setMat4("transform.view", getView());
 }
 
-void ce::Camera::boundPitch()
-{
+void ce::Camera::boundPitch() {
 	float cameraPitch = m_transform->getPitch();
 	if (cameraPitch > 89.9f) // TODO: fix broken 90 degree pitch
 		cameraPitch = 89.9f;
 	if (cameraPitch < -89.9f)
 		cameraPitch = -89.9f;
 	m_transform->setPitch(cameraPitch);
-}
-
+}

engine/rendering/camera.h

@@ -5,18 +5,20 @@
 
 namespace ce {
 	class Camera {
-	private:
+	 private:
 		ce::Transform* m_transform;
-		float speed,
-		fov;
-	public:
+		float
+			speed,
+			fov;
+
+	 public:
 		Camera();
 		~Camera();
-		
+
 		glm::mat4 getView();
 		glm::vec3 getRight();
 		void sendToShader(ce::Shader* shader);
-		Transform* getTransform(){return m_transform;}
+		Transform* getTransform() { return m_transform; }
 		void boundPitch();
 	};
 }

engine/rendering/material.cpp

@@ -6,8 +6,7 @@ ce::Material::Material(Shader* shader)
 	update();
 }
 
-ce::Material::~Material()
-{
+ce::Material::~Material() {
 	delete m_shader;
 	delete m_texture;
 }

engine/rendering/mesh.cpp

@@ -5,39 +5,63 @@
 
 ce::Mesh::Mesh(Vertex* vertexArray, const unsigned vertexCount,
 	GLuint* indexArray, const unsigned indexCount)
+<<<<<<< HEAD
 	: m_vertexCount(vertexCount), m_indexCount(indexCount), m_VAO(0), m_VBO(0), m_EBO(0) {
 	glGenVertexArrays(1, &m_VAO);
 	bind();
 	this->initVAO(vertexArray, indexArray);
 	unbind();
+=======
+	: vertexCount(vertexCount), indexCount(indexCount), VAO(0), VBO(0), EBO(0) {
+	glGenVertexArrays(1, &VAO);
+	glBindVertexArray(VAO);
+	initVAO(vertexArray, indexArray);
+	glBindVertexArray(0);
+>>>>>>> 569c3cf679420af32babc9d733f4d03bb18f0b8e
 }
-
 ce::Mesh::~Mesh() {
+<<<<<<< HEAD
 	glDeleteVertexArrays(1, &m_VAO);
 	glDeleteBuffers(1, &this->m_VBO);
 	glDeleteBuffers(1, &this->m_EBO);
 }
 
 void ce::Mesh::bind() {
 	glBindVertexArray(m_VAO);
+=======
+	glDeleteVertexArrays(1, &VAO);
+	glDeleteBuffers(1, &VBO);
+	glDeleteBuffers(1, &EBO);
 }
 
+void ce::Mesh::bind() {
+	glBindVertexArray(VAO);
+	glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+>>>>>>> 569c3cf679420af32babc9d733f4d03bb18f0b8e
+}
 void ce::Mesh::unbind() {
 	glBindVertexArray(0);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 }
 
-void ce::Mesh::sendToShader(ce::Shader* shader) {
-	bind();
-	shader->vertexAttribPointer("aPos", 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		(GLvoid*)offsetof(Vertex, position));
-	shader->vertexAttribPointer("aColor", 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		(GLvoid*)offsetof(Vertex, color));
-	shader->vertexAttribPointer("aTexCoord", 2, GL_FLOAT, GL_FALSE,
-		sizeof(Vertex), (GLvoid*)offsetof(Vertex, texCoord));
-	unbind();
+void ce::Mesh::sendToShader(ce::Shader* shader, bool bind) {
+	if (bind) {
+		glBindVertexArray(VAO);
+		glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	}
+	shader->vertexAttribPointer("aPos", 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, position));
+	shader->vertexAttribPointer("aColor", 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, color));
+	shader->vertexAttribPointer("aTexCoord", 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)offsetof(Vertex, texCoord));
+	if (bind) {
+		glBindVertexArray(0);
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+	}
 }
 
 void ce::Mesh::initVAO(Vertex* vertexArray, GLuint* indexArray) {
+<<<<<<< HEAD
 	glGenBuffers(1, &this->m_VBO);
 	glBindBuffer(GL_ARRAY_BUFFER, this->m_VBO);
 	glBufferData(GL_ARRAY_BUFFER, this->m_vertexCount * sizeof(Vertex),
@@ -48,5 +72,17 @@ void ce::Mesh::initVAO(Vertex* vertexArray, GLuint* indexArray) {
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->m_EBO);
 		glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->m_indexCount * sizeof(GLuint),
 			indexArray, GL_STATIC_DRAW);
+=======
+	glGenBuffers(1, &VBO);
+	glBindBuffer(GL_ARRAY_BUFFER, VBO);
+	glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(Vertex), vertexArray, GL_STATIC_DRAW);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	if (indexCount > 0) {
+		glGenBuffers(1, &EBO);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * sizeof(GLuint), indexArray, GL_STATIC_DRAW);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+>>>>>>> 569c3cf679420af32babc9d733f4d03bb18f0b8e
 	}
-}
+}