model.c

   1 /*
   2  * Copyright (C) 2021-2024 Mt.ZERO Software, Harry Godden - All Rights Reserved
   3  */
   4
   5 #pragma once
   6
   7 #include "model.h"
   8 #include "vg/vg_io.h"
   9 #include "vg/vg_async.h"
  10 #include "vg/vg_tex.h"
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <errno.h>
  14
  15 static void mdl_load_fatal_corrupt( mdl_context *mdl )
  16 {
  17    fclose( mdl->file );
  18    vg_file_print_invalid( mdl->file );
  19    vg_fatal_error( "Corrupt model" );
  20 }
  21
  22 /*
  23  * Model implementation
  24  */
  25
  26 void mdl_fread_pack_file( mdl_context *mdl, mdl_file *info, void *dst )
  27 {
  28    if( !info->pack_size )
  29    {
  30       vg_warn( "path: %s\n", mdl_pstr( mdl, info->pstr_path ) );
  31       vg_fatal_error( "Packed file is only a header; it is not packed" );
  32    }
  33
  34    fseek( mdl->file, mdl->pack_base_offset+info->pack_offset, SEEK_SET );
  35    u64 l = fread( dst, info->pack_size, 1, mdl->file );
  36
  37    if( l != 1 ) mdl_load_fatal_corrupt( mdl );
  38 }
  39
  40 /* TODO: Rename these */
  41 static void mdl_load_array_file_buffer( mdl_context *mdl, mdl_array *arr,
  42                                         void *buffer, u32 stride )
  43 {
  44    if( arr->item_count )
  45    {
  46       fseek( mdl->file, arr->file_offset, SEEK_SET );
  47
  48       if( stride == arr->item_size )
  49       {
  50          u64 l = fread( buffer, arr->item_size*arr->item_count, 1, mdl->file );
  51          if( l != 1 ) mdl_load_fatal_corrupt( mdl );
  52       }
  53       else
  54       {
  55          vg_warn( "Applying alignment fixup to array @%p [%u -> %u] x %u\n",
  56                   buffer, arr->item_size, stride, arr->item_count );
  57          if( stride < arr->item_size )
  58             vg_fatal_error( "not safe\n" );
  59
  60          for( u32 i=0; i<arr->item_count; i++ )
  61          {
  62             u64 l = fread( buffer+i*stride, arr->item_size, 1, mdl->file );
  63             if( l != 1 ) mdl_load_fatal_corrupt( mdl );
  64          }
  65       }
  66    }
  67 }
  68
  69 static void mdl_load_array_file( mdl_context *mdl, mdl_array_ptr *ptr,
  70                                  mdl_array *arr, void *lin_alloc, u32 stride )
  71 {
  72    if( stride < arr->item_size )
  73    {
  74       vg_error( "Structure max: %u. Got: %u\n", stride, arr->item_size );
  75       vg_fatal_error( "not safe\n" );
  76    }
  77
  78    if( arr->item_count )
  79    {
  80       u32 size = stride*arr->item_count;
  81       ptr->data = vg_linear_alloc( lin_alloc, vg_align8(size) );
  82       mdl_load_array_file_buffer( mdl, arr, ptr->data, stride );
  83    }
  84    else
  85    {
  86       ptr->data = NULL;
  87    }
  88
  89    ptr->stride = stride;
  90    ptr->count = arr->item_count;
  91 }
  92
  93 void *mdl_arritm( mdl_array_ptr *arr, u32 index )
  94 {
  95    return ((u8 *)arr->data) + index*arr->stride;
  96 }
  97
  98 u32 mdl_arrcount( mdl_array_ptr *arr )
  99 {
 100    return arr->count;
 101 }
 102
 103 static mdl_array *mdl_find_array( mdl_context *mdl, const char *name )
 104 {
 105    for( u32 i=0; i<mdl_arrcount(&mdl->index); i++ )
 106    {
 107       mdl_array *arr = mdl_arritm( &mdl->index, i );
 108
 109       if( !strncmp(arr->name,name,16) )
 110          return arr;
 111    }
 112
 113    return NULL;
 114 }
 115
 116 int _mdl_load_array( mdl_context *mdl, mdl_array_ptr *ptr,
 117                      const char *name, void *lin_alloc, u32 stride )
 118 {
 119    mdl_array *arr = mdl_find_array( mdl, name );
 120
 121    if( arr )
 122    {
 123       mdl_load_array_file( mdl, ptr, arr, lin_alloc, stride );
 124       return 1;
 125    }
 126    else
 127    {
 128       ptr->data = NULL;
 129       ptr->count = 0;
 130       ptr->stride = 0;
 131       return 0;
 132    }
 133 }
 134
 135 int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc )
 136 {
 137    int success = 1;
 138
 139    success &= MDL_LOAD_ARRAY( mdl, &mdl->verts,    mdl_vert,   lin_alloc );
 140    success &= MDL_LOAD_ARRAY( mdl, &mdl->indices,  mdl_indice, lin_alloc );
 141
 142    return success;
 143 }
 144
 145 int mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc )
 146 {
 147    int success = 1;
 148
 149    success &= _mdl_load_array( mdl, &mdl->strings, "strings", lin_alloc, 1 );
 150    success &= MDL_LOAD_ARRAY( mdl, &mdl->meshs,     mdl_mesh,     lin_alloc );
 151    success &= MDL_LOAD_ARRAY( mdl, &mdl->submeshs,  mdl_submesh,  lin_alloc );
 152    success &= MDL_LOAD_ARRAY( mdl, &mdl->materials, mdl_material, lin_alloc );
 153    success &= MDL_LOAD_ARRAY( mdl, &mdl->textures,  mdl_texture,  lin_alloc );
 154    success &= MDL_LOAD_ARRAY( mdl, &mdl->armatures, mdl_armature, lin_alloc );
 155    success &= MDL_LOAD_ARRAY( mdl, &mdl->bones,     mdl_bone,     lin_alloc );
 156    success &= MDL_LOAD_ARRAY( mdl, &mdl->animations,mdl_animation,lin_alloc );
 157
 158    return success;
 159 }
 160
 161 int mdl_load_animation_block( mdl_context *mdl, void *lin_alloc )
 162 {
 163    return MDL_LOAD_ARRAY( mdl, &mdl->keyframes, mdl_keyframe, lin_alloc );
 164 }
 165
 166 /*
 167  * if calling mdl_open, and the file does not exist, the game will fatal quit
 168  */
 169 void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc )
 170 {
 171    memset( mdl, 0, sizeof( mdl_context ) );
 172    mdl->file = fopen( path, "rb" );
 173
 174    if( !mdl->file )
 175    {
 176       vg_error( "mdl_open('%s'): %s\n", path, strerror(errno) );
 177       vg_fatal_error( "see above for details" );
 178    }
 179
 180    u64 l = fread( &mdl->info, sizeof(mdl_header), 1, mdl->file );
 181    if( l != 1 )
 182       mdl_load_fatal_corrupt( mdl );
 183
 184    if( mdl->info.version < MDL_VERSION_MIN )
 185    {
 186       vg_warn( "For model: %s\n", path );
 187       vg_warn( "  version: %u (min: %u, current: %u)\n",
 188                mdl->info.version, MDL_VERSION_MIN, MDL_VERSION_NR );
 189
 190       vg_fatal_error( "Legacy model version incompatable" );
 191    }
 192
 193    mdl_load_array_file( mdl, &mdl->index, &mdl->info.index, lin_alloc,
 194                         sizeof(mdl_array) );
 195
 196    mdl_array *pack = mdl_find_array( mdl, "pack" );
 197    if( pack ) mdl->pack_base_offset = pack->file_offset;
 198    else mdl->pack_base_offset = 0;
 199 }
 200
 201 /*
 202  * close file handle
 203  */
 204 void mdl_close( mdl_context *mdl )
 205 {
 206    fclose( mdl->file );
 207    mdl->file = NULL;
 208 }
 209
 210 /* useful things you can do with the model */
 211
 212 void mdl_transform_m4x3( mdl_transform *transform, m4x3f mtx )
 213 {
 214    q_m3x3( transform->q, mtx );
 215    v3_muls( mtx[0], transform->s[0], mtx[0] );
 216    v3_muls( mtx[1], transform->s[1], mtx[1] );
 217    v3_muls( mtx[2], transform->s[2], mtx[2] );
 218    v3_copy( transform->co, mtx[3] );
 219 }
 220
 221 const char *mdl_pstr( mdl_context *mdl, u32 pstr )
 222 {
 223    return ((char *)mdl_arritm( &mdl->strings, pstr )) + 4;
 224 }
 225
 226
 227 int mdl_pstreq( mdl_context *mdl, u32 pstr, const char *str, u32 djb2 )
 228 {
 229    u32 hash = *((u32 *)mdl_arritm( &mdl->strings, pstr ));
 230    if( hash == djb2 ){
 231       if( !strcmp( str, mdl_pstr( mdl, pstr ))) return 1;
 232       else return 0;
 233    }
 234    else return 0;
 235 }
 236
 237 /*
 238  * Simple mesh interface for OpenGL
 239  * ----------------------------------------------------------------------------
 240  */
 241
 242 static void mesh_upload( glmesh *mesh,
 243                             mdl_vert *verts, u32 vert_count,
 244                             u32 *indices, u32 indice_count )
 245 {
 246    glGenVertexArrays( 1, &mesh->vao );
 247    glGenBuffers( 1, &mesh->vbo );
 248    glGenBuffers( 1, &mesh->ebo );
 249    glBindVertexArray( mesh->vao );
 250
 251    size_t stride = sizeof(mdl_vert);
 252
 253    glBindBuffer( GL_ARRAY_BUFFER, mesh->vbo );
 254    glBufferData( GL_ARRAY_BUFFER, vert_count*stride, verts, GL_STATIC_DRAW );
 255
 256    glBindVertexArray( mesh->vao );
 257    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->ebo );
 258    glBufferData( GL_ELEMENT_ARRAY_BUFFER, indice_count*sizeof(u32),
 259          indices, GL_STATIC_DRAW );
 260
 261    /* 0: coordinates */
 262    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0 );
 263    glEnableVertexAttribArray( 0 );
 264
 265    /* 1: normal */
 266    glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE,
 267          stride, (void *)offsetof(mdl_vert, norm) );
 268    glEnableVertexAttribArray( 1 );
 269
 270    /* 2: uv */
 271    glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE,
 272          stride, (void *)offsetof(mdl_vert, uv) );
 273    glEnableVertexAttribArray( 2 );
 274
 275    /* 3: colour */
 276    glVertexAttribPointer( 3, 4, GL_UNSIGNED_BYTE, GL_TRUE,
 277          stride, (void *)offsetof(mdl_vert, colour) );
 278    glEnableVertexAttribArray( 3 );
 279
 280    /* 4: weights */
 281    glVertexAttribPointer( 4, 4, GL_UNSIGNED_SHORT, GL_TRUE,
 282          stride, (void *)offsetof(mdl_vert, weights) );
 283    glEnableVertexAttribArray( 4 );
 284
 285    /* 5: groups */
 286    glVertexAttribIPointer( 5, 4, GL_UNSIGNED_BYTE,
 287          stride, (void *)offsetof(mdl_vert, groups) );
 288    glEnableVertexAttribArray( 5 );
 289
 290    VG_CHECK_GL_ERR();
 291
 292    mesh->indice_count = indice_count;
 293    mesh->loaded = 1;
 294 }
 295
 296 void mesh_bind( glmesh *mesh )
 297 {
 298    glBindVertexArray( mesh->vao );
 299 }
 300
 301 void mesh_drawn( u32 start, u32 count )
 302 {
 303    glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_INT,
 304          (void *)(start*sizeof(u32)) );
 305 }
 306
 307 void mesh_draw( glmesh *mesh )
 308 {
 309    mesh_drawn( 0, mesh->indice_count );
 310 }
 311
 312 void mesh_free( glmesh *mesh )
 313 {
 314    if( mesh->loaded )
 315    {
 316       glDeleteVertexArrays( 1, &mesh->vao );
 317       glDeleteBuffers( 1, &mesh->ebo );
 318       glDeleteBuffers( 1, &mesh->vbo );
 319       mesh->loaded = 0;
 320    }
 321 }
 322
 323 void mdl_draw_submesh( mdl_submesh *sm )
 324 {
 325    mesh_drawn( sm->indice_start, sm->indice_count );
 326 }
 327
 328 mdl_mesh *mdl_find_mesh( mdl_context *mdl, const char *name )
 329 {
 330    for( u32 i=0; i<mdl_arrcount( &mdl->meshs ); i++ )
 331    {
 332       mdl_mesh *mesh = mdl_arritm( &mdl->meshs, i );
 333       if( !strcmp( name, mdl_pstr( mdl, mesh->pstr_name )))
 334       {
 335          return mesh;
 336       }
 337    }
 338    return NULL;
 339 }
 340
 341 struct payload_glmesh_load
 342 {
 343    mdl_vert *verts;
 344    u32 *indices;
 345
 346    u32 vertex_count,
 347        indice_count;
 348
 349    glmesh *mesh;
 350 };
 351
 352 static void _sync_mdl_load_glmesh( void *payload, u32 size )
 353 {
 354    struct payload_glmesh_load *job = payload;
 355    mesh_upload( job->mesh, job->verts, job->vertex_count,
 356                            job->indices, job->indice_count );
 357 }
 358
 359 void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh, u32 *fixup_table )
 360 {
 361    mdl_array *arr_vertices = mdl_find_array( mdl, "mdl_vert" );
 362    mdl_array *arr_indices = mdl_find_array( mdl, "mdl_indice" );
 363
 364    if( arr_vertices && arr_indices )
 365    {
 366       u32 size_verts   = vg_align8(sizeof(mdl_vert)*arr_vertices->item_count),
 367           size_indices = vg_align8(sizeof(mdl_indice)*arr_indices->item_count),
 368           size_hdr     = vg_align8(sizeof(struct payload_glmesh_load)),
 369           total        = size_hdr + size_verts + size_indices;
 370
 371       vg_async_item *call = vg_async_alloc( total );
 372       struct payload_glmesh_load *job = call->payload;
 373
 374       u8 *payload = call->payload;
 375
 376       job->mesh = mesh;
 377       job->verts = (void*)(payload + size_hdr);
 378       job->indices = (void*)(payload + size_hdr + size_verts);
 379       job->vertex_count = arr_vertices->item_count;
 380       job->indice_count = arr_indices->item_count;
 381
 382       mdl_load_array_file_buffer( mdl, arr_vertices,
 383                                   job->verts, sizeof(mdl_vert) );
 384       mdl_load_array_file_buffer( mdl, arr_indices, job->indices,
 385                                   sizeof(mdl_indice) );
 386
 387       if( fixup_table )
 388       {
 389          for( u32 i=0; i<job->vertex_count; i ++ )
 390          {
 391             mdl_vert *vert = &job->verts[i];
 392
 393             for( u32 j=0; j<4; j++ )
 394             {
 395                vert->groups[j] = fixup_table[vert->groups[j]];
 396             }
 397          }
 398       }
 399
 400       /*
 401        * Unpack the indices (if there are meshes)
 402        * ---------------------------------------------------------
 403        */
 404
 405       if( mdl_arrcount( &mdl->submeshs ) )
 406       {
 407          mdl_submesh *sm = mdl_arritm( &mdl->submeshs, 0 );
 408          u32 offset = sm->vertex_count;
 409
 410          for( u32 i=1; i<mdl_arrcount( &mdl->submeshs ); i++ )
 411          {
 412             mdl_submesh *sm = mdl_arritm( &mdl->submeshs, i );
 413             u32 *indices    = job->indices + sm->indice_start;
 414
 415             for( u32 j=0; j<sm->indice_count; j++ )
 416                indices[j] += offset;
 417
 418             offset += sm->vertex_count;
 419          }
 420       }
 421
 422       /*
 423        * Dispatch
 424        * -------------------------
 425        */
 426
 427       vg_async_dispatch( call, _sync_mdl_load_glmesh );
 428    }
 429    else
 430    {
 431       vg_fatal_error( "no vertex/indice data\n" );
 432    }
 433 }
 434
 435 /* uploads the glmesh, and textures. everything is saved into the mdl_context */
 436 void mdl_async_full_load_std( mdl_context *mdl )
 437 {
 438    mdl_async_load_glmesh( mdl, &mdl->mesh, NULL );
 439
 440    for( u32 i=0; i<mdl_arrcount( &mdl->textures ); i ++ )
 441    {
 442       vg_linear_clear( vg_mem.scratch );
 443       mdl_texture *tex = mdl_arritm( &mdl->textures, i );
 444
 445       void *data = vg_linear_alloc( vg_mem.scratch, tex->file.pack_size );
 446       mdl_fread_pack_file( mdl, &tex->file, data );
 447
 448       vg_tex2d_load_qoi_async( data, tex->file.pack_size,
 449                                VG_TEX2D_CLAMP|VG_TEX2D_NEAREST, &tex->glname );
 450    }
 451 }