X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=model.h;h=ae19f6f090d57848ff97fdb9d8f9df2533377a6e;hb=8d336ea2cde7c596296dbaf0d3ce27a82c6c6cf0;hp=54874bd55b04b9a2ba84ebea86a314ddc5729d4d;hpb=3d5597be2fd4b5d9ea3bf8863e15cc9bc8123755;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/model.h b/model.h
index 54874bd..ae19f6f 100644
--- a/model.h
+++ b/model.h
@@ -1,549 +1,320 @@
-#ifndef MODEL_H
-#define MODEL_H
-
-#include "common.h"
+/*
+ * Copyright (C) 2021-2024 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ */
 
-typedef struct glmesh glmesh;
+#pragma once
+
+#define MDL_VERSION_MIN 101
+#define MDL_VERSION_NR 105
+
+enum mdl_shader{
+   k_shader_standard                = 0,
+   k_shader_standard_cutout         = 1,
+   k_shader_terrain_blend           = 2,
+   k_shader_standard_vertex_blend   = 3,
+   k_shader_water                   = 4,
+   k_shader_invisible               = 5,
+   k_shader_boundary                = 6,
+   k_shader_fxglow                  = 7,
+   k_shader_cubemap                 = 8,
+   k_shader_walking                 = 9,
+   k_shader_foliage                 = 10,
+   k_shader_override                = 30000
+};
 
-typedef struct mdl_vert mdl_vert;
-typedef struct mdl_submesh mdl_submesh;
-typedef struct mdl_material mdl_material;
-typedef struct mdl_node mdl_node;
-typedef struct mdl_header mdl_header;
-typedef struct mdl_animation mdl_animation;
-typedef struct mdl_keyframe mdl_keyframe;
+enum mdl_surface_prop{
+   k_surface_prop_concrete = 0,
+   k_surface_prop_wood     = 1,
+   k_surface_prop_grass    = 2,
+   k_surface_prop_tiles    = 3,
+   k_surface_prop_metal    = 4,
+   k_surface_prop_snow     = 5,
+   k_surface_prop_sand     = 6
+};
 
-#define MDL_SIZE_MAX          0x1000000
-#define MDL_VERT_MAX          1000000
-#define MDL_INDICE_MAX        1000000
-#define MDL_MATERIAL_MAX      32
-#define MDL_NODE_MAX          4000
-#define MDL_SUBMESH_MAX       8000
-#define MDL_STRING_LENGTH_MAX 64
+enum material_flag{
+   k_material_flag_skate_target     = 0x0001,
+   k_material_flag_collision        = 0x0002,
+   k_material_flag_grow_grass       = 0x0004,
+   k_material_flag_grindable        = 0x0008,
+   k_material_flag_invisible        = 0x0010,
+   k_material_flag_boundary         = 0x0020,
+   k_material_flag_preview_visibile = 0x0040,
+   k_material_flag_walking          = 0x0080,
+
+   k_material_flag_ghosts      =
+      k_material_flag_boundary|
+      k_material_flag_invisible|
+      k_material_flag_walking
+};
 
 #pragma pack(push,1)
 
+/* 48 byte */
 struct mdl_vert
 {
-   v3f co,
-       norm;
-   v2f uv;
-   u8  colour[4];
-   u16 weights[4];
-   u8  groups[4];
-};
-
-struct mdl_submesh
-{
-   u32 indice_start,
-       indice_count,
-       vertex_start,
-       vertex_count;
-   
-   boxf bbx;
-   u32 material_id;
-};
+   v3f co,        /* 3*32 */
+       norm;      /* 3*32 */
+   v2f uv;        /* 2*32 */
 
-struct mdl_material
-{
-   u32 pstr_name;
+   u8  colour[4]; /* 4*8 */
+   u16 weights[4];/* 4*16 */
+   u8  groups[4]; /* 4*8 */
 };
 
-struct mdl_node
-{
-   v3f co;
-   v4f q;
-   v3f s;
-   
-   union{ u32 submesh_start, sub_uid; };
+#pragma pack(pop)
 
-   u32 
-       submesh_count,
-       classtype,
-       offset,
-       parent,
-       pstr_name;
-};
+typedef u32 mdl_indice;
 
