Epic

OpenGL/playground/resources/shaders/phong.frag

@@ -12,8 +12,9 @@ uniform sampler2D diffuseTexture;
 uniform sampler2D shadowMap;
 
 vec3 viewPos = vec3(0.0, 0.0, 0.0);
-vec3 objectColour = vec3(0.58, 0.61, 0.627);
-vec3 lightColour = vec3(0.1, 0.45, 0.9);
+vec3 objectColour = vec3(1.0, 1.0, 1.0);
+vec3 lightColour = vec3(1.0, 1.0, 1.0);
+// vec3 lightColour = vec3(0.1, 0.45, 0.9);
 
 float calculateShadow(vec4 fragPosLightSpace) {
     vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
@@ -33,7 +34,7 @@ void main() {
     vec3 diffuse = diff * lightColour;
 
 
-    float specularStrength = 5;
+    float specularStrength = 0.2;
 
     vec3 viewDir = normalize(viewPos - FragPos);
     vec3 reflectDir = reflect(-lightDir, normal);
@@ -42,7 +43,7 @@ void main() {
     vec3 specular = specularStrength * spec * lightColour;
 
 
-    float ambientStrength = 0.2;
+    float ambientStrength = 0.1;
     vec3 ambient = ambientStrength * lightColour;
 
     float shadow = calculateShadow(FragPosLightSpace);       

OpenGL/playground/src/main.cpp

@@ -26,45 +26,6 @@
 #include "shader.h"
 
 
-class Camera {
-public:
-	Camera(const glm::vec3& position, const glm::vec3& rotation, float fov, float aspect, float zNear, float zFar) {
-		perspective = glm::perspective(glm::radians(fov), aspect, zNear, zFar);
-		pos = position;
-		rot = rotation;
-		aspect = aspect;
-		zNear = zNear;
-		zFar = zFar;
-		forward = glm::vec3(0.0f, 0.0f, 1.0f);
-		up = glm::vec3(0.0f, 1.0f, 0.0f);
-	}
-
-	glm::mat4 getViewProj() {
-		rot.x = glm::clamp(rot.x, -90.0f, 90.0f);
-
-		glm::vec3 front;
-		front.x = cos(glm::radians(rot.x)) * cos(glm::radians(rot.y));
-		front.y = sin(glm::radians(rot.x));
-		front.z = cos(glm::radians(rot.x)) * sin(glm::radians(rot.y));
-		forward = glm::normalize(front);
-
-		glm::vec3 up;
-		up.x = cos(glm::radians(rot.x + 90.0f)) * cos(glm::radians(rot.y));
-		up.y = sin(glm::radians(rot.x + 90.0f));
-		up.z = cos(glm::radians(rot.x + 90.0f)) * sin(glm::radians(rot.y));
-		up = glm::normalize(up);
-
-		glm::mat4 lookAt = glm::lookAt(pos, pos + forward, up);
-		return perspective * lookAt;
-	}
-
-	glm::mat4 perspective;
-	glm::vec3 pos, rot;
-	float fov, aspect, zNear, zFar;
-	glm::vec3 forward, up;
-};
-
-
 int main(int argc, char** argv) {
 	std::cout << "-----------------------------" << std::endl;
 	std::cout << "----- OpenGL Playground -----" << std::endl;
@@ -162,7 +123,7 @@ int main(int argc, char** argv) {
 	glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
 
 	// Set up camera
-	Camera camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -90.0f, 0.0f), 45.0f, 640.0f / 480.0f, 0.1f, 1000.0f);
+	// Camera camera(glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, -90.0f, 0.0f), 45.0f, 640.0f / 480.0f, 0.1f, 1000.0f);
 
 
 	// Model matrice
@@ -226,12 +187,34 @@ int main(int argc, char** argv) {
 		while (SDL_PollEvent(&event) != 0) {
 			if (event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE)
 				isWindowOpen = false;
-			switch (event.type) {
-			case SDL_MOUSEMOTION:
+			if (event.key.keysym.sym == SDLK_r) {
+				simpleShader.reload();
+
+				posAttrib = glGetAttribLocation(simpleShader.getProgram(), "position");
+				glEnableVertexAttribArray(posAttrib);
+				glVertexAttribPointer(posAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
+
+				normalAttrib = glGetAttribLocation(simpleShader.getProgram(), "normal");
+				glEnableVertexAttribArray(normalAttrib);
+				glVertexAttribPointer(normalAttrib, 3, GL_FLOAT, GL_FALSE, 0, (const void*)(vertices.size() * sizeof(glm::vec3)));
+
+				uniTrans = glGetUniformLocation(simpleShader.getProgram(), "model");
+				glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(model));
+				
+				uniView = glGetUniformLocation(simpleShader.getProgram(), "view");
+				glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
+
+				uniProj = glGetUniformLocation(simpleShader.getProgram(), "proj");
+				glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
+
+				uniLight = glGetUniformLocation(simpleShader.getProgram(), "lightpos");
+				glUniformMatrix3fv(uniLight, 1, GL_FALSE, glm::value_ptr(lightPos));
+			}
+			if (event.type == SDL_MOUSEMOTION) {
 				int mouseX = event.motion.xrel;
 				int mouseY = event.motion.yrel;
-				camera.rot.y += mouseX * 0.5f;
-				camera.rot.x += mouseY * -0.5f;
+				// camera.rot.y += mouseX * 0.5f;
+				// camera.rot.x += mouseY * -0.5f;
 			}
 		}
 

OpenGL/playground/src/shader.cpp

@@ -106,6 +106,48 @@ Shader& Shader::load(std::string sourceLoc) {
     return *this;
 }
 
+Shader& Shader::reload() {
+	glDeleteProgram(m_program);
+	glDeleteShader(m_vert);
+	glDeleteShader(m_frag);
+
+	m_vertSource = readShader(m_vertLoc);
+	m_fragSource = readShader(m_fragLoc);
+
+	m_vert = glCreateShader(GL_VERTEX_SHADER);
+	m_frag = glCreateShader(GL_FRAGMENT_SHADER);
+
+	const char* vertSource = m_vertSource.c_str();
+	glShaderSource(m_vert, 1, &vertSource, NULL);
+	glCompileShader(m_vert);
+
+	const char* fragSource = m_fragSource.c_str();
+	glShaderSource(m_frag, 1, &fragSource, NULL);
+	glCompileShader(m_frag);
+
+	glGetShaderiv(m_vert, GL_COMPILE_STATUS, &m_status);
+	if (m_status == GL_FALSE) {
+		char buf[512];
+		glGetShaderInfoLog(m_vert, 512, NULL, buf);
+		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+	}
+
+	glGetShaderiv(m_frag, GL_COMPILE_STATUS, &m_status);
+	if (m_status == GL_FALSE) {
+		char buf[512];
+		glGetShaderInfoLog(m_frag, 512, NULL, buf);
+		logger << LOGGER_ERROR << buf << LOGGER_ENDL;
+	}
+
+	logger << LOGGER_INFO << "Vertex shader at '" << m_vertLoc << "' compiled..." << LOGGER_ENDL;
+	logger << LOGGER_INFO << "Fragment shader at '" << m_fragLoc << "' compiled..." << LOGGER_ENDL;
+
+	link();
+	attatch();
+
+	return *this;
+}
+
 GLuint Shader::getProgram() {
     return m_program;
 }

OpenGL/playground/src/shader.h

@@ -14,6 +14,7 @@ public:
     Shader& attatch();
     Shader& load(GLenum type, std::string sourceLoc);
     Shader& load(std::string sourceLoc);
+	Shader& reload();
 
     GLuint getProgram();
     GLuint getVertex();