visual improvements for the earth

ettoh · ettoh · commit 273ecaec2723 · 2021-06-21T11:29:05.000+02:00
diff --git a/resources/shader/basic.vert b/resources/shader/basic.vert
@@ -1,11 +1,18 @@
 #version 330
 layout (location = 0) in vec3 coord3d;
 layout (location = 1) in vec3 v_color;
-layout (std140) uniform Global{	mat4 modelview; mat4 projection; mat4 normal_transform;};
+layout (std140) uniform Global{	
+    mat4 model; 
+    mat4 view; 
+    mat4 projection; 
+    mat4 scaling;
+    mat4 sun_angle;
+};
+
 varying vec3 f_color;
 
 void main(void) {
-	vec4 camera_coords = modelview * vec4(coord3d, 1.0);
+	vec4 camera_coords = view * model * scaling * vec4(coord3d, 1.0);
 	gl_Position = projection * camera_coords;
 	f_color = v_color;
 }
diff --git a/resources/shader/earth.frag b/resources/shader/earth.frag
@@ -1,21 +1,46 @@
 #version 330
-uniform sampler2D texture;
+uniform sampler2D earth_day;
+uniform sampler2D earth_water;
+
 varying vec2 f_texcoord;
-varying vec3 f_normal;
+varying vec4 f_normal;
 varying vec3 f_coord3d;
-layout (std140) uniform Global{	mat4 modelview; mat4 projection; mat4 normal_transform;};
+layout (std140) uniform Global{	
+    mat4 model; 
+    mat4 view; 
+    mat4 projection; 
+    mat4 scaling;
+    mat4 sun_angle;
+};
 
 void main(void) {
     float ambient = 0.09;
-    vec3 light_source = (modelview * vec4(0.0, 0.0, 4.0, 1.0)).xyz;
-    vec3 N = normalize((normal_transform * vec4(f_normal, 1.0)).xyz);
-    vec3 L = normalize(light_source - f_coord3d); // light source
-    vec3 V = normalize(-f_coord3d); // view
-    vec3 R = -reflect(L, N); // reflection vector
+    vec3 light_source = (model * sun_angle * vec4(0.0, 0.0, 20.0, 1.0)).xyz;
+    vec3 N = normalize(f_normal).xyz;
+    vec3 L = light_source - f_coord3d; // light source
+    float sqr_distance = dot(L, L);
+    L = normalize(L);
+    vec3 V = -normalize(f_coord3d - inverse(view)[3].xyz);
+    vec3 R = -reflect(L, N);
+
+    float lambertian = max(dot(N, L), 0.0);
+    float specular = 0.0;
+    float spec_angle = max(dot(V, R), 0.0);
+    specular = pow(spec_angle, 20);
+
+    vec3 earth_color = vec3(texture2D(earth_day, f_texcoord + vec2(0.5, 0.0)));
+    vec3 water_map = vec3(texture2D(earth_water, f_texcoord + vec2(0.5, 0.0))); // black where water
+    float is_water = (water_map.r + water_map.g + water_map.b) / 3.0; // 0 -> land
+    if(is_water <= 0.1){
+        specular *= min(is_water + 0.15, 1);
+    }
+    vec3 diffuse_color = earth_color;
+    vec3 light_color = vec3(0.89, 0.855, 0.686) * 500.0;
+
+    vec3 output_color = vec3(0.0);
+    output_color += diffuse_color * vec3(0.07); // ambient
+    output_color += diffuse_color * lambertian * light_color / sqr_distance; // diffuse
+    output_color += 0.2 * vec3(1.0) * specular * light_color / sqr_distance; // specular
 
-    float diffuse = 0.8 * max(0.0, dot(L, N));
-    float e = 21.0;
-    vec3 specular = 0.4 * pow(max(0.0, dot(V, R)), e) * vec3(0.89, 0.855, 0.686) ;
-    vec3 color = min(1.0, diffuse + ambient) * vec3(texture2D(texture, f_texcoord)) + specular;
-    gl_FragColor = vec4(color, 1.0);    
-}
+    gl_FragColor = vec4(output_color, 1.0);    
+}
diff --git a/resources/shader/earth.vert b/resources/shader/earth.vert
@@ -2,16 +2,23 @@
 layout (location = 0) in vec3 coord3d;
 layout (location = 1) in vec2 texcoord;
 layout (location = 2) in vec3 normal;
-layout (std140) uniform Global{	mat4 modelview; mat4 projection; mat4 normal_transform;};
+layout (std140) uniform Global{	
+    mat4 model; 
+    mat4 view; 
+    mat4 projection; 
+    mat4 scaling;
+    mat4 sun_angle;
+};
+
 varying vec2 f_texcoord;