-struct mdl_keyframe
-{
-   v3f co;
-   v4f q;
-   v3f s;
-};
+typedef struct mdl_context mdl_context;
+typedef struct mdl_array_ptr mdl_array_ptr;
+typedef struct mdl_vert mdl_vert;
+typedef struct mdl_transform mdl_transform;
+typedef struct mdl_submesh mdl_submesh;
+typedef struct mdl_material mdl_material;
+typedef struct mdl_bone mdl_bone;
+typedef struct mdl_armature mdl_armature;
+typedef struct mdl_animation mdl_animation;
+typedef struct mdl_transform mdl_keyframe;
+typedef struct mdl_mesh mdl_mesh;
+typedef struct mdl_file mdl_file;
+typedef struct mdl_texture mdl_texture;
+typedef struct mdl_array mdl_array;
+typedef struct mdl_header mdl_header;
 
-struct mdl_animation
+typedef struct glmesh glmesh;
+struct glmesh
 {
-   u32 pstr_name,
-       length;
-
-   float rate;
-
-   u32 offset;
+   GLuint vao, vbo, ebo;
+   u32 indice_count;
+   u32 loaded;
 };
 
-struct mdl_header
+struct mdl_transform
 {
-   u32 identifier, version, file_length;
-
-   u32 vertex_count, vertex_offset,
-       indice_count, indice_offset,
-       submesh_count, submesh_offset,
-       material_count, material_offset,
-       node_count, node_offset,
-       anim_count, anim_offset,
-       strings_offset, entdata_offset, animdata_offset;
+   v3f co, s;
+   v4f q;
 };
 
-/* 
- * Entity data structures
- */
-
-struct classtype_block
+static void transform_identity( mdl_transform *transform )
 {
-   boxf bbx;
-};
+   v3_zero( transform->co );
+   q_identity( transform->q );
+   v3_fill( transform->s, 1.0f );
+}
 
-struct classtype_gate
+static void mdl_transform_vector( mdl_transform *transform, v3f vec, v3f dest )
 {
-   u32 target;
-   v3f dims;
-};
+   v3_mul( transform->s, vec, dest );
+   q_mulv( transform->q, dest, dest );
+}
 
-struct classtype_spawn
+static void mdl_transform_point( mdl_transform *transform, v3f co, v3f dest )
 {
-   u32 target;
-};
+   mdl_transform_vector( transform, co, dest );
+   v3_add( transform->co, dest, dest );
+}
 
-struct classtype_water
+static void mdl_transform_mul( mdl_transform *a, mdl_transform *b, 
+                               mdl_transform *d )
 {
-   u32 temp;
-};
+   mdl_transform_point( a, b->co, d->co );
+   q_mul( a->q, b->q, d->q );
+   q_normalize( d->q );
+   v3_mul( a->s, b->s, d->s );
+}
 
-struct classtype_car_path
+struct mdl_material
 {
-   u32 target, target1;
-};
+   u32 pstr_name,
+       shader,
+       flags,
+       surface_prop;
 
-struct classtype_instance
-{
-   u32 pstr_file;
-};
+   v4f colour,
+       colour1;
 
-struct classtype_capsule
-{
-   float height, radius;
+   u32 tex_diffuse, /* Indexes start from 1. 0 if missing. */
+       tex_none0,
+       tex_none1;
 };
 
-struct classtype_route_node
+struct mdl_bone
 {
-   u32 target, target1;
-};
+   v3f co, end;
+   u32 parent,
+       collider,
+       ik_target,
+       ik_pole,
+       flags,
+       pstr_name;
 
-struct classtype_route
-{
-   u32 pstr_name;
-   u32 id_start;
-   v3f colour;
+   boxf hitbox;
+   v3f conevx, conevy, coneva;
+   float conet;
 };
 
-struct classtype_bone
+enum bone_flag
 {
-   u32 deform;
+   k_bone_flag_deform               = 0x00000001,
+   k_bone_flag_ik                   = 0x00000002,
+   k_bone_flag_cone_constraint      = 0x00000004
 };
 
