1 #include <dragonstd/tree.h>
5 #include "client/camera.h"
6 #include "client/client_config.h"
7 #include "client/frustum.h"
8 #include "client/gl_debug.h"
9 #include "client/model.h"
17 static List scene_new;
18 static pthread_mutex_t lock_scene_new;
21 static int cmp_batch_texture(const ModelBatchTexture *ta, const ModelBatchTexture *tb)
24 ta->vertices.siz > tb->vertices.siz ? -1 :
25 ta->vertices.siz < tb->vertices.siz ? +1 :
29 static int cmp_node(const ModelNode *node, const char *str)
31 if (str == node->name)
40 return strcmp(node->name, str);
43 static void transform_node(ModelNode *node)
46 mat4x4_mul(node->abs, node->parent->abs, node->rel);
48 mat4x4_dup(node->abs, node->rel);
50 list_itr(&node->children, &transform_node, NULL, NULL);
53 static void render_node(ModelNode *node)
58 if (node->clockwise) {
59 glFrontFace(GL_CW); GL_DEBUG
62 for (size_t i = 0; i < node->meshes.siz; i++) {
63 ModelMesh *mesh = &((ModelMesh *) node->meshes.ptr)[i];
68 glUseProgram(mesh->shader->prog); GL_DEBUG
69 glUniformMatrix4fv(mesh->shader->loc_transform, 1, GL_FALSE, node->abs[0]); GL_DEBUG
72 for (GLuint i = 0; i < mesh->num_textures; i++) {
73 glBindTextureUnit(i, mesh->textures[i]); GL_DEBUG
76 mesh_render(mesh->mesh);
79 list_itr(&node->children, &render_node, NULL, NULL);
81 if (node->clockwise) {
82 glFrontFace(GL_CCW); GL_DEBUG
86 static void free_node_meshes(ModelNode *node)
88 for (size_t i = 0; i < node->meshes.siz; i++) {
89 ModelMesh *mesh = &((ModelMesh *) node->meshes.ptr)[i];
91 mesh_destroy(mesh->mesh);
95 list_clr(&node->children, &free_node_meshes, NULL, NULL);
98 static void delete_node(ModelNode *node)
100 for (size_t i = 0; i < node->meshes.siz; i++) {
101 ModelMesh *mesh = &((ModelMesh *) node->meshes.ptr)[i];
104 free(mesh->textures);
106 list_clr(&node->children, &delete_node, NULL, NULL);
107 array_clr(&node->meshes);
112 static void init_node(ModelNode *node, ModelNode *parent)
114 if ((node->parent = parent))
115 list_apd(&parent->children, node);
117 list_ini(&node->children);
120 static void clone_mesh(ModelMesh *mesh)
122 GLuint *old_textures = mesh->textures;
123 memcpy(mesh->textures = malloc(mesh->num_textures * sizeof *mesh->textures),
124 old_textures, mesh->num_textures * sizeof *mesh->textures);
127 static ModelNode *clone_node(ModelNode *original, ModelNode *parent)
129 ModelNode *node = malloc(sizeof *node);
131 init_node(node, parent);
133 array_cln(&node->meshes, &original->meshes);
134 for (size_t i = 0; i < node->meshes.siz; i++)
135 clone_mesh(&((ModelMesh *) node->meshes.ptr)[i]);
137 list_itr(&original->children, &clone_node, node, NULL);
141 static int cmp_model(const Model *model, const f32 *distance)
143 return -f32_cmp(&model->distance, distance);
146 static void render_model(Model *model)
148 if (model->callbacks.before_render)
149 model->callbacks.before_render(model);
151 render_node(model->root);
153 if (model->callbacks.after_render)
154 model->callbacks.after_render(model);
157 // step model help im stuck
158 static void model_step(Model *model, Tree *transparent, f64 dtime)
160 if (model->callbacks.step)
161 model->callbacks.step(model, dtime);
163 if (client_config.view_distance < (model->distance = sqrt(
164 pow(model->root->pos.x - camera.eye[0], 2) +
165 pow(model->root->pos.y - camera.eye[1], 2) +
166 pow(model->root->pos.z - camera.eye[2], 2))))
169 if (!model->root->visible)
172 if (model->flags.frustum_culling && frustum_cull((aabb3f32) {
173 v3f32_add(model->box.min, model->root->pos),
174 v3f32_add(model->box.max, model->root->pos)}))
177 // fixme: if there are multiple objects with the exact same distance, only one is rendered
178 if (model->flags.transparent)
179 tree_add(transparent, &model->distance, model, &cmp_model, NULL);
188 list_ini(&scene_new);
190 pthread_mutex_init(&lock_scene_new, NULL);
191 glGetIntegerv(GL_MAX_TEXTURE_UNITS, &units); GL_DEBUG
197 list_clr(&scene, &model_delete, NULL, NULL);
198 list_clr(&scene_new, &model_delete, NULL, NULL);
200 pthread_mutex_destroy(&lock_scene_new);
205 Model *model_create()
207 Model *model = malloc(sizeof *model);
208 model->root = model_node_create(NULL);
210 model->replace = NULL;
212 model->callbacks.step = NULL;
213 model->callbacks.before_render = NULL;
214 model->callbacks.after_render = NULL;
215 model->callbacks.delete = NULL;
217 model->flags.delete =
218 model->flags.frustum_culling =
219 model->flags.transparent = 0;
224 Model *model_load(const char *path, const char *textures_path, Mesh *cube, ModelShader *shader)
226 Model *model = model_create();
229 array_ini(&stack, sizeof(ModelNode *), 5);
230 array_apd(&stack, &model->root);
232 FILE *file = fopen(path, "r");
234 fprintf(stderr, "[warning] failed to open model %s\n", path);
243 while ((length = getline(&line, &siz, file)) > 0) {
249 char *cursor = line - 1;
252 while (*++cursor == '\t')
255 if (tabs >= stack.siz) {
256 fprintf(stderr, "[warning] invalid indent in model %s in line %d\n", path, count);
260 ModelNode *node = model_node_create(((ModelNode **) stack.ptr)[tabs]);
263 char key[length + 1];
264 while (sscanf(cursor, "%s %n", key, &n) == 1) {
267 if (strcmp(key, "name") == 0) {
268 char name[length + 1];
270 if (sscanf(cursor, "%s %n", name, &n) == 1) {
275 node->name = strdup(name);
277 fprintf(stderr, "[warning] invalid value for name in model %s in line %d\n", path, count);
279 } else if (strcmp(key, "pos") == 0) {
280 if (sscanf(cursor, "%f %f %f %n", &node->pos.x, &node->pos.y, &node->pos.z, &n) == 3)
283 fprintf(stderr, "[warning] invalid value for pos in model %s in line %d\n", path, count);
284 } else if (strcmp(key, "rot") == 0) {
285 if (sscanf(cursor, "%f %f %f %n", &node->rot.x, &node->rot.y, &node->rot.z, &n) == 3)
288 fprintf(stderr, "[warning] invalid value for rot in model %s in line %d\n", path, count);
290 node->rot = v3f32_scale(node->rot, M_PI / 180.0);
291 } else if (strcmp(key, "scale") == 0) {
292 if (sscanf(cursor, "%f %f %f %n", &node->scale.x, &node->scale.y, &node->scale.z, &n) == 3)
295 fprintf(stderr, "[warning] invalid value for scale in model %s in line %d\n", path, count);
296 } else if (strcmp(key, "clockwise") == 0) {
298 } else if (strcmp(key, "cube") == 0) {
299 char texture[length + 1];
301 if (sscanf(cursor, "%s %n", texture, &n) == 1) {
304 char filepath[strlen(textures_path) + 1 + strlen(texture) + 1];
305 sprintf(filepath, "%s/%s", textures_path, texture);
306 Texture *texture = texture_load_cubemap(filepath, false);
308 model_node_add_mesh(node, &(ModelMesh) {
310 .textures = &texture->txo,
315 fprintf(stderr, "[warning] invalid value for cube in model %s in line %d\n", path, count);
318 fprintf(stderr, "[warning] invalid key '%s' in model %s in line %d\n", key, path, count);
322 model_node_transform(node);
324 stack.siz = tabs + 1;
325 array_apd(&stack, &node);
334 transform_node(model->root);
338 Model *model_clone(Model *original)
340 Model *model = malloc(sizeof *model);
342 model->root = clone_node(original->root, NULL);
346 void model_delete(Model *model)
348 if (model->callbacks.delete)
349 model->callbacks.delete(model);
351 delete_node(model->root);
355 void model_free_meshes(Model *model)
357 free_node_meshes(model->root);
360 void model_get_bones(Model *model, ModelBoneMapping *mappings, size_t num_mappings)
362 char *name, *cursor, *saveptr, *tok;
364 for (size_t i = 0; i < num_mappings; i++) {
365 name = cursor = strdup(mappings[i].name);
367 ModelNode *node = model->root;
369 while (node && (tok = strtok_r(cursor, ".", &saveptr))) {
370 node = list_get(&node->children, tok, &cmp_node, NULL);
375 *mappings[i].node = node;
377 fprintf(stderr, "[warning] no such bone: %s\n", mappings[i].name);
383 // ModelNode functions
385 ModelNode *model_node_create(ModelNode *parent)
387 ModelNode *node = malloc(sizeof *node);
391 node->pos = (v3f32) {0.0f, 0.0f, 0.0f};
392 node->rot = (v3f32) {0.0f, 0.0f, 0.0f};
393 node->scale = (v3f32) {1.0f, 1.0f, 1.0f};
394 array_ini(&node->meshes, sizeof(ModelMesh), 0);
395 init_node(node, parent);
399 void model_node_transform(ModelNode *node)
401 mat4x4_identity(node->rel);
403 mat4x4_translate(node->rel,
408 mat4x4_scale_aniso(node->rel, node->rel,
413 mat4x4_rotate_X(node->rel, node->rel, node->rot.x);
414 mat4x4_rotate_Y(node->rel, node->rel, node->rot.y);
415 mat4x4_rotate_Z(node->rel, node->rel, node->rot.z);
417 transform_node(node);
420 void model_node_add_mesh(ModelNode *node, const ModelMesh *mesh)
422 array_apd(&node->meshes, mesh);
423 clone_mesh(&((ModelMesh *) node->meshes.ptr)[node->meshes.siz - 1]);
426 void model_node_add_batch(ModelNode *node, ModelBatch *batch)
428 if (!batch->textures.siz) {
433 array_srt(&batch->textures, &cmp_batch_texture);
434 ModelBatchTexture *textures = batch->textures.ptr;
436 size_t num_meshes = ceil((double) batch->textures.siz / (double) units);
437 array_grw(&node->meshes, num_meshes);
438 ModelMesh *meshes = &((ModelMesh *) node->meshes.ptr)[node->meshes.siz - num_meshes];
440 for (size_t m = 0; m < num_meshes; m++) {
441 ModelMesh *mesh = &meshes[m];
443 mesh->mesh = malloc(sizeof *mesh->mesh);
444 mesh->mesh->layout = batch->layout;
445 mesh->mesh->vao = mesh->mesh->vbo = 0;
446 mesh->mesh->free_data = true;
448 mesh->textures = malloc(sizeof *mesh->textures * (mesh->num_textures =
449 ceil((double) (batch->textures.siz - m) / (double) num_meshes)));
451 mesh->shader = batch->shader;
453 mesh->mesh->count = 0;
454 for (size_t t = 0; t < mesh->num_textures; t++) {
455 ModelBatchTexture *texture = &textures[m + t * num_meshes];
456 mesh->mesh->count += texture->vertices.siz;
457 mesh->textures[t] = texture->texture;
459 for (size_t v = 0; v < texture->vertices.siz; v++)
460 *((f32 *) (texture->vertices.ptr + v * texture->vertices.mbs
461 + batch->off_tex_idx)) = t;
464 ModelBatchTexture *first = &textures[m];
465 first->vertices.cap = mesh->mesh->count;
466 first->vertices.ext = 0;
467 array_rlc(&first->vertices);
469 mesh->mesh->data = first->vertices.ptr;
471 for (size_t t = 1; t < mesh->num_textures; t++) {
472 ModelBatchTexture *texture = &textures[m + t * num_meshes];
473 memcpy(first->vertices.ptr + first->vertices.siz * first->vertices.mbs,
474 texture->vertices.ptr, texture->vertices.siz * texture->vertices.mbs);
475 first->vertices.siz += texture->vertices.siz;
477 array_clr(&texture->vertices);
481 array_clr(&batch->textures);
485 // ModelBatch functions
487 ModelBatch *model_batch_create(ModelShader *shader, VertexLayout *layout, size_t off_tex_idx)
489 ModelBatch *batch = malloc(sizeof *batch);
490 batch->shader = shader;
491 batch->layout = layout;
492 batch->off_tex_idx = off_tex_idx;
493 array_ini(&batch->textures, sizeof(ModelBatchTexture), 5);
497 void model_batch_free(ModelBatch *batch)
499 for (size_t i = 0; i < batch->textures.siz; i++)
500 array_clr(&((ModelBatchTexture *) batch->textures.ptr)[i].vertices);
502 array_clr(&batch->textures);
506 void model_batch_add_vertex(ModelBatch *batch, GLuint texture, const void *vertex)
508 ModelBatchTexture *batch_texture = NULL;
510 for (size_t i = 0; i <= batch->textures.siz; i++) {
511 if (i == batch->textures.siz) {
512 ModelBatchTexture new;
513 new.texture = texture;
514 array_ini(&new.vertices, batch->layout->size, 10000);
515 array_apd(&batch->textures, &new);
518 if ((batch_texture = &((ModelBatchTexture *) batch->textures.ptr)[i])->texture == texture)
522 array_apd(&batch_texture->vertices, vertex);
527 void model_scene_add(Model *model)
529 pthread_mutex_lock(&lock_scene_new);
530 list_apd(&scene_new, model);
531 pthread_mutex_unlock(&lock_scene_new);
534 void model_scene_render(f64 dtime)
536 pthread_mutex_lock(&lock_scene_new);
538 *scene.end = scene_new.fst;
539 scene.end = scene_new.end;
541 list_ini(&scene_new);
543 pthread_mutex_unlock(&lock_scene_new);
546 tree_ini(&transparent);
548 for (ListNode **node = &scene.fst; *node != NULL;) {
549 Model *model = (*node)->dat;
551 if (model->flags.delete) {
553 (*node)->dat = model->replace;
555 list_nrm(&scene, node);
559 node = &(*node)->nxt;
560 model_step(model, &transparent, dtime);
564 tree_clr(&transparent, &render_model, NULL, NULL, TRAVERSION_INORDER);