-varying vec3 f_normal;
+varying vec4 f_normal;
 varying vec3 f_coord3d;
 
 void main(void) {
-	vec4 camera_coords = modelview * vec4(coord3d, 1.0);
-	gl_Position = projection * camera_coords;
+	vec4 camera_coords = model * vec4(coord3d, 1.0);
+	gl_Position = projection * view * scaling * camera_coords;
 
 	f_texcoord = texcoord;
-	f_normal = normal;
+	f_normal = model * vec4(normal, 0);
 	f_coord3d = camera_coords.xyz;
 }
diff --git a/resources/shader/satellite.vert b/resources/shader/satellite.vert
@@ -1,12 +1,19 @@
 #version 330
 layout (location = 0) in vec3 coord3d;
 layout (location = 1) in vec3 offset;
-layout (std140) uniform Global{	mat4 modelview; mat4 projection; mat4 normal_transform;};
+layout (std140) uniform Global{	
+    mat4 model; 
+    mat4 view; 
+    mat4 projection; 
+    mat4 scaling;
+    mat4 sun_angle;
+};
+
 varying vec3 f_color;
 
 void main(void) {
 	vec3 position = coord3d + offset;
-	vec4 camera_coords = modelview * vec4(position, 1.0);
+	vec4 camera_coords = view * model * scaling * vec4(position, 1.0);
 	gl_Position = projection * camera_coords;
 	f_color = vec3(1.0, 1.0, 1.0);
 }