-struct classtype_ik_bone
+enum bone_collider
 {
-   u32 deform,
-       target,
-       pole;
+   k_bone_collider_none = 0,
+   k_bone_collider_box = 1,
+   k_bone_collider_capsule = 2
 };
-
-struct classtype_skeleton
+         
+struct mdl_armature
 {
-   u32 channels,
-       ik_count,
+   mdl_transform transform;
+   u32 bone_start,
+       bone_count,
        anim_start,
        anim_count;
 };
 
-struct classtype_skin
+struct mdl_animation
 {
-   u32 skeleton;
+   u32 pstr_name,
+       length;
+   float rate;
+   u32 offset;
 };
 
-#pragma pack(pop)
-
-/*
- * Simple mesh interface for OpenGL
- */
-
-struct glmesh
+struct mdl_submesh
 {
-   GLuint vao, vbo, ebo;
-   u32 indice_count;
-};
+   u32 indice_start,
+       indice_count,
+       vertex_start,
+       vertex_count;
 
-static void mesh_upload( glmesh *mesh,
-      mdl_vert *verts, u32 vert_count,
-      u32 *indices, u32 indice_count )
-{
-   glGenVertexArrays( 1, &mesh->vao );
-   glGenBuffers( 1, &mesh->vbo );
-   glGenBuffers( 1, &mesh->ebo );
-   glBindVertexArray( mesh->vao );
-
-   size_t stride = sizeof(mdl_vert);
-
-   glBindBuffer( GL_ARRAY_BUFFER, mesh->vbo );
-   glBufferData( GL_ARRAY_BUFFER, vert_count*stride, verts, GL_STATIC_DRAW );
-
-   glBindVertexArray( mesh->vao );
-   glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->ebo );
-   glBufferData( GL_ELEMENT_ARRAY_BUFFER, indice_count*sizeof(u32),
-         indices, GL_STATIC_DRAW );
-   
-   /* 0: coordinates */
-   glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0 );
-   glEnableVertexAttribArray( 0 );
-
-   /* 1: normal */
-   glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 
-         stride, (void *)offsetof(mdl_vert, norm) );
-   glEnableVertexAttribArray( 1 );
-
-   /* 2: uv */
-   glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE, 
-         stride, (void *)offsetof(mdl_vert, uv) );
-   glEnableVertexAttribArray( 2 );
-
-   /* 3: colour */
-   glVertexAttribPointer( 3, 4, GL_UNSIGNED_BYTE, GL_TRUE, 
-         stride, (void *)offsetof(mdl_vert, colour) );
-   glEnableVertexAttribArray( 3 );
-
-   /* 4: weights */
-   glVertexAttribPointer( 4, 4, GL_UNSIGNED_SHORT, GL_TRUE, 
-         stride, (void *)offsetof(mdl_vert, weights) );
-   glEnableVertexAttribArray( 4 );
-
-   /* 5: groups */
-   glVertexAttribIPointer( 5, 4, GL_UNSIGNED_BYTE,
-         stride, (void *)offsetof(mdl_vert, groups) );
-   glEnableVertexAttribArray( 5 );
-
-   
-   VG_CHECK_GL();
-   mesh->indice_count = indice_count;
-}
+   boxf bbx;
+   u16 material_id, flags;
+};
 
-static void mesh_bind( glmesh *mesh )
+enum esubmesh_flags
 {
-   glBindVertexArray( mesh->vao );
-}
+   k_submesh_flag_none     = 0x0000,
+   k_submesh_flag_consumed = 0x0001
+};
 
-static void mesh_drawn( u32 start, u32 count )
+struct mdl_mesh
 {
-   glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_INT, 
-         (void *)(start*sizeof(u32)) );
-}
+   mdl_transform transform;
+   u32 submesh_start,
+       submesh_count,
+       pstr_name,
+       entity_id,    /* upper 16 bits: type, lower 16 bits: index */
+       armature_id;
+};
 
-static void mesh_draw( glmesh *mesh )
+struct mdl_file
 {
-   mesh_drawn( 0, mesh->indice_count );
-}
+   u32 pstr_path,
+       pack_offset,
+       pack_size;
+};
 
