angle limit constraint
[carveJwlIkooP6JGAAIwe30JlM.git] / 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 pstr_name;
146 u32 id_start;
147 v3f colour;
148 };
149
150 struct classtype_bone
151 {
152 u32 deform,
153 ik_target,
154 ik_pole,
155 collider,
156 use_limits;
157
158 v3f angle_limits[2];
159 boxf hitbox;
160 };
161
162 struct classtype_skeleton
163 {
164 u32 channels,
165 ik_count,
166 collider_count,
167 anim_start,
168 anim_count;
169 };
170
171 struct classtype_skin
172 {
173 u32 skeleton;
174 };
175
176 #pragma pack(pop)
177
178 /*
179 * Simple mesh interface for OpenGL
180 */
181
182 struct glmesh
183 {
184 GLuint vao, vbo, ebo;
185 u32 indice_count;
186 };
187
188 static void mesh_upload( glmesh *mesh,
189 mdl_vert *verts, u32 vert_count,
190 u32 *indices, u32 indice_count )
191 {
192 glGenVertexArrays( 1, &mesh->vao );
193 glGenBuffers( 1, &mesh->vbo );
194 glGenBuffers( 1, &mesh->ebo );
195 glBindVertexArray( mesh->vao );
196
197 size_t stride = sizeof(mdl_vert);
198
199 glBindBuffer( GL_ARRAY_BUFFER, mesh->vbo );
200 glBufferData( GL_ARRAY_BUFFER, vert_count*stride, verts, GL_STATIC_DRAW );
201
202 glBindVertexArray( mesh->vao );
203 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mesh->ebo );
204 glBufferData( GL_ELEMENT_ARRAY_BUFFER, indice_count*sizeof(u32),
205 indices, GL_STATIC_DRAW );
206
207 /* 0: coordinates */
208 glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0 );
209 glEnableVertexAttribArray( 0 );
210
211 /* 1: normal */
212 glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE,
213 stride, (void *)offsetof(mdl_vert, norm) );
214 glEnableVertexAttribArray( 1 );
215
216 /* 2: uv */
217 glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE,
218 stride, (void *)offsetof(mdl_vert, uv) );
219 glEnableVertexAttribArray( 2 );
220
221 /* 3: colour */
222 glVertexAttribPointer( 3, 4, GL_UNSIGNED_BYTE, GL_TRUE,
223 stride, (void *)offsetof(mdl_vert, colour) );
224 glEnableVertexAttribArray( 3 );
225
226 /* 4: weights */
227 glVertexAttribPointer( 4, 4, GL_UNSIGNED_SHORT, GL_TRUE,
228 stride, (void *)offsetof(mdl_vert, weights) );
229 glEnableVertexAttribArray( 4 );
230
231 /* 5: groups */
232 glVertexAttribIPointer( 5, 4, GL_UNSIGNED_BYTE,
233 stride, (void *)offsetof(mdl_vert, groups) );
234 glEnableVertexAttribArray( 5 );
235
236
237 VG_CHECK_GL();
238 mesh->indice_count = indice_count;
239 }
240
241 static void mesh_bind( glmesh *mesh )
242 {
243 glBindVertexArray( mesh->vao );
244 }
245
246 static void mesh_drawn( u32 start, u32 count )
247 {
248 glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_INT,
249 (void *)(start*sizeof(u32)) );
250 }
251
252 static void mesh_draw( glmesh *mesh )
253 {
254 mesh_drawn( 0, mesh->indice_count );
255 }
256
257 static void mesh_free( glmesh *mesh )
258 {
259 glDeleteVertexArrays( 1, &mesh->vao );
260 glDeleteBuffers( 1, &mesh->ebo );
261 glDeleteBuffers( 1, &mesh->vbo );
262 }
263
264
265 /*
266 * Model implementation
267 */
268
269 static mdl_header *mdl_load( const char *path )
270 {
271 i64 size;
272 mdl_header *header = vg_asset_read_s( path, &size );
273
274 /*
275 * Check file is valid
276 */
277 if( !header )
278 {
279 vg_error( "Could not open '%s'\n", path );
280 return NULL;
281 }
282
283 if( size < sizeof(mdl_header) )
284 {
285 free( header );
286 vg_error( "Invalid file '%s' (too small for header)\n", path );
287 return NULL;
288 }
289
290 if( header->file_length != size )
291 {
292 vg_error( "Invalid file '%s'"
293 "(wrong .file_length, %ub != real file size %ub)\n",
294 path, header->file_length, size );
295 free( header );
296 return NULL;
297 }
298
299 /*
300 * Validate offsets and memory sections, to ensure all arrays are in-bounds,
301 * and that they do not overlap.
302 */
303
304 struct memregion
305 {
306 const char *desc;
307 u32 count, max_count, size, offset;
308 }
309 regions[] = {
310 {
311 "Vertices",
312 header->vertex_count, MDL_VERT_MAX,
313 sizeof(mdl_vert), header->vertex_offset
314 },
315 {
316 "Indices",
317 header->indice_count, MDL_INDICE_MAX,
318 sizeof(u32), header->indice_offset
319 },
320 {
321 "Submesh",
322 header->submesh_count, MDL_SUBMESH_MAX,
323 sizeof(mdl_submesh), header->submesh_offset
324 },
325 {
326 "Materials",
327 header->material_count, MDL_MATERIAL_MAX,
328 sizeof(mdl_material), header->material_offset
329 },
330 {
331 "Nodes",
332 header->node_count, MDL_NODE_MAX,
333 sizeof(mdl_node), header->node_count
334 }
335 };
336
337 for( int i=0; i<vg_list_size(regions); i++ )
338 {
339 struct memregion *ri = &regions[i];
340
341 if( ri->count == 0 )
342 continue;
343
344 if( ri->count > ri->max_count )
345 {
346 free( header );
347 vg_error( "'%s': '%s' buffer exceeds the maximum (%u/%u)\n",
348 path, ri->desc, ri->count, ri->max_count );
349 return NULL;
350 }
351
352 if( ri->offset >= header->file_length )
353 {
354 free( header );
355 vg_error( "'%s': '%s' buffer offset is out of range\n",
356 path, ri->desc );
357 return NULL;
358 }
359
360 if( ri->offset + ri->size*ri->count > header->file_length )
361 {
362 free( header );
363 vg_error( "'%s': '%s' buffer size is out of range\n",
364 path, ri->desc );
365 return NULL;
366 }
367
368 for( int j=0; j<vg_list_size(regions); j++ )
369 {
370 struct memregion *rj = &regions[j];
371 if( rj->count == 0 )
372 continue;
373
374 if( ri->offset >= rj->offset &&
375 (ri->offset+ri->size*ri->count < rj->offset+rj->size*rj->count))
376 {
377 free( header );
378 vg_error( "'%s': '%s' buffer overlaps '%s'\n",
379 path, ri->desc, rj->desc );
380 return NULL;
381 }
382 }
383 }
384
385 /*
386 * Pointer validation TODO(workshop)
387 */
388
389 /*
390 * strings TODO(workshop)
391 */
392
393 return header;
394 }
395
396 static void *mdl_baseptr( mdl_header *mdl, u32 offset )
397 {
398 return (void *)mdl + offset;
399 }
400
401 static const char *mdl_pstr( mdl_header *mdl, u32 pstr )
402 {
403 return (const char *)(mdl_baseptr( mdl, mdl->strings_offset )) + pstr;
404 }
405
406 static mdl_node *mdl_node_from_id( mdl_header *mdl, u32 id )
407 {
408 return ((mdl_node *)mdl_baseptr( mdl, mdl->node_offset )) + id;
409 }
410
411 static mdl_node *mdl_node_from_name( mdl_header *mdl, const char *name )
412 {
413 for( int i=0; i<mdl->node_count; i++ )
414 {
415 mdl_node *pnode = mdl_node_from_id( mdl, i );
416
417 if( !strcmp( name, mdl_pstr( mdl, pnode->pstr_name )) )
418 return pnode;
419 }
420
421 return NULL;
422 }
423
424 static mdl_submesh *mdl_submesh_from_id( mdl_header *mdl, u32 id )
425 {
426 if( id >= mdl->submesh_count )
427 return NULL;
428
429 return ((mdl_submesh *)mdl_baseptr( mdl, mdl->submesh_offset )) + id;
430 }
431
432 static mdl_submesh *mdl_node_submesh( mdl_header *mdl, mdl_node *node, u32 i )
433 {
434 if( i >= node->submesh_count )
435 return NULL;
436
437 return mdl_submesh_from_id( mdl, node->submesh_start+i );
438 }
439
440 static u32 *mdl_submesh_indices( mdl_header *mdl, mdl_submesh *sm )
441 {
442 return ((u32 *)mdl_baseptr( mdl, mdl->indice_offset )) + sm->indice_start;
443 }
444
445 static mdl_vert *mdl_submesh_vertices( mdl_header *mdl, mdl_submesh *sm )
446 {
447 return ((mdl_vert *)mdl_baseptr(mdl,mdl->vertex_offset)) + sm->vertex_start;
448 }
449
450 static mdl_material *mdl_material_from_id( mdl_header *mdl, u32 id )
451 {
452 return ((mdl_material *)mdl_baseptr(mdl,mdl->material_offset)) + id;
453 }
454
455 static mdl_animation *mdl_animation_from_id( mdl_header *mdl, u32 id )
456 {
457 return ((mdl_animation *)mdl_baseptr(mdl,mdl->anim_offset)) + id;
458 }
459
460 static void mdl_node_transform( mdl_node *pnode, m4x3f transform )
461 {
462 q_m3x3( pnode->q, transform );
463 v3_muls( transform[0], pnode->s[0], transform[0] );
464 v3_muls( transform[1], pnode->s[1], transform[1] );
465 v3_muls( transform[2], pnode->s[2], transform[2] );
466 v3_copy( pnode->co, transform[3] );
467 }
468
469 static void mdl_unpack_submesh( mdl_header *mdl, glmesh *mesh, mdl_submesh *sm )
470 {
471 mesh_upload( mesh, mdl_submesh_vertices( mdl, sm ), sm->vertex_count,
472 mdl_submesh_indices( mdl, sm ), sm->indice_count );
473 }
474
475 static void mdl_unpack_glmesh( mdl_header *mdl, glmesh *mesh )
476 {
477 u32 offset = mdl_submesh_from_id( mdl, 0 )->vertex_count;
478
479 for( int i=1; i< mdl->submesh_count; i++ )
480 {
481 mdl_submesh *sm = mdl_submesh_from_id( mdl, i );
482 u32 *indices = mdl_submesh_indices( mdl, sm );
483
484 for( u32 j=0; j<sm->indice_count; j++ )
485 indices[j] += offset;
486
487 offset += sm->vertex_count;
488 }
489
490 mdl_vert *vertex_base = mdl_baseptr( mdl, mdl->vertex_offset );
491 u32 *indice_base = mdl_baseptr( mdl, mdl->indice_offset );
492
493 mesh_upload( mesh, vertex_base, mdl->vertex_count,
494 indice_base, mdl->indice_count );
495 }
496
497 static void mdl_draw_submesh( mdl_submesh *sm )
498 {
499 mesh_drawn( sm->indice_start, sm->indice_count );
500 }
501
502 static void *mdl_get_entdata( mdl_header *mdl, mdl_node *pnode )
503 {
504 return mdl_baseptr( mdl, mdl->entdata_offset ) + pnode->offset;
505 }
506
507 static mdl_keyframe *mdl_get_animdata( mdl_header *mdl, mdl_animation *anim )
508 {
509 return mdl_baseptr( mdl, mdl->animdata_offset ) + anim->offset;
510 }
511
512 static void mdl_link_materials( mdl_header *root, mdl_header *child )
513 {
514 u32 lookup[MDL_MATERIAL_MAX];
515
516 for( int i=0; i<child->material_count; i++ )
517 {
518 mdl_material *mi = mdl_material_from_id( child, i );
519 const char *si = mdl_pstr( child, mi->pstr_name );
520
521 lookup[i] = 0;
522
523 for( int j=0; j<root->material_count; j++ )
524 {
525 mdl_material *mj = mdl_material_from_id( root, j );
526 const char *sj = mdl_pstr( root, mj->pstr_name );
527
528 if( !strcmp( si, sj ) )
529 {
530 lookup[i] = j;
531 break;
532 }
533 }
534
535 if( lookup[i] == 0 && i != 0 )
536 {
537 vg_warn( "Could not link material '%s' (not present in root model)\n",
538 si );
539 }
540 }
541
542 for( int i=0; i<child->submesh_count; i++ )
543 {
544 mdl_submesh *sm = mdl_submesh_from_id( child, i );
545 sm->material_id = lookup[sm->material_id];
546 }
547 }
548
549
550 #endif