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->flags.wireframe) {
149 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); GL_DEBUG
152 render_node(model->root);
154 if (model->flags.wireframe) {
155 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); GL_DEBUG
159 // step model help im stuck
160 static void model_step(Model *model, Tree *transparent, f64 dtime)
162 if (client_config.view_distance < (model->distance = sqrt(
163 pow(model->root->pos.x - camera.eye[0], 2) +
164 pow(model->root->pos.y - camera.eye[1], 2) +
165 pow(model->root->pos.z - camera.eye[2], 2))))
168 if (model->callbacks.step)
169 model->callbacks.step(model, dtime);
171 if (!model->root->visible)
174 if (model->flags.frustum_culling && frustum_cull((aabb3f32) {
175 v3f32_add(model->box.min, model->root->pos),
176 v3f32_add(model->box.max, model->root->pos)}))
179 // fixme: if there are multiple objects with the exact same distance, only one is rendered
180 if (model->flags.transparent)
181 tree_add(transparent, &model->distance, model, &cmp_model, NULL);
190 list_ini(&scene_new);
192 pthread_mutex_init(&lock_scene_new, NULL);
193 glGetIntegerv(GL_MAX_TEXTURE_UNITS, &units); GL_DEBUG
199 list_clr(&scene, &model_delete, NULL, NULL);
200 list_clr(&scene_new, &model_delete, NULL, NULL);
202 pthread_mutex_destroy(&lock_scene_new);
207 Model *model_create()
209 Model *model = malloc(sizeof *model);
210 model->root = model_node_create(NULL);
212 model->replace = NULL;
214 model->callbacks.step = NULL;
215 model->callbacks.delete = NULL;
217 model->flags.delete =
218 model->flags.wireframe =
219 model->flags.frustum_culling =
220 model->flags.transparent = 0;
225 Model *model_load(const char *path, const char *textures_path, Mesh *cube, ModelShader *shader)
227 Model *model = model_create();
230 array_ini(&stack, sizeof(ModelNode *), 5);
231 array_apd(&stack, &model->root);
233 FILE *file = fopen(path, "r");
235 fprintf(stderr, "[warning] failed to open model %s\n", path);
244 while ((length = getline(&line, &siz, file)) > 0) {
250 char *cursor = line - 1;
253 while (*++cursor == '\t')
256 if (tabs >= stack.siz) {
257 fprintf(stderr, "[warning] invalid indent in model %s in line %d\n", path, count);
261 ModelNode *node = model_node_create(((ModelNode **) stack.ptr)[tabs]);
264 char key[length + 1];
265 while (sscanf(cursor, "%s %n", key, &n) == 1) {
268 if (strcmp(key, "name") == 0) {
269 char name[length + 1];
271 if (sscanf(cursor, "%s %n", name, &n) == 1) {
276 node->name = strdup(name);
278 fprintf(stderr, "[warning] invalid value for name in model %s in line %d\n", path, count);
280 } else if (strcmp(key, "pos") == 0) {
281 if (sscanf(cursor, "%f %f %f %n", &node->pos.x, &node->pos.y, &node->pos.z, &n) == 3)
284 fprintf(stderr, "[warning] invalid value for pos in model %s in line %d\n", path, count);
285 } else if (strcmp(key, "rot") == 0) {
286 if (sscanf(cursor, "%f %f %f %n", &node->rot.x, &node->rot.y, &node->rot.z, &n) == 3)
289 fprintf(stderr, "[warning] invalid value for rot in model %s in line %d\n", path, count);
291 node->rot = v3f32_scale(node->rot, M_PI / 180.0);
292 } else if (strcmp(key, "scale") == 0) {
293 if (sscanf(cursor, "%f %f %f %n", &node->scale.x, &node->scale.y, &node->scale.z, &n) == 3)
296 fprintf(stderr, "[warning] invalid value for scale in model %s in line %d\n", path, count);
297 } else if (strcmp(key, "clockwise") == 0) {
299 } else if (strcmp(key, "cube") == 0) {
300 char texture[length + 1];
302 if (sscanf(cursor, "%s %n", texture, &n) == 1) {
305 char filepath[strlen(textures_path) + 1 + strlen(texture) + 1];
306 sprintf(filepath, "%s/%s", textures_path, texture);
307 Texture *texture = texture_load_cubemap(filepath, false);
309 model_node_add_mesh(node, &(ModelMesh) {
311 .textures = &texture->txo,
316 fprintf(stderr, "[warning] invalid value for cube in model %s in line %d\n", path, count);
319 fprintf(stderr, "[warning] invalid key '%s' in model %s in line %d\n", key, path, count);
323 model_node_transform(node);
325 stack.siz = tabs + 1;
326 array_apd(&stack, &node);
335 transform_node(model->root);
339 Model *model_clone(Model *original)
341 Model *model = malloc(sizeof *model);
343 model->root = clone_node(original->root, NULL);
347 void model_delete(Model *model)
349 if (model->callbacks.delete)
350 model->callbacks.delete(model);
352 delete_node(model->root);
356 void model_free_meshes(Model *model)
358 free_node_meshes(model->root);
361 void model_get_bones(Model *model, ModelBoneMapping *mappings, size_t num_mappings)
363 char *name, *cursor, *saveptr, *tok;
365 for (size_t i = 0; i < num_mappings; i++) {
366 name = cursor = strdup(mappings[i].name);
368 ModelNode *node = model->root;
370 while (node && (tok = strtok_r(cursor, ".", &saveptr))) {
371 node = list_get(&node->children, tok, &cmp_node, NULL);
376 *mappings[i].node = node;
378 fprintf(stderr, "[warning] no such bone: %s\n", mappings[i].name);
384 // ModelNode functions
386 ModelNode *model_node_create(ModelNode *parent)
388 ModelNode *node = malloc(sizeof *node);
392 node->pos = (v3f32) {0.0f, 0.0f, 0.0f};
393 node->rot = (v3f32) {0.0f, 0.0f, 0.0f};
394 node->scale = (v3f32) {1.0f, 1.0f, 1.0f};
395 array_ini(&node->meshes, sizeof(ModelMesh), 0);
396 init_node(node, parent);
400 void model_node_transform(ModelNode *node)
402 mat4x4_identity(node->rel);
404 mat4x4_translate(node->rel,
409 mat4x4_scale_aniso(node->rel, node->rel,
414 mat4x4_rotate_X(node->rel, node->rel, node->rot.x);
415 mat4x4_rotate_Y(node->rel, node->rel, node->rot.y);
416 mat4x4_rotate_Z(node->rel, node->rel, node->rot.z);
418 transform_node(node);
421 void model_node_add_mesh(ModelNode *node, const ModelMesh *mesh)
423 array_apd(&node->meshes, mesh);
424 clone_mesh(&((ModelMesh *) node->meshes.ptr)[node->meshes.siz - 1]);
427 void model_node_add_batch(ModelNode *node, ModelBatch *batch)
429 if (!batch->textures.siz) {
434 array_srt(&batch->textures, &cmp_batch_texture);
435 ModelBatchTexture *textures = batch->textures.ptr;
437 size_t num_meshes = ceil((double) batch->textures.siz / (double) units);
438 array_grw(&node->meshes, num_meshes);
439 ModelMesh *meshes = &((ModelMesh *) node->meshes.ptr)[node->meshes.siz - num_meshes];
441 for (size_t m = 0; m < num_meshes; m++) {
442 ModelMesh *mesh = &meshes[m];
444 mesh->mesh = malloc(sizeof *mesh->mesh);
445 mesh->mesh->layout = batch->layout;
446 mesh->mesh->vao = mesh->mesh->vbo = 0;
447 mesh->mesh->free_data = true;
449 mesh->textures = malloc(sizeof *mesh->textures * (mesh->num_textures =
450 ceil((double) (batch->textures.siz - m) / (double) num_meshes)));
452 mesh->shader = batch->shader;
454 mesh->mesh->count = 0;
455 for (size_t t = 0; t < mesh->num_textures; t++) {
456 ModelBatchTexture *texture = &textures[m + t * num_meshes];
457 mesh->mesh->count += texture->vertices.siz;
458 mesh->textures[t] = texture->texture;
460 for (size_t v = 0; v < texture->vertices.siz; v++)
461 *((f32 *) (texture->vertices.ptr + v * texture->vertices.mbs
462 + batch->off_tex_idx)) = t;
465 ModelBatchTexture *first = &textures[m];
466 first->vertices.cap = mesh->mesh->count;
467 first->vertices.ext = 0;
468 array_rlc(&first->vertices);
470 mesh->mesh->data = first->vertices.ptr;
472 for (size_t t = 1; t < mesh->num_textures; t++) {
473 ModelBatchTexture *texture = &textures[m + t * num_meshes];
474 memcpy(first->vertices.ptr + first->vertices.siz * first->vertices.mbs,
475 texture->vertices.ptr, texture->vertices.siz * texture->vertices.mbs);
476 first->vertices.siz += texture->vertices.siz;
478 array_clr(&texture->vertices);
482 array_clr(&batch->textures);
486 // ModelBatch functions
488 ModelBatch *model_batch_create(ModelShader *shader, VertexLayout *layout, size_t off_tex_idx)
490 ModelBatch *batch = malloc(sizeof *batch);
491 batch->shader = shader;
492 batch->layout = layout;
493 batch->off_tex_idx = off_tex_idx;
494 array_ini(&batch->textures, sizeof(ModelBatchTexture), 5);
498 void model_batch_free(ModelBatch *batch)
500 for (size_t i = 0; i < batch->textures.siz; i++)
501 array_clr(&((ModelBatchTexture *) batch->textures.ptr)[i].vertices);
503 array_clr(&batch->textures);
507 void model_batch_add_vertex(ModelBatch *batch, GLuint texture, const void *vertex)
509 ModelBatchTexture *batch_texture = NULL;
511 for (size_t i = 0; i <= batch->textures.siz; i++) {
512 if (i == batch->textures.siz) {
513 ModelBatchTexture new;
514 new.texture = texture;
515 array_ini(&new.vertices, batch->layout->size, 10000);
516 array_apd(&batch->textures, &new);
519 if ((batch_texture = &((ModelBatchTexture *) batch->textures.ptr)[i])->texture == texture)
523 array_apd(&batch_texture->vertices, vertex);
528 void model_scene_add(Model *model)
530 pthread_mutex_lock(&lock_scene_new);
531 list_apd(&scene_new, model);
532 pthread_mutex_unlock(&lock_scene_new);
535 void model_scene_render(f64 dtime)
537 pthread_mutex_lock(&lock_scene_new);
539 *scene.end = scene_new.fst;
540 scene.end = scene_new.end;
542 list_ini(&scene_new);
544 pthread_mutex_unlock(&lock_scene_new);
547 tree_ini(&transparent);
549 for (ListNode **node = &scene.fst; *node != NULL;) {
550 Model *model = (*node)->dat;
552 if (model->flags.delete) {
554 (*node)->dat = model->replace;
556 list_nrm(&scene, node);
560 node = &(*node)->nxt;
561 model_step(model, &transparent, dtime);
565 tree_clr(&transparent, &render_model, NULL, NULL, TRAVERSION_INORDER);