-static void mesh_free( glmesh *mesh )
+struct mdl_texture
 {
-   glDeleteVertexArrays( 1, &mesh->vao );
-   glDeleteBuffers( 1, &mesh->ebo );
-   glDeleteBuffers( 1, &mesh->vbo );
-}
-
-
-/*
- * Model implementation
- */
+   mdl_file file;
+   u32 glname;
+};
 
-static mdl_header *mdl_load( const char *path )
+struct mdl_array
 {
-   i64 size;
-   mdl_header *header = vg_asset_read_s( path, &size );
-
-   /* 
-    * Check file is valid
-    */
-   if( !header )
-   {
-      vg_error( "Could not open '%s'\n", path );
-      return NULL;
-   }
-
-   if( size < sizeof(mdl_header) )
-   {
-      free( header );
-      vg_error( "Invalid file '%s' (too small for header)\n", path );
-      return NULL;
-   }
-
-   if( header->file_length != size )
-   {
-      vg_error( "Invalid file '%s'"
-                "(wrong .file_length, %ub != real file size %ub)\n", 
-                path, header->file_length, size );
-      free( header );
-      return NULL;
-   }
-
-   /*
-    * Validate offsets and memory sections, to ensure all arrays are in-bounds,
-    * and that they do not overlap.
-    */
-
-   struct memregion
-   {
-      const char *desc;
-      u32 count, max_count, size, offset;
-   }
-   regions[] = {
-      { 
-         "Vertices",
-         header->vertex_count, MDL_VERT_MAX, 
-         sizeof(mdl_vert), header->vertex_offset 
-      },
-      {
-         "Indices",
-         header->indice_count, MDL_INDICE_MAX,
-         sizeof(u32), header->indice_offset 
-      },
-      { 
-         "Submesh",
-         header->submesh_count, MDL_SUBMESH_MAX,
-         sizeof(mdl_submesh), header->submesh_offset 
-      },
-      { 
-         "Materials",
-         header->material_count, MDL_MATERIAL_MAX,
-         sizeof(mdl_material), header->material_offset
-      },
-      { 
-         "Nodes",
-         header->node_count, MDL_NODE_MAX,
-         sizeof(mdl_node), header->node_count
-      }
-   };
-
-   for( int i=0; i<vg_list_size(regions); i++ )
-   {
-      struct memregion *ri = &regions[i];
-
-      if( ri->count == 0 )
-         continue;
-
-      if( ri->count > ri->max_count )
-      {
-         free( header );
-         vg_error( "'%s': '%s' buffer exceeds the maximum (%u/%u)\n",
-               path, ri->desc, ri->count, ri->max_count );
-         return NULL;
-      }
-
-      if( ri->offset >= header->file_length )
-      {
-         free( header );
-         vg_error( "'%s': '%s' buffer offset is out of range\n",
-               path, ri->desc );
-         return NULL;
-      }
-
-      if( ri->offset + ri->size*ri->count > header->file_length )
-      {
-         free( header );
-         vg_error( "'%s': '%s' buffer size is out of range\n",
-               path, ri->desc );
-         return NULL;
-      }
-
-      for( int j=0; j<vg_list_size(regions); j++ )
-      {
-         struct memregion *rj = &regions[j];
-         if( rj->count == 0 )
-            continue;
-
-         if( ri->offset >= rj->offset && 
-               (ri->offset+ri->size*ri->count < rj->offset+rj->size*rj->count))
-         {
-            free( header );
-            vg_error( "'%s': '%s' buffer overlaps '%s'\n",
-                  path, ri->desc, rj->desc );
-            return NULL;
-         }
-      }
-   }
-
-   /*
-    * Pointer validation TODO(workshop)
-    */
-
-   /*
-    * strings TODO(workshop)
-    */
-
-   return header;
-}
+   u32 file_offset,
+       item_count,
+       item_size;
 
-static void *mdl_baseptr( mdl_header *mdl, u32 offset )
-{
-   return (void *)mdl + offset;
-}
+   char name[16];
+};
 
-static const char *mdl_pstr( mdl_header *mdl, u32 pstr )
+struct mdl_header
 {
-   return (const char *)(mdl_baseptr( mdl, mdl->strings_offset )) + pstr;
-}
+   u32 version;
+   mdl_array index;
+};
 
