src/client/scene.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include "client/camera.h"
   4 #include "client/client.h"
   5 #include "client/frustum.h"
   6 #include "client/scene.h"
   7 #include "client/shader.h"
   8 #include "day.h"
   9 #include "util.h"
  10
  11 struct Scene scene;
  12
  13 static int bintree_compare_f32(void *v1, void *v2, unused Bintree *tree)
  14 {
  15         f32 diff = (*(f32 *) v2) - (*(f32 *) v1);
  16         return CMPBOUNDS(diff);
  17 }
  18
  19 bool scene_init()
  20 {
  21         scene.objects = list_create(NULL);
  22         scene.transparent_objects = bintree_create(sizeof(f32), &bintree_compare_f32);
  23         pthread_mutex_init(&scene.mtx, NULL);
  24
  25         glGetIntegerv(GL_MAX_TEXTURE_UNITS, &scene.max_texture_units);
  26
  27         char max_texture_units_def[BUFSIZ];
  28         sprintf(max_texture_units_def, "#define MAX_TEXTURE_UNITS %d\n", scene.max_texture_units);
  29
  30         if (! shader_program_create(RESSOURCEPATH "shaders/3d", &scene.prog, max_texture_units_def)) {
  31                 fprintf(stderr, "Failed to create 3D shader program\n");
  32                 return false;
  33         }
  34
  35         scene.loc_model = glGetUniformLocation(scene.prog, "model");
  36         scene.loc_VP = glGetUniformLocation(scene.prog, "VP");
  37         scene.loc_daylight = glGetUniformLocation(scene.prog, "daylight");
  38         scene.loc_fogColor = glGetUniformLocation(scene.prog, "fogColor");
  39         scene.loc_ambientLight = glGetUniformLocation(scene.prog, "ambientLight");
  40         scene.loc_lightDir = glGetUniformLocation(scene.prog, "lightDir");
  41         scene.loc_cameraPos = glGetUniformLocation(scene.prog, "cameraPos");
  42
  43         GLint texture_indices[scene.max_texture_units];
  44         for (GLint i = 0; i < scene.max_texture_units; i++)
  45                 texture_indices[i] = i;
  46
  47         glProgramUniform1iv(scene.prog, glGetUniformLocation(scene.prog, "textures"), scene.max_texture_units, texture_indices);
  48
  49         scene.fov = 86.1f;
  50         scene.render_distance = 255.0f;
  51
  52         return true;
  53 }
  54
  55 static void list_delete_object(void *key, unused void *value, unused void *arg)
  56 {
  57         object_delete(key);
  58 }
  59
  60 void scene_deinit()
  61 {
  62         list_clear_func(&scene.objects, &list_delete_object, NULL);
  63         pthread_mutex_destroy(&scene.mtx);
  64         glDeleteProgram(scene.prog);
  65 }
  66
  67 void scene_add_object(Object *obj)
  68 {
  69         pthread_mutex_lock(&scene.mtx);
  70         list_put(&scene.objects, obj, NULL);
  71         pthread_mutex_unlock(&scene.mtx);
  72 }
  73
  74 static void bintree_render_object(BintreeNode *node, unused void *arg)
  75 {
  76         object_render(node->value);
  77 }
  78
  79 void scene_render(f64 dtime)
  80 {
  81         mat4x4_mul(scene.VP, scene.projection, camera.view);
  82
  83         vec4 base_sunlight_dir = {0.0f, 0.0f, -1.0f, 1.0f};
  84         vec4 sunlight_dir;
  85         mat4x4 sunlight_mat;
  86         mat4x4_identity(sunlight_mat);
  87
  88         mat4x4_rotate(sunlight_mat, sunlight_mat, 1.0f, 0.0f, 0.0f, get_sun_angle() + M_PI / 2.0f);
  89         mat4x4_mul_vec4(sunlight_dir, sunlight_mat, base_sunlight_dir);
  90
  91         frustum_update(scene.VP);
  92
  93         f32 daylight = get_daylight();
  94         f32 ambient_light = f32_mix(0.3f, 0.7f, daylight);
  95         v3f32 fog_color = v3f32_mix((v3f32) {0x03, 0x0A, 0x1A}, (v3f32) {0x87, 0xCE, 0xEB}, daylight);
  96
  97         glUseProgram(scene.prog);
  98         glUniformMatrix4fv(scene.loc_VP, 1, GL_FALSE, scene.VP[0]);
  99         glUniform3f(scene.loc_lightDir, sunlight_dir[0], sunlight_dir[1], sunlight_dir[2]);
 100         glUniform3f(scene.loc_cameraPos, camera.eye[0], camera.eye[1], camera.eye[2]);
 101         glUniform1f(scene.loc_daylight, daylight);
 102         glUniform3f(scene.loc_fogColor, fog_color.x / 0xFF * ambient_light, fog_color.y / 0xFF * ambient_light, fog_color.z / 0xFF * ambient_light);
 103         glUniform1f(scene.loc_ambientLight, ambient_light);
 104
 105         for (ListPair **pairptr = &scene.objects.first; *pairptr != NULL; ) {
 106                 ListPair *pair = *pairptr;
 107                 Object *obj = pair->key;
 108                 if (obj->remove) {
 109                         pthread_mutex_lock(&scene.mtx);
 110                         *pairptr = pair->next;
 111                         pthread_mutex_unlock(&scene.mtx);
 112                         free(pair);
 113                         object_delete(obj);
 114                 } else {
 115                         f32 distance = sqrt(pow(obj->pos.x - camera.eye[0], 2) + pow(obj->pos.y - camera.eye[1], 2) + pow(obj->pos.z - camera.eye[2], 2));
 116                         if (distance < scene.render_distance && object_before_render(obj, dtime)) {
 117                                 if (obj->transparent)
 118                                         bintree_insert(&scene.transparent_objects, &distance, obj);
 119                                 else
 120                                         object_render(obj);
 121                         }
 122                         pairptr = &pair->next;
 123                 }
 124         }
 125
 126         bintree_traverse(&scene.transparent_objects, BTT_INORDER, &bintree_render_object, NULL);
 127         bintree_clear(&scene.transparent_objects, NULL, NULL);
 128 }
 129
 130 void scene_on_resize(int width, int height)
 131 {
 132         mat4x4_perspective(scene.projection, scene.fov / 180.0f * M_PI, (float) width / (float) height, 0.01f, scene.render_distance + 28.0f);
 133 }
 134
 135 GLuint scene_get_max_texture_units()
 136 {
 137         return scene.max_texture_units;
 138 }