diff --git a/resources/textures/earth_clouds.jpg b/resources/textures/earth_clouds.jpg
diff --git a/src/opengl_primitives.cpp b/src/opengl_primitives.cpp
@@ -92,7 +92,6 @@ Object OpenGLPrimitives::createSphere(const float radius, const glm::vec3 center
 Object OpenGLPrimitives::createSatellite() {
     Object model = Object();
     model.gl_draw_mode = GL_TRIANGLES;
-    const float cube_length = 0.005f;
 
     return createSphere(0.005f, glm::vec3(0.0f), 10);
 }
diff --git a/src/opengl_widgets.cpp b/src/opengl_widgets.cpp
@@ -157,22 +157,29 @@ void OpenGLWidget::init() {
     glUniformBlockBinding(earth_prog, index, 1);
 
     // load textures
+    loadTextures("earth_day", uniform_texture_location[0], "textures/earth_day.jpg", texture_id[0]);
+    loadTextures("earth_water", uniform_texture_location[1], "textures/earth_water.jpg", texture_id[1]);
+}
+
+// ------------------------------------------------------------------------------------------------
+
+void OpenGLWidget::loadTextures(const char* uniform_name, GLint& tex_location, const char* file, GLuint& id) {
     int w, h;
     int channels;
     unsigned char* image;
-    const char* filename = "textures/earth_day.jpg";
     stbi_set_flip_vertically_on_load(1);
-    image = stbi_load(filename, &w, &h, &channels, STBI_rgb);
+    image = stbi_load(file, &w, &h, &channels, STBI_rgb);
 
     if (image == nullptr) {
-        printf("Failed to load image %s\n", filename);
+        printf("Failed to load image %s\n", file);
         assert(false);
         exit(EXIT_FAILURE);
     }
 
-    glGenTextures(1, &texture_id);
-    glBindTexture(GL_TEXTURE_2D, texture_id);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glGenTextures(1, &id);
+    glBindTexture(GL_TEXTURE_2D, id);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexImage2D(GL_TEXTURE_2D, 0,
                  GL_RGB, // internalformat
                  w, h, 0,
@@ -181,9 +188,8 @@ void OpenGLWidget::init() {
     stbi_image_free(image);
 
     // bind texture uniform
-    const char* uniform_name = "texture"; // name of uniform in shader
-    uniform_texture_location = glGetUniformLocation(earth_prog, uniform_name);
-    if (uniform_texture_location == -1) {
+    tex_location = glGetUniformLocation(earth_prog, uniform_name);
+    if (tex_location == -1) {
         std::cout << "Could not bind uniform " << uniform_name << std::endl;
     }
 }
@@ -193,7 +199,7 @@ void OpenGLWidget::init() {
 void OpenGLWidget::show(const PhysicalInstance& instance, const float t0) {
     visualizeInstance(instance);
     sim_time = t0;
-    glm::vec3 clear_color = glm::vec3(0.15f, 0.15f, 0.15f);
+    glm::vec3 clear_color = glm::vec3(0.03f);
 
     // Main loop
     while (!glfwWindowShouldClose(window)) {
@@ -221,7 +227,7 @@ void OpenGLWidget::show(const PhysicalInstance& instance, const float t0) {
 
 void OpenGLWidget::show(const PhysicalInstance& instance, const Solution& solution) {
     visualizeSolution(instance, solution);
-    glm::vec3 clear_color = glm::vec3(0.15f, 0.15f, 0.15f);
+    glm::vec3 clear_color = glm::vec3(0.03f);
 
     // Main loop
     while (!glfwWindowShouldClose(window)) {
@@ -250,10 +256,14 @@ void OpenGLWidget::show(const PhysicalInstance& instance, const Solution& soluti
 void OpenGLWidget::renderScene() {
     recalculate();
 
-    // bind texture
+    // bind textures
     glActiveTexture(GL_TEXTURE0);
-    glUniform1i(uniform_texture_location, /*GL_TEXTURE*/ 0);
-    glBindTexture(GL_TEXTURE_2D, texture_id);
+    glUniform1i(uniform_texture_location[0], /*GL_TEXTURE*/ 0);
+    glBindTexture(GL_TEXTURE_2D, texture_id[0]);
+
+    glActiveTexture(GL_TEXTURE1);
+    glUniform1i(uniform_texture_location[1], /*GL_TEXTURE*/ 1);
+    glBindTexture(GL_TEXTURE_2D, texture_id[1]);
 
     // Draw the scene:
     for (const Subscene& s : scene) {
@@ -273,6 +283,10 @@ void OpenGLWidget::recalculate() {
     if (!paused)
         sim_time += diff * sim_speed;
 
+    // sun rotation
+    float sun_angle = sim_time * 0.000290f; // 6h -> one turn around the earth
+    glm::mat4 sun_rotation = glm::rotate(glm::mat4(1.f), sun_angle, glm::vec3(0.f, 1.f, 0.f));
+
     /* Camera circumnavigating around the central mass.
      * Instead of performing two rotations for the camera, the rotation around the y-axis is done by rotation the entire
      * world itself. */
@@ -294,15 +308,17 @@ void OpenGLWidget::recalculate() {
     glGetIntegerv(GL_VIEWPORT, viewport);
     projection = glm::perspective(45.0f, 1.0f * viewport[2] / viewport[3], 0.1f, 10.0f);
     glm::mat4 scale = glm::scale(glm::vec3(1.0f) * zoom);
-    glm::mat4 modelview = view * world_rotation * scale;
-    glm::mat4 normal_proj = glm::transpose(glm::inverse(modelview));
+    glm::mat4 model = world_rotation;
+    // glm::mat4 normal_proj = glm::transpose(glm::inverse(modelview));
 
     // push mvp to VBO
     glBindBuffer(GL_UNIFORM_BUFFER, vbo_uniforms);
-    glBufferData(GL_UNIFORM_BUFFER, 3 * sizeof(glm::mat4), 0, GL_STREAM_DRAW);
-    glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(modelview));
-    glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(projection));
-    glBufferSubData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(normal_proj));
+    glBufferData(GL_UNIFORM_BUFFER, 5 * sizeof(glm::mat4), 0, GL_STREAM_DRAW);
+    glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(model));
+    glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(view));
+    glBufferSubData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(projection));
+    glBufferSubData(GL_UNIFORM_BUFFER, 3 * sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(scale));
+    glBufferSubData(GL_UNIFORM_BUFFER, 4 * sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(sun_rotation));
     glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
     // dynamic part of scene
@@ -762,7 +778,9 @@ void OpenGLWidget::destroy() {
     deleteInstance();
     glDeleteProgram(basic_program);
     glDeleteProgram(satellite_prog);
-    glDeleteTextures(1, &texture_id);
+    glDeleteTextures(1, &texture_id[0]);
+    glDeleteTextures(1, &texture_id[1]);
+    glDeleteTextures(1, &texture_id[2]);
 
     glfwDestroyWindow(window);
     glfwTerminate();
diff --git a/src/opengl_widgets.hpp b/src/opengl_widgets.hpp
@@ -38,6 +38,7 @@ class OpenGLWidget {
     void recalculateEdges();
     void deleteInstance();
     void pushSceneToGPU();
+    void loadTextures(const char* uniform_name, GLint& tex_location, const char* file, GLuint& id);
 
     /**
      * @brief Convert a given instance with orbits and communications between the satellites into an opengl
@@ -83,8 +84,8 @@ class OpenGLWidget {
     // Handler
     GLuint basic_program = 0, satellite_prog = 0, earth_prog = 0;
     GLuint vbo_uniforms = 0;
-    GLuint texture_id = 0;
-    GLint uniform_texture_location = 0;
+    GLuint texture_id[2] = {0, 0};
+    GLint uniform_texture_location[2] = {-1, -1};
     // view and camera
     float zoom = 1.0f;
     glm::vec2 camera_rotation_angle_offset = glm::vec2(.0f, .0f);

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,6 @@ Object OpenGLPrimitives::createSphere(const float radius, const glm::vec3 center`
`92`	`92`	`Object OpenGLPrimitives::createSatellite() {`
`93`	`93`	`Object model = Object();`
`94`	`94`	`model.gl_draw_mode = GL_TRIANGLES;`
`95`		`- const float cube_length = 0.005f;`
`96`	`95`
`97`	`96`	`return createSphere(0.005f, glm::vec3(0.0f), 10);`
`98`	`97`	`}`