-static mdl_node *mdl_node_from_id( mdl_header *mdl, u32 id )
-{
-   return ((mdl_node *)mdl_baseptr( mdl, mdl->node_offset )) + id;
-}
+struct mdl_context{
+   FILE *file;
+   mdl_header info;
 
-static mdl_node *mdl_node_from_name( mdl_header *mdl, const char *name )
-{
-   for( int i=0; i<mdl->node_count; i++ )
+   struct mdl_array_ptr
    {
-      mdl_node *pnode = mdl_node_from_id( mdl, i );
-      
-      if( !strcmp( name, mdl_pstr( mdl, pnode->pstr_name )) )
-         return pnode;
+      void *data;
+      u32 count, stride;
    }
-   
-   return NULL;
-}
-
-static mdl_submesh *mdl_submesh_from_id( mdl_header *mdl, u32 id )
-{
-   if( id >= mdl->submesh_count )
-      return NULL;
-
-   return ((mdl_submesh *)mdl_baseptr( mdl, mdl->submesh_offset )) + id;
-}
-
-static mdl_submesh *mdl_node_submesh( mdl_header *mdl, mdl_node *node, u32 i )
-{
-   if( i >= node->submesh_count )
-      return NULL;
-
-   return mdl_submesh_from_id( mdl, node->submesh_start+i );
-}
-
-static u32 *mdl_submesh_indices( mdl_header *mdl, mdl_submesh *sm )
-{
-   return ((u32 *)mdl_baseptr( mdl, mdl->indice_offset )) + sm->indice_start;
-}
-
-static mdl_vert *mdl_submesh_vertices( mdl_header *mdl, mdl_submesh *sm )
-{
-   return ((mdl_vert *)mdl_baseptr(mdl,mdl->vertex_offset)) + sm->vertex_start;
-}
-
-static mdl_material *mdl_material_from_id( mdl_header *mdl, u32 id )
-{
-   return ((mdl_material *)mdl_baseptr(mdl,mdl->material_offset)) + id;
-}
-
-static mdl_animation *mdl_animation_from_id( mdl_header *mdl, u32 id )
-{
-   return ((mdl_animation *)mdl_baseptr(mdl,mdl->anim_offset)) + id;
-}
-
-static void mdl_node_transform( mdl_node *pnode, m4x3f transform )
-{
-   q_m3x3( pnode->q, transform );
-   v3_muls( transform[0], pnode->s[0], transform[0] );
-   v3_muls( transform[1], pnode->s[1], transform[1] );
-   v3_muls( transform[2], pnode->s[2], transform[2] );
-   v3_copy( pnode->co, transform[3] );
-}
-
-static void mdl_unpack_submesh( mdl_header *mdl, glmesh *mesh, mdl_submesh *sm )
-{
-   mesh_upload( mesh, mdl_submesh_vertices( mdl, sm ), sm->vertex_count,
-                      mdl_submesh_indices( mdl, sm ), sm->indice_count );
-}
+   index,
+
+   /* metadata */
+   strings,
+   meshs,
+   submeshs,
+   materials,
+   textures,
+   armatures,
+   bones,
+   animations,
+
+   /* animation buffers */
+   keyframes,
+
+   /* mesh buffers */
+   verts,
+   indices;
+   u32 pack_base_offset;
+
+   /* runtime */
+   glmesh mesh;
+};
 
