model.h

   1 #ifndef MODEL_H
   2 #define MODEL_H
   3
   4 #include "common.h"
   5
   6 typedef struct glmesh glmesh;
   7
   8 typedef struct mdl_vert mdl_vert;
   9 typedef struct mdl_submesh mdl_submesh;
  10 typedef struct mdl_material mdl_material;
  11 typedef struct mdl_node mdl_node;
  12 typedef struct mdl_header mdl_header;
  13 typedef struct mdl_animation mdl_animation;
  14 typedef struct mdl_keyframe mdl_keyframe;
  15
  16 #define MDL_SIZE_MAX          0x1000000
  17 #define MDL_VERT_MAX          1000000
  18 #define MDL_INDICE_MAX        1000000
  19 #define MDL_MATERIAL_MAX      32
  20 #define MDL_NODE_MAX          4000
  21 #define MDL_SUBMESH_MAX       8000
  22 #define MDL_STRING_LENGTH_MAX 64
  23
  24 #pragma pack(push,1)
  25
  26 struct mdl_vert
  27 {
  28    v3f co,
  29        norm;
  30    v2f uv;
  31    u8  colour[4];
  32    u16 weights[4];
  33    u8  groups[4];
  34 };
  35
  36 struct mdl_submesh
  37 {
  38    u32 indice_start,
  39        indice_count,
  40        vertex_start,
  41        vertex_count;
  42
  43    boxf bbx;
  44    u32 material_id;
  45 };
  46
  47 struct mdl_material
  48 {
  49    u32 pstr_name;
  50 };
  51
  52 struct mdl_node
  53 {
  54    v3f co;
  55    v4f q;
  56    v3f s;
  57
  58    union{ u32 submesh_start, sub_uid; };
  59
  60    u32
  61        submesh_count,
  62        classtype,
  63        offset,
  64        parent,
  65        pstr_name;
  66 };
  67
  68 struct mdl_keyframe
  69 {
  70    v3f co;
  71    v4f q;
  72    v3f s;
  73 };
  74
  75 struct mdl_animation
  76 {
  77    u32 pstr_name,
  78        length;
  79
  80    float rate;
  81
  82    u32 offset;
  83 };
  84
  85 struct mdl_header
  86 {
  87    u32 identifier, version, file_length;
  88
  89    u32 vertex_count, vertex_offset,
  90        indice_count, indice_offset,
  91        submesh_count, submesh_offset,
  92        material_count, material_offset,
  93        node_count, node_offset,
  94        anim_count, anim_offset,
  95        strings_offset, entdata_offset, animdata_offset;
  96 };
  97
  98 /*
  99  * Entity data structures
 100  */
 101
 102 struct classtype_block
 103 {
 104    boxf bbx;
 105 };
 106
 107 struct classtype_gate
 108 {
 109    u32 target;
 110    v3f dims;
 111 };
 112
 113 struct classtype_spawn
 114 {
 115    u32 target;
 116 };
 117
 118 struct classtype_water
 119 {
 120    u32 temp;
 121 };
 122
 123 struct classtype_car_path
 124 {
 125    u32 target, target1;
 126 };
 127
 128 struct classtype_instance
 129 {
 130    u32 pstr_file;
 131 };
 132
 133 struct classtype_capsule
 134 {
 135    float height, radius;
 136 };
 137
 138 struct classtype_route_node
 139 {
 140    u32 target, target1;
 141 };
 142
 143 struct classtype_route
 144 {
 145    u32 id_start;
 146    v3f colour;
 147 };
 148
 149 struct classtype_bone
 150 {
 151    u32 deform,
 152        ik_target,
 153        ik_pole,
 154        collider,
 155        use_limits;
 156
 157    v3f angle_limits[2];
 158    boxf hitbox;
 159 };
 160
 161 struct classtype_skeleton
 162 {
 163    u32 channels,
 164        ik_count,
 165        collider_count,
 166        anim_start,
 167        anim_count;
 168 };
 169
 170 struct classtype_skin
 171 {
 172    u32 skeleton;
 173 };
 174
 175 #pragma pack(pop)
 176
 177 /*
 178  * Simple mesh interface for OpenGL
 179  */
 180
 181 struct glmesh
 182 {
 183    GLuint vao, vbo, ebo;
 184    u32 indice_count;
 185    u32 loaded;
 186 };
 187
 188 static void mesh_upload( glmesh *mesh,
 189                          mdl_vert *verts, u32 vert_count,
 190                          u32 *indices, u32 indice_count )
 191 {
 192    //assert( mesh->loaded == 0 );
 193
 194    glGenVertexArrays( 1, &mesh->vao );
 195    glGenBuffers( 1, &mesh->vbo );
 196    glGenBuffers( 1, &mesh->ebo );
 197    glBindVertexArray( mesh->vao );
 198
 199    size_t stride = sizeof(mdl_vert);
 200
 201    glBindBuffer( GL_ARRAY_BUFFER, mesh->vbo );
 202    glBufferData( GL_ARRAY_BUFFER, vert_count*stride, verts, GL_STATIC_DRAW );
 203
 204    glBindVertexArray( mesh->vao );
 205    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->ebo );
 206    glBufferData( GL_ELEMENT_ARRAY_BUFFER, indice_count*sizeof(u32),
 207          indices, GL_STATIC_DRAW );
 208
 209    /* 0: coordinates */
 210    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0 );
 211    glEnableVertexAttribArray( 0 );
 212
 213    /* 1: normal */
 214    glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE,
 215          stride, (void *)offsetof(mdl_vert, norm) );
 216    glEnableVertexAttribArray( 1 );
 217
 218    /* 2: uv */
 219    glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE,
 220          stride, (void *)offsetof(mdl_vert, uv) );
 221    glEnableVertexAttribArray( 2 );
 222
 223    /* 3: colour */
 224    glVertexAttribPointer( 3, 4, GL_UNSIGNED_BYTE, GL_TRUE,
 225          stride, (void *)offsetof(mdl_vert, colour) );
 226    glEnableVertexAttribArray( 3 );
 227
 228    /* 4: weights */
 229    glVertexAttribPointer( 4, 4, GL_UNSIGNED_SHORT, GL_TRUE,
 230          stride, (void *)offsetof(mdl_vert, weights) );
 231    glEnableVertexAttribArray( 4 );
 232
 233    /* 5: groups */
 234    glVertexAttribIPointer( 5, 4, GL_UNSIGNED_BYTE,
 235          stride, (void *)offsetof(mdl_vert, groups) );
 236    glEnableVertexAttribArray( 5 );
 237
 238    VG_CHECK_GL_ERR();
 239
 240    mesh->indice_count = indice_count;
 241    mesh->loaded = 1;
 242 }
 243
 244 static void mesh_bind( glmesh *mesh )
 245 {
 246    glBindVertexArray( mesh->vao );
 247 }
 248
 249 static void mesh_drawn( u32 start, u32 count )
 250 {
 251    glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_INT,
 252          (void *)(start*sizeof(u32)) );
 253 }
 254
 255 static void mesh_draw( glmesh *mesh )
 256 {
 257    mesh_drawn( 0, mesh->indice_count );
 258 }
 259
 260 static void mesh_free( glmesh *mesh )
 261 {
 262    if( mesh->loaded )
 263    {
 264       glDeleteVertexArrays( 1, &mesh->vao );
 265       glDeleteBuffers( 1, &mesh->ebo );
 266       glDeleteBuffers( 1, &mesh->vbo );
 267    }
 268 }
 269
 270
 271 /*
 272  * Model implementation
 273  */
 274
 275 static mdl_header *mdl_load( const char *path )
 276 {
 277    i64 size;
 278    mdl_header *header = vg_asset_read_s( path, &size );
 279
 280    /*
 281     * Check file is valid
 282     */
 283    if( !header )
 284    {
 285       vg_error( "Could not open '%s'\n", path );
 286       return NULL;
 287    }
 288
 289    if( size < sizeof(mdl_header) )
 290    {
 291       vg_free( header );
 292       vg_error( "Invalid file '%s' (too small for header)\n", path );
 293       return NULL;
 294    }
 295
 296    if( header->file_length != size )
 297    {
 298       vg_error( "Invalid file '%s'"
 299                 "(wrong .file_length, %ub != real file size %ub)\n",
 300                 path, header->file_length, size );
 301       vg_free( header );
 302       return NULL;
 303    }
 304
 305    /*
 306     * Validate offsets and memory sections, to ensure all arrays are in-bounds,
 307     * and that they do not overlap.
 308     */
 309
 310    struct memregion
 311    {
 312       const char *desc;
 313       u32 count, max_count, size, offset;
 314    }
 315    regions[] = {
 316       {
 317          "Vertices",
 318          header->vertex_count, MDL_VERT_MAX,
 319          sizeof(mdl_vert), header->vertex_offset
 320       },
 321       {
 322          "Indices",
 323          header->indice_count, MDL_INDICE_MAX,
 324          sizeof(u32), header->indice_offset
 325       },
 326       {
 327          "Submesh",
 328          header->submesh_count, MDL_SUBMESH_MAX,
 329          sizeof(mdl_submesh), header->submesh_offset
 330       },
 331       {
 332          "Materials",
 333          header->material_count, MDL_MATERIAL_MAX,
 334          sizeof(mdl_material), header->material_offset
 335       },
 336       {
 337          "Nodes",
 338          header->node_count, MDL_NODE_MAX,
 339          sizeof(mdl_node), header->node_count
 340       }
 341    };
 342
 343    for( int i=0; i<vg_list_size(regions); i++ )
 344    {
 345       struct memregion *ri = &regions[i];
 346
 347       if( ri->count == 0 )
 348          continue;
 349
 350       if( ri->count > ri->max_count )
 351       {
 352          vg_free( header );
 353          vg_error( "'%s': '%s' buffer exceeds the maximum (%u/%u)\n",
 354                path, ri->desc, ri->count, ri->max_count );
 355          return NULL;
 356       }
 357
 358       if( ri->offset >= header->file_length )
 359       {
 360          vg_free( header );
 361          vg_error( "'%s': '%s' buffer offset is out of range\n",
 362                path, ri->desc );
 363          return NULL;
 364       }
 365
 366       if( ri->offset + ri->size*ri->count > header->file_length )
 367       {
 368          vg_free( header );
 369          vg_error( "'%s': '%s' buffer size is out of range\n",
 370                path, ri->desc );
 371          return NULL;
 372       }
 373
 374       for( int j=0; j<vg_list_size(regions); j++ )
 375       {
 376          struct memregion *rj = &regions[j];
 377          if( rj->count == 0 )
 378             continue;
 379
 380          if( ri->offset >= rj->offset &&
 381                (ri->offset+ri->size*ri->count < rj->offset+rj->size*rj->count))
 382          {
 383             vg_free( header );
 384             vg_error( "'%s': '%s' buffer overlaps '%s'\n",
 385                   path, ri->desc, rj->desc );
 386             return NULL;
 387          }
 388       }
 389    }
 390
 391    /*
 392     * Pointer validation TODO(workshop)
 393     */
 394
 395    /*
 396     * strings TODO(workshop)
 397     */
 398
 399    return header;
 400 }
 401
 402 static void *mdl_baseptr( mdl_header *mdl, u32 offset )
 403 {
 404    return (void *)mdl + offset;
 405 }
 406
 407 static const char *mdl_pstr( mdl_header *mdl, u32 pstr )
 408 {
 409    return (const char *)(mdl_baseptr( mdl, mdl->strings_offset )) + pstr;
 410 }
 411
 412 static mdl_node *mdl_node_from_id( mdl_header *mdl, u32 id )
 413 {
 414    return ((mdl_node *)mdl_baseptr( mdl, mdl->node_offset )) + id;
 415 }
 416
 417 static mdl_node *mdl_node_from_name( mdl_header *mdl, const char *name )
 418 {
 419    for( int i=0; i<mdl->node_count; i++ )
 420    {
 421       mdl_node *pnode = mdl_node_from_id( mdl, i );
 422
 423       if( !strcmp( name, mdl_pstr( mdl, pnode->pstr_name )) )
 424          return pnode;
 425    }
 426
 427    return NULL;
 428 }
 429
 430 static mdl_submesh *mdl_submesh_from_id( mdl_header *mdl, u32 id )
 431 {
 432    if( id >= mdl->submesh_count )
 433       return NULL;
 434
 435    return ((mdl_submesh *)mdl_baseptr( mdl, mdl->submesh_offset )) + id;
 436 }
 437
 438 static mdl_submesh *mdl_node_submesh( mdl_header *mdl, mdl_node *node, u32 i )
 439 {
 440    if( i >= node->submesh_count )
 441       return NULL;
 442
 443    return mdl_submesh_from_id( mdl, node->submesh_start+i );
 444 }
 445
 446 static u32 *mdl_submesh_indices( mdl_header *mdl, mdl_submesh *sm )
 447 {
 448    return ((u32 *)mdl_baseptr( mdl, mdl->indice_offset )) + sm->indice_start;
 449 }
 450
 451 static mdl_vert *mdl_submesh_vertices( mdl_header *mdl, mdl_submesh *sm )
 452 {
 453    return ((mdl_vert *)mdl_baseptr(mdl,mdl->vertex_offset)) + sm->vertex_start;
 454 }
 455
 456 static mdl_material *mdl_material_from_id( mdl_header *mdl, u32 id )
 457 {
 458    return ((mdl_material *)mdl_baseptr(mdl,mdl->material_offset)) + id;
 459 }
 460
 461 static mdl_animation *mdl_animation_from_id( mdl_header *mdl, u32 id )
 462 {
 463    return ((mdl_animation *)mdl_baseptr(mdl,mdl->anim_offset)) + id;
 464 }
 465
 466 static void mdl_node_transform( mdl_node *pnode, m4x3f transform )
 467 {
 468    q_m3x3( pnode->q, transform );
 469    v3_muls( transform[0], pnode->s[0], transform[0] );
 470    v3_muls( transform[1], pnode->s[1], transform[1] );
 471    v3_muls( transform[2], pnode->s[2], transform[2] );
 472    v3_copy( pnode->co, transform[3] );
 473 }
 474
 475 static void mdl_unpack_submesh( mdl_header *mdl, glmesh *mesh, mdl_submesh *sm )
 476 {
 477    mesh_upload( mesh, mdl_submesh_vertices( mdl, sm ), sm->vertex_count,
 478                       mdl_submesh_indices( mdl, sm ), sm->indice_count );
 479 }
 480
 481 static void mdl_unpack_glmesh( mdl_header *mdl, glmesh *mesh )
 482 {
 483    u32 offset = mdl_submesh_from_id( mdl, 0 )->vertex_count;
 484
 485    for( int i=1; i< mdl->submesh_count; i++ )
 486    {
 487       mdl_submesh *sm = mdl_submesh_from_id( mdl, i );
 488       u32 *indices =    mdl_submesh_indices( mdl, sm );
 489
 490       for( u32 j=0; j<sm->indice_count; j++ )
 491          indices[j] += offset;
 492
 493       offset += sm->vertex_count;
 494    }
 495
 496    mdl_vert *vertex_base = mdl_baseptr( mdl, mdl->vertex_offset );
 497    u32 *indice_base = mdl_baseptr( mdl, mdl->indice_offset );
 498
 499    mesh_upload( mesh, vertex_base, mdl->vertex_count,
 500                       indice_base, mdl->indice_count );
 501 }
 502
 503 static void mdl_draw_submesh( mdl_submesh *sm )
 504 {
 505    mesh_drawn( sm->indice_start, sm->indice_count );
 506 }
 507
 508 static void *mdl_get_entdata( mdl_header *mdl, mdl_node *pnode )
 509 {
 510    return mdl_baseptr( mdl, mdl->entdata_offset ) + pnode->offset;
 511 }
 512
 513 static mdl_keyframe *mdl_get_animdata( mdl_header *mdl, mdl_animation *anim )
 514 {
 515    return mdl_baseptr( mdl, mdl->animdata_offset ) + anim->offset;
 516 }
 517
 518 static void mdl_link_materials( mdl_header *root, mdl_header *child )
 519 {
 520    u32 lookup[MDL_MATERIAL_MAX];
 521
 522    for( int i=0; i<child->material_count; i++ )
 523    {
 524       mdl_material *mi = mdl_material_from_id( child, i );
 525       const char *si = mdl_pstr( child, mi->pstr_name );
 526
 527       lookup[i] = 0;
 528
 529       for( int j=0; j<root->material_count; j++ )
 530       {
 531          mdl_material *mj = mdl_material_from_id( root, j );
 532          const char *sj = mdl_pstr( root, mj->pstr_name );
 533
 534          if( !strcmp( si, sj ) )
 535          {
 536             lookup[i] = j;
 537             break;
 538          }
 539       }
 540
 541       if( lookup[i] == 0 && i != 0 )
 542       {
 543          vg_warn( "Could not link material '%s' (not present in root model)\n",
 544                    si );
 545       }
 546    }
 547
 548    for( int i=0; i<child->submesh_count; i++ )
 549    {
 550       mdl_submesh *sm = mdl_submesh_from_id( child, i );
 551       sm->material_id = lookup[sm->material_id];
 552    }
 553 }
 554
 555
 556 #endif