model.h

   1 /*
   2  * Copyright (C) 2021-2022 Mt.ZERO Software, Harry Godden - All Rights Reserved
   3  */
   4
   5 #ifndef MODEL_H
   6 #define MODEL_H
   7
   8 #include "common.h"
   9
  10 typedef struct glmesh glmesh;
  11
  12 typedef struct mdl_vert mdl_vert;
  13 typedef struct mdl_submesh mdl_submesh;
  14 typedef struct mdl_material mdl_material;
  15 typedef struct mdl_node mdl_node;
  16 typedef struct mdl_file_header mdl_file_header;
  17 typedef struct mdl_animation mdl_animation;
  18 typedef struct mdl_keyframe mdl_keyframe;
  19 typedef struct mdl_texture mdl_texture;
  20 typedef struct mdl_context mdl_context;
  21
  22 #define MDL_SIZE_MAX          0x1000000
  23 #define MDL_VERT_MAX          1000000
  24 #define MDL_INDICE_MAX        1000000
  25 #define MDL_MATERIAL_MAX      32
  26 #define MDL_NODE_MAX          4000
  27 #define MDL_SUBMESH_MAX       8000
  28 #define MDL_STRING_LENGTH_MAX 64
  29
  30 enum classtype
  31 {
  32    k_classtype_none                 = 0,
  33    k_classtype_gate                 = 1,
  34    k_classtype_spawn                = 3,
  35    k_classtype_water                = 4,
  36    k_classtype_route_node           = 8,
  37    k_classtype_route                = 9,
  38    k_classtype_bone                 = 10,
  39    k_classtype_skeleton             = 11,
  40    k_classtype_skin                 = 12,
  41    k_classtype_audio                = 14,
  42    k_classtype_trigger              = 100,
  43    k_classtype_logic_achievement    = 101,
  44    k_classtype_logic_relay          = 102,
  45    k_classtype_point_light          = 200,
  46    k_classtype_nonlocal_gate        = 300
  47 };
  48
  49 enum mdl_shader
  50 {
  51    k_shader_standard                = 0,
  52    k_shader_standard_cutout         = 1,
  53    k_shader_terrain_blend           = 2,
  54    k_shader_standard_vertex_blend   = 3,
  55    k_shader_water                   = 4
  56 };
  57
  58 enum mdl_surface_prop
  59 {
  60    k_surface_prop_concrete          = 0,
  61    k_surface_prop_wood              = 1,
  62    k_surface_prop_grass             = 2
  63 };
  64
  65 enum material_flag
  66 {
  67    k_material_flag_skate_surface    = 0x1,
  68    k_material_flag_collision        = 0x2,
  69    k_material_flag_grow_grass       = 0x4,
  70    k_material_flag_grind_surface    = 0x8
  71 };
  72
  73 enum bone_flag
  74 {
  75    k_bone_flag_deform               = 0x1,
  76    k_bone_flag_ik                   = 0x2,
  77    k_bone_flag_collider_box         = 0x4,
  78    k_bone_flag_collider_capsule     = 0x8,
  79    k_bone_flag_collider_reserved0   = 0x10,
  80    k_bone_flag_collider_reserved1   = 0x20,
  81    k_bone_flag_collider_reserved2   = 0x40,
  82    k_bone_flag_collider_reserved3   = 0x80,
  83    k_bone_flag_collider_any         = k_bone_flag_collider_box |
  84                                       k_bone_flag_collider_capsule |
  85                                       k_bone_flag_collider_reserved0 |
  86                                       k_bone_flag_collider_reserved1 |
  87                                       k_bone_flag_collider_reserved2 |
  88                                       k_bone_flag_collider_reserved3,
  89    k_bone_flag_cone_constraint      = 0x100,
  90    k_bone_flag_force_u32            = 0xffffffff
  91 };
  92
  93 #pragma pack(push,1)
  94
  95 /* 48 byte */
  96 struct mdl_vert
  97 {
  98    v3f co,        /* 3*32 */
  99        norm;      /* 3*32 */
 100    v2f uv;        /* 2*32 */
 101
 102    u8  colour[4]; /* 4*8 */
 103    u16 weights[4];/* 4*16 */
 104    u8  groups[4]; /* 4*8 */
 105 };
 106
 107 struct mdl_submesh
 108 {
 109    u32 indice_start,
 110        indice_count,
 111        vertex_start,
 112        vertex_count;
 113
 114    boxf bbx;
 115    u32 material_id;
 116 };
 117
 118 struct mdl_texture
 119 {
 120    u32 pstr_name,
 121        pack_offset,
 122        pack_length;
 123 };
 124
 125 struct mdl_material
 126 {
 127    u32 pstr_name,
 128        shader,
 129        flags,
 130        surface_prop;
 131
 132    v4f colour,
 133        colour1;
 134
 135    u32 tex_diffuse,
 136        tex_decal,
 137        tex_normal;
 138 };
 139
 140 struct mdl_node
 141 {
 142    v3f co;
 143    v4f q;
 144    v3f s;
 145
 146    u32 sub_uid,         /* allocated in-file... too bad. */
 147        submesh_start,
 148        submesh_count,
 149        classtype,
 150        offset,
 151        parent,
 152        pstr_name;
 153 };
 154
 155 struct mdl_keyframe
 156 {
 157    v3f co;
 158    v4f q;
 159    v3f s;
 160 };
 161
 162 struct mdl_animation
 163 {
 164    u32 pstr_name,
 165        length;
 166
 167    float rate;
 168
 169    u32 offset;
 170 };
 171
 172 struct mdl_file_header
 173 {
 174    u32 identifier, version, file_length, pad0;
 175
 176    u32
 177        node_count,      node_offset,
 178        submesh_count,   submesh_offset,
 179        material_count,  material_offset,
 180        texture_count,   texture_offset,
 181        anim_count,      anim_offset,
 182        entdata_size,    entdata_offset,
 183        strings_size,    strings_offset,
 184
 185        keyframe_count,  keyframe_offset,
 186
 187        vertex_count,    vertex_offset,
 188        indice_count,    indice_offset,
 189
 190        pack_size,       pack_offset;
 191 };
 192
 193 /*
 194  * Entity data structures
 195  */
 196
 197 struct classtype_gate
 198 {
 199    u32 target;
 200    v3f dims;
 201 };
 202
 203 struct classtype_spawn
 204 {
 205    u32 pstr_alias;
 206 };
 207
 208 struct classtype_water
 209 {
 210    u32 temp;
 211 };
 212
 213 struct classtype_route_node
 214 {
 215    u32 target, target1;
 216 };
 217
 218 struct classtype_route
 219 {
 220    u32 id_start;
 221    u32 pstr_name;
 222    v3f colour;
 223 };
 224
 225 struct classtype_bone
 226 {
 227    u32 flags,
 228        ik_target,
 229        ik_pole;
 230
 231    boxf hitbox;
 232
 233    v3f conevx, conevy, coneva;
 234    float conet;
 235 };
 236
 237 struct classtype_skeleton
 238 {
 239    u32 channels,
 240        ik_count,
 241        collider_count,
 242        anim_start,
 243        anim_count;
 244 };
 245
 246 struct classtype_skin
 247 {
 248    u32 skeleton;
 249 };
 250
 251 struct classtype_trigger
 252 {
 253    u32 target;
 254 };
 255
 256 struct classtype_logic_relay
 257 {
 258    u32 targets[4];
 259 };
 260
 261 struct classtype_logic_achievement
 262 {
 263    u32 pstr_name;
 264 };
 265
 266 struct classtype_audio
 267 {
 268    u32 pstr_file,
 269        flags;
 270
 271    float volume;
 272 };
 273
 274 struct classtype_point_light
 275 {
 276    v4f colour; /* RGB, Energy */
 277 };
 278
 279 #pragma pack(pop)
 280
 281
 282 struct mdl_context
 283 {
 284    FILE *file;
 285    mdl_file_header info;
 286
 287    /* each buffer becomes availible after each _load function is called */
 288    mdl_node       *node_buffer;     /* mdl_load_metadata() */
 289    mdl_submesh    *submesh_buffer;
 290    mdl_material   *material_buffer;
 291    mdl_texture    *texture_buffer;
 292    mdl_animation  *anim_buffer;
 293    void           *entdata_buffer;
 294    const char     *string_buffer;
 295
 296    mdl_keyframe   *keyframe_buffer; /* mdl_load_anim_data() */
 297
 298    mdl_vert       *vertex_buffer;   /* mdl_load_mesh_data() */
 299    u32            *index_buffer;
 300
 301    void           *pack;            /* mdl_load_pack_data() */
 302 };
 303
 304 /*
 305  * Simple mesh interface for OpenGL
 306  */
 307
 308 struct glmesh
 309 {
 310    GLuint vao, vbo, ebo;
 311    u32 indice_count;
 312    u32 loaded;
 313 };
 314
 315 VG_STATIC void mesh_upload( glmesh *mesh,
 316                          mdl_vert *verts, u32 vert_count,
 317                          u32 *indices, u32 indice_count )
 318 {
 319    //assert( mesh->loaded == 0 );
 320
 321    glGenVertexArrays( 1, &mesh->vao );
 322    glGenBuffers( 1, &mesh->vbo );
 323    glGenBuffers( 1, &mesh->ebo );
 324    glBindVertexArray( mesh->vao );
 325
 326    size_t stride = sizeof(mdl_vert);
 327
 328    glBindBuffer( GL_ARRAY_BUFFER, mesh->vbo );
 329    glBufferData( GL_ARRAY_BUFFER, vert_count*stride, verts, GL_STATIC_DRAW );
 330
 331    glBindVertexArray( mesh->vao );
 332    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->ebo );
 333    glBufferData( GL_ELEMENT_ARRAY_BUFFER, indice_count*sizeof(u32),
 334          indices, GL_STATIC_DRAW );
 335
 336    /* 0: coordinates */
 337    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0 );
 338    glEnableVertexAttribArray( 0 );
 339
 340    /* 1: normal */
 341    glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE,
 342          stride, (void *)offsetof(mdl_vert, norm) );
 343    glEnableVertexAttribArray( 1 );
 344
 345    /* 2: uv */
 346    glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE,
 347          stride, (void *)offsetof(mdl_vert, uv) );
 348    glEnableVertexAttribArray( 2 );
 349
 350    /* 3: colour */
 351    glVertexAttribPointer( 3, 4, GL_UNSIGNED_BYTE, GL_TRUE,
 352          stride, (void *)offsetof(mdl_vert, colour) );
 353    glEnableVertexAttribArray( 3 );
 354
 355    /* 4: weights */
 356    glVertexAttribPointer( 4, 4, GL_UNSIGNED_SHORT, GL_TRUE,
 357          stride, (void *)offsetof(mdl_vert, weights) );
 358    glEnableVertexAttribArray( 4 );
 359
 360    /* 5: groups */
 361    glVertexAttribIPointer( 5, 4, GL_UNSIGNED_BYTE,
 362          stride, (void *)offsetof(mdl_vert, groups) );
 363    glEnableVertexAttribArray( 5 );
 364
 365    VG_CHECK_GL_ERR();
 366
 367    mesh->indice_count = indice_count;
 368    mesh->loaded = 1;
 369 }
 370
 371 VG_STATIC void mesh_bind( glmesh *mesh )
 372 {
 373    glBindVertexArray( mesh->vao );
 374 }
 375
 376 VG_STATIC void mesh_drawn( u32 start, u32 count )
 377 {
 378    glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_INT,
 379          (void *)(start*sizeof(u32)) );
 380 }
 381
 382 VG_STATIC void mesh_draw( glmesh *mesh )
 383 {
 384    mesh_drawn( 0, mesh->indice_count );
 385 }
 386
 387 VG_STATIC void mesh_free( glmesh *mesh )
 388 {
 389    if( mesh->loaded )
 390    {
 391       glDeleteVertexArrays( 1, &mesh->vao );
 392       glDeleteBuffers( 1, &mesh->ebo );
 393       glDeleteBuffers( 1, &mesh->vbo );
 394       mesh->loaded = 0;
 395    }
 396 }
 397
 398 VG_STATIC void mdl_load_fatal_corrupt( mdl_context *mdl )
 399 {
 400    fclose( mdl->file );
 401    vg_file_print_invalid( mdl->file );
 402    vg_fatal_exit_loop( "Corrupt model" );
 403 }
 404
 405 /*
 406  * Model implementation
 407  *
 408  * TODO.
 409  *
 410  * you have two api options for loading a model, first, the easy way:
 411  *       mdl_load ...
 412  *    will put the entire model straight into the linear_alloc
 413  *
 414  * or, to target different allocators:
 415  *
 416  *       mdl_open
 417  *       mdl_load_metadata
 418  *       mdl_load_vertex_data
 419  *       mdl_load_indice_data
 420  *       mdl_close
 421  *
 422  * these should ideally be called in quick succession to limit stalls.
 423  */
 424
 425 /*
 426  * if calling mdl_open, and the file does not exist, the game will fatal quit
 427  */
 428 VG_STATIC void mdl_open( mdl_context *mdl, const char *path )
 429 {
 430    memset( mdl, 0, sizeof( mdl_context ) );
 431    mdl->file = fopen( path, "rb" );
 432
 433    if( !mdl->file )
 434    {
 435       vg_error( "mdl_open('%s'): %s\n", path, strerror(errno) );
 436       vg_fatal_exit_loop( "see above for details" );
 437    }
 438
 439    u64 l = fread( &mdl->info, sizeof(mdl_file_header), 1, mdl->file );
 440    if( l != 1 )
 441       mdl_load_fatal_corrupt( mdl );
 442 }
 443
 444 /*
 445  * Load all metadata (everything up until the large buffers). Probs at most 50k
 446  */
 447 VG_STATIC void mdl_load_metadata( mdl_context *mdl, void *lin_alloc )
 448 {
 449    assert( mdl->file );
 450
 451    u64 lheader  = sizeof(mdl_file_header),
 452        ldata    = mdl->info.keyframe_offset - lheader;
 453
 454    void *all_data = vg_linear_alloc( lin_alloc, ldata );
 455
 456    fseek( mdl->file, lheader, SEEK_SET );
 457    u64 l = fread( all_data, ldata, 1, mdl->file );
 458
 459    if( l != 1 )
 460    {
 461       vg_file_print_invalid( mdl->file );
 462       vg_fatal_exit_loop( "Corrupt model" );
 463    }
 464
 465    mdl->node_buffer     = all_data + (mdl->info.node_offset     - lheader);
 466    mdl->submesh_buffer  = all_data + (mdl->info.submesh_offset  - lheader);
 467    mdl->material_buffer = all_data + (mdl->info.material_offset - lheader);
 468    mdl->texture_buffer  = all_data + (mdl->info.texture_offset  - lheader);
 469    mdl->anim_buffer     = all_data + (mdl->info.anim_offset     - lheader);
 470    mdl->entdata_buffer  = all_data + (mdl->info.entdata_offset  - lheader);
 471    mdl->string_buffer   = all_data + (mdl->info.strings_offset  - lheader);
 472 }
 473
 474 /*
 475  * Load just the mesh data
 476  */
 477 VG_STATIC void mdl_load_mesh_data( mdl_context *mdl, void *lin_alloc )
 478 {
 479    assert( mdl->file );
 480
 481    u64 size_verts = vg_align8( mdl->info.vertex_count * sizeof(mdl_vert) ),
 482        size_index = vg_align8( mdl->info.indice_count * sizeof(u32) );
 483
 484    mdl->vertex_buffer = vg_linear_alloc( lin_alloc, size_verts );
 485    mdl->index_buffer  = vg_linear_alloc( lin_alloc, size_index );
 486
 487    {
 488       fseek( mdl->file, mdl->info.vertex_offset, SEEK_SET );
 489       u64 l = fread( mdl->vertex_buffer, size_verts, 1, mdl->file );
 490       if( l != 1 )
 491          mdl_load_fatal_corrupt( mdl );
 492    }
 493    {
 494       fseek( mdl->file, mdl->info.indice_offset, SEEK_SET );
 495       u64 l = fread( mdl->index_buffer, size_index, 1, mdl->file );
 496       if( l != 1 )
 497          mdl_load_fatal_corrupt( mdl );
 498    }
 499 }
 500
 501 /*
 502  * Load animation data
 503  */
 504 VG_STATIC void mdl_load_anim_data( mdl_context *mdl, void *lin_alloc )
 505 {
 506    assert( mdl->file );
 507
 508    if( mdl->info.keyframe_count == 0 )
 509       return;
 510
 511    u64 size_kf = vg_align8( mdl->info.keyframe_count * sizeof(mdl_keyframe) );
 512    mdl->keyframe_buffer = vg_linear_alloc( lin_alloc, size_kf );
 513
 514    fseek( mdl->file, mdl->info.keyframe_offset, SEEK_SET );
 515    u64 l = fread( mdl->keyframe_buffer, size_kf, 1, mdl->file );
 516    if( l != 1 )
 517       mdl_load_fatal_corrupt( mdl );
 518 }
 519
 520 /*
 521  * Load pack contents
 522  *
 523  * TODO request specific files (low)
 524  */
 525 VG_STATIC void mdl_load_pack_data( mdl_context *mdl, void *lin_alloc )
 526 {
 527    assert( mdl->file );
 528
 529    if( mdl->info.pack_size == 0 )
 530       return;
 531
 532    mdl->pack = vg_linear_alloc( lin_alloc, vg_align8( mdl->info.pack_size ) );
 533    fseek( mdl->file, mdl->info.pack_offset, SEEK_SET );
 534
 535    u64 l = fread( mdl->pack, mdl->info.pack_size, 1, mdl->file );
 536    if( l != 1 )
 537       mdl_load_fatal_corrupt( mdl );
 538 }
 539
 540 /*
 541  * close file handle
 542  */
 543 VG_STATIC void mdl_close( mdl_context *mdl )
 544 {
 545    fclose( mdl->file );
 546    mdl->file = NULL;
 547 }
 548
 549 /* open a model. TODO: make this flags ( ANIM_DATA|MESH_DATA ... ) */
 550 VG_STATIC mdl_context *mdl_load_full( void *lin_alloc, const char *path )
 551 {
 552    /* Inspect the header by opening it, give us the size needed */
 553    mdl_context temp_ctx;
 554    mdl_open( &temp_ctx, path );
 555
 556    /* create allocator */
 557    u32 tot_size = temp_ctx.info.file_length + sizeof( mdl_context ) + 64;
 558    void *data = vg_create_linear_allocator( lin_alloc, tot_size,
 559                                             VG_MEMORY_SYSTEM );
 560
 561    /* copy context and load all other data */
 562    mdl_context *ctx = vg_linear_alloc( data, sizeof(mdl_context) );
 563    memcpy( ctx, &temp_ctx, sizeof(mdl_context) );
 564
 565    mdl_load_metadata( ctx, data );
 566    mdl_load_anim_data( ctx, data );
 567    mdl_load_mesh_data( ctx, data );
 568    mdl_load_pack_data( ctx, data );
 569    mdl_close( ctx );
 570
 571    return ctx;
 572 }
 573
 574 /*
 575  * Item getters
 576  * ----------------------------------------------------------------------------
 577  * TODO: Clamp access and oob errors
 578  */
 579 VG_STATIC const char *mdl_pstr( mdl_context *mdl, u32 pstr )
 580 {
 581    return mdl->string_buffer + pstr;
 582 }
 583
 584 VG_STATIC mdl_node *mdl_node_from_id( mdl_context *mdl, u32 id )
 585 {
 586    return &mdl->node_buffer[id];
 587 }
 588
 589 VG_STATIC mdl_node *mdl_node_from_name( mdl_context *mdl, const char *name )
 590 {
 591    for( int i=0; i < mdl->info.node_count; i++ )
 592    {
 593       mdl_node *pnode = mdl_node_from_id( mdl, i );
 594
 595       if( !strcmp( name, mdl_pstr( mdl, pnode->pstr_name )) )
 596          return pnode;
 597    }
 598
 599    return NULL;
 600 }
 601
 602 VG_STATIC mdl_submesh *mdl_node_submesh( mdl_context *mdl,
 603                                          mdl_node *node, u32 i )
 604 {
 605    return &mdl->submesh_buffer[ node->submesh_start+i ];
 606 }
 607
 608 VG_STATIC u32 *mdl_submesh_indices( mdl_context *mdl, mdl_submesh *sm )
 609 {
 610    return &mdl->index_buffer[ sm->indice_start ];
 611 }
 612
 613 VG_STATIC mdl_vert *mdl_submesh_vertices( mdl_context *mdl, mdl_submesh *sm )
 614 {
 615    return &mdl->vertex_buffer[ sm->vertex_start ];
 616 }
 617
 618 VG_STATIC void mdl_node_transform( mdl_node *pnode, m4x3f transform )
 619 {
 620    q_m3x3( pnode->q, transform );
 621    v3_muls( transform[0], pnode->s[0], transform[0] );
 622    v3_muls( transform[1], pnode->s[1], transform[1] );
 623    v3_muls( transform[2], pnode->s[2], transform[2] );
 624    v3_copy( pnode->co, transform[3] );
 625 }
 626
 627 /* upload a mesh based on file submesh */
 628 VG_STATIC void mdl_unpack_submesh( mdl_context *mdl, glmesh *mesh,
 629                                 mdl_submesh *sm )
 630 {
 631    mesh_upload( mesh, mdl_submesh_vertices( mdl, sm ), sm->vertex_count,
 632                       mdl_submesh_indices( mdl, sm ), sm->indice_count );
 633 }
 634
 635 /* upload entire mesh from model */
 636 VG_STATIC void mdl_unpack_glmesh( mdl_context *mdl, glmesh *mesh )
 637 {
 638    u32 offset = mdl->submesh_buffer[0].vertex_count;
 639
 640    for( int i=1; i< mdl->info.submesh_count; i++ )
 641    {
 642       mdl_submesh *sm = &mdl->submesh_buffer[i];
 643       u32 *indices    =  mdl_submesh_indices( mdl, sm );
 644
 645       for( u32 j=0; j<sm->indice_count; j++ )
 646          indices[j] += offset;
 647
 648       offset += sm->vertex_count;
 649    }
 650
 651    mesh_upload( mesh, mdl->vertex_buffer, mdl->info.vertex_count,
 652                       mdl->index_buffer,  mdl->info.indice_count );
 653 }
 654
 655 VG_STATIC void mdl_draw_submesh( mdl_submesh *sm )
 656 {
 657    mesh_drawn( sm->indice_start, sm->indice_count );
 658 }
 659
 660 VG_STATIC void *mdl_get_entdata( mdl_context *mdl, mdl_node *pnode )
 661 {
 662    return mdl->entdata_buffer + pnode->offset;
 663 }
 664
 665 VG_STATIC mdl_keyframe *mdl_get_animdata( mdl_context *mdl, mdl_animation *anim )
 666 {
 667    return mdl->keyframe_buffer + anim->offset;
 668 }
 669
 670 VG_STATIC void mdl_link_materials( mdl_context *root, mdl_context *child )
 671 {
 672    u32 lookup[MDL_MATERIAL_MAX];
 673
 674    for( int i=0; i<child->info.material_count; i++ )
 675    {
 676       mdl_material *mi = &child->material_buffer[i];
 677       const char *si = mdl_pstr( child, mi->pstr_name );
 678
 679       lookup[i] = 0;
 680
 681       for( int j=0; j<root->info.material_count; j++ )
 682       {
 683          mdl_material *mj = &root->material_buffer[j];
 684          const char *sj = mdl_pstr( root, mj->pstr_name );
 685
 686          if( !strcmp( si, sj ) )
 687          {
 688             lookup[i] = j;
 689             break;
 690          }
 691       }
 692
 693       if( lookup[i] == 0 && i != 0 )
 694       {
 695          vg_warn( "Could not link material '%s' (not present in root model)\n",
 696                    si );
 697       }
 698    }
 699
 700    for( int i=0; i<child->info.submesh_count; i++ )
 701    {
 702       mdl_submesh *sm = &child->submesh_buffer[i];
 703       sm->material_id =  lookup[sm->material_id];
 704    }
 705 }
 706
 707 VG_STATIC void mdl_invert_uv_coordinates( mdl_context *mdl )
 708 {
 709    for( int i=0; i<mdl->info.vertex_count; i++ )
 710    {
 711       mdl_vert *vert = &mdl->vertex_buffer[i];
 712       vert->uv[1] = 1.0f-vert->uv[1];
 713    }
 714 }
 715
 716 #endif