-static void mdl_unpack_glmesh( mdl_header *mdl, glmesh *mesh )
-{
-   u32 offset = mdl_submesh_from_id( mdl, 0 )->vertex_count;
+void mesh_bind( glmesh *mesh );
+void mesh_drawn( u32 start, u32 count );
+void mesh_draw( glmesh *mesh );
+void mesh_free( glmesh *mesh );
 
-   for( int i=1; i< mdl->submesh_count; i++ )
-   {
-      mdl_submesh *sm = mdl_submesh_from_id( mdl, i );
-      u32 *indices =    mdl_submesh_indices( mdl, sm );
+/* file context management */
+void mdl_open( mdl_context *mdl, const char *path, void *lin_alloc );
+void mdl_close( mdl_context *mdl );
 
-      for( u32 j=0; j<sm->indice_count; j++ )
-         indices[j] += offset;
+/* array loading */
+int _mdl_load_array( mdl_context *mdl, mdl_array_ptr *ptr,
+                     const char *name, void *lin_alloc, u32 stride );
+#define MDL_LOAD_ARRAY( MDL, PTR, STRUCT, ALLOCATOR ) \
+   _mdl_load_array( MDL, PTR, #STRUCT, ALLOCATOR, sizeof(STRUCT) )
 
-      offset += sm->vertex_count;
-   }
+/* array access */
+void *mdl_arritm( mdl_array_ptr *arr, u32 index );
+u32 mdl_arrcount( mdl_array_ptr *arr );
 
-   mdl_vert *vertex_base = mdl_baseptr( mdl, mdl->vertex_offset );
-   u32 *indice_base = mdl_baseptr( mdl, mdl->indice_offset );
+/* pack access */
+void mdl_fread_pack_file( mdl_context *mdl, mdl_file *info, void *dst );
 
-   mesh_upload( mesh, vertex_base, mdl->vertex_count,
-                      indice_base, mdl->indice_count ); 
-}
+/* standard array groups */
+int mdl_load_animation_block( mdl_context *mdl, void *lin_alloc );
+int mdl_load_metadata_block( mdl_context *mdl, void *lin_alloc );
+int mdl_load_mesh_block( mdl_context *mdl, void *lin_alloc );
 
-static void mdl_draw_submesh( mdl_submesh *sm )
-{
-   mesh_drawn( sm->indice_start, sm->indice_count );
-}
+/* load mesh */
+void mdl_async_load_glmesh( mdl_context *mdl, glmesh *mesh, u32 *fixup_table );
 
-static void *mdl_get_entdata( mdl_header *mdl, mdl_node *pnode )
-{
-   return mdl_baseptr( mdl, mdl->entdata_offset ) + pnode->offset;
-}
+/* load textures and mesh */
+void mdl_async_full_load_std( mdl_context *mdl );
 
-static mdl_keyframe *mdl_get_animdata( mdl_header *mdl, mdl_animation *anim )
-{
-   return mdl_baseptr( mdl, mdl->animdata_offset ) + anim->offset;
-}
-
-static void mdl_link_materials( mdl_header *root, mdl_header *child )
-{
-   u32 lookup[MDL_MATERIAL_MAX];
-   
-   for( int i=0; i<child->material_count; i++ )
-   {
-      mdl_material *mi = mdl_material_from_id( child, i );
-      const char *si = mdl_pstr( child, mi->pstr_name );
-
-      lookup[i] = 0;
+/* rendering */
+void mdl_draw_submesh( mdl_submesh *sm );
+mdl_mesh *mdl_find_mesh( mdl_context *mdl, const char *name );
 
-      for( int j=0; j<root->material_count; j++ )
-      {
-         mdl_material *mj = mdl_material_from_id( root, j );
-         const char *sj = mdl_pstr( root, mj->pstr_name );
-         
-         if( !strcmp( si, sj ) )
-         {
-            lookup[i] = j;
-            break;
-         }
-      }
-
-      if( lookup[i] == 0 && i != 0 )
-      {
-         vg_warn( "Could not link material '%s' (not present in root model)\n", 
-                   si );
-      }
-   }
-
-   for( int i=0; i<child->submesh_count; i++ )
-   {
-      mdl_submesh *sm = mdl_submesh_from_id( child, i );
-      sm->material_id = lookup[sm->material_id];
-   }
-}
+/* pstrs */
+const char *mdl_pstr( mdl_context *mdl, u32 pstr );
+int mdl_pstreq( mdl_context *mdl, u32 pstr, const char *str, u32 djb2 );
+#define MDL_CONST_PSTREQ( MDL, Q, CONSTSTR )\
+   mdl_pstreq( MDL, Q, CONSTSTR, vg_strdjb2( CONSTSTR ) )
 
+void mdl_transform_m4x3( mdl_transform *transform, m4x3f mtx );
 
-#endif