GCC Code Coverage Report

Directory: ./
File: submodules/raylib/src/external/m3d.h
Date: 2023-09-29 04:53:15
Exec Total Coverage
Lines: 0 1564 0.0%
Branches: 0 2004 0.0%
Line Branch Exec Source
1 /*
2 * m3d.h
3 * https://gitlab.com/bztsrc/model3d
4 *
5 * Copyright (C) 2020 bzt (bztsrc@gitlab)
6 *
7 * Permission is hereby granted, free of charge, to any person
8 * obtaining a copy of this software and associated documentation
9 * files (the "Software"), to deal in the Software without
10 * restriction, including without limitation the rights to use, copy,
11 * modify, merge, publish, distribute, sublicense, and/or sell copies
12 * of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be
16 * included in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25 * DEALINGS IN THE SOFTWARE.
26 *
27 * @brief ANSI C89 / C++11 single header importer / exporter SDK for the Model 3D (.M3D) format
28 * https://gitlab.com/bztsrc/model3d
29 *
30 * PNG decompressor included from (with minor modifications to make it C89 valid):
31 * stb_image - v2.13 - public domain image loader - http://nothings.org/stb_image.h
32 *
33 * @version: 1.0.0
34 */
35
36 #ifndef _M3D_H_
37 #define _M3D_H_
38
39 #ifdef __cplusplus
40 extern "C" {
41 #endif
42
43 #include <stdint.h>
44
45 /*** configuration ***/
46 #ifndef M3D_MALLOC
47 # define M3D_MALLOC(sz) malloc(sz)
48 #endif
49 #ifndef M3D_REALLOC
50 # define M3D_REALLOC(p,nsz) realloc(p,nsz)
51 #endif
52 #ifndef M3D_FREE
53 # define M3D_FREE(p) free(p)
54 #endif
55 #ifndef M3D_LOG
56 # define M3D_LOG(x)
57 #endif
58 #ifndef M3D_APIVERSION
59 #define M3D_APIVERSION 0x0100
60 #ifndef M3D_DOUBLE
61 typedef float M3D_FLOAT;
62 #ifndef M3D_EPSILON
63 /* carefully choosen for IEEE 754 don't change */
64 #define M3D_EPSILON ((M3D_FLOAT)1e-7)
65 #endif
66 #else
67 typedef double M3D_FLOAT;
68 #ifndef M3D_EPSILON
69 #define M3D_EPSILON ((M3D_FLOAT)1e-14)
70 #endif
71 #endif
72 #if !defined(M3D_SMALLINDEX)
73 typedef uint32_t M3D_INDEX;
74 typedef uint16_t M3D_VOXEL;
75 #define M3D_UNDEF 0xffffffff
76 #define M3D_INDEXMAX 0xfffffffe
77 #define M3D_VOXUNDEF 0xffff
78 #define M3D_VOXCLEAR 0xfffe
79 #else
80 typedef uint16_t M3D_INDEX;
81 typedef uint8_t M3D_VOXEL;
82 #define M3D_UNDEF 0xffff
83 #define M3D_INDEXMAX 0xfffe
84 #define M3D_VOXUNDEF 0xff
85 #define M3D_VOXCLEAR 0xfe
86 #endif
87 #define M3D_NOTDEFINED 0xffffffff
88 #ifndef M3D_NUMBONE
89 #define M3D_NUMBONE 4
90 #endif
91 #ifndef M3D_BONEMAXLEVEL
92 #define M3D_BONEMAXLEVEL 8
93 #endif
94 #ifndef _MSC_VER
95 #ifndef _inline
96 #define _inline __inline__
97 #endif
98 #define _pack __attribute__((packed))
99 #define _unused __attribute__((unused))
100 #else
101 #define _inline
102 #define _pack
103 #define _unused __pragma(warning(suppress:4100))
104 #endif
105 #ifndef __cplusplus
106 #define _register register
107 #else
108 #define _register
109 #endif
110
111 /*** File format structures ***/
112
113 /**
114 * M3D file format structure
115 * 3DMO m3dchunk_t file header chunk, may followed by compressed data
116 * PRVW preview chunk (optional)
117 * HEAD m3dhdr_t model header chunk
118 * n x m3dchunk_t more chunks follow
119 * CMAP color map chunk (optional)
120 * TMAP texture map chunk (optional)
121 * VRTS vertex data chunk (optional if it's a material library)
122 * BONE bind-pose skeleton, bone hierarchy chunk (optional)
123 * n x m3db_t contains propably more, but at least one bone
124 * n x m3ds_t skin group records
125 * MTRL* material chunk(s), can be more (optional)
126 * n x m3dp_t each material contains propapbly more, but at least one property
127 * the properties are configurable with a static array, see m3d_propertytypes
128 * n x m3dchunk_t at least one, but maybe more face chunks
129 * PROC* procedural face, or
130 * MESH* triangle mesh (vertex index list) or
131 * VOXT, VOXD* voxel image (converted to mesh) or
132 * SHPE* mathematical shapes like parameterized surfaces
133 * LBLS* annotation label chunks, can be more (optional)
134 * ACTN* action chunk(s), animation-pose skeletons, can be more (optional)
135 * n x m3dfr_t each action contains probably more, but at least one frame
136 * n x m3dtr_t each frame contains probably more, but at least one transformation
137 * ASET* inlined asset chunk(s), can be more (optional)
138 * OMD3 end chunk
139 *
140 * Typical chunks for a game engine: 3DMO, HEAD, CMAP, TMAP, VRTS, BONE, MTRL, MESH, ACTN, OMD3
141 * Typical chunks for distibution: 3DMO, PRVW, HEAD, CMAP, TMAP, VRTS, BONE, MTRL, MESH, ACTN, ASET, OMD3
142 * Typical chunks for voxel image: 3DMO, HEAD, CMAP, MTRL, VOXT, VOXD, VOXD, VOXD, OMD3
143 * Typical chunks for CAD software: 3DMO, PRVW, HEAD, CMAP, TMAP, VRTS, MTRL, SHPE, LBLS, OMD3
144 */
145 #ifdef _MSC_VER
146 #pragma pack(push)
147 #pragma pack(1)
148 #endif
149
150 typedef struct {
151 char magic[4];
152 uint32_t length;
153 float scale; /* deliberately not M3D_FLOAT */
154 uint32_t types;
155 } _pack m3dhdr_t;
156
157 typedef struct {
158 char magic[4];
159 uint32_t length;
160 } _pack m3dchunk_t;
161
162 #ifdef _MSC_VER
163 #pragma pack(pop)
164 #endif
165
166 /*** in-memory model structure ***/
167
168 /* textmap entry */
169 typedef struct {
170 M3D_FLOAT u;
171 M3D_FLOAT v;
172 } m3dti_t;
173 #define m3d_textureindex_t m3dti_t
174
175 /* texture */
176 typedef struct {
177 char *name; /* texture name */
178 uint8_t *d; /* pixels data */
179 uint16_t w; /* width */
180 uint16_t h; /* height */
181 uint8_t f; /* format, 1 = grayscale, 2 = grayscale+alpha, 3 = rgb, 4 = rgba */
182 } m3dtx_t;
183 #define m3d_texturedata_t m3dtx_t
184
185 typedef struct {
186 M3D_INDEX vertexid;
187 M3D_FLOAT weight;
188 } m3dw_t;
189 #define m3d_weight_t m3dw_t
190
191 /* bone entry */
192 typedef struct {
193 M3D_INDEX parent; /* parent bone index */
194 char *name; /* name for this bone */
195 M3D_INDEX pos; /* vertex index position */
196 M3D_INDEX ori; /* vertex index orientation (quaternion) */
197 M3D_INDEX numweight; /* number of controlled vertices */
198 m3dw_t *weight; /* weights for those vertices */
199 M3D_FLOAT mat4[16]; /* transformation matrix */
200 } m3db_t;
201 #define m3d_bone_t m3db_t
202
203 /* skin: bone per vertex entry */
204 typedef struct {
205 M3D_INDEX boneid[M3D_NUMBONE];
206 M3D_FLOAT weight[M3D_NUMBONE];
207 } m3ds_t;
208 #define m3d_skin_t m3ds_t
209
210 /* vertex entry */
211 typedef struct {
212 M3D_FLOAT x; /* 3D coordinates and weight */
213 M3D_FLOAT y;
214 M3D_FLOAT z;
215 M3D_FLOAT w;
216 uint32_t color; /* default vertex color */
217 M3D_INDEX skinid; /* skin index */
218 #ifdef M3D_VERTEXTYPE
219 uint8_t type;
220 #endif
221 } m3dv_t;
222 #define m3d_vertex_t m3dv_t
223
224 /* material property formats */
225 enum {
226 m3dpf_color,
227 m3dpf_uint8,
228 m3dpf_uint16,
229 m3dpf_uint32,
230 m3dpf_float,
231 m3dpf_map
232 };
233 typedef struct {
234 uint8_t format;
235 uint8_t id;
236 #ifdef M3D_ASCII
237 #define M3D_PROPERTYDEF(f,i,n) { (f), (i), (char*)(n) }
238 char *key;
239 #else
240 #define M3D_PROPERTYDEF(f,i,n) { (f), (i) }
241 #endif
242 } m3dpd_t;
243
244 /* material property types */
245 /* You shouldn't change the first 8 display and first 4 physical property. Assign the rest as you like. */
246 enum {
247 m3dp_Kd = 0, /* scalar display properties */
248 m3dp_Ka,
249 m3dp_Ks,
250 m3dp_Ns,
251 m3dp_Ke,
252 m3dp_Tf,
253 m3dp_Km,
254 m3dp_d,
255 m3dp_il,
256
257 m3dp_Pr = 64, /* scalar physical properties */
258 m3dp_Pm,
259 m3dp_Ps,
260 m3dp_Ni,
261 m3dp_Nt,
262
263 m3dp_map_Kd = 128, /* textured display map properties */
264 m3dp_map_Ka,
265 m3dp_map_Ks,
266 m3dp_map_Ns,
267 m3dp_map_Ke,
268 m3dp_map_Tf,
269 m3dp_map_Km, /* bump map */
270 m3dp_map_D,
271 m3dp_map_N, /* normal map */
272
273 m3dp_map_Pr = 192, /* textured physical map properties */
274 m3dp_map_Pm,
275 m3dp_map_Ps,
276 m3dp_map_Ni,
277 m3dp_map_Nt
278 };
279 enum { /* aliases */
280 m3dp_bump = m3dp_map_Km,
281 m3dp_map_il = m3dp_map_N,
282 m3dp_refl = m3dp_map_Pm
283 };
284
285 /* material property */
286 typedef struct {
287 uint8_t type; /* property type, see "m3dp_*" enumeration */
288 union {
289 uint32_t color; /* if value is a color, m3dpf_color */
290 uint32_t num; /* if value is a number, m3dpf_uint8, m3pf_uint16, m3dpf_uint32 */
291 float fnum; /* if value is a floating point number, m3dpf_float */
292 M3D_INDEX textureid; /* if value is a texture, m3dpf_map */
293 } value;
294 } m3dp_t;
295 #define m3d_property_t m3dp_t
296
297 /* material entry */
298 typedef struct {
299 char *name; /* name of the material */
300 uint8_t numprop; /* number of properties */
301 m3dp_t *prop; /* properties array */
302 } m3dm_t;
303 #define m3d_material_t m3dm_t
304
305 /* face entry */
306 typedef struct {
307 M3D_INDEX materialid; /* material index */
308 M3D_INDEX vertex[3]; /* 3D points of the triangle in CCW order */
309 M3D_INDEX normal[3]; /* normal vectors */
310 M3D_INDEX texcoord[3]; /* UV coordinates */
311 #ifdef M3D_VERTEXMAX
312 M3D_INDEX paramid; /* parameter index */
313 M3D_INDEX vertmax[3]; /* maximum 3D points of the triangle in CCW order */
314 #endif
315 } m3df_t;
316 #define m3d_face_t m3df_t
317
318 typedef struct {
319 uint16_t count;
320 char *name;
321 } m3dvi_t;
322 #define m3d_voxelitem_t m3dvi_t
323 #define m3d_parameter_t m3dvi_t
324
325 /* voxel types (voxel palette) */
326 typedef struct {
327 char *name; /* technical name of the voxel */
328 uint8_t rotation; /* rotation info */
329 uint16_t voxshape; /* voxel shape */
330 M3D_INDEX materialid; /* material index */
331 uint32_t color; /* default voxel color */
332 M3D_INDEX skinid; /* skin index */
333 uint8_t numitem; /* number of sub-voxels */
334 m3dvi_t *item; /* list of sub-voxels */
335 } m3dvt_t;
336 #define m3d_voxeltype_t m3dvt_t
337
338 /* voxel data blocks */
339 typedef struct {
340 char *name; /* name of the block */
341 int32_t x, y, z; /* position */
342 uint32_t w, h, d; /* dimension */
343 uint8_t uncertain; /* probability */
344 uint8_t groupid; /* block group id */
345 M3D_VOXEL *data; /* voxel data, indices to voxel type */
346 } m3dvx_t;
347 #define m3d_voxel_t m3dvx_t
348
349 /* shape command types. must match the row in m3d_commandtypes */
350 enum {
351 /* special commands */
352 m3dc_use = 0, /* use material */
353 m3dc_inc, /* include another shape */
354 m3dc_mesh, /* include part of polygon mesh */
355 /* approximations */
356 m3dc_div, /* subdivision by constant resolution for both u, v */
357 m3dc_sub, /* subdivision by constant, different for u and v */
358 m3dc_len, /* spacial subdivision by maxlength */
359 m3dc_dist, /* subdivision by maxdistance and maxangle */
360 /* modifiers */
361 m3dc_degu, /* degree for both u, v */
362 m3dc_deg, /* separate degree for u and v */
363 m3dc_rangeu, /* range for u */
364 m3dc_range, /* range for u and v */
365 m3dc_paru, /* u parameters (knots) */
366 m3dc_parv, /* v parameters */
367 m3dc_trim, /* outer trimming curve */
368 m3dc_hole, /* inner trimming curve */
369 m3dc_scrv, /* spacial curve */
370 m3dc_sp, /* special points */
371 /* helper curves */
372 m3dc_bez1, /* Bezier 1D */
373 m3dc_bsp1, /* B-spline 1D */
374 m3dc_bez2, /* bezier 2D */
375 m3dc_bsp2, /* B-spline 2D */
376 /* surfaces */
377 m3dc_bezun, /* Bezier 3D with control, UV, normal */
378 m3dc_bezu, /* with control and UV */
379 m3dc_bezn, /* with control and normal */
380 m3dc_bez, /* control points only */
381 m3dc_nurbsun, /* B-spline 3D */
382 m3dc_nurbsu,
383 m3dc_nurbsn,
384 m3dc_nurbs,
385 m3dc_conn, /* connect surfaces */
386 /* geometrical */
387 m3dc_line,
388 m3dc_polygon,
389 m3dc_circle,
390 m3dc_cylinder,
391 m3dc_shpere,
392 m3dc_torus,
393 m3dc_cone,
394 m3dc_cube
395 };
396
397 /* shape command argument types */
398 enum {
399 m3dcp_mi_t = 1, /* material index */
400 m3dcp_hi_t, /* shape index */
401 m3dcp_fi_t, /* face index */
402 m3dcp_ti_t, /* texture map index */
403 m3dcp_vi_t, /* vertex index */
404 m3dcp_qi_t, /* vertex index for quaternions */
405 m3dcp_vc_t, /* coordinate or radius, float scalar */
406 m3dcp_i1_t, /* int8 scalar */
407 m3dcp_i2_t, /* int16 scalar */
408 m3dcp_i4_t, /* int32 scalar */
409 m3dcp_va_t /* variadic arguments */
410 };
411
412 #define M3D_CMDMAXARG 8 /* if you increase this, add more arguments to the macro below */
413 typedef struct {
414 #ifdef M3D_ASCII
415 #define M3D_CMDDEF(t,n,p,a,b,c,d,e,f,g,h) { (char*)(n), (p), { (a), (b), (c), (d), (e), (f), (g), (h) } }
416 char *key;
417 #else
418 #define M3D_CMDDEF(t,n,p,a,b,c,d,e,f,g,h) { (p), { (a), (b), (c), (d), (e), (f), (g), (h) } }
419 #endif
420 uint8_t p;
421 uint8_t a[M3D_CMDMAXARG];
422 } m3dcd_t;
423
424 /* shape command */
425 typedef struct {
426 uint16_t type; /* shape type */
427 uint32_t *arg; /* arguments array */
428 } m3dc_t;
429 #define m3d_shapecommand_t m3dc_t
430
431 /* shape entry */
432 typedef struct {
433 char *name; /* name of the mathematical shape */
434 M3D_INDEX group; /* group this shape belongs to or -1 */
435 uint32_t numcmd; /* number of commands */
436 m3dc_t *cmd; /* commands array */
437 } m3dh_t;
438 #define m3d_shape_t m3dh_t
439
440 /* label entry */
441 typedef struct {
442 char *name; /* name of the annotation layer or NULL */
443 char *lang; /* language code or NULL */
444 char *text; /* the label text */
445 uint32_t color; /* color */
446 M3D_INDEX vertexid; /* the vertex the label refers to */
447 } m3dl_t;
448 #define m3d_label_t m3dl_t
449
450 /* frame transformations / working copy skeleton entry */
451 typedef struct {
452 M3D_INDEX boneid; /* selects a node in bone hierarchy */
453 M3D_INDEX pos; /* vertex index new position */
454 M3D_INDEX ori; /* vertex index new orientation (quaternion) */
455 } m3dtr_t;
456 #define m3d_transform_t m3dtr_t
457
458 /* animation frame entry */
459 typedef struct {
460 uint32_t msec; /* frame's position on the timeline, timestamp */
461 M3D_INDEX numtransform; /* number of transformations in this frame */
462 m3dtr_t *transform; /* transformations */
463 } m3dfr_t;
464 #define m3d_frame_t m3dfr_t
465
466 /* model action entry */
467 typedef struct {
468 char *name; /* name of the action */
469 uint32_t durationmsec; /* duration in millisec (1/1000 sec) */
470 M3D_INDEX numframe; /* number of frames in this animation */
471 m3dfr_t *frame; /* frames array */
472 } m3da_t;
473 #define m3d_action_t m3da_t
474
475 /* inlined asset */
476 typedef struct {
477 char *name; /* asset name (same pointer as in texture[].name) */
478 uint8_t *data; /* compressed asset data */
479 uint32_t length; /* compressed data length */
480 } m3di_t;
481 #define m3d_inlinedasset_t m3di_t
482
483 /*** in-memory model structure ***/
484 #define M3D_FLG_FREERAW (1<<0)
485 #define M3D_FLG_FREESTR (1<<1)
486 #define M3D_FLG_MTLLIB (1<<2)
487 #define M3D_FLG_GENNORM (1<<3)
488
489 typedef struct {
490 m3dhdr_t *raw; /* pointer to raw data */
491 char flags; /* internal flags */
492 signed char errcode; /* returned error code */
493 char vc_s, vi_s, si_s, ci_s, ti_s, bi_s, nb_s, sk_s, fc_s, hi_s, fi_s, vd_s, vp_s; /* decoded sizes for types */
494 char *name; /* name of the model, like "Utah teapot" */
495 char *license; /* usage condition or license, like "MIT", "LGPL" or "BSD-3clause" */
496 char *author; /* nickname, email, homepage or github URL etc. */
497 char *desc; /* comments, descriptions. May contain '\n' newline character */
498 M3D_FLOAT scale; /* the model's bounding cube's size in SI meters */
499 M3D_INDEX numcmap;
500 uint32_t *cmap; /* color map */
501 M3D_INDEX numtmap;
502 m3dti_t *tmap; /* texture map indices */
503 M3D_INDEX numtexture;
504 m3dtx_t *texture; /* uncompressed textures */
505 M3D_INDEX numbone;
506 m3db_t *bone; /* bone hierarchy */
507 M3D_INDEX numvertex;
508 m3dv_t *vertex; /* vertex data */
509 M3D_INDEX numskin;
510 m3ds_t *skin; /* skin data */
511 M3D_INDEX nummaterial;
512 m3dm_t *material; /* material list */
513 #ifdef M3D_VERTEXMAX
514 M3D_INDEX numparam;
515 m3dvi_t *param; /* parameters and their values list */
516 #endif
517 M3D_INDEX numface;
518 m3df_t *face; /* model face, polygon (triangle) mesh */
519 M3D_INDEX numvoxtype;
520 m3dvt_t *voxtype; /* model face, voxel types */
521 M3D_INDEX numvoxel;
522 m3dvx_t *voxel; /* model face, cubes compressed into voxels */
523 M3D_INDEX numshape;
524 m3dh_t *shape; /* model face, shape commands */
525 M3D_INDEX numlabel;
526 m3dl_t *label; /* annotation labels */
527 M3D_INDEX numaction;
528 m3da_t *action; /* action animations */
529 M3D_INDEX numinlined;
530 m3di_t *inlined; /* inlined assets */
531 M3D_INDEX numextra;
532 m3dchunk_t **extra; /* unknown chunks, application / engine specific data probably */
533 m3di_t preview; /* preview chunk */
534 } m3d_t;
535
536 /*** export parameters ***/
537 #define M3D_EXP_INT8 0
538 #define M3D_EXP_INT16 1
539 #define M3D_EXP_FLOAT 2
540 #define M3D_EXP_DOUBLE 3
541
542 #define M3D_EXP_NOCMAP (1<<0)
543 #define M3D_EXP_NOMATERIAL (1<<1)
544 #define M3D_EXP_NOFACE (1<<2)
545 #define M3D_EXP_NONORMAL (1<<3)
546 #define M3D_EXP_NOTXTCRD (1<<4)
547 #define M3D_EXP_FLIPTXTCRD (1<<5)
548 #define M3D_EXP_NORECALC (1<<6)
549 #define M3D_EXP_IDOSUCK (1<<7)
550 #define M3D_EXP_NOBONE (1<<8)
551 #define M3D_EXP_NOACTION (1<<9)
552 #define M3D_EXP_INLINE (1<<10)
553 #define M3D_EXP_EXTRA (1<<11)
554 #define M3D_EXP_NOZLIB (1<<14)
555 #define M3D_EXP_ASCII (1<<15)
556 #define M3D_EXP_NOVRTMAX (1<<16)
557
558 /*** error codes ***/
559 #define M3D_SUCCESS 0
560 #define M3D_ERR_ALLOC -1
561 #define M3D_ERR_BADFILE -2
562 #define M3D_ERR_UNIMPL -65
563 #define M3D_ERR_UNKPROP -66
564 #define M3D_ERR_UNKMESH -67
565 #define M3D_ERR_UNKIMG -68
566 #define M3D_ERR_UNKFRAME -69
567 #define M3D_ERR_UNKCMD -70
568 #define M3D_ERR_UNKVOX -71
569 #define M3D_ERR_TRUNC -72
570 #define M3D_ERR_CMAP -73
571 #define M3D_ERR_TMAP -74
572 #define M3D_ERR_VRTS -75
573 #define M3D_ERR_BONE -76
574 #define M3D_ERR_MTRL -77
575 #define M3D_ERR_SHPE -78
576 #define M3D_ERR_VOXT -79
577
578 #define M3D_ERR_ISFATAL(x) ((x) < 0 && (x) > -65)
579
580 /* callbacks */
581 typedef unsigned char *(*m3dread_t)(char *filename, unsigned int *size); /* read file contents into buffer */
582 typedef void (*m3dfree_t)(void *buffer); /* free file contents buffer */
583 typedef int (*m3dtxsc_t)(const char *name, const void *script, uint32_t len, m3dtx_t *output); /* interpret texture script */
584 typedef int (*m3dprsc_t)(const char *name, const void *script, uint32_t len, m3d_t *model); /* interpret surface script */
585 #endif /* ifndef M3D_APIVERSION */
586
587 /*** C prototypes ***/
588 /* import / export */
589 m3d_t *m3d_load(unsigned char *data, m3dread_t readfilecb, m3dfree_t freecb, m3d_t *mtllib);
590 unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size);
591 void m3d_free(m3d_t *model);
592 /* generate animation pose skeleton */
593 m3dtr_t *m3d_frame(m3d_t *model, M3D_INDEX actionid, M3D_INDEX frameid, m3dtr_t *skeleton);
594 m3db_t *m3d_pose(m3d_t *model, M3D_INDEX actionid, uint32_t msec);
595
596 /* private prototypes used by both importer and exporter */
597 char *_m3d_safestr(char *in, int morelines);
598
599 /*** C implementation ***/
600 #ifdef M3D_IMPLEMENTATION
601 #if !defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER)
602 /* material property definitions */
603 static m3dpd_t m3d_propertytypes[] = {
604 M3D_PROPERTYDEF(m3dpf_color, m3dp_Kd, "Kd"), /* diffuse color */
605 M3D_PROPERTYDEF(m3dpf_color, m3dp_Ka, "Ka"), /* ambient color */
606 M3D_PROPERTYDEF(m3dpf_color, m3dp_Ks, "Ks"), /* specular color */
607 M3D_PROPERTYDEF(m3dpf_float, m3dp_Ns, "Ns"), /* specular exponent */
608 M3D_PROPERTYDEF(m3dpf_color, m3dp_Ke, "Ke"), /* emissive (emitting light of this color) */
609 M3D_PROPERTYDEF(m3dpf_color, m3dp_Tf, "Tf"), /* transmission color */
610 M3D_PROPERTYDEF(m3dpf_float, m3dp_Km, "Km"), /* bump strength */
611 M3D_PROPERTYDEF(m3dpf_float, m3dp_d, "d"), /* dissolve (transparency) */
612 M3D_PROPERTYDEF(m3dpf_uint8, m3dp_il, "il"), /* illumination model (informational, ignored by PBR-shaders) */
613
614 M3D_PROPERTYDEF(m3dpf_float, m3dp_Pr, "Pr"), /* roughness */
615 M3D_PROPERTYDEF(m3dpf_float, m3dp_Pm, "Pm"), /* metallic, also reflection */
616 M3D_PROPERTYDEF(m3dpf_float, m3dp_Ps, "Ps"), /* sheen */
617 M3D_PROPERTYDEF(m3dpf_float, m3dp_Ni, "Ni"), /* index of refraction (optical density) */
618 M3D_PROPERTYDEF(m3dpf_float, m3dp_Nt, "Nt"), /* thickness of face in millimeter, for printing */
619
620 /* aliases, note that "map_*" aliases are handled automatically */
621 M3D_PROPERTYDEF(m3dpf_map, m3dp_map_Km, "bump"),
622 M3D_PROPERTYDEF(m3dpf_map, m3dp_map_N, "map_N"),/* as normal map has no scalar version, it's counterpart is 'il' */
623 M3D_PROPERTYDEF(m3dpf_map, m3dp_map_Pm, "refl")
624 };
625 /* shape command definitions. if more commands start with the same string, the longer must come first */
626 static m3dcd_t m3d_commandtypes[] = {
627 /* technical */
628 M3D_CMDDEF(m3dc_use, "use", 1, m3dcp_mi_t, 0, 0, 0, 0, 0, 0, 0),
629 M3D_CMDDEF(m3dc_inc, "inc", 3, m3dcp_hi_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vi_t, 0, 0, 0, 0),
630 M3D_CMDDEF(m3dc_mesh, "mesh", 1, m3dcp_fi_t, m3dcp_fi_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vi_t, 0, 0, 0),
631 /* approximations */
632 M3D_CMDDEF(m3dc_div, "div", 1, m3dcp_vc_t, 0, 0, 0, 0, 0, 0, 0),
633 M3D_CMDDEF(m3dc_sub, "sub", 2, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
634 M3D_CMDDEF(m3dc_len, "len", 1, m3dcp_vc_t, 0, 0, 0, 0, 0, 0, 0),
635 M3D_CMDDEF(m3dc_dist, "dist", 2, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
636 /* modifiers */
637 M3D_CMDDEF(m3dc_degu, "degu", 1, m3dcp_i1_t, 0, 0, 0, 0, 0, 0, 0),
638 M3D_CMDDEF(m3dc_deg, "deg", 2, m3dcp_i1_t, m3dcp_i1_t, 0, 0, 0, 0, 0, 0),
639 M3D_CMDDEF(m3dc_rangeu, "rangeu", 1, m3dcp_ti_t, 0, 0, 0, 0, 0, 0, 0),
640 M3D_CMDDEF(m3dc_range, "range", 2, m3dcp_ti_t, m3dcp_ti_t, 0, 0, 0, 0, 0, 0),
641 M3D_CMDDEF(m3dc_paru, "paru", 2, m3dcp_va_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
642 M3D_CMDDEF(m3dc_parv, "parv", 2, m3dcp_va_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
643 M3D_CMDDEF(m3dc_trim, "trim", 3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
644 M3D_CMDDEF(m3dc_hole, "hole", 3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
645 M3D_CMDDEF(m3dc_scrv, "scrv", 3, m3dcp_va_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0, 0, 0, 0),
646 M3D_CMDDEF(m3dc_sp, "sp", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
647 /* helper curves */
648 M3D_CMDDEF(m3dc_bez1, "bez1", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
649 M3D_CMDDEF(m3dc_bsp1, "bsp1", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
650 M3D_CMDDEF(m3dc_bez2, "bez2", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
651 M3D_CMDDEF(m3dc_bsp2, "bsp2", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
652 /* surfaces */
653 M3D_CMDDEF(m3dc_bezun, "bezun", 4, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, m3dcp_vi_t, 0, 0, 0, 0),
654 M3D_CMDDEF(m3dc_bezu, "bezu", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, 0, 0, 0, 0, 0),
655 M3D_CMDDEF(m3dc_bezn, "bezn", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
656 M3D_CMDDEF(m3dc_bez, "bez", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
657 M3D_CMDDEF(m3dc_nurbsun, "nurbsun", 4, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, m3dcp_vi_t, 0, 0, 0, 0),
658 M3D_CMDDEF(m3dc_nurbsu, "nurbsu", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_ti_t, 0, 0, 0, 0, 0),
659 M3D_CMDDEF(m3dc_nurbsn, "nurbsn", 3, m3dcp_va_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
660 M3D_CMDDEF(m3dc_nurbs, "nurbs", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
661 M3D_CMDDEF(m3dc_conn, "conn", 6, m3dcp_i2_t, m3dcp_ti_t, m3dcp_i2_t, m3dcp_i2_t, m3dcp_ti_t, m3dcp_i2_t, 0, 0),
662 /* geometrical */
663 M3D_CMDDEF(m3dc_line, "line", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
664 M3D_CMDDEF(m3dc_polygon, "polygon", 2, m3dcp_va_t, m3dcp_vi_t, 0, 0, 0, 0, 0, 0),
665 M3D_CMDDEF(m3dc_circle, "circle", 3, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, 0, 0, 0, 0, 0),
666 M3D_CMDDEF(m3dc_cylinder,"cylinder",6, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, 0, 0),
667 M3D_CMDDEF(m3dc_shpere, "shpere", 2, m3dcp_vi_t, m3dcp_vc_t, 0, 0, 0, 0, 0, 0),
668 M3D_CMDDEF(m3dc_torus, "torus", 4, m3dcp_vi_t, m3dcp_qi_t, m3dcp_vc_t, m3dcp_vc_t, 0, 0, 0, 0),
669 M3D_CMDDEF(m3dc_cone, "cone", 3, m3dcp_vi_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0),
670 M3D_CMDDEF(m3dc_cube, "cube", 3, m3dcp_vi_t, m3dcp_vi_t, m3dcp_vi_t, 0, 0, 0, 0, 0)
671 };
672 #endif
673
674 #include <stdlib.h>
675 #include <string.h>
676
677 #if !defined(M3D_NOIMPORTER) && !defined(STBI_INCLUDE_STB_IMAGE_H)
678 /* PNG decompressor from
679
680 stb_image - v2.23 - public domain image loader - http://nothings.org/stb_image.h
681 */
682 static const char *_m3dstbi__g_failure_reason;
683
684 enum
685 {
686 STBI_default = 0,
687
688 STBI_grey = 1,
689 STBI_grey_alpha = 2,
690 STBI_rgb = 3,
691 STBI_rgb_alpha = 4
692 };
693
694 enum
695 {
696 STBI__SCAN_load=0,
697 STBI__SCAN_type,
698 STBI__SCAN_header
699 };
700
701 typedef unsigned short _m3dstbi_us;
702
703 typedef uint16_t _m3dstbi__uint16;
704 typedef int16_t _m3dstbi__int16;
705 typedef uint32_t _m3dstbi__uint32;
706 typedef int32_t _m3dstbi__int32;
707
708 typedef struct
709 {
710 _m3dstbi__uint32 img_x, img_y;
711 int img_n, img_out_n;
712
713 void *io_user_data;
714
715 int read_from_callbacks;
716 int buflen;
717 unsigned char buffer_start[128];
718
719 unsigned char *img_buffer, *img_buffer_end;
720 unsigned char *img_buffer_original, *img_buffer_original_end;
721 } _m3dstbi__context;
722
723 typedef struct
724 {
725 int bits_per_channel;
726 int num_channels;
727 int channel_order;
728 } _m3dstbi__result_info;
729
730 #define STBI_ASSERT(v)
731 #define STBI_NOTUSED(v) (void)sizeof(v)
732 #define STBI__BYTECAST(x) ((unsigned char) ((x) & 255))
733 #define STBI_MALLOC(sz) M3D_MALLOC(sz)
734 #define STBI_REALLOC(p,newsz) M3D_REALLOC(p,newsz)
735 #define STBI_FREE(p) M3D_FREE(p)
736 #define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)
737
738 _inline static unsigned char _m3dstbi__get8(_m3dstbi__context *s)
739 {
740 ✗ if (s->img_buffer < s->img_buffer_end)
741 ✗ return *s->img_buffer++;
742 return 0;
743 }
744
745 _inline static int _m3dstbi__at_eof(_m3dstbi__context *s)
746 {
747 return s->img_buffer >= s->img_buffer_end;
748 }
749
750 static void _m3dstbi__skip(_m3dstbi__context *s, int n)
751 {
752 ✗ if (n < 0) {
753 ✗ s->img_buffer = s->img_buffer_end;
754 ✗ return;
755 }
756 ✗ s->img_buffer += n;
757 }
758
759 static int _m3dstbi__getn(_m3dstbi__context *s, unsigned char *buffer, int n)
760 {
761 ✗ if (s->img_buffer+n <= s->img_buffer_end) {
762 memcpy(buffer, s->img_buffer, n);
763 ✗ s->img_buffer += n;
764 return 1;
765 } else
766 return 0;
767 }
768
769 static int _m3dstbi__get16be(_m3dstbi__context *s)
770 {
771 ✗ int z = _m3dstbi__get8(s);
772 ✗ return (z << 8) + _m3dstbi__get8(s);
773 }
774
775 ✗ static _m3dstbi__uint32 _m3dstbi__get32be(_m3dstbi__context *s)
776 {
777 ✗ _m3dstbi__uint32 z = _m3dstbi__get16be(s);
778 ✗ return (z << 16) + _m3dstbi__get16be(s);
779 }
780
781 #define _m3dstbi__err(x,y) _m3dstbi__errstr(y)
782 static int _m3dstbi__errstr(const char *str)
783 {
784 ✗ _m3dstbi__g_failure_reason = str;
785 return 0;
786 }
787
788 _inline static void *_m3dstbi__malloc(size_t size)
789 {
790 ✗ return STBI_MALLOC(size);
791 }
792
793 static int _m3dstbi__addsizes_valid(int a, int b)
794 {
795 ✗ if (b < 0) return 0;
796 ✗ return a <= 2147483647 - b;
797 }
798
799 static int _m3dstbi__mul2sizes_valid(int a, int b)
800 {
801 ✗ if (a < 0 || b < 0) return 0;
802 ✗ if (b == 0) return 1;
803 ✗ return a <= 2147483647/b;
804 }
805
806 static int _m3dstbi__mad2sizes_valid(int a, int b, int add)
807 {
808 ✗ return _m3dstbi__mul2sizes_valid(a, b) && _m3dstbi__addsizes_valid(a*b, add);
809 }
810
811 ✗ static int _m3dstbi__mad3sizes_valid(int a, int b, int c, int add)
812 {
813 ✗ return _m3dstbi__mul2sizes_valid(a, b) && _m3dstbi__mul2sizes_valid(a*b, c) &&
814 ✗ _m3dstbi__addsizes_valid(a*b*c, add);
815 }
816
817 ✗ static void *_m3dstbi__malloc_mad2(int a, int b, int add)
818 {
819 if (!_m3dstbi__mad2sizes_valid(a, b, add)) return NULL;
820 ✗ return _m3dstbi__malloc(a*b + add);
821 }
822
823 ✗ static void *_m3dstbi__malloc_mad3(int a, int b, int c, int add)
824 {
825 ✗ if (!_m3dstbi__mad3sizes_valid(a, b, c, add)) return NULL;
826 ✗ return _m3dstbi__malloc(a*b*c + add);
827 }
828
829 static unsigned char _m3dstbi__compute_y(int r, int g, int b)
830 {
831 ✗ return (unsigned char) (((r*77) + (g*150) + (29*b)) >> 8);
832 }
833
834 ✗ static unsigned char *_m3dstbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)
835 {
836 int i,j;
837 unsigned char *good;
838
839 ✗ if (req_comp == img_n) return data;
840 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
841
842 ✗ good = (unsigned char *) _m3dstbi__malloc_mad3(req_comp, x, y, 0);
843 ✗ if (good == NULL) {
844 ✗ STBI_FREE(data);
845 _m3dstbi__err("outofmem", "Out of memory");
846 ✗ return NULL;
847 }
848
849 ✗ for (j=0; j < (int) y; ++j) {
850 ✗ unsigned char *src = data + j * x * img_n ;
851 ✗ unsigned char *dest = good + j * x * req_comp;
852
853 #define STBI__COMBO(a,b) ((a)*8+(b))
854 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
855 ✗ switch (STBI__COMBO(img_n, req_comp)) {
856 ✗ STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255; } break;
857 ✗ STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
858 ✗ STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; } break;
859 ✗ STBI__CASE(2,1) { dest[0]=src[0]; } break;
860 ✗ STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
861 ✗ STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break;
862 ✗ STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; } break;
863 ✗ STBI__CASE(3,1) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]); } break;
864 ✗ STBI__CASE(3,2) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; } break;
865 ✗ STBI__CASE(4,1) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]); } break;
866 ✗ STBI__CASE(4,2) { dest[0]=_m3dstbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break;
867 ✗ STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break;
868 ✗ default: STBI_ASSERT(0);
869 }
870 #undef STBI__CASE
871 }
872
873 ✗ STBI_FREE(data);
874 ✗ return good;
875 }
876
877 static _m3dstbi__uint16 _m3dstbi__compute_y_16(int r, int g, int b)
878 {
879 ✗ return (_m3dstbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);
880 }
881
882 ✗ static _m3dstbi__uint16 *_m3dstbi__convert_format16(_m3dstbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)
883 {
884 int i,j;
885 _m3dstbi__uint16 *good;
886
887 ✗ if (req_comp == img_n) return data;
888 STBI_ASSERT(req_comp >= 1 && req_comp <= 4);
889
890 ✗ good = (_m3dstbi__uint16 *) _m3dstbi__malloc(req_comp * x * y * 2);
891 ✗ if (good == NULL) {
892 ✗ STBI_FREE(data);
893 _m3dstbi__err("outofmem", "Out of memory");
894 ✗ return NULL;
895 }
896
897 ✗ for (j=0; j < (int) y; ++j) {
898 ✗ _m3dstbi__uint16 *src = data + j * x * img_n ;
899 ✗ _m3dstbi__uint16 *dest = good + j * x * req_comp;
900
901 #define STBI__COMBO(a,b) ((a)*8+(b))
902 #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)
903 ✗ switch (STBI__COMBO(img_n, req_comp)) {
904 ✗ STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff; } break;
905 ✗ STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
906 ✗ STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff; } break;
907 ✗ STBI__CASE(2,1) { dest[0]=src[0]; } break;
908 ✗ STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;
909 ✗ STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break;
910 ✗ STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff; } break;
911 ✗ STBI__CASE(3,1) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]); } break;
912 ✗ STBI__CASE(3,2) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break;
913 ✗ STBI__CASE(4,1) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]); } break;
914 ✗ STBI__CASE(4,2) { dest[0]=_m3dstbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break;
915 ✗ STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break;
916 ✗ default: STBI_ASSERT(0);
917 }
918 #undef STBI__CASE
919 }
920
921 ✗ STBI_FREE(data);
922 ✗ return good;
923 }
924
925 #define STBI__ZFAST_BITS 9
926 #define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)
927
928 typedef struct
929 {
930 _m3dstbi__uint16 fast[1 << STBI__ZFAST_BITS];
931 _m3dstbi__uint16 firstcode[16];
932 int maxcode[17];
933 _m3dstbi__uint16 firstsymbol[16];
934 unsigned char size[288];
935 _m3dstbi__uint16 value[288];
936 } _m3dstbi__zhuffman;
937
938 ✗ _inline static int _m3dstbi__bitreverse16(int n)
939 {
940 ✗ n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);
941 ✗ n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);
942 ✗ n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);
943 ✗ n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);
944 ✗ return n;
945 }
946
947 _inline static int _m3dstbi__bit_reverse(int v, int bits)
948 {
949 STBI_ASSERT(bits <= 16);
950 ✗ return _m3dstbi__bitreverse16(v) >> (16-bits);
951 }
952
953 ✗ static int _m3dstbi__zbuild_huffman(_m3dstbi__zhuffman *z, unsigned char *sizelist, int num)
954 {
955 int i,k=0;
956 int code, next_code[16], sizes[17];
957
958 memset(sizes, 0, sizeof(sizes));
959 ✗ memset(z->fast, 0, sizeof(z->fast));
960 ✗ for (i=0; i < num; ++i)
961 ✗ ++sizes[sizelist[i]];
962 ✗ sizes[0] = 0;
963 ✗ for (i=1; i < 16; ++i)
964 ✗ if (sizes[i] > (1 << i))
965 ✗ return _m3dstbi__err("bad sizes", "Corrupt PNG");
966 code = 0;
967 ✗ for (i=1; i < 16; ++i) {
968 ✗ next_code[i] = code;
969 ✗ z->firstcode[i] = (_m3dstbi__uint16) code;
970 ✗ z->firstsymbol[i] = (_m3dstbi__uint16) k;
971 ✗ code = (code + sizes[i]);
972 ✗ if (sizes[i])
973 ✗ if (code-1 >= (1 << i)) return _m3dstbi__err("bad codelengths","Corrupt PNG");
974 ✗ z->maxcode[i] = code << (16-i);
975 ✗ code <<= 1;
976 ✗ k += sizes[i];
977 }
978 ✗ z->maxcode[16] = 0x10000;
979 ✗ for (i=0; i < num; ++i) {
980 ✗ int s = sizelist[i];
981 ✗ if (s) {
982 ✗ int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];
983 ✗ _m3dstbi__uint16 fastv = (_m3dstbi__uint16) ((s << 9) | i);
984 ✗ z->size [c] = (unsigned char ) s;
985 ✗ z->value[c] = (_m3dstbi__uint16) i;
986 ✗ if (s <= STBI__ZFAST_BITS) {
987 int j = _m3dstbi__bit_reverse(next_code[s],s);
988 ✗ while (j < (1 << STBI__ZFAST_BITS)) {
989 ✗ z->fast[j] = fastv;
990 ✗ j += (1 << s);
991 }
992 }
993 ✗ ++next_code[s];
994 }
995 }
996 return 1;
997 }
998
999 typedef struct
1000 {
1001 unsigned char *zbuffer, *zbuffer_end;
1002 int num_bits;
1003 _m3dstbi__uint32 code_buffer;
1004
1005 char *zout;
1006 char *zout_start;
1007 char *zout_end;
1008 int z_expandable;
1009
1010 _m3dstbi__zhuffman z_length, z_distance;
1011 } _m3dstbi__zbuf;
1012
1013 _inline static unsigned char _m3dstbi__zget8(_m3dstbi__zbuf *z)
1014 {
1015 ✗ if (z->zbuffer >= z->zbuffer_end) return 0;
1016 ✗ return *z->zbuffer++;
1017 }
1018
1019 static void _m3dstbi__fill_bits(_m3dstbi__zbuf *z)
1020 {
1021 do {
1022 STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
1023 ✗ z->code_buffer |= (unsigned int) _m3dstbi__zget8(z) << z->num_bits;
1024 ✗ z->num_bits += 8;
1025 ✗ } while (z->num_bits <= 24);
1026 }
1027
1028 ✗ _inline static unsigned int _m3dstbi__zreceive(_m3dstbi__zbuf *z, int n)
1029 {
1030 unsigned int k;
1031 ✗ if (z->num_bits < n) _m3dstbi__fill_bits(z);
1032 ✗ k = z->code_buffer & ((1 << n) - 1);
1033 ✗ z->code_buffer >>= n;
1034 ✗ z->num_bits -= n;
1035 ✗ return k;
1036 }
1037
1038 ✗ static int _m3dstbi__zhuffman_decode_slowpath(_m3dstbi__zbuf *a, _m3dstbi__zhuffman *z)
1039 {
1040 int b,s,k;
1041 ✗ k = _m3dstbi__bit_reverse(a->code_buffer, 16);
1042 ✗ for (s=STBI__ZFAST_BITS+1; ; ++s)
1043 ✗ if (k < z->maxcode[s])
1044 break;
1045 ✗ if (s == 16) return -1;
1046 ✗ b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
1047 STBI_ASSERT(z->size[b] == s);
1048 ✗ a->code_buffer >>= s;
1049 ✗ a->num_bits -= s;
1050 ✗ return z->value[b];
1051 }
1052
1053 ✗ _inline static int _m3dstbi__zhuffman_decode(_m3dstbi__zbuf *a, _m3dstbi__zhuffman *z)
1054 {
1055 int b,s;
1056 ✗ if (a->num_bits < 16) _m3dstbi__fill_bits(a);
1057 ✗ b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
1058 ✗ if (b) {
1059 ✗ s = b >> 9;
1060 ✗ a->code_buffer >>= s;
1061 ✗ a->num_bits -= s;
1062 ✗ return b & 511;
1063 }
1064 ✗ return _m3dstbi__zhuffman_decode_slowpath(a, z);
1065 }
1066
1067 ✗ static int _m3dstbi__zexpand(_m3dstbi__zbuf *z, char *zout, int n)
1068 {
1069 char *q;
1070 int cur, limit, old_limit;
1071 ✗ z->zout = zout;
1072 ✗ if (!z->z_expandable) return _m3dstbi__err("output buffer limit","Corrupt PNG");
1073 ✗ cur = (int) (z->zout - z->zout_start);
1074 ✗ limit = old_limit = (int) (z->zout_end - z->zout_start);
1075 ✗ while (cur + n > limit)
1076 ✗ limit *= 2;
1077 ✗ q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
1078 STBI_NOTUSED(old_limit);
1079 ✗ if (q == NULL) return _m3dstbi__err("outofmem", "Out of memory");
1080 ✗ z->zout_start = q;
1081 ✗ z->zout = q + cur;
1082 ✗ z->zout_end = q + limit;
1083 ✗ return 1;
1084 }
1085
1086 static int _m3dstbi__zlength_base[31] = {
1087 3,4,5,6,7,8,9,10,11,13,
1088 15,17,19,23,27,31,35,43,51,59,
1089 67,83,99,115,131,163,195,227,258,0,0 };
1090
1091 static int _m3dstbi__zlength_extra[31]=
1092 { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };
1093
1094 static int _m3dstbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
1095 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};
1096
1097 static int _m3dstbi__zdist_extra[32] =
1098 { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
1099
1100 ✗ static int _m3dstbi__parse_huffman_block(_m3dstbi__zbuf *a)
1101 {
1102 ✗ char *zout = a->zout;
1103 for(;;) {
1104 ✗ int z = _m3dstbi__zhuffman_decode(a, &a->z_length);
1105 ✗ if (z < 256) {
1106 ✗ if (z < 0) return _m3dstbi__err("bad huffman code","Corrupt PNG");
1107 ✗ if (zout >= a->zout_end) {
1108 ✗ if (!_m3dstbi__zexpand(a, zout, 1)) return 0;
1109 ✗ zout = a->zout;
1110 }
1111 ✗ *zout++ = (char) z;
1112 } else {
1113 unsigned char *p;
1114 int len,dist;
1115 ✗ if (z == 256) {
1116 ✗ a->zout = zout;
1117 ✗ return 1;
1118 }
1119 ✗ z -= 257;
1120 ✗ len = _m3dstbi__zlength_base[z];
1121 ✗ if (_m3dstbi__zlength_extra[z]) len += _m3dstbi__zreceive(a, _m3dstbi__zlength_extra[z]);
1122 ✗ z = _m3dstbi__zhuffman_decode(a, &a->z_distance);
1123 ✗ if (z < 0) return _m3dstbi__err("bad huffman code","Corrupt PNG");
1124 ✗ dist = _m3dstbi__zdist_base[z];
1125 ✗ if (_m3dstbi__zdist_extra[z]) dist += _m3dstbi__zreceive(a, _m3dstbi__zdist_extra[z]);
1126 ✗ if (zout - a->zout_start < dist) return _m3dstbi__err("bad dist","Corrupt PNG");
1127 ✗ if (zout + len > a->zout_end) {
1128 ✗ if (!_m3dstbi__zexpand(a, zout, len)) return 0;
1129 ✗ zout = a->zout;
1130 }
1131 ✗ p = (unsigned char *) (zout - dist);
1132 ✗ if (dist == 1) {
1133 ✗ unsigned char v = *p;
1134 ✗ if (len) { do *zout++ = v; while (--len); }
1135 } else {
1136 ✗ if (len) { do *zout++ = *p++; while (--len); }
1137 }
1138 }
1139 }
1140 }
1141
1142 ✗ static int _m3dstbi__compute_huffman_codes(_m3dstbi__zbuf *a)
1143 {
1144 static unsigned char length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };
1145 _m3dstbi__zhuffman z_codelength;
1146 unsigned char lencodes[286+32+137];
1147 unsigned char codelength_sizes[19];
1148 int i,n;
1149
1150 ✗ int hlit = _m3dstbi__zreceive(a,5) + 257;
1151 ✗ int hdist = _m3dstbi__zreceive(a,5) + 1;
1152 ✗ int hclen = _m3dstbi__zreceive(a,4) + 4;
1153 ✗ int ntot = hlit + hdist;
1154
1155 memset(codelength_sizes, 0, sizeof(codelength_sizes));
1156 ✗ for (i=0; i < hclen; ++i) {
1157 ✗ int s = _m3dstbi__zreceive(a,3);
1158 ✗ codelength_sizes[length_dezigzag[i]] = (unsigned char) s;
1159 }
1160 ✗ if (!_m3dstbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;
1161
1162 n = 0;
1163 ✗ while (n < ntot) {
1164 ✗ int c = _m3dstbi__zhuffman_decode(a, &z_codelength);
1165 ✗ if (c < 0 || c >= 19) return _m3dstbi__err("bad codelengths", "Corrupt PNG");
1166 ✗ if (c < 16)
1167 ✗ lencodes[n++] = (unsigned char) c;
1168 else {
1169 unsigned char fill = 0;
1170 ✗ if (c == 16) {
1171 ✗ c = _m3dstbi__zreceive(a,2)+3;
1172 ✗ if (n == 0) return _m3dstbi__err("bad codelengths", "Corrupt PNG");
1173 ✗ fill = lencodes[n-1];
1174 ✗ } else if (c == 17)
1175 ✗ c = _m3dstbi__zreceive(a,3)+3;
1176 else {
1177 STBI_ASSERT(c == 18);
1178 ✗ c = _m3dstbi__zreceive(a,7)+11;
1179 }
1180 ✗ if (ntot - n < c) return _m3dstbi__err("bad codelengths", "Corrupt PNG");
1181 ✗ memset(lencodes+n, fill, c);
1182 ✗ n += c;
1183 }
1184 }
1185 ✗ if (n != ntot) return _m3dstbi__err("bad codelengths","Corrupt PNG");
1186 ✗ if (!_m3dstbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;
1187 ✗ if (!_m3dstbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;
1188 return 1;
1189 }
1190
1191 ✗ _inline static int _m3dstbi__parse_uncompressed_block(_m3dstbi__zbuf *a)
1192 {
1193 unsigned char header[4];
1194 int len,nlen,k;
1195 ✗ if (a->num_bits & 7)
1196 ✗ _m3dstbi__zreceive(a, a->num_bits & 7);
1197 k = 0;
1198 ✗ while (a->num_bits > 0) {
1199 ✗ header[k++] = (unsigned char) (a->code_buffer & 255);
1200 ✗ a->code_buffer >>= 8;
1201 ✗ a->num_bits -= 8;
1202 }
1203 STBI_ASSERT(a->num_bits == 0);
1204 ✗ while (k < 4)
1205 ✗ header[k++] = _m3dstbi__zget8(a);
1206 ✗ len = header[1] * 256 + header[0];
1207 ✗ nlen = header[3] * 256 + header[2];
1208 ✗ if (nlen != (len ^ 0xffff)) return _m3dstbi__err("zlib corrupt","Corrupt PNG");
1209 ✗ if (a->zbuffer + len > a->zbuffer_end) return _m3dstbi__err("read past buffer","Corrupt PNG");
1210 ✗ if (a->zout + len > a->zout_end)
1211 ✗ if (!_m3dstbi__zexpand(a, a->zout, len)) return 0;
1212 ✗ memcpy(a->zout, a->zbuffer, len);
1213 ✗ a->zbuffer += len;
1214 ✗ a->zout += len;
1215 ✗ return 1;
1216 }
1217
1218 ✗ static int _m3dstbi__parse_zlib_header(_m3dstbi__zbuf *a)
1219 {
1220 ✗ int cmf = _m3dstbi__zget8(a);
1221 int cm = cmf & 15;
1222 /* int cinfo = cmf >> 4; */
1223 ✗ int flg = _m3dstbi__zget8(a);
1224 ✗ if ((cmf*256+flg) % 31 != 0) return _m3dstbi__err("bad zlib header","Corrupt PNG");
1225 ✗ if (flg & 32) return _m3dstbi__err("no preset dict","Corrupt PNG");
1226 ✗ if (cm != 8) return _m3dstbi__err("bad compression","Corrupt PNG");
1227 return 1;
1228 }
1229
1230 static unsigned char _m3dstbi__zdefault_length[288], _m3dstbi__zdefault_distance[32];
1231 ✗ static void _m3dstbi__init_zdefaults(void)
1232 {
1233 int i;
1234 ✗ for (i=0; i <= 143; ++i) _m3dstbi__zdefault_length[i] = 8;
1235 ✗ for ( ; i <= 255; ++i) _m3dstbi__zdefault_length[i] = 9;
1236 ✗ for ( ; i <= 279; ++i) _m3dstbi__zdefault_length[i] = 7;
1237 ✗ for ( ; i <= 287; ++i) _m3dstbi__zdefault_length[i] = 8;
1238
1239 ✗ for (i=0; i <= 31; ++i) _m3dstbi__zdefault_distance[i] = 5;
1240 }
1241
1242 ✗ static int _m3dstbi__parse_zlib(_m3dstbi__zbuf *a, int parse_header)
1243 {
1244 int final, type;
1245 ✗ if (parse_header)
1246 ✗ if (!_m3dstbi__parse_zlib_header(a)) return 0;
1247 ✗ a->num_bits = 0;
1248 ✗ a->code_buffer = 0;
1249 do {
1250 ✗ final = _m3dstbi__zreceive(a,1);
1251 ✗ type = _m3dstbi__zreceive(a,2);
1252 ✗ if (type == 0) {
1253 ✗ if (!_m3dstbi__parse_uncompressed_block(a)) return 0;
1254 ✗ } else if (type == 3) {
1255 return 0;
1256 } else {
1257 ✗ if (type == 1) {
1258 ✗ if (!_m3dstbi__zbuild_huffman(&a->z_length , _m3dstbi__zdefault_length , 288)) return 0;
1259 ✗ if (!_m3dstbi__zbuild_huffman(&a->z_distance, _m3dstbi__zdefault_distance, 32)) return 0;
1260 } else {
1261 ✗ if (!_m3dstbi__compute_huffman_codes(a)) return 0;
1262 }
1263 ✗ if (!_m3dstbi__parse_huffman_block(a)) return 0;
1264 }
1265 ✗ } while (!final);
1266 return 1;
1267 }
1268
1269 static int _m3dstbi__do_zlib(_m3dstbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
1270 {
1271 ✗ a->zout_start = obuf;
1272 ✗ a->zout = obuf;
1273 ✗ a->zout_end = obuf + olen;
1274 ✗ a->z_expandable = exp;
1275 ✗ _m3dstbi__init_zdefaults();
1276 ✗ return _m3dstbi__parse_zlib(a, parse_header);
1277 }
1278
1279 ✗ char *_m3dstbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
1280 {
1281 _m3dstbi__zbuf a;
1282 ✗ char *p = (char *) _m3dstbi__malloc(initial_size);
1283 ✗ if (p == NULL) return NULL;
1284 ✗ a.zbuffer = (unsigned char *) buffer;
1285 ✗ a.zbuffer_end = (unsigned char *) buffer + len;
1286 ✗ if (_m3dstbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
1287 ✗ if (outlen) *outlen = (int) (a.zout - a.zout_start);
1288 ✗ return a.zout_start;
1289 } else {
1290 ✗ STBI_FREE(a.zout_start);
1291 ✗ return NULL;
1292 }
1293 }
1294
1295 typedef struct
1296 {
1297 _m3dstbi__uint32 length;
1298 _m3dstbi__uint32 type;
1299 } _m3dstbi__pngchunk;
1300
1301 ✗ static _m3dstbi__pngchunk _m3dstbi__get_chunk_header(_m3dstbi__context *s)
1302 {
1303 _m3dstbi__pngchunk c;
1304 ✗ c.length = _m3dstbi__get32be(s);
1305 ✗ c.type = _m3dstbi__get32be(s);
1306 ✗ return c;
1307 }
1308
1309 _inline static int _m3dstbi__check_png_header(_m3dstbi__context *s)
1310 {
1311 static unsigned char png_sig[8] = { 137,80,78,71,13,10,26,10 };
1312 int i;
1313 ✗ for (i=0; i < 8; ++i)
1314 ✗ if (_m3dstbi__get8(s) != png_sig[i]) return _m3dstbi__err("bad png sig","Not a PNG");
1315 return 1;
1316 }
1317
1318 typedef struct
1319 {
1320 _m3dstbi__context *s;
1321 unsigned char *idata, *expanded, *out;
1322 int depth;
1323 } _m3dstbi__png;
1324
1325
1326 enum {
1327 STBI__F_none=0,
1328 STBI__F_sub=1,
1329 STBI__F_up=2,
1330 STBI__F_avg=3,
1331 STBI__F_paeth=4,
1332 STBI__F_avg_first,
1333 STBI__F_paeth_first
1334 };
1335
1336 static unsigned char first_row_filter[5] =
1337 {
1338 STBI__F_none,
1339 STBI__F_sub,
1340 STBI__F_none,
1341 STBI__F_avg_first,
1342 STBI__F_paeth_first
1343 };
1344
1345 static int _m3dstbi__paeth(int a, int b, int c)
1346 {
1347 ✗ int p = a + b - c;
1348 ✗ int pa = abs(p-a);
1349 ✗ int pb = abs(p-b);
1350 ✗ int pc = abs(p-c);
1351 ✗ if (pa <= pb && pa <= pc) return a;
1352 ✗ if (pb <= pc) return b;
1353 return c;
1354 }
1355
1356 static unsigned char _m3dstbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };
1357
1358 ✗ static int _m3dstbi__create_png_image_raw(_m3dstbi__png *a, unsigned char *raw, _m3dstbi__uint32 raw_len, int out_n, _m3dstbi__uint32 x, _m3dstbi__uint32 y, int depth, int color)
1359 {
1360 ✗ int bytes = (depth == 16? 2 : 1);
1361 ✗ _m3dstbi__context *s = a->s;
1362 ✗ _m3dstbi__uint32 i,j,stride = x*out_n*bytes;
1363 _m3dstbi__uint32 img_len, img_width_bytes;
1364 int k;
1365 ✗ int img_n = s->img_n;
1366
1367 ✗ int output_bytes = out_n*bytes;
1368 ✗ int filter_bytes = img_n*bytes;
1369 ✗ int width = x;
1370
1371 STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);
1372 ✗ a->out = (unsigned char *) _m3dstbi__malloc_mad3(x, y, output_bytes, 0);
1373 ✗ if (!a->out) return _m3dstbi__err("outofmem", "Out of memory");
1374
1375 ✗ if (!_m3dstbi__mad3sizes_valid(img_n, x, depth, 7)) return _m3dstbi__err("too large", "Corrupt PNG");
1376 ✗ img_width_bytes = (((img_n * x * depth) + 7) >> 3);
1377 ✗ img_len = (img_width_bytes + 1) * y;
1378 ✗ if (s->img_x == x && s->img_y == y) {
1379 ✗ if (raw_len != img_len) return _m3dstbi__err("not enough pixels","Corrupt PNG");
1380 } else {
1381 ✗ if (raw_len < img_len) return _m3dstbi__err("not enough pixels","Corrupt PNG");
1382 }
1383
1384 ✗ for (j=0; j < y; ++j) {
1385 ✗ unsigned char *cur = a->out + stride*j;
1386 ✗ unsigned char *prior = cur - stride;
1387 ✗ int filter = *raw++;
1388
1389 ✗ if (filter > 4)
1390 ✗ return _m3dstbi__err("invalid filter","Corrupt PNG");
1391
1392 ✗ if (depth < 8) {
1393 STBI_ASSERT(img_width_bytes <= x);
1394 ✗ cur += x*out_n - img_width_bytes;
1395 filter_bytes = 1;
1396 ✗ width = img_width_bytes;
1397 }
1398 ✗ prior = cur - stride;
1399
1400 ✗ if (j == 0) filter = first_row_filter[filter];
1401
1402 ✗ for (k=0; k < filter_bytes; ++k) {
1403 ✗ switch (filter) {
1404 ✗ case STBI__F_none : cur[k] = raw[k]; break;
1405 ✗ case STBI__F_sub : cur[k] = raw[k]; break;
1406 ✗ case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break;
1407 ✗ case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break;
1408 ✗ case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(0,prior[k],0)); break;
1409 ✗ case STBI__F_avg_first : cur[k] = raw[k]; break;
1410 ✗ case STBI__F_paeth_first: cur[k] = raw[k]; break;
1411 }
1412 }
1413
1414 ✗ if (depth == 8) {
1415 ✗ if (img_n != out_n)
1416 ✗ cur[img_n] = 255;
1417 ✗ raw += img_n;
1418 ✗ cur += out_n;
1419 ✗ prior += out_n;
1420 ✗ } else if (depth == 16) {
1421 ✗ if (img_n != out_n) {
1422 ✗ cur[filter_bytes] = 255;
1423 ✗ cur[filter_bytes+1] = 255;
1424 }
1425 ✗ raw += filter_bytes;
1426 ✗ cur += output_bytes;
1427 ✗ prior += output_bytes;
1428 } else {
1429 ✗ raw += 1;
1430 ✗ cur += 1;
1431 ✗ prior += 1;
1432 }
1433
1434 ✗ if (depth < 8 || img_n == out_n) {
1435 ✗ int nk = (width - 1)*filter_bytes;
1436 #define STBI__CASE(f) \
1437 case f: \
1438 for (k=0; k < nk; ++k)
1439 ✗ switch (filter) {
1440 ✗ case STBI__F_none: memcpy(cur, raw, nk); break;
1441 ✗ STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break;
1442 ✗ STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
1443 ✗ STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break;
1444 ✗ STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break;
1445 ✗ STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break;
1446 ✗ STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k-filter_bytes],0,0)); } break;
1447 }
1448 #undef STBI__CASE
1449 ✗ raw += nk;
1450 } else {
1451 STBI_ASSERT(img_n+1 == out_n);
1452 #define STBI__CASE(f) \
1453 case f: \
1454 for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \
1455 for (k=0; k < filter_bytes; ++k)
1456 ✗ switch (filter) {
1457 ✗ STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break;
1458 ✗ STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break;
1459 ✗ STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break;
1460 ✗ STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break;
1461 ✗ STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break;
1462 ✗ STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break;
1463 ✗ STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + _m3dstbi__paeth(cur[k- output_bytes],0,0)); } break;
1464 }
1465 #undef STBI__CASE
1466
1467 ✗ if (depth == 16) {
1468 ✗ cur = a->out + stride*j;
1469 ✗ for (i=0; i < x; ++i,cur+=output_bytes) {
1470 ✗ cur[filter_bytes+1] = 255;
1471 }
1472 }
1473 }
1474 }
1475
1476 ✗ if (depth < 8) {
1477 ✗ for (j=0; j < y; ++j) {
1478 ✗ unsigned char *cur = a->out + stride*j;
1479 ✗ unsigned char *in = a->out + stride*j + x*out_n - img_width_bytes;
1480 ✗ unsigned char scale = (color == 0) ? _m3dstbi__depth_scale_table[depth] : 1;
1481
1482 ✗ if (depth == 4) {
1483 ✗ for (k=x*img_n; k >= 2; k-=2, ++in) {
1484 ✗ *cur++ = scale * ((*in >> 4) );
1485 ✗ *cur++ = scale * ((*in ) & 0x0f);
1486 }
1487 ✗ if (k > 0) *cur++ = scale * ((*in >> 4) );
1488 ✗ } else if (depth == 2) {
1489 ✗ for (k=x*img_n; k >= 4; k-=4, ++in) {
1490 ✗ *cur++ = scale * ((*in >> 6) );
1491 ✗ *cur++ = scale * ((*in >> 4) & 0x03);
1492 ✗ *cur++ = scale * ((*in >> 2) & 0x03);
1493 ✗ *cur++ = scale * ((*in ) & 0x03);
1494 }
1495 ✗ if (k > 0) *cur++ = scale * ((*in >> 6) );
1496 ✗ if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03);
1497 ✗ if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03);
1498 ✗ } else if (depth == 1) {
1499 ✗ for (k=x*img_n; k >= 8; k-=8, ++in) {
1500 ✗ *cur++ = scale * ((*in >> 7) );
1501 ✗ *cur++ = scale * ((*in >> 6) & 0x01);
1502 ✗ *cur++ = scale * ((*in >> 5) & 0x01);
1503 ✗ *cur++ = scale * ((*in >> 4) & 0x01);
1504 ✗ *cur++ = scale * ((*in >> 3) & 0x01);
1505 ✗ *cur++ = scale * ((*in >> 2) & 0x01);
1506 ✗ *cur++ = scale * ((*in >> 1) & 0x01);
1507 ✗ *cur++ = scale * ((*in ) & 0x01);
1508 }
1509 ✗ if (k > 0) *cur++ = scale * ((*in >> 7) );
1510 ✗ if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01);
1511 ✗ if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01);
1512 ✗ if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01);
1513 ✗ if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01);
1514 ✗ if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01);
1515 ✗ if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01);
1516 }
1517 ✗ if (img_n != out_n) {
1518 int q;
1519 ✗ cur = a->out + stride*j;
1520 ✗ if (img_n == 1) {
1521 ✗ for (q=x-1; q >= 0; --q) {
1522 ✗ cur[q*2+1] = 255;
1523 ✗ cur[q*2+0] = cur[q];
1524 }
1525 } else {
1526 STBI_ASSERT(img_n == 3);
1527 ✗ for (q=x-1; q >= 0; --q) {
1528 ✗ cur[q*4+3] = 255;
1529 ✗ cur[q*4+2] = cur[q*3+2];
1530 ✗ cur[q*4+1] = cur[q*3+1];
1531 ✗ cur[q*4+0] = cur[q*3+0];
1532 }
1533 }
1534 }
1535 }
1536 ✗ } else if (depth == 16) {
1537 ✗ unsigned char *cur = a->out;
1538 _m3dstbi__uint16 *cur16 = (_m3dstbi__uint16*)cur;
1539
1540 ✗ for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) {
1541 ✗ *cur16 = (cur[0] << 8) | cur[1];
1542 }
1543 }
1544
1545 return 1;
1546 }
1547
1548 ✗ static int _m3dstbi__create_png_image(_m3dstbi__png *a, unsigned char *image_data, _m3dstbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)
1549 {
1550 ✗ int bytes = (depth == 16 ? 2 : 1);
1551 ✗ int out_bytes = out_n * bytes;
1552 unsigned char *final;
1553 int p;
1554 ✗ if (!interlaced)
1555 ✗ return _m3dstbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);
1556
1557 ✗ final = (unsigned char *) _m3dstbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);
1558 ✗ for (p=0; p < 7; ++p) {
1559 ✗ int xorig[] = { 0,4,0,2,0,1,0 };
1560 ✗ int yorig[] = { 0,0,4,0,2,0,1 };
1561 ✗ int xspc[] = { 8,8,4,4,2,2,1 };
1562 ✗ int yspc[] = { 8,8,8,4,4,2,2 };
1563 int i,j,x,y;
1564 ✗ x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];
1565 ✗ y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];
1566 ✗ if (x && y) {
1567 ✗ _m3dstbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;
1568 ✗ if (!_m3dstbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {
1569 ✗ STBI_FREE(final);
1570 ✗ return 0;
1571 }
1572 ✗ for (j=0; j < y; ++j) {
1573 ✗ for (i=0; i < x; ++i) {
1574 ✗ int out_y = j*yspc[p]+yorig[p];
1575 ✗ int out_x = i*xspc[p]+xorig[p];
1576 ✗ memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,
1577 ✗ a->out + (j*x+i)*out_bytes, out_bytes);
1578 }
1579 }
1580 ✗ STBI_FREE(a->out);
1581 ✗ image_data += img_len;
1582 ✗ image_data_len -= img_len;
1583 }
1584 }
1585 ✗ a->out = final;
1586
1587 ✗ return 1;
1588 }
1589
1590 ✗ static int _m3dstbi__compute_transparency(_m3dstbi__png *z, unsigned char tc[3], int out_n)
1591 {
1592 ✗ _m3dstbi__context *s = z->s;
1593 ✗ _m3dstbi__uint32 i, pixel_count = s->img_x * s->img_y;
1594 ✗ unsigned char *p = z->out;
1595
1596 STBI_ASSERT(out_n == 2 || out_n == 4);
1597
1598 ✗ if (out_n == 2) {
1599 ✗ for (i=0; i < pixel_count; ++i) {
1600 ✗ p[1] = (p[0] == tc[0] ? 0 : 255);
1601 ✗ p += 2;
1602 }
1603 } else {
1604 ✗ for (i=0; i < pixel_count; ++i) {
1605 ✗ if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
1606 ✗ p[3] = 0;
1607 ✗ p += 4;
1608 }
1609 }
1610 ✗ return 1;
1611 }
1612
1613 ✗ static int _m3dstbi__compute_transparency16(_m3dstbi__png *z, _m3dstbi__uint16 tc[3], int out_n)
1614 {
1615 ✗ _m3dstbi__context *s = z->s;
1616 ✗ _m3dstbi__uint32 i, pixel_count = s->img_x * s->img_y;
1617 ✗ _m3dstbi__uint16 *p = (_m3dstbi__uint16*) z->out;
1618
1619 STBI_ASSERT(out_n == 2 || out_n == 4);
1620
1621 ✗ if (out_n == 2) {
1622 ✗ for (i = 0; i < pixel_count; ++i) {
1623 ✗ p[1] = (p[0] == tc[0] ? 0 : 65535);
1624 ✗ p += 2;
1625 }
1626 } else {
1627 ✗ for (i = 0; i < pixel_count; ++i) {
1628 ✗ if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
1629 ✗ p[3] = 0;
1630 ✗ p += 4;
1631 }
1632 }
1633 ✗ return 1;
1634 }
1635
1636 ✗ static int _m3dstbi__expand_png_palette(_m3dstbi__png *a, unsigned char *palette, int len, int pal_img_n)
1637 {
1638 ✗ _m3dstbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;
1639 ✗ unsigned char *p, *temp_out, *orig = a->out;
1640
1641 ✗ p = (unsigned char *) _m3dstbi__malloc_mad2(pixel_count, pal_img_n, 0);
1642 ✗ if (p == NULL) return _m3dstbi__err("outofmem", "Out of memory");
1643
1644 temp_out = p;
1645
1646 ✗ if (pal_img_n == 3) {
1647 ✗ for (i=0; i < pixel_count; ++i) {
1648 ✗ int n = orig[i]*4;
1649 ✗ p[0] = palette[n ];
1650 ✗ p[1] = palette[n+1];
1651 ✗ p[2] = palette[n+2];
1652 ✗ p += 3;
1653 }
1654 } else {
1655 ✗ for (i=0; i < pixel_count; ++i) {
1656 ✗ int n = orig[i]*4;
1657 ✗ p[0] = palette[n ];
1658 ✗ p[1] = palette[n+1];
1659 ✗ p[2] = palette[n+2];
1660 ✗ p[3] = palette[n+3];
1661 ✗ p += 4;
1662 }
1663 }
1664 ✗ STBI_FREE(a->out);
1665 ✗ a->out = temp_out;
1666
1667 STBI_NOTUSED(len);
1668
1669 ✗ return 1;
1670 }
1671
1672 #define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))
1673
1674 ✗ static int _m3dstbi__parse_png_file(_m3dstbi__png *z, int scan, int req_comp)
1675 {
1676 unsigned char palette[1024], pal_img_n=0;
1677 unsigned char has_trans=0, tc[3];
1678 _m3dstbi__uint16 tc16[3];
1679 _m3dstbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;
1680 int first=1,k,interlace=0, color=0;
1681 ✗ _m3dstbi__context *s = z->s;
1682
1683 ✗ z->expanded = NULL;
1684 ✗ z->idata = NULL;
1685 ✗ z->out = NULL;
1686
1687 ✗ if (!_m3dstbi__check_png_header(s)) return 0;
1688
1689 ✗ if (scan == STBI__SCAN_type) return 1;
1690
1691 ✗ for (;;) {
1692 ✗ _m3dstbi__pngchunk c = _m3dstbi__get_chunk_header(s);
1693 ✗ switch (c.type) {
1694 ✗ case STBI__PNG_TYPE('C','g','B','I'):
1695 ✗ _m3dstbi__skip(s, c.length);
1696 break;
1697 ✗ case STBI__PNG_TYPE('I','H','D','R'): {
1698 int comp,filter;
1699 ✗ if (!first) return _m3dstbi__err("multiple IHDR","Corrupt PNG");
1700 first = 0;
1701 ✗ if (c.length != 13) return _m3dstbi__err("bad IHDR len","Corrupt PNG");
1702 ✗ s->img_x = _m3dstbi__get32be(s); if (s->img_x > (1 << 24)) return _m3dstbi__err("too large","Very large image (corrupt?)");
1703 ✗ s->img_y = _m3dstbi__get32be(s); if (s->img_y > (1 << 24)) return _m3dstbi__err("too large","Very large image (corrupt?)");
1704 ✗ z->depth = _m3dstbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return _m3dstbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only");
1705 ✗ color = _m3dstbi__get8(s); if (color > 6) return _m3dstbi__err("bad ctype","Corrupt PNG");
1706 ✗ if (color == 3 && z->depth == 16) return _m3dstbi__err("bad ctype","Corrupt PNG");
1707 ✗ if (color == 3) pal_img_n = 3; else if (color & 1) return _m3dstbi__err("bad ctype","Corrupt PNG");
1708 ✗ comp = _m3dstbi__get8(s); if (comp) return _m3dstbi__err("bad comp method","Corrupt PNG");
1709 ✗ filter= _m3dstbi__get8(s); if (filter) return _m3dstbi__err("bad filter method","Corrupt PNG");
1710 ✗ interlace = _m3dstbi__get8(s); if (interlace>1) return _m3dstbi__err("bad interlace method","Corrupt PNG");
1711 ✗ if (!s->img_x || !s->img_y) return _m3dstbi__err("0-pixel image","Corrupt PNG");
1712 ✗ if (!pal_img_n) {
1713 ✗ s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);
1714 ✗ if ((1 << 30) / s->img_x / s->img_n < s->img_y) return _m3dstbi__err("too large", "Image too large to decode");
1715 ✗ if (scan == STBI__SCAN_header) return 1;
1716 } else {
1717 ✗ s->img_n = 1;
1718 ✗ if ((1 << 30) / s->img_x / 4 < s->img_y) return _m3dstbi__err("too large","Corrupt PNG");
1719 }
1720 break;
1721 }
1722
1723 ✗ case STBI__PNG_TYPE('P','L','T','E'): {
1724 ✗ if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
1725 ✗ if (c.length > 256*3) return _m3dstbi__err("invalid PLTE","Corrupt PNG");
1726 ✗ pal_len = c.length / 3;
1727 ✗ if (pal_len * 3 != c.length) return _m3dstbi__err("invalid PLTE","Corrupt PNG");
1728 ✗ for (i=0; i < pal_len; ++i) {
1729 ✗ palette[i*4+0] = _m3dstbi__get8(s);
1730 ✗ palette[i*4+1] = _m3dstbi__get8(s);
1731 ✗ palette[i*4+2] = _m3dstbi__get8(s);
1732 ✗ palette[i*4+3] = 255;
1733 }
1734 break;
1735 }
1736
1737 ✗ case STBI__PNG_TYPE('t','R','N','S'): {
1738 ✗ if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
1739 ✗ if (z->idata) return _m3dstbi__err("tRNS after IDAT","Corrupt PNG");
1740 ✗ if (pal_img_n) {
1741 ✗ if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }
1742 ✗ if (pal_len == 0) return _m3dstbi__err("tRNS before PLTE","Corrupt PNG");
1743 ✗ if (c.length > pal_len) return _m3dstbi__err("bad tRNS len","Corrupt PNG");
1744 pal_img_n = 4;
1745 ✗ for (i=0; i < c.length; ++i)
1746 ✗ palette[i*4+3] = _m3dstbi__get8(s);
1747 } else {
1748 ✗ if (!(s->img_n & 1)) return _m3dstbi__err("tRNS with alpha","Corrupt PNG");
1749 ✗ if (c.length != (_m3dstbi__uint32) s->img_n*2) return _m3dstbi__err("bad tRNS len","Corrupt PNG");
1750 has_trans = 1;
1751 ✗ if (z->depth == 16) {
1752 ✗ for (k = 0; k < s->img_n; ++k) tc16[k] = (_m3dstbi__uint16)_m3dstbi__get16be(s);
1753 } else {
1754 ✗ for (k = 0; k < s->img_n; ++k) tc[k] = (unsigned char)(_m3dstbi__get16be(s) & 255) * _m3dstbi__depth_scale_table[z->depth];
1755 }
1756 }
1757 break;
1758 }
1759
1760 ✗ case STBI__PNG_TYPE('I','D','A','T'): {
1761 ✗ if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
1762 ✗ if (pal_img_n && !pal_len) return _m3dstbi__err("no PLTE","Corrupt PNG");
1763 ✗ if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; }
1764 ✗ if ((int)(ioff + c.length) < (int)ioff) return 0;
1765 ✗ if (ioff + c.length > idata_limit) {
1766 _m3dstbi__uint32 idata_limit_old = idata_limit;
1767 unsigned char *p;
1768 ✗ if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;
1769 ✗ while (ioff + c.length > idata_limit)
1770 ✗ idata_limit *= 2;
1771 STBI_NOTUSED(idata_limit_old);
1772 ✗ p = (unsigned char *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return _m3dstbi__err("outofmem", "Out of memory");
1773 ✗ z->idata = p;
1774 }
1775 ✗ if (!_m3dstbi__getn(s, z->idata+ioff,c.length)) return _m3dstbi__err("outofdata","Corrupt PNG");
1776 ioff += c.length;
1777 ✗ break;
1778 }
1779
1780 ✗ case STBI__PNG_TYPE('I','E','N','D'): {
1781 _m3dstbi__uint32 raw_len, bpl;
1782 ✗ if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
1783 ✗ if (scan != STBI__SCAN_load) return 1;
1784 ✗ if (z->idata == NULL) return _m3dstbi__err("no IDAT","Corrupt PNG");
1785 ✗ bpl = (s->img_x * z->depth + 7) / 8;
1786 ✗ raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;
1787 ✗ z->expanded = (unsigned char *) _m3dstbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, 1);
1788 ✗ if (z->expanded == NULL) return 0;
1789 ✗ STBI_FREE(z->idata); z->idata = NULL;
1790 ✗ if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)
1791 ✗ s->img_out_n = s->img_n+1;
1792 else
1793 ✗ s->img_out_n = s->img_n;
1794 ✗ if (!_m3dstbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;
1795 ✗ if (has_trans) {
1796 ✗ if (z->depth == 16) {
1797 ✗ if (!_m3dstbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;
1798 } else {
1799 ✗ if (!_m3dstbi__compute_transparency(z, tc, s->img_out_n)) return 0;
1800 }
1801 }
1802 ✗ if (pal_img_n) {
1803 ✗ s->img_n = pal_img_n;
1804 ✗ s->img_out_n = pal_img_n;
1805 ✗ if (req_comp >= 3) s->img_out_n = req_comp;
1806 ✗ if (!_m3dstbi__expand_png_palette(z, palette, pal_len, s->img_out_n))
1807 return 0;
1808 ✗ } else if (has_trans) {
1809 ✗ ++s->img_n;
1810 }
1811 ✗ STBI_FREE(z->expanded); z->expanded = NULL;
1812 ✗ return 1;
1813 }
1814
1815 ✗ default:
1816 ✗ if (first) return _m3dstbi__err("first not IHDR", "Corrupt PNG");
1817 ✗ if ((c.type & (1 << 29)) == 0) {
1818 ✗ return _m3dstbi__err("invalid_chunk", "PNG not supported: unknown PNG chunk type");
1819 }
1820 ✗ _m3dstbi__skip(s, c.length);
1821 break;
1822 }
1823 ✗ _m3dstbi__get32be(s);
1824 }
1825 }
1826
1827 ✗ static void *_m3dstbi__do_png(_m3dstbi__png *p, int *x, int *y, int *n, int req_comp, _m3dstbi__result_info *ri)
1828 {
1829 void *result=NULL;
1830 ✗ if (req_comp < 0 || req_comp > 4) { _m3dstbi__err("bad req_comp", "Internal error"); return NULL; }
1831 ✗ if (_m3dstbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {
1832 ✗ if (p->depth < 8)
1833 ✗ ri->bits_per_channel = 8;
1834 else
1835 ✗ ri->bits_per_channel = p->depth;
1836 ✗ result = p->out;
1837 ✗ p->out = NULL;
1838 ✗ if (req_comp && req_comp != p->s->img_out_n) {
1839 ✗ if (ri->bits_per_channel == 8)
1840 ✗ result = _m3dstbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
1841 else
1842 ✗ result = _m3dstbi__convert_format16((_m3dstbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);
1843 ✗ p->s->img_out_n = req_comp;
1844 ✗ if (result == NULL) return result;
1845 }
1846 ✗ *x = p->s->img_x;
1847 ✗ *y = p->s->img_y;
1848 ✗ if (n) *n = p->s->img_n;
1849 }
1850 ✗ STBI_FREE(p->out); p->out = NULL;
1851 ✗ STBI_FREE(p->expanded); p->expanded = NULL;
1852 ✗ STBI_FREE(p->idata); p->idata = NULL;
1853
1854 ✗ return result;
1855 }
1856
1857 static void *_m3dstbi__png_load(_m3dstbi__context *s, int *x, int *y, int *comp, int req_comp, _m3dstbi__result_info *ri)
1858 {
1859 _m3dstbi__png p;
1860 ✗ p.s = s;
1861 ✗ return _m3dstbi__do_png(&p, x,y,comp,req_comp, ri);
1862 }
1863 #define stbi__context _m3dstbi__context
1864 #define stbi__result_info _m3dstbi__result_info
1865 #define stbi__png_load _m3dstbi__png_load
1866 #define stbi_zlib_decode_malloc_guesssize_headerflag _m3dstbi_zlib_decode_malloc_guesssize_headerflag
1867 #endif
1868 #if !defined(M3D_NOIMPORTER) && defined(STBI_INCLUDE_STB_IMAGE_H) && !defined(STB_IMAGE_IMPLEMENTATION)
1869 #error "stb_image.h included without STB_IMAGE_IMPLEMENTATION. Sorry, we need some stuff defined inside the ifguard for proper integration"
1870 #endif
1871
1872 #if defined(M3D_EXPORTER) && !defined(INCLUDE_STB_IMAGE_WRITE_H)
1873 /* zlib_compressor from
1874
1875 stb_image_write - v1.13 - public domain - http://nothings.org/stb/stb_image_write.h
1876 */
1877 typedef unsigned char _m3dstbiw__uc;
1878 typedef unsigned short _m3dstbiw__us;
1879
1880 typedef uint16_t _m3dstbiw__uint16;
1881 typedef int16_t _m3dstbiw__int16;
1882 typedef uint32_t _m3dstbiw__uint32;
1883 typedef int32_t _m3dstbiw__int32;
1884
1885 #define STBIW_MALLOC(s) M3D_MALLOC(s)
1886 #define STBIW_REALLOC(p,ns) M3D_REALLOC(p,ns)
1887 #define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz)
1888 #define STBIW_FREE M3D_FREE
1889 #define STBIW_MEMMOVE memmove
1890 #define STBIW_UCHAR (uint8_t)
1891 #define STBIW_ASSERT(x)
1892 #define _m3dstbiw___sbraw(a) ((int *) (a) - 2)
1893 #define _m3dstbiw___sbm(a) _m3dstbiw___sbraw(a)[0]
1894 #define _m3dstbiw___sbn(a) _m3dstbiw___sbraw(a)[1]
1895
1896 #define _m3dstbiw___sbneedgrow(a,n) ((a)==0 || _m3dstbiw___sbn(a)+n >= _m3dstbiw___sbm(a))
1897 #define _m3dstbiw___sbmaybegrow(a,n) (_m3dstbiw___sbneedgrow(a,(n)) ? _m3dstbiw___sbgrow(a,n) : 0)
1898 #define _m3dstbiw___sbgrow(a,n) _m3dstbiw___sbgrowf((void **) &(a), (n), sizeof(*(a)))
1899
1900 #define _m3dstbiw___sbpush(a, v) (_m3dstbiw___sbmaybegrow(a,1), (a)[_m3dstbiw___sbn(a)++] = (v))
1901 #define _m3dstbiw___sbcount(a) ((a) ? _m3dstbiw___sbn(a) : 0)
1902 #define _m3dstbiw___sbfree(a) ((a) ? STBIW_FREE(_m3dstbiw___sbraw(a)),0 : 0)
1903
1904 static void *_m3dstbiw___sbgrowf(void **arr, int increment, int itemsize)
1905 {
1906 int m = *arr ? 2*_m3dstbiw___sbm(*arr)+increment : increment+1;
1907 void *p = STBIW_REALLOC_SIZED(*arr ? _m3dstbiw___sbraw(*arr) : 0, *arr ? (_m3dstbiw___sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
1908 STBIW_ASSERT(p);
1909 if (p) {
1910 if (!*arr) ((int *) p)[1] = 0;
1911 *arr = (void *) ((int *) p + 2);
1912 _m3dstbiw___sbm(*arr) = m;
1913 }
1914 return *arr;
1915 }
1916
1917 static unsigned char *_m3dstbiw___zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
1918 {
1919 while (*bitcount >= 8) {
1920 _m3dstbiw___sbpush(data, STBIW_UCHAR(*bitbuffer));
1921 *bitbuffer >>= 8;
1922 *bitcount -= 8;
1923 }
1924 return data;
1925 }
1926
1927 static int _m3dstbiw___zlib_bitrev(int code, int codebits)
1928 {
1929 int res=0;
1930 while (codebits--) {
1931 res = (res << 1) | (code & 1);
1932 code >>= 1;
1933 }
1934 return res;
1935 }
1936
1937 static unsigned int _m3dstbiw___zlib_countm(unsigned char *a, unsigned char *b, int limit)
1938 {
1939 int i;
1940 for (i=0; i < limit && i < 258; ++i)
1941 if (a[i] != b[i]) break;
1942 return i;
1943 }
1944
1945 static unsigned int _m3dstbiw___zhash(unsigned char *data)
1946 {
1947 _m3dstbiw__uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
1948 hash ^= hash << 3;
1949 hash += hash >> 5;
1950 hash ^= hash << 4;
1951 hash += hash >> 17;
1952 hash ^= hash << 25;
1953 hash += hash >> 6;
1954 return hash;
1955 }
1956
1957 #define _m3dstbiw___zlib_flush() (out = _m3dstbiw___zlib_flushf(out, &bitbuf, &bitcount))
1958 #define _m3dstbiw___zlib_add(code,codebits) \
1959 (bitbuf |= (code) << bitcount, bitcount += (codebits), _m3dstbiw___zlib_flush())
1960 #define _m3dstbiw___zlib_huffa(b,c) _m3dstbiw___zlib_add(_m3dstbiw___zlib_bitrev(b,c),c)
1961 #define _m3dstbiw___zlib_huff1(n) _m3dstbiw___zlib_huffa(0x30 + (n), 8)
1962 #define _m3dstbiw___zlib_huff2(n) _m3dstbiw___zlib_huffa(0x190 + (n)-144, 9)
1963 #define _m3dstbiw___zlib_huff3(n) _m3dstbiw___zlib_huffa(0 + (n)-256,7)
1964 #define _m3dstbiw___zlib_huff4(n) _m3dstbiw___zlib_huffa(0xc0 + (n)-280,8)
1965 #define _m3dstbiw___zlib_huff(n) ((n) <= 143 ? _m3dstbiw___zlib_huff1(n) : (n) <= 255 ? _m3dstbiw___zlib_huff2(n) : (n) <= 279 ? _m3dstbiw___zlib_huff3(n) : _m3dstbiw___zlib_huff4(n))
1966 #define _m3dstbiw___zlib_huffb(n) ((n) <= 143 ? _m3dstbiw___zlib_huff1(n) : _m3dstbiw___zlib_huff2(n))
1967
1968 #define _m3dstbiw___ZHASH 16384
1969
1970 unsigned char * _m3dstbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
1971 {
1972 static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 };
1973 static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 };
1974 static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 };
1975 static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 };
1976 unsigned int bitbuf=0;
1977 int i,j, bitcount=0;
1978 unsigned char *out = NULL;
1979 unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(_m3dstbiw___ZHASH * sizeof(char**));
1980 if (hash_table == NULL)
1981 return NULL;
1982 if (quality < 5) quality = 5;
1983
1984 _m3dstbiw___sbpush(out, 0x78);
1985 _m3dstbiw___sbpush(out, 0x5e);
1986 _m3dstbiw___zlib_add(1,1);
1987 _m3dstbiw___zlib_add(1,2);
1988
1989 for (i=0; i < _m3dstbiw___ZHASH; ++i)
1990 hash_table[i] = NULL;
1991
1992 i=0;
1993 while (i < data_len-3) {
1994 int h = _m3dstbiw___zhash(data+i)&(_m3dstbiw___ZHASH-1), best=3;
1995 unsigned char *bestloc = 0;
1996 unsigned char **hlist = hash_table[h];
1997 int n = _m3dstbiw___sbcount(hlist);
1998 for (j=0; j < n; ++j) {
1999 if (hlist[j]-data > i-32768) {
2000 int d = _m3dstbiw___zlib_countm(hlist[j], data+i, data_len-i);
2001 if (d >= best) best=d,bestloc=hlist[j];
2002 }
2003 }
2004 if (hash_table[h] && _m3dstbiw___sbn(hash_table[h]) == 2*quality) {
2005 STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality);
2006 _m3dstbiw___sbn(hash_table[h]) = quality;
2007 }
2008 _m3dstbiw___sbpush(hash_table[h],data+i);
2009
2010 if (bestloc) {
2011 h = _m3dstbiw___zhash(data+i+1)&(_m3dstbiw___ZHASH-1);
2012 hlist = hash_table[h];
2013 n = _m3dstbiw___sbcount(hlist);
2014 for (j=0; j < n; ++j) {
2015 if (hlist[j]-data > i-32767) {
2016 int e = _m3dstbiw___zlib_countm(hlist[j], data+i+1, data_len-i-1);
2017 if (e > best) {
2018 bestloc = NULL;
2019 break;
2020 }
2021 }
2022 }
2023 }
2024
2025 if (bestloc) {
2026 int d = (int) (data+i - bestloc);
2027 STBIW_ASSERT(d <= 32767 && best <= 258);
2028 for (j=0; best > lengthc[j+1]-1; ++j);
2029 _m3dstbiw___zlib_huff(j+257);
2030 if (lengtheb[j]) _m3dstbiw___zlib_add(best - lengthc[j], lengtheb[j]);
2031 for (j=0; d > distc[j+1]-1; ++j);
2032 _m3dstbiw___zlib_add(_m3dstbiw___zlib_bitrev(j,5),5);
2033 if (disteb[j]) _m3dstbiw___zlib_add(d - distc[j], disteb[j]);
2034 i += best;
2035 } else {
2036 _m3dstbiw___zlib_huffb(data[i]);
2037 ++i;
2038 }
2039 }
2040 for (;i < data_len; ++i)
2041 _m3dstbiw___zlib_huffb(data[i]);
2042 _m3dstbiw___zlib_huff(256);
2043 while (bitcount)
2044 _m3dstbiw___zlib_add(0,1);
2045
2046 for (i=0; i < _m3dstbiw___ZHASH; ++i)
2047 (void) _m3dstbiw___sbfree(hash_table[i]);
2048 STBIW_FREE(hash_table);
2049
2050 {
2051 unsigned int s1=1, s2=0;
2052 int blocklen = (int) (data_len % 5552);
2053 j=0;
2054 while (j < data_len) {
2055 for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
2056 s1 %= 65521, s2 %= 65521;
2057 j += blocklen;
2058 blocklen = 5552;
2059 }
2060 _m3dstbiw___sbpush(out, STBIW_UCHAR(s2 >> 8));
2061 _m3dstbiw___sbpush(out, STBIW_UCHAR(s2));
2062 _m3dstbiw___sbpush(out, STBIW_UCHAR(s1 >> 8));
2063 _m3dstbiw___sbpush(out, STBIW_UCHAR(s1));
2064 }
2065 *out_len = _m3dstbiw___sbn(out);
2066 STBIW_MEMMOVE(_m3dstbiw___sbraw(out), out, *out_len);
2067 return (unsigned char *) _m3dstbiw___sbraw(out);
2068 }
2069 #define stbi_zlib_compress _m3dstbi_zlib_compress
2070 #else
2071 unsigned char * _m3dstbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality);
2072 #endif
2073
2074 #define M3D_CHUNKMAGIC(m, a,b,c,d) ((m)[0]==(a) && (m)[1]==(b) && (m)[2]==(c) && (m)[3]==(d))
2075
2076 #ifdef M3D_ASCII
2077 #include <stdio.h> /* get sprintf */
2078 #include <locale.h> /* sprintf and strtod cares about number locale */
2079 #endif
2080 #ifdef M3D_PROFILING
2081 #include <sys/time.h>
2082 #endif
2083
2084 #if !defined(M3D_NOIMPORTER) && defined(M3D_ASCII)
2085 /* helper functions for the ASCII parser */
2086 static char *_m3d_findarg(char *s) {
2087 while(s && *s && *s != ' ' && *s != '\t' && *s != '\r' && *s != '\n') s++;
2088 while(s && *s && (*s == ' ' || *s == '\t')) s++;
2089 return s;
2090 }
2091 static char *_m3d_findnl(char *s) {
2092 while(s && *s && *s != '\r' && *s != '\n') s++;
2093 if(*s == '\r') s++;
2094 if(*s == '\n') s++;
2095 return s;
2096 }
2097 static char *_m3d_gethex(char *s, uint32_t *ret)
2098 {
2099 if(*s == '#') s++;
2100 *ret = 0;
2101 for(; *s; s++) {
2102 if(*s >= '0' && *s <= '9') { *ret <<= 4; *ret += (uint32_t)(*s-'0'); }
2103 else if(*s >= 'a' && *s <= 'f') { *ret <<= 4; *ret += (uint32_t)(*s-'a'+10); }
2104 else if(*s >= 'A' && *s <= 'F') { *ret <<= 4; *ret += (uint32_t)(*s-'A'+10); }
2105 else break;
2106 }
2107 return _m3d_findarg(s);
2108 }
2109 static char *_m3d_getint(char *s, uint32_t *ret)
2110 {
2111 char *e = s;
2112 if(!s || !*s || *s == '\r' || *s == '\n') return s;
2113 for(; *e >= '0' && *e <= '9'; e++);
2114 *ret = atoi(s);
2115 return e;
2116 }
2117 static char *_m3d_getfloat(char *s, M3D_FLOAT *ret)
2118 {
2119 char *e = s;
2120 if(!s || !*s || *s == '\r' || *s == '\n') return s;
2121 for(; *e == '-' || *e == '+' || *e == '.' || (*e >= '0' && *e <= '9') || *e == 'e' || *e == 'E'; e++);
2122 *ret = (M3D_FLOAT)strtod(s, NULL);
2123 return _m3d_findarg(e);
2124 }
2125 #endif
2126 #if !defined(M3D_NODUP) && (!defined(M3D_NOIMPORTER) || defined(M3D_ASCII) || defined(M3D_EXPORTER))
2127 /* helper function to create safe strings */
2128 ✗ char *_m3d_safestr(char *in, int morelines)
2129 {
2130 char *out, *o, *i = in;
2131 int l;
2132 ✗ if(!in || !*in) {
2133 ✗ out = (char*)M3D_MALLOC(1);
2134 ✗ if(!out) return NULL;
2135 ✗ out[0] =0;
2136 } else {
2137 ✗ for(o = in, l = 0; *o && ((morelines & 1) || (*o != '\r' && *o != '\n')) && l < 256; o++, l++);
2138 ✗ out = o = (char*)M3D_MALLOC(l+1);
2139 ✗ if(!out) return NULL;
2140 ✗ while(*i == ' ' || *i == '\t' || *i == '\r' || (morelines && *i == '\n')) i++;
2141 ✗ for(; *i && (morelines || (*i != '\r' && *i != '\n')); i++) {
2142 ✗ if(*i == '\r') continue;
2143 ✗ if(*i == '\n') {
2144 ✗ if(morelines >= 3 && o > out && *(o-1) == '\n') break;
2145 ✗ if(i > in && *(i-1) == '\n') continue;
2146 ✗ if(morelines & 1) {
2147 ✗ if(morelines == 1) *o++ = '\r';
2148 ✗ *o++ = '\n';
2149 } else
2150 break;
2151 } else
2152 ✗ if(*i == ' ' || *i == '\t') {
2153 ✗ *o++ = morelines? ' ' : '_';
2154 } else
2155 ✗ *o++ = !morelines && (*i == '/' || *i == '\\') ? '_' : *i;
2156 }
2157 ✗ for(; o > out && (*(o-1) == ' ' || *(o-1) == '\t' || *(o-1) == '\r' || *(o-1) == '\n'); o--);
2158 ✗ *o = 0;
2159 ✗ out = (char*)M3D_REALLOC(out, (uintptr_t)o - (uintptr_t)out + 1);
2160 }
2161 return out;
2162 }
2163 #endif
2164 #ifndef M3D_NOIMPORTER
2165 /* helper function to load and decode/generate a texture */
2166 ✗ M3D_INDEX _m3d_gettx(m3d_t *model, m3dread_t readfilecb, m3dfree_t freecb, char *fn)
2167 {
2168 ✗ unsigned int i, len = 0;
2169 unsigned char *buff = NULL;
2170 char *fn2;
2171 unsigned int w, h;
2172 stbi__context s;
2173 stbi__result_info ri;
2174
2175 /* do we have loaded this texture already? */
2176 ✗ for(i = 0; i < model->numtexture; i++)
2177 ✗ if(!strcmp(fn, model->texture[i].name)) return i;
2178 /* see if it's inlined in the model */
2179 ✗ if(model->inlined) {
2180 ✗ for(i = 0; i < model->numinlined; i++)
2181 ✗ if(!strcmp(fn, model->inlined[i].name)) {
2182 ✗ buff = model->inlined[i].data;
2183 ✗ len = model->inlined[i].length;
2184 freecb = NULL;
2185 ✗ break;
2186 }
2187 }
2188 /* try to load from external source */
2189 ✗ if(!buff && readfilecb) {
2190 ✗ i = (unsigned int)strlen(fn);
2191 ✗ if(i < 5 || fn[i - 4] != '.') {
2192 ✗ fn2 = (char*)M3D_MALLOC(i + 5);
2193 ✗ if(!fn2) { model->errcode = M3D_ERR_ALLOC; return M3D_UNDEF; }
2194 memcpy(fn2, fn, i);
2195 ✗ memcpy(fn2+i, ".png", 5);
2196 ✗ buff = (*readfilecb)(fn2, &len);
2197 ✗ M3D_FREE(fn2);
2198 }
2199 ✗ if(!buff) {
2200 ✗ buff = (*readfilecb)(fn, &len);
2201 ✗ if(!buff) return M3D_UNDEF;
2202 }
2203 }
2204 /* add to textures array */
2205 ✗ i = model->numtexture++;
2206 ✗ model->texture = (m3dtx_t*)M3D_REALLOC(model->texture, model->numtexture * sizeof(m3dtx_t));
2207 ✗ if(!model->texture) {
2208 ✗ if(buff && freecb) (*freecb)(buff);
2209 ✗ model->errcode = M3D_ERR_ALLOC;
2210 ✗ return M3D_UNDEF;
2211 }
2212 ✗ model->texture[i].name = fn;
2213 ✗ model->texture[i].w = model->texture[i].h = 0; model->texture[i].d = NULL;
2214 ✗ if(buff) {
2215 ✗ if(buff[0] == 0x89 && buff[1] == 'P' && buff[2] == 'N' && buff[3] == 'G') {
2216 ✗ s.read_from_callbacks = 0;
2217 ✗ s.img_buffer = s.img_buffer_original = (unsigned char *) buff;
2218 ✗ s.img_buffer_end = s.img_buffer_original_end = (unsigned char *) buff+len;
2219 /* don't use model->texture[i].w directly, it's a uint16_t */
2220 ✗ w = h = len = 0;
2221 ✗ ri.bits_per_channel = 8;
2222 ✗ model->texture[i].d = (uint8_t*)stbi__png_load(&s, (int*)&w, (int*)&h, (int*)&len, 0, &ri);
2223 ✗ model->texture[i].w = w;
2224 ✗ model->texture[i].h = h;
2225 ✗ model->texture[i].f = (uint8_t)len;
2226 } else {
2227 #ifdef M3D_TX_INTERP
2228 if((model->errcode = M3D_TX_INTERP(fn, buff, len, &model->texture[i])) != M3D_SUCCESS) {
2229 M3D_LOG("Unable to generate texture");
2230 M3D_LOG(fn);
2231 }
2232 #else
2233 M3D_LOG("Unimplemented interpreter");
2234 M3D_LOG(fn);
2235 #endif
2236 }
2237 ✗ if(freecb) (*freecb)(buff);
2238 }
2239 ✗ if(!model->texture[i].d)
2240 ✗ model->errcode = M3D_ERR_UNKIMG;
2241 return i;
2242 }
2243
2244 /* helper function to load and generate a procedural surface */
2245 ✗ void _m3d_getpr(m3d_t *model, _unused m3dread_t readfilecb, _unused m3dfree_t freecb, _unused char *fn)
2246 {
2247 #ifdef M3D_PR_INTERP
2248 unsigned int i, len = 0;
2249 unsigned char *buff = readfilecb ? (*readfilecb)(fn, &len) : NULL;
2250
2251 if(!buff && model->inlined) {
2252 for(i = 0; i < model->numinlined; i++)
2253 if(!strcmp(fn, model->inlined[i].name)) {
2254 buff = model->inlined[i].data;
2255 len = model->inlined[i].length;
2256 freecb = NULL;
2257 break;
2258 }
2259 }
2260 if(!buff || !len || (model->errcode = M3D_PR_INTERP(fn, buff, len, model)) != M3D_SUCCESS) {
2261 M3D_LOG("Unable to generate procedural surface");
2262 M3D_LOG(fn);
2263 model->errcode = M3D_ERR_UNKIMG;
2264 }
2265 if(freecb && buff) (*freecb)(buff);
2266 #else
2267 (void)readfilecb;
2268 (void)freecb;
2269 (void)fn;
2270 M3D_LOG("Unimplemented interpreter");
2271 M3D_LOG(fn);
2272 ✗ model->errcode = M3D_ERR_UNIMPL;
2273 #endif
2274 }
2275 /* helpers to read indices from data stream */
2276 #define M3D_GETSTR(x) do{offs=0;data=_m3d_getidx(data,model->si_s,&offs);x=offs?((char*)model->raw+16+offs):NULL;}while(0)
2277 _inline static unsigned char *_m3d_getidx(unsigned char *data, char type, M3D_INDEX *idx)
2278 {
2279 ✗ switch(type) {
2280 ✗ case 1: *idx = data[0] > 253 ? (int8_t)data[0] : data[0]; data++; break;
2281 ✗ case 2: *idx = *((uint16_t*)data) > 65533 ? *((int16_t*)data) : *((uint16_t*)data); data += 2; break;
2282 ✗ case 4: *idx = *((int32_t*)data); data += 4; break;
2283 }
2284 return data;
2285 }
2286
2287 #ifndef M3D_NOANIMATION
2288 /* multiply 4 x 4 matrices. Do not use float *r[16] as argument, because some compilers misinterpret that as
2289 * 16 pointers each pointing to a float, but we need a single pointer to 16 floats. */
2290 ✗ void _m3d_mul(M3D_FLOAT *r, M3D_FLOAT *a, M3D_FLOAT *b)
2291 {
2292 ✗ r[ 0] = b[ 0] * a[ 0] + b[ 4] * a[ 1] + b[ 8] * a[ 2] + b[12] * a[ 3];
2293 ✗ r[ 1] = b[ 1] * a[ 0] + b[ 5] * a[ 1] + b[ 9] * a[ 2] + b[13] * a[ 3];
2294 ✗ r[ 2] = b[ 2] * a[ 0] + b[ 6] * a[ 1] + b[10] * a[ 2] + b[14] * a[ 3];
2295 ✗ r[ 3] = b[ 3] * a[ 0] + b[ 7] * a[ 1] + b[11] * a[ 2] + b[15] * a[ 3];
2296 ✗ r[ 4] = b[ 0] * a[ 4] + b[ 4] * a[ 5] + b[ 8] * a[ 6] + b[12] * a[ 7];
2297 ✗ r[ 5] = b[ 1] * a[ 4] + b[ 5] * a[ 5] + b[ 9] * a[ 6] + b[13] * a[ 7];
2298 ✗ r[ 6] = b[ 2] * a[ 4] + b[ 6] * a[ 5] + b[10] * a[ 6] + b[14] * a[ 7];
2299 ✗ r[ 7] = b[ 3] * a[ 4] + b[ 7] * a[ 5] + b[11] * a[ 6] + b[15] * a[ 7];
2300 ✗ r[ 8] = b[ 0] * a[ 8] + b[ 4] * a[ 9] + b[ 8] * a[10] + b[12] * a[11];
2301 ✗ r[ 9] = b[ 1] * a[ 8] + b[ 5] * a[ 9] + b[ 9] * a[10] + b[13] * a[11];
2302 ✗ r[10] = b[ 2] * a[ 8] + b[ 6] * a[ 9] + b[10] * a[10] + b[14] * a[11];
2303 ✗ r[11] = b[ 3] * a[ 8] + b[ 7] * a[ 9] + b[11] * a[10] + b[15] * a[11];
2304 ✗ r[12] = b[ 0] * a[12] + b[ 4] * a[13] + b[ 8] * a[14] + b[12] * a[15];
2305 ✗ r[13] = b[ 1] * a[12] + b[ 5] * a[13] + b[ 9] * a[14] + b[13] * a[15];
2306 ✗ r[14] = b[ 2] * a[12] + b[ 6] * a[13] + b[10] * a[14] + b[14] * a[15];
2307 ✗ r[15] = b[ 3] * a[12] + b[ 7] * a[13] + b[11] * a[14] + b[15] * a[15];
2308 }
2309 /* calculate 4 x 4 matrix inverse */
2310 ✗ void _m3d_inv(M3D_FLOAT *m)
2311 {
2312 M3D_FLOAT r[16];
2313 ✗ M3D_FLOAT det =
2314 ✗ m[ 0]*m[ 5]*m[10]*m[15] - m[ 0]*m[ 5]*m[11]*m[14] + m[ 0]*m[ 6]*m[11]*m[13] - m[ 0]*m[ 6]*m[ 9]*m[15]
2315 ✗ + m[ 0]*m[ 7]*m[ 9]*m[14] - m[ 0]*m[ 7]*m[10]*m[13] - m[ 1]*m[ 6]*m[11]*m[12] + m[ 1]*m[ 6]*m[ 8]*m[15]
2316 ✗ - m[ 1]*m[ 7]*m[ 8]*m[14] + m[ 1]*m[ 7]*m[10]*m[12] - m[ 1]*m[ 4]*m[10]*m[15] + m[ 1]*m[ 4]*m[11]*m[14]
2317 ✗ + m[ 2]*m[ 7]*m[ 8]*m[13] - m[ 2]*m[ 7]*m[ 9]*m[12] + m[ 2]*m[ 4]*m[ 9]*m[15] - m[ 2]*m[ 4]*m[11]*m[13]
2318 ✗ + m[ 2]*m[ 5]*m[11]*m[12] - m[ 2]*m[ 5]*m[ 8]*m[15] - m[ 3]*m[ 4]*m[ 9]*m[14] + m[ 3]*m[ 4]*m[10]*m[13]
2319 ✗ - m[ 3]*m[ 5]*m[10]*m[12] + m[ 3]*m[ 5]*m[ 8]*m[14] - m[ 3]*m[ 6]*m[ 8]*m[13] + m[ 3]*m[ 6]*m[ 9]*m[12];
2320 ✗ if(det == (M3D_FLOAT)0.0 || det == (M3D_FLOAT)-0.0) det = (M3D_FLOAT)1.0; else det = (M3D_FLOAT)1.0 / det;
2321 ✗ r[ 0] = det *(m[ 5]*(m[10]*m[15] - m[11]*m[14]) + m[ 6]*(m[11]*m[13] - m[ 9]*m[15]) + m[ 7]*(m[ 9]*m[14] - m[10]*m[13]));
2322 ✗ r[ 1] = -det*(m[ 1]*(m[10]*m[15] - m[11]*m[14]) + m[ 2]*(m[11]*m[13] - m[ 9]*m[15]) + m[ 3]*(m[ 9]*m[14] - m[10]*m[13]));
2323 ✗ r[ 2] = det *(m[ 1]*(m[ 6]*m[15] - m[ 7]*m[14]) + m[ 2]*(m[ 7]*m[13] - m[ 5]*m[15]) + m[ 3]*(m[ 5]*m[14] - m[ 6]*m[13]));
2324 ✗ r[ 3] = -det*(m[ 1]*(m[ 6]*m[11] - m[ 7]*m[10]) + m[ 2]*(m[ 7]*m[ 9] - m[ 5]*m[11]) + m[ 3]*(m[ 5]*m[10] - m[ 6]*m[ 9]));
2325 ✗ r[ 4] = -det*(m[ 4]*(m[10]*m[15] - m[11]*m[14]) + m[ 6]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 7]*(m[ 8]*m[14] - m[10]*m[12]));
2326 ✗ r[ 5] = det *(m[ 0]*(m[10]*m[15] - m[11]*m[14]) + m[ 2]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 3]*(m[ 8]*m[14] - m[10]*m[12]));
2327 ✗ r[ 6] = -det*(m[ 0]*(m[ 6]*m[15] - m[ 7]*m[14]) + m[ 2]*(m[ 7]*m[12] - m[ 4]*m[15]) + m[ 3]*(m[ 4]*m[14] - m[ 6]*m[12]));
2328 ✗ r[ 7] = det *(m[ 0]*(m[ 6]*m[11] - m[ 7]*m[10]) + m[ 2]*(m[ 7]*m[ 8] - m[ 4]*m[11]) + m[ 3]*(m[ 4]*m[10] - m[ 6]*m[ 8]));
2329 ✗ r[ 8] = det *(m[ 4]*(m[ 9]*m[15] - m[11]*m[13]) + m[ 5]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 7]*(m[ 8]*m[13] - m[ 9]*m[12]));
2330 ✗ r[ 9] = -det*(m[ 0]*(m[ 9]*m[15] - m[11]*m[13]) + m[ 1]*(m[11]*m[12] - m[ 8]*m[15]) + m[ 3]*(m[ 8]*m[13] - m[ 9]*m[12]));
2331 ✗ r[10] = det *(m[ 0]*(m[ 5]*m[15] - m[ 7]*m[13]) + m[ 1]*(m[ 7]*m[12] - m[ 4]*m[15]) + m[ 3]*(m[ 4]*m[13] - m[ 5]*m[12]));
2332 ✗ r[11] = -det*(m[ 0]*(m[ 5]*m[11] - m[ 7]*m[ 9]) + m[ 1]*(m[ 7]*m[ 8] - m[ 4]*m[11]) + m[ 3]*(m[ 4]*m[ 9] - m[ 5]*m[ 8]));
2333 ✗ r[12] = -det*(m[ 4]*(m[ 9]*m[14] - m[10]*m[13]) + m[ 5]*(m[10]*m[12] - m[ 8]*m[14]) + m[ 6]*(m[ 8]*m[13] - m[ 9]*m[12]));
2334 ✗ r[13] = det *(m[ 0]*(m[ 9]*m[14] - m[10]*m[13]) + m[ 1]*(m[10]*m[12] - m[ 8]*m[14]) + m[ 2]*(m[ 8]*m[13] - m[ 9]*m[12]));
2335 ✗ r[14] = -det*(m[ 0]*(m[ 5]*m[14] - m[ 6]*m[13]) + m[ 1]*(m[ 6]*m[12] - m[ 4]*m[14]) + m[ 2]*(m[ 4]*m[13] - m[ 5]*m[12]));
2336 ✗ r[15] = det *(m[ 0]*(m[ 5]*m[10] - m[ 6]*m[ 9]) + m[ 1]*(m[ 6]*m[ 8] - m[ 4]*m[10]) + m[ 2]*(m[ 4]*m[ 9] - m[ 5]*m[ 8]));
2337 memcpy(m, &r, sizeof(r));
2338 }
2339 /* compose a coloumn major 4 x 4 matrix from vec3 position and vec4 orientation/rotation quaternion */
2340 ✗ void _m3d_mat(M3D_FLOAT *r, m3dv_t *p, m3dv_t *q)
2341 {
2342 ✗ if(q->x == (M3D_FLOAT)0.0 && q->y == (M3D_FLOAT)0.0 && q->z >=(M3D_FLOAT) 0.7071065 && q->z <= (M3D_FLOAT)0.7071075 &&
2343 ✗ q->w == (M3D_FLOAT)0.0) {
2344 ✗ r[ 1] = r[ 2] = r[ 4] = r[ 6] = r[ 8] = r[ 9] = (M3D_FLOAT)0.0;
2345 ✗ r[ 0] = r[ 5] = r[10] = (M3D_FLOAT)-1.0;
2346 } else {
2347 ✗ r[ 0] = 1 - 2 * (q->y * q->y + q->z * q->z); if(r[ 0]>-M3D_EPSILON && r[ 0]<M3D_EPSILON) r[ 0]=(M3D_FLOAT)0.0;
2348 ✗ r[ 1] = 2 * (q->x * q->y - q->z * q->w); if(r[ 1]>-M3D_EPSILON && r[ 1]<M3D_EPSILON) r[ 1]=(M3D_FLOAT)0.0;
2349 ✗ r[ 2] = 2 * (q->x * q->z + q->y * q->w); if(r[ 2]>-M3D_EPSILON && r[ 2]<M3D_EPSILON) r[ 2]=(M3D_FLOAT)0.0;
2350 ✗ r[ 4] = 2 * (q->x * q->y + q->z * q->w); if(r[ 4]>-M3D_EPSILON && r[ 4]<M3D_EPSILON) r[ 4]=(M3D_FLOAT)0.0;
2351 ✗ r[ 5] = 1 - 2 * (q->x * q->x + q->z * q->z); if(r[ 5]>-M3D_EPSILON && r[ 5]<M3D_EPSILON) r[ 5]=(M3D_FLOAT)0.0;
2352 ✗ r[ 6] = 2 * (q->y * q->z - q->x * q->w); if(r[ 6]>-M3D_EPSILON && r[ 6]<M3D_EPSILON) r[ 6]=(M3D_FLOAT)0.0;
2353 ✗ r[ 8] = 2 * (q->x * q->z - q->y * q->w); if(r[ 8]>-M3D_EPSILON && r[ 8]<M3D_EPSILON) r[ 8]=(M3D_FLOAT)0.0;
2354 ✗ r[ 9] = 2 * (q->y * q->z + q->x * q->w); if(r[ 9]>-M3D_EPSILON && r[ 9]<M3D_EPSILON) r[ 9]=(M3D_FLOAT)0.0;
2355 ✗ r[10] = 1 - 2 * (q->x * q->x + q->y * q->y); if(r[10]>-M3D_EPSILON && r[10]<M3D_EPSILON) r[10]=(M3D_FLOAT)0.0;
2356 }
2357 ✗ r[ 3] = p->x; r[ 7] = p->y; r[11] = p->z;
2358 ✗ r[12] = 0; r[13] = 0; r[14] = 0; r[15] = 1;
2359 }
2360 #endif
2361 #if !defined(M3D_NOANIMATION) || !defined(M3D_NONORMALS)
2362 /* portable fast inverse square root calculation. returns 1/sqrt(x) */
2363 static M3D_FLOAT _m3d_rsq(M3D_FLOAT x)
2364 {
2365 #ifdef M3D_DOUBLE
2366 return ((M3D_FLOAT)15.0/(M3D_FLOAT)8.0) + ((M3D_FLOAT)-5.0/(M3D_FLOAT)4.0)*x + ((M3D_FLOAT)3.0/(M3D_FLOAT)8.0)*x*x;
2367 #else
2368 /* John Carmack's */
2369 ✗ float x2 = x * 0.5f;
2370 uint32_t *i = (uint32_t*)&x;
2371 ✗ *i = (0x5f3759df - (*i >> 1));
2372 ✗ return x * (1.5f - (x2 * x * x));
2373 #endif
2374 }
2375 #endif
2376
2377 /**
2378 * Function to decode a Model 3D into in-memory format
2379 */
2380 ✗ m3d_t *m3d_load(unsigned char *data, m3dread_t readfilecb, m3dfree_t freecb, m3d_t *mtllib)
2381 {
2382 unsigned char *end, *chunk, *buff, weights[8];
2383 ✗ unsigned int i, j, k, l, n, am, len = 0, reclen, offs;
2384 #ifndef M3D_NOVOXELS
2385 int32_t min_x, min_y, min_z, max_x, max_y, max_z, sx, sy, sz, x, y, z;
2386 M3D_INDEX edge[8], enorm;
2387 #endif
2388 char *name, *lang;
2389 float f;
2390 m3d_t *model;
2391 M3D_INDEX mi;
2392 #ifdef M3D_VERTEXMAX
2393 M3D_INDEX pi;
2394 #endif
2395 M3D_FLOAT w;
2396 m3dcd_t *cd;
2397 m3dtx_t *tx;
2398 m3dh_t *h;
2399 m3dm_t *m;
2400 m3da_t *a;
2401 m3di_t *t;
2402 #ifndef M3D_NONORMALS
2403 char neednorm = 0;
2404 m3dv_t *norm = NULL, *v0, *v1, *v2, va, vb;
2405 #endif
2406 #ifndef M3D_NOANIMATION
2407 M3D_FLOAT r[16];
2408 #endif
2409 #if !defined(M3D_NOWEIGHTS) || !defined(M3D_NOANIMATION)
2410 m3db_t *b;
2411 #endif
2412 #ifndef M3D_NOWEIGHTS
2413 m3ds_t *sk;
2414 #endif
2415 #ifdef M3D_ASCII
2416 m3ds_t s;
2417 M3D_INDEX bi[M3D_BONEMAXLEVEL+1], level;
2418 const char *ol;
2419 char *ptr, *pe, *fn;
2420 #endif
2421 #ifdef M3D_PROFILING
2422 struct timeval tv0, tv1, tvd;
2423 gettimeofday(&tv0, NULL);
2424 #endif
2425
2426 ✗ if(!data || (!M3D_CHUNKMAGIC(data, '3','D','M','O')
2427 #ifdef M3D_ASCII
2428 && !M3D_CHUNKMAGIC(data, '3','d','m','o')
2429 #endif
2430 )) return NULL;
2431 ✗ model = (m3d_t*)M3D_MALLOC(sizeof(m3d_t));
2432 ✗ if(!model) {
2433 M3D_LOG("Out of memory");
2434 return NULL;
2435 }
2436 memset(model, 0, sizeof(m3d_t));
2437
2438 ✗ if(mtllib) {
2439 ✗ model->nummaterial = mtllib->nummaterial;
2440 ✗ model->material = mtllib->material;
2441 ✗ model->numtexture = mtllib->numtexture;
2442 ✗ model->texture = mtllib->texture;
2443 ✗ model->flags |= M3D_FLG_MTLLIB;
2444 }
2445 #ifdef M3D_ASCII
2446 /* ASCII variant? */
2447 if(M3D_CHUNKMAGIC(data, '3','d','m','o')) {
2448 model->errcode = M3D_ERR_BADFILE;
2449 model->flags |= M3D_FLG_FREESTR;
2450 model->raw = (m3dhdr_t*)data;
2451 ptr = (char*)data;
2452 ol = setlocale(LC_NUMERIC, NULL);
2453 setlocale(LC_NUMERIC, "C");
2454 /* parse header. Don't use sscanf, that's incredibly slow */
2455 ptr = _m3d_findarg(ptr);
2456 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2457 pe = _m3d_findnl(ptr);
2458 model->scale = (float)strtod(ptr, NULL); ptr = pe;
2459 if(model->scale <= (M3D_FLOAT)0.0) model->scale = (M3D_FLOAT)1.0;
2460 model->name = _m3d_safestr(ptr, 2); ptr = _m3d_findnl(ptr);
2461 if(!*ptr) goto asciiend;
2462 model->license = _m3d_safestr(ptr, 2); ptr = _m3d_findnl(ptr);
2463 if(!*ptr) goto asciiend;
2464 model->author = _m3d_safestr(ptr, 2); ptr = _m3d_findnl(ptr);
2465 if(!*ptr) goto asciiend;
2466 if(*ptr != '\r' && *ptr != '\n')
2467 model->desc = _m3d_safestr(ptr, 3);
2468 while(*ptr) {
2469 while(*ptr && *ptr!='\n') ptr++;
2470 ptr++; if(*ptr=='\r') ptr++;
2471 if(*ptr == '\n') break;
2472 }
2473
2474 /* the main chunk reader loop */
2475 while(*ptr) {
2476 while(*ptr && (*ptr == '\r' || *ptr == '\n')) ptr++;
2477 if(!*ptr || (ptr[0]=='E' && ptr[1]=='n' && ptr[2]=='d')) break;
2478 /* make sure there's at least one data row */
2479 pe = ptr; ptr = _m3d_findnl(ptr);
2480 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2481 /* Preview chunk */
2482 if(!memcmp(pe, "Preview", 7)) {
2483 if(readfilecb) {
2484 pe = _m3d_safestr(ptr, 0);
2485 if(!pe || !*pe) goto asciiend;
2486 model->preview.data = (*readfilecb)(pe, &model->preview.length);
2487 M3D_FREE(pe);
2488 }
2489 while(*ptr && *ptr != '\r' && *ptr != '\n')
2490 ptr = _m3d_findnl(ptr);
2491 } else
2492 /* texture map chunk */
2493 if(!memcmp(pe, "Textmap", 7)) {
2494 if(model->tmap) { M3D_LOG("More texture map chunks, should be unique"); goto asciiend; }
2495 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2496 i = model->numtmap++;
2497 model->tmap = (m3dti_t*)M3D_REALLOC(model->tmap, model->numtmap * sizeof(m3dti_t));
2498 if(!model->tmap) goto memerr;
2499 ptr = _m3d_getfloat(ptr, &model->tmap[i].u);
2500 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2501 _m3d_getfloat(ptr, &model->tmap[i].v);
2502 ptr = _m3d_findnl(ptr);
2503 }
2504 } else
2505 /* vertex chunk */
2506 if(!memcmp(pe, "Vertex", 6)) {
2507 if(model->vertex) { M3D_LOG("More vertex chunks, should be unique"); goto asciiend; }
2508 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2509 i = model->numvertex++;
2510 model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
2511 if(!model->vertex) goto memerr;
2512 memset(&model->vertex[i], 0, sizeof(m3dv_t));
2513 model->vertex[i].skinid = M3D_UNDEF;
2514 model->vertex[i].color = 0;
2515 model->vertex[i].w = (M3D_FLOAT)1.0;
2516 ptr = _m3d_getfloat(ptr, &model->vertex[i].x);
2517 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2518 ptr = _m3d_getfloat(ptr, &model->vertex[i].y);
2519 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2520 ptr = _m3d_getfloat(ptr, &model->vertex[i].z);
2521 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2522 ptr = _m3d_getfloat(ptr, &model->vertex[i].w);
2523 if(!*ptr) goto asciiend;
2524 if(*ptr == '#') {
2525 ptr = _m3d_gethex(ptr, &model->vertex[i].color);
2526 if(!*ptr) goto asciiend;
2527 }
2528 /* parse skin */
2529 memset(&s, 0, sizeof(m3ds_t));
2530 for(j = 0, w = (M3D_FLOAT)0.0; j < M3D_NUMBONE && *ptr && *ptr != '\r' && *ptr != '\n'; j++) {
2531 ptr = _m3d_findarg(ptr);
2532 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2533 ptr = _m3d_getint(ptr, &k);
2534 s.boneid[j] = (M3D_INDEX)k;
2535 if(*ptr == ':') {
2536 ptr++;
2537 ptr = _m3d_getfloat(ptr, &s.weight[j]);
2538 w += s.weight[j];
2539 } else if(!j)
2540 s.weight[j] = (M3D_FLOAT)1.0;
2541 if(!*ptr) goto asciiend;
2542 }
2543 if(s.boneid[0] != M3D_UNDEF && s.weight[0] > (M3D_FLOAT)0.0) {
2544 if(w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0)
2545 for(j = 0; j < M3D_NUMBONE && s.weight[j] > (M3D_FLOAT)0.0; j++)
2546 s.weight[j] /= w;
2547 k = M3D_NOTDEFINED;
2548 if(model->skin) {
2549 for(j = 0; j < model->numskin; j++)
2550 if(!memcmp(&model->skin[j], &s, sizeof(m3ds_t))) { k = j; break; }
2551 }
2552 if(k == M3D_NOTDEFINED) {
2553 k = model->numskin++;
2554 model->skin = (m3ds_t*)M3D_REALLOC(model->skin, model->numskin * sizeof(m3ds_t));
2555 if(!model->skin) goto memerr;
2556 memcpy(&model->skin[k], &s, sizeof(m3ds_t));
2557 }
2558 model->vertex[i].skinid = (M3D_INDEX)k;
2559 }
2560 ptr = _m3d_findnl(ptr);
2561 }
2562 } else
2563 /* Skeleton, bone hierarchy */
2564 if(!memcmp(pe, "Bones", 5)) {
2565 if(model->bone) { M3D_LOG("More bones chunks, should be unique"); goto asciiend; }
2566 bi[0] = M3D_UNDEF;
2567 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2568 i = model->numbone++;
2569 model->bone = (m3db_t*)M3D_REALLOC(model->bone, model->numbone * sizeof(m3db_t));
2570 if(!model->bone) goto memerr;
2571 for(level = 0; *ptr == '/'; ptr++, level++);
2572 if(level > M3D_BONEMAXLEVEL || !*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2573 bi[level+1] = i;
2574 model->bone[i].numweight = 0;
2575 model->bone[i].weight = NULL;
2576 model->bone[i].parent = bi[level];
2577 ptr = _m3d_getint(ptr, &k);
2578 ptr = _m3d_findarg(ptr);
2579 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2580 model->bone[i].pos = (M3D_INDEX)k;
2581 ptr = _m3d_getint(ptr, &k);
2582 ptr = _m3d_findarg(ptr);
2583 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2584 model->bone[i].ori = (M3D_INDEX)k;
2585 model->vertex[k].skinid = M3D_INDEXMAX;
2586 pe = _m3d_safestr(ptr, 0);
2587 if(!pe || !*pe) goto asciiend;
2588 model->bone[i].name = pe;
2589 ptr = _m3d_findnl(ptr);
2590 }
2591 } else
2592 /* material chunk */
2593 if(!memcmp(pe, "Material", 8)) {
2594 pe = _m3d_findarg(pe);
2595 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
2596 pe = _m3d_safestr(pe, 0);
2597 if(!pe || !*pe) goto asciiend;
2598 for(i = 0; i < model->nummaterial; i++)
2599 if(!strcmp(pe, model->material[i].name)) {
2600 M3D_LOG("Multiple definitions for material");
2601 M3D_LOG(pe);
2602 M3D_FREE(pe);
2603 pe = NULL;
2604 while(*ptr && *ptr != '\r' && *ptr != '\n') ptr = _m3d_findnl(ptr);
2605 break;
2606 }
2607 if(!pe) continue;
2608 i = model->nummaterial++;
2609 if(model->flags & M3D_FLG_MTLLIB) {
2610 m = model->material;
2611 model->material = (m3dm_t*)M3D_MALLOC(model->nummaterial * sizeof(m3dm_t));
2612 if(!model->material) goto memerr;
2613 memcpy(model->material, m, (model->nummaterial - 1) * sizeof(m3dm_t));
2614 if(model->texture) {
2615 tx = model->texture;
2616 model->texture = (m3dtx_t*)M3D_MALLOC(model->numtexture * sizeof(m3dtx_t));
2617 if(!model->texture) goto memerr;
2618 memcpy(model->texture, tx, model->numtexture * sizeof(m3dm_t));
2619 }
2620 model->flags &= ~M3D_FLG_MTLLIB;
2621 } else {
2622 model->material = (m3dm_t*)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
2623 if(!model->material) goto memerr;
2624 }
2625 m = &model->material[i];
2626 m->name = pe;
2627 m->numprop = 0;
2628 m->prop = NULL;
2629 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2630 k = n = 256;
2631 if(*ptr == 'm' && *(ptr+1) == 'a' && *(ptr+2) == 'p' && *(ptr+3) == '_') {
2632 k = m3dpf_map;
2633 ptr += 4;
2634 }
2635 for(j = 0; j < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); j++)
2636 if(!memcmp(ptr, m3d_propertytypes[j].key, strlen(m3d_propertytypes[j].key))) {
2637 n = m3d_propertytypes[j].id;
2638 if(k != m3dpf_map) k = m3d_propertytypes[j].format;
2639 break;
2640 }
2641 if(n != 256 && k != 256) {
2642 ptr = _m3d_findarg(ptr);
2643 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2644 j = m->numprop++;
2645 m->prop = (m3dp_t*)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
2646 if(!m->prop) goto memerr;
2647 m->prop[j].type = n + (k == m3dpf_map && n < 128 ? 128 : 0);
2648 switch(k) {
2649 case m3dpf_color: ptr = _m3d_gethex(ptr, &m->prop[j].value.color); break;
2650 case m3dpf_uint8:
2651 case m3dpf_uint16:
2652 case m3dpf_uint32: ptr = _m3d_getint(ptr, &m->prop[j].value.num); break;
2653 case m3dpf_float: ptr = _m3d_getfloat(ptr, &m->prop[j].value.fnum); break;
2654 case m3dpf_map:
2655 pe = _m3d_safestr(ptr, 0);
2656 if(!pe || !*pe) goto asciiend;
2657 m->prop[j].value.textureid = _m3d_gettx(model, readfilecb, freecb, pe);
2658 if(model->errcode == M3D_ERR_ALLOC) { M3D_FREE(pe); goto memerr; }
2659 /* this error code only returned if readfilecb was specified */
2660 if(m->prop[j].value.textureid == M3D_UNDEF) {
2661 M3D_LOG("Texture not found");
2662 M3D_LOG(pe);
2663 m->numprop--;
2664 }
2665 M3D_FREE(pe);
2666 break;
2667 }
2668 } else {
2669 M3D_LOG("Unknown material property in");
2670 M3D_LOG(m->name);
2671 model->errcode = M3D_ERR_UNKPROP;
2672 }
2673 ptr = _m3d_findnl(ptr);
2674 }
2675 if(!m->numprop) model->nummaterial--;
2676 } else
2677 /* procedural */
2678 if(!memcmp(pe, "Procedural", 10)) {
2679 pe = _m3d_safestr(ptr, 0);
2680 _m3d_getpr(model, readfilecb, freecb, pe);
2681 M3D_FREE(pe);
2682 while(*ptr && *ptr != '\r' && *ptr != '\n') ptr = _m3d_findnl(ptr);
2683 } else
2684 /* mesh */
2685 if(!memcmp(pe, "Mesh", 4)) {
2686 mi = M3D_UNDEF;
2687 #ifdef M3D_VERTEXMAX
2688 pi = M3D_UNDEF;
2689 #endif
2690 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2691 if(*ptr == 'u') {
2692 ptr = _m3d_findarg(ptr);
2693 if(!*ptr) goto asciiend;
2694 mi = M3D_UNDEF;
2695 if(*ptr != '\r' && *ptr != '\n') {
2696 pe = _m3d_safestr(ptr, 0);
2697 if(!pe || !*pe) goto asciiend;
2698 for(j = 0; j < model->nummaterial; j++)
2699 if(!strcmp(pe, model->material[j].name)) { mi = (M3D_INDEX)j; break; }
2700 if(mi == M3D_UNDEF && !(model->flags & M3D_FLG_MTLLIB)) {
2701 mi = model->nummaterial++;
2702 model->material = (m3dm_t*)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
2703 if(!model->material) goto memerr;
2704 model->material[mi].name = pe;
2705 model->material[mi].numprop = 1;
2706 model->material[mi].prop = NULL;
2707 } else
2708 M3D_FREE(pe);
2709 }
2710 } else
2711 if(*ptr == 'p') {
2712 ptr = _m3d_findarg(ptr);
2713 if(!*ptr) goto asciiend;
2714 #ifdef M3D_VERTEXMAX
2715 pi = M3D_UNDEF;
2716 if(*ptr != '\r' && *ptr != '\n') {
2717 pe = _m3d_safestr(ptr, 0);
2718 if(!pe || !*pe) goto asciiend;
2719 for(j = 0; j < model->numparam; j++)
2720 if(!strcmp(pe, model->param[j].name)) { pi = (M3D_INDEX)j; break; }
2721 if(pi == M3D_UNDEF) {
2722 pi = model->numparam++;
2723 model->param = (m3dvi_t*)M3D_REALLOC(model->param, model->numparam * sizeof(m3dvi_t));
2724 if(!model->param) goto memerr;
2725 model->param[pi].name = pe;
2726 model->param[pi].count = 0;
2727 } else
2728 M3D_FREE(pe);
2729 }
2730 #endif
2731 } else {
2732 i = model->numface++;
2733 model->face = (m3df_t*)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
2734 if(!model->face) goto memerr;
2735 memset(&model->face[i], 255, sizeof(m3df_t)); /* set all index to -1 by default */
2736 model->face[i].materialid = mi;
2737 #ifdef M3D_VERTEXMAX
2738 model->face[i].paramid = pi;
2739 #endif
2740 /* hardcoded triangles. */
2741 for(j = 0; j < 3; j++) {
2742 /* vertex */
2743 ptr = _m3d_getint(ptr, &k);
2744 model->face[i].vertex[j] = (M3D_INDEX)k;
2745 if(!*ptr) goto asciiend;
2746 if(*ptr == '/') {
2747 ptr++;
2748 if(*ptr != '/') {
2749 /* texcoord */
2750 ptr = _m3d_getint(ptr, &k);
2751 model->face[i].texcoord[j] = (M3D_INDEX)k;
2752 if(!*ptr) goto asciiend;
2753 }
2754 if(*ptr == '/') {
2755 ptr++;
2756 /* normal */
2757 ptr = _m3d_getint(ptr, &k);
2758 model->face[i].normal[j] = (M3D_INDEX)k;
2759 if(!*ptr) goto asciiend;
2760 }
2761 if(*ptr == '/') {
2762 ptr++;
2763 /* maximum */
2764 ptr = _m3d_getint(ptr, &k);
2765 #ifdef M3D_VERTEXMAX
2766 model->face[i].vertmax[j] = (M3D_INDEX)k;
2767 #endif
2768 if(!*ptr) goto asciiend;
2769 }
2770 }
2771 #ifndef M3D_NONORMALS
2772 if(model->face[i].normal[j] == M3D_UNDEF) neednorm = 1;
2773 #endif
2774 ptr = _m3d_findarg(ptr);
2775 }
2776 }
2777 ptr = _m3d_findnl(ptr);
2778 }
2779 } else
2780 /* voxel types chunk */
2781 if(!memcmp(pe, "VoxTypes", 8) || !memcmp(pe, "Voxtypes", 8)) {
2782 if(model->voxtype) { M3D_LOG("More voxel types chunks, should be unique"); goto asciiend; }
2783 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2784 i = model->numvoxtype++;
2785 model->voxtype = (m3dvt_t*)M3D_REALLOC(model->voxtype, model->numvoxtype * sizeof(m3dvt_t));
2786 if(!model->voxtype) goto memerr;
2787 memset(&model->voxtype[i], 0, sizeof(m3dvt_t));
2788 model->voxtype[i].materialid = M3D_UNDEF;
2789 model->voxtype[i].skinid = M3D_UNDEF;
2790 ptr = _m3d_gethex(ptr, &model->voxtype[i].color);
2791 if(!*ptr) goto asciiend;
2792 if(*ptr == '/') {
2793 ptr = _m3d_gethex(ptr, &k);
2794 model->voxtype[i].rotation = k;
2795 if(!*ptr) goto asciiend;
2796 if(*ptr == '/') {
2797 ptr = _m3d_gethex(ptr, &k);
2798 model->voxtype[i].voxshape = k;
2799 if(!*ptr) goto asciiend;
2800 }
2801 }
2802 while(*ptr == ' ' || *ptr == '\t') ptr++;
2803 if(*ptr == '\r' || *ptr == '\n') { ptr = _m3d_findnl(ptr); continue; }
2804 /* name */
2805 if(*ptr != '-') {
2806 pe = _m3d_safestr(ptr, 0);
2807 if(!pe || !*pe) goto asciiend;
2808 model->voxtype[i].name = pe;
2809 for(j = 0; j < model->nummaterial; j++)
2810 if(!strcmp(pe, model->material[j].name)) { model->voxtype[i].materialid = (M3D_INDEX)j; break; }
2811 }
2812 ptr = _m3d_findarg(ptr);
2813 /* parse skin */
2814 memset(&s, 0, sizeof(m3ds_t));
2815 for(j = 0, w = (M3D_FLOAT)0.0; j < M3D_NUMBONE && *ptr && *ptr != '{' && *ptr != '\r' && *ptr != '\n'; j++) {
2816 ptr = _m3d_getint(ptr, &k);
2817 s.boneid[j] = (M3D_INDEX)k;
2818 if(*ptr == ':') {
2819 ptr++;
2820 ptr = _m3d_getfloat(ptr, &s.weight[j]);
2821 w += s.weight[j];
2822 } else if(!j)
2823 s.weight[j] = (M3D_FLOAT)1.0;
2824 if(!*ptr) goto asciiend;
2825 ptr = _m3d_findarg(ptr);
2826 }
2827 if(s.boneid[0] != M3D_UNDEF && s.weight[0] > (M3D_FLOAT)0.0) {
2828 if(w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0)
2829 for(j = 0; j < M3D_NUMBONE && s.weight[j] > (M3D_FLOAT)0.0; j++)
2830 s.weight[j] /= w;
2831 k = M3D_NOTDEFINED;
2832 if(model->skin) {
2833 for(j = 0; j < model->numskin; j++)
2834 if(!memcmp(&model->skin[j], &s, sizeof(m3ds_t))) { k = j; break; }
2835 }
2836 if(k == M3D_NOTDEFINED) {
2837 k = model->numskin++;
2838 model->skin = (m3ds_t*)M3D_REALLOC(model->skin, model->numskin * sizeof(m3ds_t));
2839 if(!model->skin) goto memerr;
2840 memcpy(&model->skin[k], &s, sizeof(m3ds_t));
2841 }
2842 model->voxtype[i].skinid = (M3D_INDEX)k;
2843 }
2844 /* parse item list */
2845 if(*ptr == '{') {
2846 while(*ptr == '{' || *ptr == ' ' || *ptr == '\t') ptr++;
2847 while(*ptr && *ptr != '}' && *ptr != '\r' && *ptr != '\n') {
2848 ptr = _m3d_getint(ptr, &k);
2849 ptr = _m3d_findarg(ptr);
2850 if(!*ptr || *ptr == '}' || *ptr == '\r' || *ptr == '\n') goto asciiend;
2851 pe = _m3d_safestr(ptr, 0);
2852 if(!pe || !*pe) goto asciiend;
2853 ptr = _m3d_findarg(ptr);
2854 j = model->voxtype[i].numitem++;
2855 model->voxtype[i].item = (m3dvi_t*)M3D_REALLOC(model->voxtype[i].item,
2856 model->voxtype[i].numitem * sizeof(m3dvi_t));
2857 if(!model->voxtype[i].item) goto memerr;
2858 model->voxtype[i].item[j].count = k;
2859 model->voxtype[i].item[j].name = pe;
2860 }
2861 if(*ptr != '}') goto asciiend;
2862 }
2863 ptr = _m3d_findnl(ptr);
2864 }
2865 } else
2866 /* voxel data */
2867 if(!memcmp(pe, "Voxel", 5)) {
2868 if(!model->voxtype) { M3D_LOG("No voxel type chunk before voxel data"); goto asciiend; }
2869 pe = _m3d_findarg(pe);
2870 if(!*pe) goto asciiend;
2871 if(*pe == '\r' || *pe == '\n') pe = NULL;
2872 else pe = _m3d_safestr(pe, 0);
2873 i = model->numvoxel++;
2874 model->voxel = (m3dvx_t*)M3D_REALLOC(model->voxel, model->numvoxel * sizeof(m3dvx_t));
2875 if(!model->voxel) goto memerr;
2876 memset(&model->voxel[i], 0, sizeof(m3dvx_t));
2877 model->voxel[i].name = pe;
2878 k = l = 0;
2879 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2880 switch(*ptr) {
2881 case 'u':
2882 ptr = _m3d_findarg(ptr);
2883 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2884 ptr = _m3d_getint(ptr, &n);
2885 model->voxel[i].uncertain = ((n > 0 && n < 256 ? n : 0) * 255) / 100;
2886 ptr = _m3d_findarg(ptr);
2887 if(*ptr && *ptr != '\r' && *ptr != '\n') {
2888 ptr = _m3d_getint(ptr, &n);
2889 model->voxel[i].groupid = n > 0 && n < 256 ? n : 0;
2890 }
2891 break;
2892 case 'p':
2893 ptr = _m3d_findarg(ptr);
2894 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2895 ptr = _m3d_getint(ptr, &n);
2896 model->voxel[i].x = n;
2897 ptr = _m3d_findarg(ptr);
2898 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2899 ptr = _m3d_getint(ptr, &n);
2900 model->voxel[i].y = n;
2901 ptr = _m3d_findarg(ptr);
2902 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2903 ptr = _m3d_getint(ptr, &n);
2904 model->voxel[i].z = n;
2905 break;
2906 case 'd':
2907 ptr = _m3d_findarg(ptr);
2908 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2909 ptr = _m3d_getint(ptr, &n);
2910 model->voxel[i].w = n;
2911 ptr = _m3d_findarg(ptr);
2912 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2913 ptr = _m3d_getint(ptr, &n);
2914 model->voxel[i].h = n;
2915 ptr = _m3d_findarg(ptr);
2916 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
2917 ptr = _m3d_getint(ptr, &n);
2918 model->voxel[i].d = n;
2919 break;
2920 case 'l':
2921 if(model->voxel[i].data) { l++; k = 0; }
2922 else {
2923 if(!model->voxel[i].w || !model->voxel[i].h || !model->voxel[i].d) {
2924 M3D_LOG("No voxel dimension before layer data");
2925 goto asciiend;
2926 }
2927 model->voxel[i].data = (M3D_VOXEL*)M3D_MALLOC(
2928 model->voxel[i].w * model->voxel[i].h * model->voxel[i].d * sizeof(M3D_VOXEL));
2929 if(!model->voxel[i].data) goto memerr;
2930 }
2931 break;
2932 default:
2933 if(!model->voxel[i].data || l >= model->voxel[i].h || k >= model->voxel[i].d) {
2934 M3D_LOG("Missing voxel attributes or out of bound data");
2935 goto asciiend;
2936 }
2937 for(n = l * model->voxel[i].w * model->voxel[i].d + k * model->voxel[i].w;
2938 j < model->voxel[i].w && *ptr && *ptr != '\r' && *ptr != '\n'; j++) {
2939 ptr = _m3d_getint(ptr, &am);
2940 if(am >= model->numvoxtype) goto asciiend;
2941 model->voxel[i].data[n + j] = am;
2942 }
2943 k++;
2944 break;
2945 }
2946 ptr = _m3d_findnl(ptr);
2947 }
2948 } else
2949 /* mathematical shape */
2950 if(!memcmp(pe, "Shape", 5)) {
2951 pe = _m3d_findarg(pe);
2952 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
2953 pe = _m3d_safestr(pe, 0);
2954 if(!pe || !*pe) goto asciiend;
2955 i = model->numshape++;
2956 model->shape = (m3dh_t*)M3D_REALLOC(model->shape, model->numshape * sizeof(m3ds_t));
2957 if(!model->shape) goto memerr;
2958 h = &model->shape[i];
2959 h->name = pe;
2960 h->group = M3D_UNDEF;
2961 h->numcmd = 0;
2962 h->cmd = NULL;
2963 while(*ptr && *ptr != '\r' && *ptr != '\n') {
2964 if(!memcmp(ptr, "group", 5)) {
2965 ptr = _m3d_findarg(ptr);
2966 ptr = _m3d_getint(ptr, &h->group);
2967 ptr = _m3d_findnl(ptr);
2968 if(h->group != M3D_UNDEF && h->group >= model->numbone) {
2969 M3D_LOG("Unknown bone id as shape group in shape");
2970 M3D_LOG(pe);
2971 h->group = M3D_UNDEF;
2972 model->errcode = M3D_ERR_SHPE;
2973 }
2974 continue;
2975 }
2976 for(cd = NULL, k = 0; k < (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])); k++) {
2977 j = (unsigned int)strlen(m3d_commandtypes[k].key);
2978 if(!memcmp(ptr, m3d_commandtypes[k].key, j) && (ptr[j] == ' ' || ptr[j] == '\r' || ptr[j] == '\n'))
2979 { cd = &m3d_commandtypes[k]; break; }
2980 }
2981 if(cd) {
2982 j = h->numcmd++;
2983 h->cmd = (m3dc_t*)M3D_REALLOC(h->cmd, h->numcmd * sizeof(m3dc_t));
2984 if(!h->cmd) goto memerr;
2985 h->cmd[j].type = k;
2986 h->cmd[j].arg = (uint32_t*)M3D_MALLOC(cd->p * sizeof(uint32_t));
2987 if(!h->cmd[j].arg) goto memerr;
2988 memset(h->cmd[j].arg, 0, cd->p * sizeof(uint32_t));
2989 for(k = n = 0, l = cd->p; k < l; k++) {
2990 ptr = _m3d_findarg(ptr);
2991 if(!*ptr) goto asciiend;
2992 if(*ptr == '[') {
2993 ptr = _m3d_findarg(ptr + 1);
2994 if(!*ptr) goto asciiend;
2995 }
2996 if(*ptr == ']' || *ptr == '\r' || *ptr == '\n') break;
2997 switch(cd->a[((k - n) % (cd->p - n)) + n]) {
2998 case m3dcp_mi_t:
2999 mi = M3D_UNDEF;
3000 if(*ptr != '\r' && *ptr != '\n') {
3001 pe = _m3d_safestr(ptr, 0);
3002 if(!pe || !*pe) goto asciiend;
3003 for(n = 0; n < model->nummaterial; n++)
3004 if(!strcmp(pe, model->material[n].name)) { mi = (M3D_INDEX)n; break; }
3005 if(mi == M3D_UNDEF && !(model->flags & M3D_FLG_MTLLIB)) {
3006 mi = model->nummaterial++;
3007 model->material = (m3dm_t*)M3D_REALLOC(model->material,
3008 model->nummaterial * sizeof(m3dm_t));
3009 if(!model->material) goto memerr;
3010 model->material[mi].name = pe;
3011 model->material[mi].numprop = 1;
3012 model->material[mi].prop = NULL;
3013 } else
3014 M3D_FREE(pe);
3015 }
3016 h->cmd[j].arg[k] = mi;
3017 break;
3018 case m3dcp_vc_t:
3019 #ifdef M3D_DOUBLE
3020 _m3d_getfloat(ptr, &w); f = w;
3021 memcpy(&h->cmd[j].arg[k], &f, 4);
3022 #else
3023 _m3d_getfloat(ptr, (float*)&h->cmd[j].arg[k]);
3024 #endif
3025 break;
3026 case m3dcp_va_t:
3027 ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
3028 n = k + 1; l += (h->cmd[j].arg[k] - 1) * (cd->p - k - 1);
3029 h->cmd[j].arg = (uint32_t*)M3D_REALLOC(h->cmd[j].arg, l * sizeof(uint32_t));
3030 if(!h->cmd[j].arg) goto memerr;
3031 memset(&h->cmd[j].arg[k + 1], 0, (l - k - 1) * sizeof(uint32_t));
3032 break;
3033 case m3dcp_qi_t:
3034 ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
3035 model->vertex[h->cmd[i].arg[k]].skinid = M3D_INDEXMAX;
3036 break;
3037 default:
3038 ptr = _m3d_getint(ptr, &h->cmd[j].arg[k]);
3039 break;
3040 }
3041 }
3042 } else {
3043 M3D_LOG("Unknown shape command in");
3044 M3D_LOG(h->name);
3045 model->errcode = M3D_ERR_UNKCMD;
3046 }
3047 ptr = _m3d_findnl(ptr);
3048 }
3049 if(!h->numcmd) model->numshape--;
3050 } else
3051 /* annotation labels */
3052 if(!memcmp(pe, "Labels", 6)) {
3053 pe = _m3d_findarg(pe);
3054 if(!*pe) goto asciiend;
3055 if(*pe == '\r' || *pe == '\n') pe = NULL;
3056 else pe = _m3d_safestr(pe, 0);
3057 k = 0; fn = NULL;
3058 while(*ptr && *ptr != '\r' && *ptr != '\n') {
3059 if(*ptr == 'c') {
3060 ptr = _m3d_findarg(ptr);
3061 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
3062 ptr = _m3d_gethex(ptr, &k);
3063 } else
3064 if(*ptr == 'l') {
3065 ptr = _m3d_findarg(ptr);
3066 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
3067 fn = _m3d_safestr(ptr, 2);
3068 } else {
3069 i = model->numlabel++;
3070 model->label = (m3dl_t*)M3D_REALLOC(model->label, model->numlabel * sizeof(m3dl_t));
3071 if(!model->label) goto memerr;
3072 model->label[i].name = pe;
3073 model->label[i].lang = fn;
3074 model->label[i].color = k;
3075 ptr = _m3d_getint(ptr, &j);
3076 model->label[i].vertexid = (M3D_INDEX)j;
3077 ptr = _m3d_findarg(ptr);
3078 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
3079 model->label[i].text = _m3d_safestr(ptr, 2);
3080 }
3081 ptr = _m3d_findnl(ptr);
3082 }
3083 } else
3084 /* action */
3085 if(!memcmp(pe, "Action", 6)) {
3086 pe = _m3d_findarg(pe);
3087 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
3088 pe = _m3d_getint(pe, &k);
3089 pe = _m3d_findarg(pe);
3090 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
3091 pe = _m3d_safestr(pe, 0);
3092 if(!pe || !*pe) goto asciiend;
3093 i = model->numaction++;
3094 model->action = (m3da_t*)M3D_REALLOC(model->action, model->numaction * sizeof(m3da_t));
3095 if(!model->action) goto memerr;
3096 a = &model->action[i];
3097 a->name = pe;
3098 a->durationmsec = k;
3099 /* skip the first frame marker as there's always at least one frame */
3100 a->numframe = 1;
3101 a->frame = (m3dfr_t*)M3D_MALLOC(sizeof(m3dfr_t));
3102 if(!a->frame) goto memerr;
3103 a->frame[0].msec = 0;
3104 a->frame[0].numtransform = 0;
3105 a->frame[0].transform = NULL;
3106 i = 0;
3107 if(*ptr == 'f')
3108 ptr = _m3d_findnl(ptr);
3109 while(*ptr && *ptr != '\r' && *ptr != '\n') {
3110 if(*ptr == 'f') {
3111 i = a->numframe++;
3112 a->frame = (m3dfr_t*)M3D_REALLOC(a->frame, a->numframe * sizeof(m3dfr_t));
3113 if(!a->frame) goto memerr;
3114 ptr = _m3d_findarg(ptr);
3115 ptr = _m3d_getint(ptr, &a->frame[i].msec);
3116 a->frame[i].numtransform = 0;
3117 a->frame[i].transform = NULL;
3118 } else {
3119 j = a->frame[i].numtransform++;
3120 a->frame[i].transform = (m3dtr_t*)M3D_REALLOC(a->frame[i].transform,
3121 a->frame[i].numtransform * sizeof(m3dtr_t));
3122 if(!a->frame[i].transform) goto memerr;
3123 ptr = _m3d_getint(ptr, &k);
3124 ptr = _m3d_findarg(ptr);
3125 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
3126 a->frame[i].transform[j].boneid = (M3D_INDEX)k;
3127 ptr = _m3d_getint(ptr, &k);
3128 ptr = _m3d_findarg(ptr);
3129 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
3130 a->frame[i].transform[j].pos = (M3D_INDEX)k;
3131 ptr = _m3d_getint(ptr, &k);
3132 if(!*ptr || *ptr == '\r' || *ptr == '\n') goto asciiend;
3133 a->frame[i].transform[j].ori = (M3D_INDEX)k;
3134 model->vertex[k].skinid = M3D_INDEXMAX;
3135 }
3136 ptr = _m3d_findnl(ptr);
3137 }
3138 } else
3139 /* inlined assets chunk */
3140 if(!memcmp(pe, "Assets", 6)) {
3141 while(*ptr && *ptr != '\r' && *ptr != '\n') {
3142 if(readfilecb) {
3143 pe = _m3d_safestr(ptr, 2);
3144 if(!pe || !*pe) goto asciiend;
3145 i = model->numinlined++;
3146 model->inlined = (m3di_t*)M3D_REALLOC(model->inlined, model->numinlined * sizeof(m3di_t));
3147 if(!model->inlined) goto memerr;
3148 t = &model->inlined[i];
3149 model->inlined[i].data = (*readfilecb)(pe, &model->inlined[i].length);
3150 if(model->inlined[i].data) {
3151 fn = strrchr(pe, '.');
3152 if(fn && (fn[1] == 'p' || fn[1] == 'P') && (fn[2] == 'n' || fn[2] == 'N') &&
3153 (fn[3] == 'g' || fn[3] == 'G')) *fn = 0;
3154 fn = strrchr(pe, '/');
3155 if(!fn) fn = strrchr(pe, '\\');
3156 if(!fn) fn = pe; else fn++;
3157 model->inlined[i].name = _m3d_safestr(fn, 0);
3158 } else
3159 model->numinlined--;
3160 M3D_FREE(pe);
3161 }
3162 ptr = _m3d_findnl(ptr);
3163 }
3164 } else
3165 /* extra chunks */
3166 if(!memcmp(pe, "Extra", 5)) {
3167 pe = _m3d_findarg(pe);
3168 if(!*pe || *pe == '\r' || *pe == '\n') goto asciiend;
3169 buff = (unsigned char*)_m3d_findnl(ptr);
3170 k = ((uint32_t)((uintptr_t)buff - (uintptr_t)ptr) / 3) + 1;
3171 i = model->numextra++;
3172 model->extra = (m3dchunk_t**)M3D_REALLOC(model->extra, model->numextra * sizeof(m3dchunk_t*));
3173 if(!model->extra) goto memerr;
3174 model->extra[i] = (m3dchunk_t*)M3D_MALLOC(k + sizeof(m3dchunk_t));
3175 if(!model->extra[i]) goto memerr;
3176 memcpy(&model->extra[i]->magic, pe, 4);
3177 model->extra[i]->length = sizeof(m3dchunk_t);
3178 pe = (char*)model->extra[i] + sizeof(m3dchunk_t);
3179 while(*ptr && *ptr != '\r' && *ptr != '\n') {
3180 ptr = _m3d_gethex(ptr, &k);
3181 *pe++ = (uint8_t)k;
3182 model->extra[i]->length++;
3183 }
3184 } else
3185 goto asciiend;
3186 }
3187 model->errcode = M3D_SUCCESS;
3188 asciiend:
3189 setlocale(LC_NUMERIC, ol);
3190 goto postprocess;
3191 }
3192 #endif
3193 /* Binary variant */
3194 ✗ len = ((m3dhdr_t*)data)->length - 8;
3195 ✗ data += 8;
3196 ✗ if(M3D_CHUNKMAGIC(data, 'P','R','V','W')) {
3197 /* optional preview chunk */
3198 ✗ model->preview.length = ((m3dchunk_t*)data)->length;
3199 ✗ model->preview.data = data + sizeof(m3dchunk_t);
3200 ✗ data += model->preview.length;
3201 ✗ len -= model->preview.length;
3202 }
3203 ✗ if(!M3D_CHUNKMAGIC(data, 'H','E','A','D')) {
3204 ✗ buff = (unsigned char *)stbi_zlib_decode_malloc_guesssize_headerflag((const char*)data, len, 4096, (int*)&len, 1);
3205 ✗ if(!buff || !len || !M3D_CHUNKMAGIC(buff, 'H','E','A','D')) {
3206 ✗ if(buff) M3D_FREE(buff);
3207 ✗ M3D_FREE(model);
3208 ✗ return NULL;
3209 }
3210 ✗ buff = (unsigned char*)M3D_REALLOC(buff, len);
3211 ✗ model->flags |= M3D_FLG_FREERAW; /* mark that we have to free the raw buffer */
3212 data = buff;
3213 #ifdef M3D_PROFILING
3214 gettimeofday(&tv1, NULL);
3215 tvd.tv_sec = tv1.tv_sec - tv0.tv_sec;
3216 tvd.tv_usec = tv1.tv_usec - tv0.tv_usec;
3217 if(tvd.tv_usec < 0) { tvd.tv_sec--; tvd.tv_usec += 1000000L; }
3218 printf(" Deflate model %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
3219 memcpy(&tv0, &tv1, sizeof(struct timeval));
3220 #endif
3221 }
3222 ✗ model->raw = (m3dhdr_t*)data;
3223 ✗ end = data + len;
3224
3225 /* parse header */
3226 ✗ data += sizeof(m3dhdr_t);
3227 M3D_LOG((char*)data);
3228 ✗ model->name = (char*)data;
3229 ✗ for(; data < end && *data; data++) {}; data++;
3230 ✗ model->license = (char*)data;
3231 ✗ for(; data < end && *data; data++) {}; data++;
3232 ✗ model->author = (char*)data;
3233 ✗ for(; data < end && *data; data++) {}; data++;
3234 ✗ model->desc = (char*)data;
3235 ✗ chunk = (unsigned char*)model->raw + model->raw->length;
3236 ✗ model->scale = (M3D_FLOAT)model->raw->scale;
3237 ✗ if(model->scale <= (M3D_FLOAT)0.0) model->scale = (M3D_FLOAT)1.0;
3238 ✗ model->vc_s = 1 << ((model->raw->types >> 0) & 3); /* vertex coordinate size */
3239 ✗ model->vi_s = 1 << ((model->raw->types >> 2) & 3); /* vertex index size */
3240 ✗ model->si_s = 1 << ((model->raw->types >> 4) & 3); /* string offset size */
3241 ✗ model->ci_s = 1 << ((model->raw->types >> 6) & 3); /* color index size */
3242 ✗ model->ti_s = 1 << ((model->raw->types >> 8) & 3); /* tmap index size */
3243 ✗ model->bi_s = 1 << ((model->raw->types >>10) & 3); /* bone index size */
3244 ✗ model->nb_s = 1 << ((model->raw->types >>12) & 3); /* number of bones per vertex */
3245 ✗ model->sk_s = 1 << ((model->raw->types >>14) & 3); /* skin index size */
3246 ✗ model->fc_s = 1 << ((model->raw->types >>16) & 3); /* frame counter size */
3247 ✗ model->hi_s = 1 << ((model->raw->types >>18) & 3); /* shape index size */
3248 ✗ model->fi_s = 1 << ((model->raw->types >>20) & 3); /* face index size */
3249 ✗ model->vd_s = 1 << ((model->raw->types >>22) & 3); /* voxel dimension size */
3250 ✗ model->vp_s = 1 << ((model->raw->types >>24) & 3); /* voxel pixel size */
3251 ✗ if(model->ci_s == 8) model->ci_s = 0; /* optional indices */
3252 ✗ if(model->ti_s == 8) model->ti_s = 0;
3253 ✗ if(model->bi_s == 8) model->bi_s = 0;
3254 ✗ if(model->sk_s == 8) model->sk_s = 0;
3255 ✗ if(model->fc_s == 8) model->fc_s = 0;
3256 ✗ if(model->hi_s == 8) model->hi_s = 0;
3257 ✗ if(model->fi_s == 8) model->fi_s = 0;
3258
3259 /* variable limit checks */
3260 ✗ if(sizeof(M3D_FLOAT) == 4 && model->vc_s > 4) {
3261 M3D_LOG("Double precision coordinates not supported, truncating to float...");
3262 ✗ model->errcode = M3D_ERR_TRUNC;
3263 }
3264 ✗ if((sizeof(M3D_INDEX) == 2 && (model->vi_s > 2 || model->si_s > 2 || model->ci_s > 2 || model->ti_s > 2 ||
3265 ✗ model->bi_s > 2 || model->sk_s > 2 || model->fc_s > 2 || model->hi_s > 2 || model->fi_s > 2)) ||
3266 ✗ (sizeof(M3D_VOXEL) < (size_t)model->vp_s && model->vp_s != 8)) {
3267 M3D_LOG("32 bit indices not supported, unable to load model");
3268 ✗ M3D_FREE(model);
3269 ✗ return NULL;
3270 }
3271 ✗ if(model->vi_s > 4 || model->si_s > 4 || model->vp_s == 4) {
3272 M3D_LOG("Invalid index size, unable to load model");
3273 ✗ M3D_FREE(model);
3274 ✗ return NULL;
3275 }
3276 ✗ if(!M3D_CHUNKMAGIC(end - 4, 'O','M','D','3')) {
3277 M3D_LOG("Missing end chunk");
3278 ✗ M3D_FREE(model);
3279 ✗ return NULL;
3280 }
3281 ✗ if(model->nb_s > M3D_NUMBONE) {
3282 M3D_LOG("Model has more bones per vertex than what importer was configured to support");
3283 ✗ model->errcode = M3D_ERR_TRUNC;
3284 }
3285
3286 /* look for inlined assets in advance, material and procedural chunks may need them */
3287 buff = chunk;
3288 ✗ while(buff < end && !M3D_CHUNKMAGIC(buff, 'O','M','D','3')) {
3289 data = buff;
3290 ✗ len = ((m3dchunk_t*)data)->length;
3291 ✗ buff += len;
3292 ✗ if(len < sizeof(m3dchunk_t) || buff >= end) {
3293 M3D_LOG("Invalid chunk size");
3294 break;
3295 }
3296 ✗ len -= sizeof(m3dchunk_t) + model->si_s;
3297
3298 /* inlined assets */
3299 ✗ if(M3D_CHUNKMAGIC(data, 'A','S','E','T') && len > 0) {
3300 M3D_LOG("Inlined asset");
3301 ✗ i = model->numinlined++;
3302 ✗ model->inlined = (m3di_t*)M3D_REALLOC(model->inlined, model->numinlined * sizeof(m3di_t));
3303 ✗ if(!model->inlined) {
3304 ✗ memerr: M3D_LOG("Out of memory");
3305 ✗ model->errcode = M3D_ERR_ALLOC;
3306 ✗ return model;
3307 }
3308 ✗ data += sizeof(m3dchunk_t);
3309 ✗ t = &model->inlined[i];
3310 ✗ M3D_GETSTR(t->name);
3311 M3D_LOG(t->name);
3312 ✗ t->data = (uint8_t*)data;
3313 ✗ t->length = len;
3314 }
3315 }
3316
3317 /* parse chunks */
3318 ✗ while(chunk < end && !M3D_CHUNKMAGIC(chunk, 'O','M','D','3')) {
3319 data = chunk;
3320 ✗ len = ((m3dchunk_t*)chunk)->length;
3321 ✗ chunk += len;
3322 ✗ if(len < sizeof(m3dchunk_t) || chunk >= end) {
3323 M3D_LOG("Invalid chunk size");
3324 break;
3325 }
3326 ✗ len -= sizeof(m3dchunk_t);
3327
3328 /* color map */
3329 ✗ if(M3D_CHUNKMAGIC(data, 'C','M','A','P')) {
3330 M3D_LOG("Color map");
3331 ✗ if(model->cmap) { M3D_LOG("More color map chunks, should be unique"); model->errcode = M3D_ERR_CMAP; continue; }
3332 ✗ if(!model->ci_s) { M3D_LOG("Color map chunk, shouldn't be any"); model->errcode = M3D_ERR_CMAP; continue; }
3333 ✗ model->numcmap = len / sizeof(uint32_t);
3334 ✗ model->cmap = (uint32_t*)(data + sizeof(m3dchunk_t));
3335 } else
3336 /* texture map */
3337 ✗ if(M3D_CHUNKMAGIC(data, 'T','M','A','P')) {
3338 M3D_LOG("Texture map");
3339 ✗ if(model->tmap) { M3D_LOG("More texture map chunks, should be unique"); model->errcode = M3D_ERR_TMAP; continue; }
3340 ✗ if(!model->ti_s) { M3D_LOG("Texture map chunk, shouldn't be any"); model->errcode = M3D_ERR_TMAP; continue; }
3341 ✗ reclen = model->vc_s + model->vc_s;
3342 ✗ model->numtmap = len / reclen;
3343 ✗ model->tmap = (m3dti_t*)M3D_MALLOC(model->numtmap * sizeof(m3dti_t));
3344 ✗ if(!model->tmap) goto memerr;
3345 ✗ for(i = 0, data += sizeof(m3dchunk_t); data < chunk; i++) {
3346 ✗ switch(model->vc_s) {
3347 ✗ case 1:
3348 ✗ model->tmap[i].u = (M3D_FLOAT)((uint8_t)data[0]) / (M3D_FLOAT)255.0;
3349 ✗ model->tmap[i].v = (M3D_FLOAT)((uint8_t)data[1]) / (M3D_FLOAT)255.0;
3350 ✗ break;
3351 ✗ case 2:
3352 ✗ model->tmap[i].u = (M3D_FLOAT)(*((uint16_t*)(data+0))) / (M3D_FLOAT)65535.0;
3353 ✗ model->tmap[i].v = (M3D_FLOAT)(*((uint16_t*)(data+2))) / (M3D_FLOAT)65535.0;
3354 ✗ break;
3355 ✗ case 4:
3356 ✗ model->tmap[i].u = (M3D_FLOAT)(*((float*)(data+0)));
3357 ✗ model->tmap[i].v = (M3D_FLOAT)(*((float*)(data+4)));
3358 ✗ break;
3359 ✗ case 8:
3360 ✗ model->tmap[i].u = (M3D_FLOAT)(*((double*)(data+0)));
3361 ✗ model->tmap[i].v = (M3D_FLOAT)(*((double*)(data+8)));
3362 ✗ break;
3363 }
3364 ✗ data += reclen;
3365 }
3366 } else
3367 /* vertex list */
3368 ✗ if(M3D_CHUNKMAGIC(data, 'V','R','T','S')) {
3369 M3D_LOG("Vertex list");
3370 ✗ if(model->vertex) { M3D_LOG("More vertex chunks, should be unique"); model->errcode = M3D_ERR_VRTS; continue; }
3371 ✗ if(model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
3372 ✗ reclen = model->ci_s + model->sk_s + 4 * model->vc_s;
3373 ✗ model->numvertex = len / reclen;
3374 ✗ model->vertex = (m3dv_t*)M3D_MALLOC(model->numvertex * sizeof(m3dv_t));
3375 ✗ if(!model->vertex) goto memerr;
3376 memset(model->vertex, 0, model->numvertex * sizeof(m3dv_t));
3377 ✗ for(i = 0, data += sizeof(m3dchunk_t); data < chunk && i < model->numvertex; i++) {
3378 ✗ switch(model->vc_s) {
3379 ✗ case 1:
3380 ✗ model->vertex[i].x = (M3D_FLOAT)((int8_t)data[0]) / (M3D_FLOAT)127.0;
3381 ✗ model->vertex[i].y = (M3D_FLOAT)((int8_t)data[1]) / (M3D_FLOAT)127.0;
3382 ✗ model->vertex[i].z = (M3D_FLOAT)((int8_t)data[2]) / (M3D_FLOAT)127.0;
3383 ✗ model->vertex[i].w = (M3D_FLOAT)((int8_t)data[3]) / (M3D_FLOAT)127.0;
3384 ✗ data += 4;
3385 ✗ break;
3386 ✗ case 2:
3387 ✗ model->vertex[i].x = (M3D_FLOAT)(*((int16_t*)(data+0))) / (M3D_FLOAT)32767.0;
3388 ✗ model->vertex[i].y = (M3D_FLOAT)(*((int16_t*)(data+2))) / (M3D_FLOAT)32767.0;
3389 ✗ model->vertex[i].z = (M3D_FLOAT)(*((int16_t*)(data+4))) / (M3D_FLOAT)32767.0;
3390 ✗ model->vertex[i].w = (M3D_FLOAT)(*((int16_t*)(data+6))) / (M3D_FLOAT)32767.0;
3391 ✗ data += 8;
3392 ✗ break;
3393 ✗ case 4:
3394 ✗ model->vertex[i].x = (M3D_FLOAT)(*((float*)(data+0)));
3395 ✗ model->vertex[i].y = (M3D_FLOAT)(*((float*)(data+4)));
3396 ✗ model->vertex[i].z = (M3D_FLOAT)(*((float*)(data+8)));
3397 ✗ model->vertex[i].w = (M3D_FLOAT)(*((float*)(data+12)));
3398 ✗ data += 16;
3399 ✗ break;
3400 ✗ case 8:
3401 ✗ model->vertex[i].x = (M3D_FLOAT)(*((double*)(data+0)));
3402 ✗ model->vertex[i].y = (M3D_FLOAT)(*((double*)(data+8)));
3403 ✗ model->vertex[i].z = (M3D_FLOAT)(*((double*)(data+16)));
3404 ✗ model->vertex[i].w = (M3D_FLOAT)(*((double*)(data+24)));
3405 ✗ data += 32;
3406 ✗ break;
3407 }
3408 ✗ switch(model->ci_s) {
3409 ✗ case 1: model->vertex[i].color = model->cmap ? model->cmap[data[0]] : 0; data++; break;
3410 ✗ case 2: model->vertex[i].color = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
3411 ✗ case 4: model->vertex[i].color = *((uint32_t*)data); data += 4; break;
3412 /* case 8: break; */
3413 }
3414 ✗ model->vertex[i].skinid = M3D_UNDEF;
3415 ✗ data = _m3d_getidx(data, model->sk_s, &model->vertex[i].skinid);
3416 }
3417 } else
3418 /* skeleton: bone hierarchy and skin */
3419 ✗ if(M3D_CHUNKMAGIC(data, 'B','O','N','E')) {
3420 M3D_LOG("Skeleton");
3421 ✗ if(model->bone) { M3D_LOG("More bone chunks, should be unique"); model->errcode = M3D_ERR_BONE; continue; }
3422 ✗ if(!model->bi_s) { M3D_LOG("Bone chunk, shouldn't be any"); model->errcode=M3D_ERR_BONE; continue; }
3423 ✗ if(!model->vertex) { M3D_LOG("No vertex chunk before bones"); model->errcode = M3D_ERR_VRTS; break; }
3424 ✗ data += sizeof(m3dchunk_t);
3425 ✗ model->numbone = 0;
3426 data = _m3d_getidx(data, model->bi_s, &model->numbone);
3427 ✗ if(model->numbone) {
3428 ✗ model->bone = (m3db_t*)M3D_MALLOC(model->numbone * sizeof(m3db_t));
3429 ✗ if(!model->bone) goto memerr;
3430 }
3431 ✗ model->numskin = 0;
3432 ✗ data = _m3d_getidx(data, model->sk_s, &model->numskin);
3433 /* read bone hierarchy */
3434 ✗ for(i = 0; data < chunk && i < model->numbone; i++) {
3435 ✗ data = _m3d_getidx(data, model->bi_s, &model->bone[i].parent);
3436 ✗ M3D_GETSTR(model->bone[i].name);
3437 ✗ data = _m3d_getidx(data, model->vi_s, &model->bone[i].pos);
3438 ✗ data = _m3d_getidx(data, model->vi_s, &model->bone[i].ori);
3439 ✗ model->bone[i].numweight = 0;
3440 ✗ model->bone[i].weight = NULL;
3441 }
3442 /* read skin definitions */
3443 ✗ if(model->numskin) {
3444 ✗ model->skin = (m3ds_t*)M3D_MALLOC(model->numskin * sizeof(m3ds_t));
3445 ✗ if(!model->skin) goto memerr;
3446 ✗ for(i = 0; data < chunk && i < model->numskin; i++) {
3447 ✗ for(j = 0; j < M3D_NUMBONE; j++) {
3448 ✗ model->skin[i].boneid[j] = M3D_UNDEF;
3449 ✗ model->skin[i].weight[j] = (M3D_FLOAT)0.0;
3450 }
3451 memset(&weights, 0, sizeof(weights));
3452 ✗ if(model->nb_s == 1) weights[0] = 255;
3453 else {
3454 ✗ memcpy(&weights, data, model->nb_s);
3455 ✗ data += model->nb_s;
3456 }
3457 ✗ for(j = 0, w = (M3D_FLOAT)0.0; j < (unsigned int)model->nb_s; j++) {
3458 ✗ if(weights[j]) {
3459 ✗ if(j >= M3D_NUMBONE)
3460 ✗ data += model->bi_s;
3461 else {
3462 ✗ model->skin[i].weight[j] = (M3D_FLOAT)(weights[j]) / (M3D_FLOAT)255.0;
3463 ✗ w += model->skin[i].weight[j];
3464 ✗ data = _m3d_getidx(data, model->bi_s, &model->skin[i].boneid[j]);
3465 }
3466 }
3467 }
3468 /* this can occur if model has more bones than what the importer is configured to handle */
3469 ✗ if(w != (M3D_FLOAT)1.0 && w != (M3D_FLOAT)0.0) {
3470 ✗ for(j = 0; j < M3D_NUMBONE; j++)
3471 ✗ model->skin[i].weight[j] /= w;
3472 }
3473 }
3474 }
3475 } else
3476 /* material */
3477 ✗ if(M3D_CHUNKMAGIC(data, 'M','T','R','L')) {
3478 ✗ data += sizeof(m3dchunk_t);
3479 ✗ M3D_GETSTR(name);
3480 M3D_LOG("Material");
3481 M3D_LOG(name);
3482 ✗ if(model->ci_s < 4 && !model->numcmap) model->errcode = M3D_ERR_CMAP;
3483 ✗ for(i = 0; i < model->nummaterial; i++)
3484 ✗ if(!strcmp(name, model->material[i].name)) {
3485 ✗ model->errcode = M3D_ERR_MTRL;
3486 M3D_LOG("Multiple definitions for material");
3487 M3D_LOG(name);
3488 name = NULL;
3489 break;
3490 }
3491 ✗ if(name) {
3492 ✗ i = model->nummaterial++;
3493 ✗ if(model->flags & M3D_FLG_MTLLIB) {
3494 ✗ m = model->material;
3495 ✗ model->material = (m3dm_t*)M3D_MALLOC(model->nummaterial * sizeof(m3dm_t));
3496 ✗ if(!model->material) goto memerr;
3497 ✗ memcpy(model->material, m, (model->nummaterial - 1) * sizeof(m3dm_t));
3498 ✗ if(model->texture) {
3499 tx = model->texture;
3500 ✗ model->texture = (m3dtx_t*)M3D_MALLOC(model->numtexture * sizeof(m3dtx_t));
3501 ✗ if(!model->texture) goto memerr;
3502 memcpy(model->texture, tx, model->numtexture * sizeof(m3dm_t));
3503 }
3504 ✗ model->flags &= ~M3D_FLG_MTLLIB;
3505 } else {
3506 ✗ model->material = (m3dm_t*)M3D_REALLOC(model->material, model->nummaterial * sizeof(m3dm_t));
3507 ✗ if(!model->material) goto memerr;
3508 }
3509 ✗ m = &model->material[i];
3510 ✗ m->numprop = 0;
3511 ✗ m->name = name;
3512 ✗ m->prop = (m3dp_t*)M3D_MALLOC((len / 2) * sizeof(m3dp_t));
3513 ✗ if(!m->prop) goto memerr;
3514 ✗ while(data < chunk) {
3515 ✗ i = m->numprop++;
3516 ✗ m->prop[i].type = *data++;
3517 ✗ m->prop[i].value.num = 0;
3518 ✗ if(m->prop[i].type >= 128)
3519 k = m3dpf_map;
3520 else {
3521 ✗ for(k = 256, j = 0; j < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); j++)
3522 ✗ if(m->prop[i].type == m3d_propertytypes[j].id) { k = m3d_propertytypes[j].format; break; }
3523 }
3524 ✗ switch(k) {
3525 ✗ case m3dpf_color:
3526 ✗ switch(model->ci_s) {
3527 ✗ case 1: m->prop[i].value.color = model->cmap ? model->cmap[data[0]] : 0; data++; break;
3528 ✗ case 2: m->prop[i].value.color = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
3529 ✗ case 4: m->prop[i].value.color = *((uint32_t*)data); data += 4; break;
3530 }
3531 break;
3532
3533 ✗ case m3dpf_uint8: m->prop[i].value.num = *data++; break;
3534 ✗ case m3dpf_uint16:m->prop[i].value.num = *((uint16_t*)data); data += 2; break;
3535 ✗ case m3dpf_uint32:m->prop[i].value.num = *((uint32_t*)data); data += 4; break;
3536 ✗ case m3dpf_float: m->prop[i].value.fnum = *((float*)data); data += 4; break;
3537
3538 ✗ case m3dpf_map:
3539 ✗ M3D_GETSTR(name);
3540 ✗ m->prop[i].value.textureid = _m3d_gettx(model, readfilecb, freecb, name);
3541 ✗ if(model->errcode == M3D_ERR_ALLOC) goto memerr;
3542 /* this error code only returned if readfilecb was specified */
3543 ✗ if(m->prop[i].value.textureid == M3D_UNDEF) {
3544 M3D_LOG("Texture not found");
3545 M3D_LOG(m->name);
3546 ✗ m->numprop--;
3547 }
3548 break;
3549
3550 ✗ default:
3551 M3D_LOG("Unknown material property in");
3552 M3D_LOG(m->name);
3553 ✗ model->errcode = M3D_ERR_UNKPROP;
3554 data = chunk;
3555 ✗ break;
3556 }
3557 }
3558 ✗ m->prop = (m3dp_t*)M3D_REALLOC(m->prop, m->numprop * sizeof(m3dp_t));
3559 ✗ if(!m->prop) goto memerr;
3560 }
3561 } else
3562 /* face */
3563 ✗ if(M3D_CHUNKMAGIC(data, 'P','R','O','C')) {
3564 /* procedural surface */
3565 ✗ M3D_GETSTR(name);
3566 M3D_LOG("Procedural surface");
3567 M3D_LOG(name);
3568 ✗ _m3d_getpr(model, readfilecb, freecb, name);
3569 } else
3570 ✗ if(M3D_CHUNKMAGIC(data, 'M','E','S','H')) {
3571 M3D_LOG("Mesh data");
3572 ✗ if(!model->vertex) { M3D_LOG("No vertex chunk before mesh"); model->errcode = M3D_ERR_VRTS; }
3573 /* mesh */
3574 ✗ data += sizeof(m3dchunk_t);
3575 mi = M3D_UNDEF;
3576 #ifdef M3D_VERTEXMAX
3577 pi = M3D_UNDEF;
3578 #endif
3579 ✗ am = model->numface;
3580 ✗ while(data < chunk) {
3581 ✗ k = *data++;
3582 ✗ n = k >> 4;
3583 k &= 15;
3584 ✗ if(!n) {
3585 ✗ if(!k) {
3586 /* use material */
3587 mi = M3D_UNDEF;
3588 ✗ M3D_GETSTR(name);
3589 if(name) {
3590 ✗ for(j = 0; j < model->nummaterial; j++)
3591 ✗ if(!strcmp(name, model->material[j].name)) {
3592 mi = (M3D_INDEX)j;
3593 break;
3594 }
3595 ✗ if(mi == M3D_UNDEF) model->errcode = M3D_ERR_MTRL;
3596 }
3597 } else {
3598 /* use parameter */
3599 ✗ M3D_GETSTR(name);
3600 #ifdef M3D_VERTEXMAX
3601 pi = M3D_UNDEF;
3602 if(name) {
3603 for(j = 0; j < model->numparam; j++)
3604 if(!strcmp(name, model->param[j].name)) {
3605 pi = (M3D_INDEX)j;
3606 break;
3607 }
3608 if(pi == M3D_UNDEF) {
3609 pi = model->numparam++;
3610 model->param = (m3dvi_t*)M3D_REALLOC(model->param, model->numparam * sizeof(m3dvi_t));
3611 if(!model->param) goto memerr;
3612 model->param[pi].name = name;
3613 model->param[pi].count = 0;
3614 }
3615 }
3616 #endif
3617 }
3618 ✗ continue;
3619 }
3620 ✗ if(n != 3) { M3D_LOG("Only triangle mesh supported for now"); model->errcode = M3D_ERR_UNKMESH; return model; }
3621 ✗ i = model->numface++;
3622 ✗ if(model->numface > am) {
3623 ✗ am = model->numface + 4095;
3624 ✗ model->face = (m3df_t*)M3D_REALLOC(model->face, am * sizeof(m3df_t));
3625 ✗ if(!model->face) goto memerr;
3626 }
3627 ✗ memset(&model->face[i], 255, sizeof(m3df_t)); /* set all index to -1 by default */
3628 ✗ model->face[i].materialid = mi;
3629 #ifdef M3D_VERTEXMAX
3630 model->face[i].paramid = pi;
3631 #endif
3632 ✗ for(j = 0; data < chunk && j < n; j++) {
3633 /* vertex */
3634 ✗ data = _m3d_getidx(data, model->vi_s, &model->face[i].vertex[j]);
3635 /* texcoord */
3636 ✗ if(k & 1)
3637 ✗ data = _m3d_getidx(data, model->ti_s, &model->face[i].texcoord[j]);
3638 /* normal */
3639 ✗ if(k & 2)
3640 ✗ data = _m3d_getidx(data, model->vi_s, &model->face[i].normal[j]);
3641 #ifndef M3D_NONORMALS
3642 ✗ if(model->face[i].normal[j] == M3D_UNDEF) neednorm = 1;
3643 #endif
3644 /* maximum */
3645 ✗ if(k & 4)
3646 #ifdef M3D_VERTEXMAX
3647 data = _m3d_getidx(data, model->vi_s, &model->face[i].vertmax[j]);
3648 #else
3649 ✗ data += model->vi_s;
3650 #endif
3651 }
3652 ✗ if(j != n) { M3D_LOG("Invalid mesh"); model->numface = 0; model->errcode = M3D_ERR_UNKMESH; return model; }
3653 }
3654 ✗ model->face = (m3df_t*)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
3655 } else
3656 ✗ if(M3D_CHUNKMAGIC(data, 'V','O','X','T')) {
3657 /* voxel types */
3658 M3D_LOG("Voxel types list");
3659 ✗ if(model->voxtype) { M3D_LOG("More voxel type chunks, should be unique"); model->errcode = M3D_ERR_VOXT; continue; }
3660 ✗ if(model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
3661 ✗ reclen = model->ci_s + model->si_s + 3 + model->sk_s;
3662 ✗ k = len / reclen;
3663 ✗ model->voxtype = (m3dvt_t*)M3D_MALLOC(k * sizeof(m3dvt_t));
3664 ✗ if(!model->voxtype) goto memerr;
3665 memset(model->voxtype, 0, k * sizeof(m3dvt_t));
3666 ✗ model->numvoxtype = 0;
3667 ✗ for(i = 0, data += sizeof(m3dchunk_t); data < chunk && i < k; i++) {
3668 ✗ switch(model->ci_s) {
3669 ✗ case 1: model->voxtype[i].color = model->cmap ? model->cmap[data[0]] : 0; data++; break;
3670 ✗ case 2: model->voxtype[i].color = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
3671 ✗ case 4: model->voxtype[i].color = *((uint32_t*)data); data += 4; break;
3672 /* case 8: break; */
3673 }
3674 ✗ M3D_GETSTR(name);
3675 ✗ model->voxtype[i].materialid = M3D_UNDEF;
3676 ✗ if(name) {
3677 ✗ model->voxtype[i].name = name;
3678 /*
3679 for(j = 0; j < model->nummaterial; j++)
3680 if(!strcmp(name, model->material[j].name)) {
3681 model->voxtype[i].materialid = (M3D_INDEX)j;
3682 break;
3683 }
3684 */
3685 }
3686 ✗ j = *data++;
3687 ✗ model->voxtype[i].rotation = j & 0xBF;
3688 ✗ model->voxtype[i].voxshape = ((j & 0x40) << 2) | *data++;
3689 ✗ model->voxtype[i].numitem = *data++;
3690 ✗ model->voxtype[i].skinid = M3D_UNDEF;
3691 ✗ data = _m3d_getidx(data, model->sk_s, &model->voxtype[i].skinid);
3692 ✗ if(model->voxtype[i].numitem) {
3693 ✗ model->voxtype[i].item = (m3dvi_t*)M3D_MALLOC(model->voxtype[i].numitem * sizeof(m3dvi_t));
3694 ✗ if(!model->voxtype[i].item) goto memerr;
3695 ✗ memset(model->voxtype[i].item, 0, model->voxtype[i].numitem * sizeof(m3dvi_t));
3696 ✗ for(j = 0; j < model->voxtype[i].numitem; j++) {
3697 ✗ model->voxtype[i].item[j].count = *data++;
3698 ✗ model->voxtype[i].item[j].count |= (*data++) << 8;
3699 ✗ M3D_GETSTR(model->voxtype[i].item[j].name);
3700 }
3701 }
3702 }
3703 ✗ model->numvoxtype = i;
3704 ✗ if(k != model->numvoxtype) {
3705 ✗ model->voxtype = (m3dvt_t*)M3D_REALLOC(model->voxtype, model->numvoxtype * sizeof(m3dvt_t));
3706 ✗ if(!model->voxtype) goto memerr;
3707 }
3708 } else
3709 ✗ if(M3D_CHUNKMAGIC(data, 'V','O','X','D')) {
3710 /* voxel data */
3711 ✗ data += sizeof(m3dchunk_t);
3712 ✗ M3D_GETSTR(name);
3713 M3D_LOG("Voxel Data Layer");
3714 M3D_LOG(name);
3715 ✗ if(model->vd_s > 4 || model->vp_s > 2) { M3D_LOG("No voxel index size"); model->errcode = M3D_ERR_UNKVOX; continue; }
3716 ✗ if(!model->voxtype) { M3D_LOG("No voxel type chunk before voxel data"); model->errcode = M3D_ERR_VOXT; }
3717 ✗ i = model->numvoxel++;
3718 ✗ model->voxel = (m3dvx_t*)M3D_REALLOC(model->voxel, model->numvoxel * sizeof(m3dvx_t));
3719 ✗ if(!model->voxel) goto memerr;
3720 ✗ memset(&model->voxel[i], 0, sizeof(m3dvx_t));
3721 ✗ model->voxel[i].name = name;
3722 ✗ switch(model->vd_s) {
3723 ✗ case 1:
3724 ✗ model->voxel[i].x = (int32_t)((int8_t)data[0]);
3725 ✗ model->voxel[i].y = (int32_t)((int8_t)data[1]);
3726 ✗ model->voxel[i].z = (int32_t)((int8_t)data[2]);
3727 ✗ model->voxel[i].w = (uint32_t)(data[3]);
3728 ✗ model->voxel[i].h = (uint32_t)(data[4]);
3729 ✗ model->voxel[i].d = (uint32_t)(data[5]);
3730 ✗ data += 6;
3731 ✗ break;
3732 ✗ case 2:
3733 ✗ model->voxel[i].x = (int32_t)(*((int16_t*)(data+0)));
3734 ✗ model->voxel[i].y = (int32_t)(*((int16_t*)(data+2)));
3735 ✗ model->voxel[i].z = (int32_t)(*((int16_t*)(data+4)));
3736 ✗ model->voxel[i].w = (uint32_t)(*((uint16_t*)(data+6)));
3737 ✗ model->voxel[i].h = (uint32_t)(*((uint16_t*)(data+8)));
3738 ✗ model->voxel[i].d = (uint32_t)(*((uint16_t*)(data+10)));
3739 ✗ data += 12;
3740 ✗ break;
3741 ✗ case 4:
3742 ✗ model->voxel[i].x = *((int32_t*)(data+0));
3743 ✗ model->voxel[i].y = *((int32_t*)(data+4));
3744 ✗ model->voxel[i].z = *((int32_t*)(data+8));
3745 ✗ model->voxel[i].w = *((uint32_t*)(data+12));
3746 ✗ model->voxel[i].h = *((uint32_t*)(data+16));
3747 ✗ model->voxel[i].d = *((uint32_t*)(data+20));
3748 ✗ data += 24;
3749 ✗ break;
3750 }
3751 ✗ model->voxel[i].uncertain = *data++;
3752 ✗ model->voxel[i].groupid = *data++;
3753 ✗ k = model->voxel[i].w * model->voxel[i].h * model->voxel[i].d;
3754 ✗ model->voxel[i].data = (M3D_VOXEL*)M3D_MALLOC(k * sizeof(M3D_VOXEL));
3755 ✗ if(!model->voxel[i].data) goto memerr;
3756 memset(model->voxel[i].data, 0xff, k * sizeof(M3D_VOXEL));
3757 ✗ for(j = 0; data < chunk && j < k;) {
3758 ✗ l = ((*data++) & 0x7F) + 1;
3759 ✗ if(data[-1] & 0x80) {
3760 ✗ data = _m3d_getidx(data, model->vp_s, &mi);
3761 ✗ while(l-- && j < k) model->voxel[i].data[j++] = (M3D_VOXEL)mi;
3762 } else
3763 ✗ while(l-- && j < k) {
3764 ✗ data = _m3d_getidx(data, model->vp_s, &mi);
3765 ✗ model->voxel[i].data[j++] = (M3D_VOXEL)mi;
3766 }
3767 }
3768 } else
3769 ✗ if(M3D_CHUNKMAGIC(data, 'S','H','P','E')) {
3770 /* mathematical shape */
3771 ✗ data += sizeof(m3dchunk_t);
3772 ✗ M3D_GETSTR(name);
3773 M3D_LOG("Mathematical Shape");
3774 M3D_LOG(name);
3775 ✗ i = model->numshape++;
3776 ✗ model->shape = (m3dh_t*)M3D_REALLOC(model->shape, model->numshape * sizeof(m3dh_t));
3777 ✗ if(!model->shape) goto memerr;
3778 ✗ h = &model->shape[i];
3779 ✗ h->numcmd = 0;
3780 ✗ h->cmd = NULL;
3781 ✗ h->name = name;
3782 ✗ h->group = M3D_UNDEF;
3783 ✗ data = _m3d_getidx(data, model->bi_s, &h->group);
3784 ✗ if(h->group != M3D_UNDEF && h->group >= model->numbone) {
3785 M3D_LOG("Unknown bone id as shape group in shape");
3786 M3D_LOG(name);
3787 ✗ h->group = M3D_UNDEF;
3788 ✗ model->errcode = M3D_ERR_SHPE;
3789 }
3790 ✗ while(data < chunk) {
3791 ✗ i = h->numcmd++;
3792 ✗ h->cmd = (m3dc_t*)M3D_REALLOC(h->cmd, h->numcmd * sizeof(m3dc_t));
3793 ✗ if(!h->cmd) goto memerr;
3794 ✗ h->cmd[i].type = *data++;
3795 ✗ if(h->cmd[i].type & 0x80) {
3796 ✗ h->cmd[i].type &= 0x7F;
3797 ✗ h->cmd[i].type |= (*data++ << 7);
3798 }
3799 ✗ if(h->cmd[i].type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0]))) {
3800 M3D_LOG("Unknown shape command in");
3801 M3D_LOG(h->name);
3802 ✗ model->errcode = M3D_ERR_UNKCMD;
3803 ✗ break;
3804 }
3805 ✗ cd = &m3d_commandtypes[h->cmd[i].type];
3806 ✗ h->cmd[i].arg = (uint32_t*)M3D_MALLOC(cd->p * sizeof(uint32_t));
3807 ✗ if(!h->cmd[i].arg) goto memerr;
3808 ✗ memset(h->cmd[i].arg, 0, cd->p * sizeof(uint32_t));
3809 ✗ for(k = n = 0, l = cd->p; k < l; k++)
3810 ✗ switch(cd->a[((k - n) % (cd->p - n)) + n]) {
3811 ✗ case m3dcp_mi_t:
3812 ✗ h->cmd[i].arg[k] = M3D_NOTDEFINED;
3813 ✗ M3D_GETSTR(name);
3814 if(name) {
3815 ✗ for(n = 0; n < model->nummaterial; n++)
3816 ✗ if(!strcmp(name, model->material[n].name)) {
3817 ✗ h->cmd[i].arg[k] = n;
3818 ✗ break;
3819 }
3820 ✗ if(h->cmd[i].arg[k] == M3D_NOTDEFINED) model->errcode = M3D_ERR_MTRL;
3821 }
3822 break;
3823 ✗ case m3dcp_vc_t:
3824 ✗ f = 0.0f;
3825 ✗ switch(model->vc_s) {
3826 ✗ case 1: f = (float)((int8_t)data[0]) / 127; break;
3827 ✗ case 2: f = (float)(*((int16_t*)(data+0))) / 32767; break;
3828 ✗ case 4: f = (float)(*((float*)(data+0))); break;
3829 ✗ case 8: f = (float)(*((double*)(data+0))); break;
3830 }
3831 ✗ memcpy(&h->cmd[i].arg[k], &f, 4);
3832 ✗ data += model->vc_s;
3833 ✗ break;
3834 ✗ case m3dcp_hi_t: data = _m3d_getidx(data, model->hi_s, &h->cmd[i].arg[k]); break;
3835 ✗ case m3dcp_fi_t: data = _m3d_getidx(data, model->fi_s, &h->cmd[i].arg[k]); break;
3836 ✗ case m3dcp_ti_t: data = _m3d_getidx(data, model->ti_s, &h->cmd[i].arg[k]); break;
3837 ✗ case m3dcp_qi_t:
3838 ✗ case m3dcp_vi_t: data = _m3d_getidx(data, model->vi_s, &h->cmd[i].arg[k]); break;
3839 ✗ case m3dcp_i1_t: data = _m3d_getidx(data, 1, &h->cmd[i].arg[k]); break;
3840 ✗ case m3dcp_i2_t: data = _m3d_getidx(data, 2, &h->cmd[i].arg[k]); break;
3841 ✗ case m3dcp_i4_t: data = _m3d_getidx(data, 4, &h->cmd[i].arg[k]); break;
3842 ✗ case m3dcp_va_t: data = _m3d_getidx(data, 4, &h->cmd[i].arg[k]);
3843 ✗ n = k + 1; l += (h->cmd[i].arg[k] - 1) * (cd->p - k - 1);
3844 ✗ h->cmd[i].arg = (uint32_t*)M3D_REALLOC(h->cmd[i].arg, l * sizeof(uint32_t));
3845 ✗ if(!h->cmd[i].arg) goto memerr;
3846 ✗ memset(&h->cmd[i].arg[k + 1], 0, (l - k - 1) * sizeof(uint32_t));
3847 break;
3848 }
3849 }
3850 } else
3851 /* annotation label list */
3852 ✗ if(M3D_CHUNKMAGIC(data, 'L','B','L','S')) {
3853 ✗ data += sizeof(m3dchunk_t);
3854 ✗ M3D_GETSTR(name);
3855 ✗ M3D_GETSTR(lang);
3856 M3D_LOG("Label list");
3857 if(name) { M3D_LOG(name); }
3858 if(lang) { M3D_LOG(lang); }
3859 ✗ if(model->ci_s && model->ci_s < 4 && !model->cmap) model->errcode = M3D_ERR_CMAP;
3860 k = 0;
3861 ✗ switch(model->ci_s) {
3862 ✗ case 1: k = model->cmap ? model->cmap[data[0]] : 0; data++; break;
3863 ✗ case 2: k = model->cmap ? model->cmap[*((uint16_t*)data)] : 0; data += 2; break;
3864 ✗ case 4: k = *((uint32_t*)data); data += 4; break;
3865 /* case 8: break; */
3866 }
3867 ✗ reclen = model->vi_s + model->si_s;
3868 ✗ i = model->numlabel; model->numlabel += len / reclen;
3869 ✗ model->label = (m3dl_t*)M3D_REALLOC(model->label, model->numlabel * sizeof(m3dl_t));
3870 ✗ if(!model->label) goto memerr;
3871 ✗ memset(&model->label[i], 0, (model->numlabel - i) * sizeof(m3dl_t));
3872 ✗ for(; data < chunk && i < model->numlabel; i++) {
3873 ✗ model->label[i].name = name;
3874 ✗ model->label[i].lang = lang;
3875 ✗ model->label[i].color = k;
3876 ✗ data = _m3d_getidx(data, model->vi_s, &model->label[i].vertexid);
3877 ✗ M3D_GETSTR(model->label[i].text);
3878 }
3879 } else
3880 /* action */
3881 ✗ if(M3D_CHUNKMAGIC(data, 'A','C','T','N')) {
3882 M3D_LOG("Action");
3883 ✗ i = model->numaction++;
3884 ✗ model->action = (m3da_t*)M3D_REALLOC(model->action, model->numaction * sizeof(m3da_t));
3885 ✗ if(!model->action) goto memerr;
3886 ✗ a = &model->action[i];
3887 ✗ data += sizeof(m3dchunk_t);
3888 ✗ M3D_GETSTR(a->name);
3889 M3D_LOG(a->name);
3890 ✗ a->numframe = *((uint16_t*)data); data += 2;
3891 ✗ if(a->numframe < 1) {
3892 ✗ model->numaction--;
3893 } else {
3894 ✗ a->durationmsec = *((uint32_t*)data); data += 4;
3895 ✗ a->frame = (m3dfr_t*)M3D_MALLOC(a->numframe * sizeof(m3dfr_t));
3896 ✗ if(!a->frame) goto memerr;
3897 ✗ for(i = 0; data < chunk && i < a->numframe; i++) {
3898 ✗ a->frame[i].msec = *((uint32_t*)data); data += 4;
3899 ✗ a->frame[i].numtransform = 0; a->frame[i].transform = NULL;
3900 ✗ data = _m3d_getidx(data, model->fc_s, &a->frame[i].numtransform);
3901 ✗ if(a->frame[i].numtransform > 0) {
3902 ✗ a->frame[i].transform = (m3dtr_t*)M3D_MALLOC(a->frame[i].numtransform * sizeof(m3dtr_t));
3903 ✗ for(j = 0; j < a->frame[i].numtransform; j++) {
3904 ✗ data = _m3d_getidx(data, model->bi_s, &a->frame[i].transform[j].boneid);
3905 ✗ data = _m3d_getidx(data, model->vi_s, &a->frame[i].transform[j].pos);
3906 ✗ data = _m3d_getidx(data, model->vi_s, &a->frame[i].transform[j].ori);
3907 }
3908 }
3909 }
3910 }
3911 } else {
3912 ✗ i = model->numextra++;
3913 ✗ model->extra = (m3dchunk_t**)M3D_REALLOC(model->extra, model->numextra * sizeof(m3dchunk_t*));
3914 ✗ if(!model->extra) goto memerr;
3915 ✗ model->extra[i] = (m3dchunk_t*)data;
3916 }
3917 }
3918 /* calculate normals, normalize skin weights, create bone/vertex cross-references and calculate transform matrices */
3919 #ifdef M3D_ASCII
3920 postprocess:
3921 #endif
3922 if(model) {
3923 M3D_LOG("Post-process");
3924 #ifdef M3D_PROFILING
3925 gettimeofday(&tv1, NULL);
3926 tvd.tv_sec = tv1.tv_sec - tv0.tv_sec;
3927 tvd.tv_usec = tv1.tv_usec - tv0.tv_usec;
3928 if(tvd.tv_usec < 0) { tvd.tv_sec--; tvd.tv_usec += 1000000L; }
3929 printf(" Parsing chunks %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
3930 #endif
3931 #ifndef M3D_NOVOXELS
3932 ✗ if(model->numvoxel && model->voxel) {
3933 M3D_LOG("Converting voxels into vertices and mesh");
3934 /* add normals */
3935 ✗ enorm = model->numvertex; model->numvertex += 6;
3936 ✗ model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
3937 ✗ if(!model->vertex) goto memerr;
3938 ✗ memset(&model->vertex[enorm], 0, 6 * sizeof(m3dv_t));
3939 ✗ for(l = 0; l < 6; l++)
3940 ✗ model->vertex[enorm+l].skinid = M3D_UNDEF;
3941 ✗ model->vertex[enorm+0].y = (M3D_FLOAT)-1.0;
3942 ✗ model->vertex[enorm+1].z = (M3D_FLOAT)-1.0;
3943 ✗ model->vertex[enorm+2].x = (M3D_FLOAT)-1.0;
3944 ✗ model->vertex[enorm+3].y = (M3D_FLOAT)1.0;
3945 ✗ model->vertex[enorm+4].z = (M3D_FLOAT)1.0;
3946 ✗ model->vertex[enorm+5].x = (M3D_FLOAT)1.0;
3947 /* this is a fast, not so memory efficient version, only basic face culling used */
3948 min_x = min_y = min_z = 2147483647L;
3949 max_x = max_y = max_z = -2147483647L;
3950 ✗ for(i = 0; i < model->numvoxel; i++) {
3951 ✗ if(model->voxel[i].x + (int32_t)model->voxel[i].w > max_x) max_x = model->voxel[i].x + (int32_t)model->voxel[i].w;
3952 if(model->voxel[i].x < min_x) min_x = model->voxel[i].x;
3953 ✗ if(model->voxel[i].y + (int32_t)model->voxel[i].h > max_y) max_y = model->voxel[i].y + (int32_t)model->voxel[i].h;
3954 if(model->voxel[i].y < min_y) min_y = model->voxel[i].y;
3955 ✗ if(model->voxel[i].z + (int32_t)model->voxel[i].d > max_z) max_z = model->voxel[i].z + (int32_t)model->voxel[i].d;
3956 if(model->voxel[i].z < min_z) min_z = model->voxel[i].z;
3957 }
3958 ✗ i = (-min_x > max_x ? -min_x : max_x);
3959 ✗ j = (-min_y > max_y ? -min_y : max_y);
3960 ✗ k = (-min_z > max_z ? -min_z : max_z);
3961 if(j > i) i = j;
3962 if(k > i) i = k;
3963 if(i <= 1) i = 1;
3964 ✗ w = (M3D_FLOAT)1.0 / (M3D_FLOAT)i;
3965 ✗ if(i >= 254) model->vc_s = 2;
3966 ✗ if(i >= 65534) model->vc_s = 4;
3967 ✗ for(i = 0; i < model->numvoxel; i++) {
3968 ✗ sx = model->voxel[i].w; sz = model->voxel[i].d; sy = model->voxel[i].h;
3969 ✗ for(y = 0, j = 0; y < sy; y++)
3970 ✗ for(z = 0; z < sz; z++)
3971 ✗ for(x = 0; x < sx; x++, j++)
3972 ✗ if(model->voxel[i].data[j] < model->numvoxtype) {
3973 k = 0;
3974 /* 16__32 ____
3975 * /| /| /|2 /|
3976 *64_128 | /_8_/ 32
3977 * | 1_|_2 |4|_|_|
3978 * |/ |/ |/ 1|/
3979 * 4___8 |16_| */
3980 k = n = am = 0;
3981 ✗ if(!y || model->voxel[i].data[j - sx*sz] >= model->numvoxtype) { n++; am |= 1; k |= 1|2|4|8; }
3982 ✗ if(!z || model->voxel[i].data[j - sx] >= model->numvoxtype) { n++; am |= 2; k |= 1|2|16|32; }
3983 ✗ if(!x || model->voxel[i].data[j - 1] >= model->numvoxtype) { n++; am |= 4; k |= 1|4|16|64; }
3984 ✗ if(y == sy-1 || model->voxel[i].data[j + sx*sz] >= model->numvoxtype) { n++; am |= 8; k |= 16|32|64|128; }
3985 ✗ if(z == sz-1 || model->voxel[i].data[j + sx] >= model->numvoxtype) { n++; am |= 16; k |= 4|8|64|128; }
3986 ✗ if(x == sx-1 || model->voxel[i].data[j + 1] >= model->numvoxtype) { n++; am |= 32; k |= 2|8|32|128; }
3987 ✗ if(k) {
3988 memset(edge, 255, sizeof(edge));
3989 ✗ for(l = 0, len = 1, reclen = model->numvertex; l < 8; l++, len <<= 1)
3990 ✗ if(k & len) edge[l] = model->numvertex++;
3991 ✗ model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
3992 ✗ if(!model->vertex) goto memerr;
3993 ✗ memset(&model->vertex[reclen], 0, (model->numvertex-reclen) * sizeof(m3dv_t));
3994 ✗ for(l = reclen; l < model->numvertex; l++) {
3995 ✗ model->vertex[l].skinid = model->voxtype[model->voxel[i].data[j]].skinid;
3996 ✗ model->vertex[l].color = model->voxtype[model->voxel[i].data[j]].color;
3997 }
3998 l = reclen;
3999 ✗ if(k & 1) {
4000 ✗ model->vertex[l].x = (model->voxel[i].x + x) * w;
4001 ✗ model->vertex[l].y = (model->voxel[i].y + y) * w;
4002 ✗ model->vertex[l].z = (model->voxel[i].z + z) * w;
4003 ✗ l++;
4004 }
4005 ✗ if(k & 2) {
4006 ✗ model->vertex[l].x = (model->voxel[i].x + x + 1) * w;
4007 ✗ model->vertex[l].y = (model->voxel[i].y + y) * w;
4008 ✗ model->vertex[l].z = (model->voxel[i].z + z) * w;
4009 ✗ l++;
4010 }
4011 ✗ if(k & 4) {
4012 ✗ model->vertex[l].x = (model->voxel[i].x + x) * w;
4013 ✗ model->vertex[l].y = (model->voxel[i].y + y) * w;
4014 ✗ model->vertex[l].z = (model->voxel[i].z + z + 1) * w;
4015 ✗ l++;
4016 }
4017 ✗ if(k & 8) {
4018 ✗ model->vertex[l].x = (model->voxel[i].x + x + 1) * w;
4019 ✗ model->vertex[l].y = (model->voxel[i].y + y) * w;
4020 ✗ model->vertex[l].z = (model->voxel[i].z + z + 1) * w;
4021 ✗ l++;
4022 }
4023 ✗ if(k & 16) {
4024 ✗ model->vertex[l].x = (model->voxel[i].x + x) * w;
4025 ✗ model->vertex[l].y = (model->voxel[i].y + y + 1) * w;
4026 ✗ model->vertex[l].z = (model->voxel[i].z + z) * w;
4027 ✗ l++;
4028 }
4029 ✗ if(k & 32) {
4030 ✗ model->vertex[l].x = (model->voxel[i].x + x + 1) * w;
4031 ✗ model->vertex[l].y = (model->voxel[i].y + y + 1) * w;
4032 ✗ model->vertex[l].z = (model->voxel[i].z + z) * w;
4033 ✗ l++;
4034 }
4035 ✗ if(k & 64) {
4036 ✗ model->vertex[l].x = (model->voxel[i].x + x) * w;
4037 ✗ model->vertex[l].y = (model->voxel[i].y + y + 1) * w;
4038 ✗ model->vertex[l].z = (model->voxel[i].z + z + 1) * w;
4039 ✗ l++;
4040 }
4041 ✗ if(k & 128) {
4042 ✗ model->vertex[l].x = (model->voxel[i].x + x + 1) * w;
4043 ✗ model->vertex[l].y = (model->voxel[i].y + y + 1) * w;
4044 ✗ model->vertex[l].z = (model->voxel[i].z + z + 1) * w;
4045 l++;
4046 }
4047 ✗ n <<= 1;
4048 ✗ l = model->numface; model->numface += n;
4049 ✗ model->face = (m3df_t*)M3D_REALLOC(model->face, model->numface * sizeof(m3df_t));
4050 ✗ if(!model->face) goto memerr;
4051 ✗ memset(&model->face[l], 255, n * sizeof(m3df_t));
4052 ✗ for(reclen = l; reclen < model->numface; reclen++)
4053 ✗ model->face[reclen].materialid = model->voxtype[model->voxel[i].data[j]].materialid;
4054 ✗ if(am & 1) { /* bottom */
4055 ✗ model->face[l].vertex[0] = edge[0]; model->face[l].vertex[1] = edge[1]; model->face[l].vertex[2] = edge[2];
4056 ✗ model->face[l+1].vertex[0] = edge[2]; model->face[l+1].vertex[1] = edge[1]; model->face[l+1].vertex[2] = edge[3];
4057 ✗ model->face[l].normal[0] = model->face[l].normal[1] = model->face[l].normal[2] =
4058 ✗ model->face[l+1].normal[0] = model->face[l+1].normal[1] = model->face[l+1].normal[2] = enorm;
4059 ✗ l += 2;
4060 }
4061 ✗ if(am & 2) { /* north */
4062 ✗ model->face[l].vertex[0] = edge[0]; model->face[l].vertex[1] = edge[4]; model->face[l].vertex[2] = edge[1];
4063 ✗ model->face[l+1].vertex[0] = edge[1]; model->face[l+1].vertex[1] = edge[4]; model->face[l+1].vertex[2] = edge[5];
4064 ✗ model->face[l].normal[0] = model->face[l].normal[1] = model->face[l].normal[2] =
4065 ✗ model->face[l+1].normal[0] = model->face[l+1].normal[1] = model->face[l+1].normal[2] = enorm+1;
4066 ✗ l += 2;
4067 }
4068 ✗ if(am & 4) { /* west */
4069 ✗ model->face[l].vertex[0] = edge[0]; model->face[l].vertex[1] = edge[2]; model->face[l].vertex[2] = edge[4];
4070 ✗ model->face[l+1].vertex[0] = edge[2]; model->face[l+1].vertex[1] = edge[6]; model->face[l+1].vertex[2] = edge[4];
4071 ✗ model->face[l].normal[0] = model->face[l].normal[1] = model->face[l].normal[2] =
4072 ✗ model->face[l+1].normal[0] = model->face[l+1].normal[1] = model->face[l+1].normal[2] = enorm+2;
4073 ✗ l += 2;
4074 }
4075 ✗ if(am & 8) { /* top */
4076 ✗ model->face[l].vertex[0] = edge[4]; model->face[l].vertex[1] = edge[6]; model->face[l].vertex[2] = edge[5];
4077 ✗ model->face[l+1].vertex[0] = edge[5]; model->face[l+1].vertex[1] = edge[6]; model->face[l+1].vertex[2] = edge[7];
4078 ✗ model->face[l].normal[0] = model->face[l].normal[1] = model->face[l].normal[2] =
4079 ✗ model->face[l+1].normal[0] = model->face[l+1].normal[1] = model->face[l+1].normal[2] = enorm+3;
4080 ✗ l += 2;
4081 }
4082 ✗ if(am & 16) { /* south */
4083 ✗ model->face[l].vertex[0] = edge[2]; model->face[l].vertex[1] = edge[7]; model->face[l].vertex[2] = edge[6];
4084 ✗ model->face[l+1].vertex[0] = edge[7]; model->face[l+1].vertex[1] = edge[2]; model->face[l+1].vertex[2] = edge[3];
4085 ✗ model->face[l].normal[0] = model->face[l].normal[1] = model->face[l].normal[2] =
4086 ✗ model->face[l+1].normal[0] = model->face[l+1].normal[1] = model->face[l+1].normal[2] = enorm+4;
4087 ✗ l += 2;
4088 }
4089 ✗ if(am & 32) { /* east */
4090 ✗ model->face[l].vertex[0] = edge[1]; model->face[l].vertex[1] = edge[5]; model->face[l].vertex[2] = edge[7];
4091 ✗ model->face[l+1].vertex[0] = edge[1]; model->face[l+1].vertex[1] = edge[7]; model->face[l+1].vertex[2] = edge[3];
4092 ✗ model->face[l].normal[0] = model->face[l].normal[1] = model->face[l].normal[2] =
4093 ✗ model->face[l+1].normal[0] = model->face[l+1].normal[1] = model->face[l+1].normal[2] = enorm+5;
4094 l += 2;
4095 }
4096 }
4097 }
4098 }
4099 }
4100 #endif
4101 #ifndef M3D_NONORMALS
4102 ✗ if(model->numface && model->face && neednorm) {
4103 /* if they are missing, calculate triangle normals into a temporary buffer */
4104 ✗ norm = (m3dv_t*)M3D_MALLOC(model->numface * sizeof(m3dv_t));
4105 ✗ if(!norm) goto memerr;
4106 ✗ for(i = 0, n = model->numvertex; i < model->numface; i++)
4107 ✗ if(model->face[i].normal[0] == M3D_UNDEF) {
4108 ✗ v0 = &model->vertex[model->face[i].vertex[0]];
4109 ✗ v1 = &model->vertex[model->face[i].vertex[1]];
4110 ✗ v2 = &model->vertex[model->face[i].vertex[2]];
4111 ✗ va.x = v1->x - v0->x; va.y = v1->y - v0->y; va.z = v1->z - v0->z;
4112 ✗ vb.x = v2->x - v0->x; vb.y = v2->y - v0->y; vb.z = v2->z - v0->z;
4113 ✗ v0 = &norm[i];
4114 ✗ v0->x = (va.y * vb.z) - (va.z * vb.y);
4115 ✗ v0->y = (va.z * vb.x) - (va.x * vb.z);
4116 ✗ v0->z = (va.x * vb.y) - (va.y * vb.x);
4117 ✗ w = _m3d_rsq((v0->x * v0->x) + (v0->y * v0->y) + (v0->z * v0->z));
4118 ✗ v0->x *= w; v0->y *= w; v0->z *= w;
4119 ✗ model->face[i].normal[0] = model->face[i].vertex[0] + n;
4120 ✗ model->face[i].normal[1] = model->face[i].vertex[1] + n;
4121 ✗ model->face[i].normal[2] = model->face[i].vertex[2] + n;
4122 }
4123 /* this is the fast way, we don't care if a normal is repeated in model->vertex */
4124 M3D_LOG("Generating normals");
4125 ✗ model->flags |= M3D_FLG_GENNORM;
4126 ✗ model->numvertex <<= 1;
4127 ✗ model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, model->numvertex * sizeof(m3dv_t));
4128 ✗ if(!model->vertex) goto memerr;
4129 ✗ memset(&model->vertex[n], 0, n * sizeof(m3dv_t));
4130 ✗ for(i = 0; i < model->numface; i++)
4131 ✗ for(j = 0; j < 3; j++) {
4132 ✗ v0 = &model->vertex[model->face[i].vertex[j] + n];
4133 ✗ v0->x += norm[i].x;
4134 ✗ v0->y += norm[i].y;
4135 ✗ v0->z += norm[i].z;
4136 }
4137 /* for each vertex, take the average of the temporary normals and use that */
4138 ✗ for(i = 0, v0 = &model->vertex[n]; i < n; i++, v0++) {
4139 ✗ w = _m3d_rsq((v0->x * v0->x) + (v0->y * v0->y) + (v0->z * v0->z));
4140 ✗ v0->x *= w; v0->y *= w; v0->z *= w;
4141 ✗ v0->skinid = M3D_UNDEF;
4142 }
4143 ✗ M3D_FREE(norm);
4144 }
4145 #endif
4146 ✗ if(model->numbone && model->bone && model->numskin && model->skin && model->numvertex && model->vertex) {
4147 #ifndef M3D_NOWEIGHTS
4148 M3D_LOG("Generating weight cross-reference");
4149 ✗ for(i = 0; i < model->numvertex; i++) {
4150 ✗ if(model->vertex[i].skinid < model->numskin) {
4151 ✗ sk = &model->skin[model->vertex[i].skinid];
4152 w = (M3D_FLOAT)0.0;
4153 ✗ for(j = 0; j < M3D_NUMBONE && sk->boneid[j] != M3D_UNDEF && sk->weight[j] > (M3D_FLOAT)0.0; j++)
4154 ✗ w += sk->weight[j];
4155 ✗ for(j = 0; j < M3D_NUMBONE && sk->boneid[j] != M3D_UNDEF && sk->weight[j] > (M3D_FLOAT)0.0; j++) {
4156 ✗ sk->weight[j] /= w;
4157 ✗ b = &model->bone[sk->boneid[j]];
4158 ✗ k = b->numweight++;
4159 ✗ b->weight = (m3dw_t*)M3D_REALLOC(b->weight, b->numweight * sizeof(m3da_t));
4160 ✗ if(!b->weight) goto memerr;
4161 ✗ b->weight[k].vertexid = i;
4162 ✗ b->weight[k].weight = sk->weight[j];
4163 }
4164 }
4165 }
4166 #endif
4167 #ifndef M3D_NOANIMATION
4168 M3D_LOG("Calculating bone transformation matrices");
4169 ✗ for(i = 0; i < model->numbone; i++) {
4170 ✗ b = &model->bone[i];
4171 ✗ if(model->bone[i].parent == M3D_UNDEF) {
4172 ✗ _m3d_mat((M3D_FLOAT*)&b->mat4, &model->vertex[b->pos], &model->vertex[b->ori]);
4173 } else {
4174 ✗ _m3d_mat((M3D_FLOAT*)&r, &model->vertex[b->pos], &model->vertex[b->ori]);
4175 ✗ _m3d_mul((M3D_FLOAT*)&b->mat4, (M3D_FLOAT*)&model->bone[b->parent].mat4, (M3D_FLOAT*)&r);
4176 }
4177 }
4178 ✗ for(i = 0; i < model->numbone; i++)
4179 ✗ _m3d_inv((M3D_FLOAT*)&model->bone[i].mat4);
4180 #endif
4181 }
4182 #ifdef M3D_PROFILING
4183 gettimeofday(&tv0, NULL);
4184 tvd.tv_sec = tv0.tv_sec - tv1.tv_sec;
4185 tvd.tv_usec = tv0.tv_usec - tv1.tv_usec;
4186 if(tvd.tv_usec < 0) { tvd.tv_sec--; tvd.tv_usec += 1000000L; }
4187 printf(" Post-process %ld.%06ld sec\n", tvd.tv_sec, tvd.tv_usec);
4188 #endif
4189 }
4190 return model;
4191 }
4192
4193 /**
4194 * Calculates skeletons for animation frames, returns a working copy (should be freed after use)
4195 */
4196 ✗ m3dtr_t *m3d_frame(m3d_t *model, M3D_INDEX actionid, M3D_INDEX frameid, m3dtr_t *skeleton)
4197 {
4198 unsigned int i;
4199 M3D_INDEX s = frameid;
4200 m3dfr_t *fr;
4201
4202 ✗ if(!model || !model->numbone || !model->bone || (actionid != M3D_UNDEF && (!model->action ||
4203 ✗ actionid >= model->numaction || frameid >= model->action[actionid].numframe))) {
4204 ✗ model->errcode = M3D_ERR_UNKFRAME;
4205 ✗ return skeleton;
4206 }
4207 ✗ model->errcode = M3D_SUCCESS;
4208 ✗ if(!skeleton) {
4209 ✗ skeleton = (m3dtr_t*)M3D_MALLOC(model->numbone * sizeof(m3dtr_t));
4210 ✗ if(!skeleton) {
4211 ✗ model->errcode = M3D_ERR_ALLOC;
4212 ✗ return NULL;
4213 }
4214 ✗ goto gen;
4215 }
4216 ✗ if(actionid == M3D_UNDEF || !frameid) {
4217 ✗ gen: s = 0;
4218 ✗ for(i = 0; i < model->numbone; i++) {
4219 ✗ skeleton[i].boneid = i;
4220 ✗ skeleton[i].pos = model->bone[i].pos;
4221 ✗ skeleton[i].ori = model->bone[i].ori;
4222 }
4223 }
4224 ✗ if(actionid < model->numaction && (frameid || !model->action[actionid].frame[0].msec)) {
4225 ✗ for(; s <= frameid; s++) {
4226 ✗ fr = &model->action[actionid].frame[s];
4227 ✗ for(i = 0; i < fr->numtransform; i++) {
4228 ✗ skeleton[fr->transform[i].boneid].pos = fr->transform[i].pos;
4229 ✗ skeleton[fr->transform[i].boneid].ori = fr->transform[i].ori;
4230 }
4231 }
4232 }
4233 return skeleton;
4234 }
4235
4236 #ifndef M3D_NOANIMATION
4237 /**
4238 * Returns interpolated animation-pose, a working copy (should be freed after use)
4239 */
4240 ✗ m3db_t *m3d_pose(m3d_t *model, M3D_INDEX actionid, uint32_t msec)
4241 {
4242 unsigned int i, j, l;
4243 M3D_FLOAT r[16], t, c, d, s;
4244 m3db_t *ret;
4245 m3dv_t *v, *p, *f;
4246 m3dtr_t *tmp;
4247 m3dfr_t *fr;
4248
4249 ✗ if(!model || !model->numbone || !model->bone) {
4250 ✗ model->errcode = M3D_ERR_UNKFRAME;
4251 ✗ return NULL;
4252 }
4253 ✗ ret = (m3db_t*)M3D_MALLOC(model->numbone * sizeof(m3db_t));
4254 ✗ if(!ret) {
4255 ✗ model->errcode = M3D_ERR_ALLOC;
4256 ✗ return NULL;
4257 }
4258 memcpy(ret, model->bone, model->numbone * sizeof(m3db_t));
4259 ✗ for(i = 0; i < model->numbone; i++)
4260 ✗ _m3d_inv((M3D_FLOAT*)&ret[i].mat4);
4261 ✗ if(!model->action || actionid >= model->numaction) {
4262 ✗ model->errcode = M3D_ERR_UNKFRAME;
4263 ✗ return ret;
4264 }
4265 ✗ msec %= model->action[actionid].durationmsec;
4266 ✗ model->errcode = M3D_SUCCESS;
4267 fr = &model->action[actionid].frame[0];
4268 ✗ for(j = l = 0; j < model->action[actionid].numframe && model->action[actionid].frame[j].msec <= msec; j++) {
4269 fr = &model->action[actionid].frame[j];
4270 l = fr->msec;
4271 ✗ for(i = 0; i < fr->numtransform; i++) {
4272 ✗ ret[fr->transform[i].boneid].pos = fr->transform[i].pos;
4273 ✗ ret[fr->transform[i].boneid].ori = fr->transform[i].ori;
4274 }
4275 }
4276 ✗ if(l != msec) {
4277 ✗ model->vertex = (m3dv_t*)M3D_REALLOC(model->vertex, (model->numvertex + 2 * model->numbone) * sizeof(m3dv_t));
4278 ✗ if(!model->vertex) {
4279 ✗ free(ret);
4280 ✗ model->errcode = M3D_ERR_ALLOC;
4281 ✗ return NULL;
4282 }
4283 ✗ tmp = (m3dtr_t*)M3D_MALLOC(model->numbone * sizeof(m3dtr_t));
4284 ✗ if(tmp) {
4285 ✗ for(i = 0; i < model->numbone; i++) {
4286 ✗ tmp[i].pos = ret[i].pos;
4287 ✗ tmp[i].ori = ret[i].ori;
4288 }
4289 ✗ fr = &model->action[actionid].frame[j % model->action[actionid].numframe];
4290 ✗ t = l >= fr->msec ? (M3D_FLOAT)1.0 : (M3D_FLOAT)(msec - l) / (M3D_FLOAT)(fr->msec - l);
4291 ✗ for(i = 0; i < fr->numtransform; i++) {
4292 ✗ tmp[fr->transform[i].boneid].pos = fr->transform[i].pos;
4293 ✗ tmp[fr->transform[i].boneid].ori = fr->transform[i].ori;
4294 }
4295 ✗ for(i = 0, j = model->numvertex; i < model->numbone; i++) {
4296 /* interpolation of position */
4297 ✗ if(ret[i].pos != tmp[i].pos) {
4298 ✗ p = &model->vertex[ret[i].pos];
4299 ✗ f = &model->vertex[tmp[i].pos];
4300 ✗ v = &model->vertex[j];
4301 ✗ v->x = p->x + t * (f->x - p->x);
4302 ✗ v->y = p->y + t * (f->y - p->y);
4303 ✗ v->z = p->z + t * (f->z - p->z);
4304 ✗ ret[i].pos = j++;
4305 }
4306 /* interpolation of orientation */
4307 ✗ if(ret[i].ori != tmp[i].ori) {
4308 ✗ p = &model->vertex[ret[i].ori];
4309 ✗ f = &model->vertex[tmp[i].ori];
4310 ✗ v = &model->vertex[j];
4311 ✗ d = p->w * f->w + p->x * f->x + p->y * f->y + p->z * f->z;
4312 ✗ if(d < 0) { d = -d; s = (M3D_FLOAT)-1.0; } else s = (M3D_FLOAT)1.0;
4313 #if 0
4314 /* don't use SLERP, requires two more variables, libm linkage and it is slow (but nice) */
4315 a = (M3D_FLOAT)1.0 - t; b = t;
4316 if(d < (M3D_FLOAT)0.999999) { c = acosf(d); b = 1 / sinf(c); a = sinf(a * c) * b; b *= sinf(t * c) * s; }
4317 v->x = p->x * a + f->x * b;
4318 v->y = p->y * a + f->y * b;
4319 v->z = p->z * a + f->z * b;
4320 v->w = p->w * a + f->w * b;
4321 #else
4322 /* approximated NLERP, original approximation by Arseny Kapoulkine, heavily optimized by me */
4323 ✗ c = t - (M3D_FLOAT)0.5; t += t * c * (t - (M3D_FLOAT)1.0) * (((M3D_FLOAT)1.0904 + d * ((M3D_FLOAT)-3.2452 +
4324 ✗ d * ((M3D_FLOAT)3.55645 - d * (M3D_FLOAT)1.43519))) * c * c + ((M3D_FLOAT)0.848013 + d *
4325 ✗ ((M3D_FLOAT)-1.06021 + d * (M3D_FLOAT)0.215638)));
4326 ✗ v->x = p->x + t * (s * f->x - p->x);
4327 ✗ v->y = p->y + t * (s * f->y - p->y);
4328 ✗ v->z = p->z + t * (s * f->z - p->z);
4329 ✗ v->w = p->w + t * (s * f->w - p->w);
4330 ✗ d = _m3d_rsq(v->w * v->w + v->x * v->x + v->y * v->y + v->z * v->z);
4331 ✗ v->x *= d; v->y *= d; v->z *= d; v->w *= d;
4332 #endif
4333 ✗ ret[i].ori = j++;
4334 }
4335 }
4336 ✗ M3D_FREE(tmp);
4337 }
4338 }
4339 ✗ for(i = 0; i < model->numbone; i++) {
4340 ✗ if(ret[i].parent == M3D_UNDEF) {
4341 ✗ _m3d_mat((M3D_FLOAT*)&ret[i].mat4, &model->vertex[ret[i].pos], &model->vertex[ret[i].ori]);
4342 } else {
4343 ✗ _m3d_mat((M3D_FLOAT*)&r, &model->vertex[ret[i].pos], &model->vertex[ret[i].ori]);
4344 ✗ _m3d_mul((M3D_FLOAT*)&ret[i].mat4, (M3D_FLOAT*)&ret[ret[i].parent].mat4, (M3D_FLOAT*)&r);
4345 }
4346 }
4347 return ret;
4348 }
4349
4350 #endif /* M3D_NOANIMATION */
4351
4352 #endif /* M3D_IMPLEMENTATION */
4353
4354 #if !defined(M3D_NODUP) && (!defined(M3D_NOIMPORTER) || defined(M3D_EXPORTER))
4355 /**
4356 * Free the in-memory model
4357 */
4358 ✗ void m3d_free(m3d_t *model)
4359 {
4360 unsigned int i, j;
4361
4362 ✗ if(!model) return;
4363 #ifdef M3D_ASCII
4364 /* if model imported from ASCII, we have to free all strings as well */
4365 if(model->flags & M3D_FLG_FREESTR) {
4366 if(model->name) M3D_FREE(model->name);
4367 if(model->license) M3D_FREE(model->license);
4368 if(model->author) M3D_FREE(model->author);
4369 if(model->desc) M3D_FREE(model->desc);
4370 if(model->bone)
4371 for(i = 0; i < model->numbone; i++)
4372 if(model->bone[i].name)
4373 M3D_FREE(model->bone[i].name);
4374 if(model->shape)
4375 for(i = 0; i < model->numshape; i++)
4376 if(model->shape[i].name)
4377 M3D_FREE(model->shape[i].name);
4378 if(model->numvoxtype)
4379 for(i = 0; i < model->numvoxtype; i++) {
4380 if(model->voxtype[i].name)
4381 M3D_FREE(model->voxtype[i].name);
4382 for(j = 0; j < model->voxtype[i].numitem; j++)
4383 if(model->voxtype[i].item[j].name)
4384 M3D_FREE(model->voxtype[i].item[j].name);
4385 }
4386 if(model->numvoxel)
4387 for(i = 0; i < model->numvoxel; i++)
4388 if(model->voxel[i].name)
4389 M3D_FREE(model->voxel[i].name);
4390 if(model->material)
4391 for(i = 0; i < model->nummaterial; i++)
4392 if(model->material[i].name)
4393 M3D_FREE(model->material[i].name);
4394 if(model->action)
4395 for(i = 0; i < model->numaction; i++)
4396 if(model->action[i].name)
4397 M3D_FREE(model->action[i].name);
4398 if(model->texture)
4399 for(i = 0; i < model->numtexture; i++)
4400 if(model->texture[i].name)
4401 M3D_FREE(model->texture[i].name);
4402 if(model->inlined)
4403 for(i = 0; i < model->numinlined; i++) {
4404 if(model->inlined[i].name)
4405 M3D_FREE(model->inlined[i].name);
4406 if(model->inlined[i].data)
4407 M3D_FREE(model->inlined[i].data);
4408 }
4409 if(model->extra)
4410 for(i = 0; i < model->numextra; i++)
4411 if(model->extra[i])
4412 M3D_FREE(model->extra[i]);
4413 if(model->label)
4414 for(i = 0; i < model->numlabel; i++) {
4415 if(model->label[i].name) {
4416 for(j = i + 1; j < model->numlabel; j++)
4417 if(model->label[j].name == model->label[i].name)
4418 model->label[j].name = NULL;
4419 M3D_FREE(model->label[i].name);
4420 }
4421 if(model->label[i].lang) {
4422 for(j = i + 1; j < model->numlabel; j++)
4423 if(model->label[j].lang == model->label[i].lang)
4424 model->label[j].lang = NULL;
4425 M3D_FREE(model->label[i].lang);
4426 }
4427 if(model->label[i].text)
4428 M3D_FREE(model->label[i].text);
4429 }
4430 if(model->preview.data)
4431 M3D_FREE(model->preview.data);
4432 }
4433 #endif
4434 ✗ if(model->flags & M3D_FLG_FREERAW) M3D_FREE(model->raw);
4435
4436 ✗ if(model->tmap) M3D_FREE(model->tmap);
4437 ✗ if(model->bone) {
4438 ✗ for(i = 0; i < model->numbone; i++)
4439 ✗ if(model->bone[i].weight)
4440 ✗ M3D_FREE(model->bone[i].weight);
4441 ✗ M3D_FREE(model->bone);
4442 }
4443 ✗ if(model->skin) M3D_FREE(model->skin);
4444 ✗ if(model->vertex) M3D_FREE(model->vertex);
4445 ✗ if(model->face) M3D_FREE(model->face);
4446 ✗ if(model->voxtype) {
4447 ✗ for(i = 0; i < model->numvoxtype; i++)
4448 ✗ if(model->voxtype[i].item)
4449 ✗ M3D_FREE(model->voxtype[i].item);
4450 ✗ M3D_FREE(model->voxtype);
4451 }
4452 ✗ if(model->voxel) {
4453 ✗ for(i = 0; i < model->numvoxel; i++)
4454 ✗ if(model->voxel[i].data)
4455 ✗ M3D_FREE(model->voxel[i].data);
4456 ✗ M3D_FREE(model->voxel);
4457 }
4458 ✗ if(model->shape) {
4459 ✗ for(i = 0; i < model->numshape; i++) {
4460 ✗ if(model->shape[i].cmd) {
4461 ✗ for(j = 0; j < model->shape[i].numcmd; j++)
4462 ✗ if(model->shape[i].cmd[j].arg) M3D_FREE(model->shape[i].cmd[j].arg);
4463 ✗ M3D_FREE(model->shape[i].cmd);
4464 }
4465 }
4466 ✗ M3D_FREE(model->shape);
4467 }
4468 ✗ if(model->material && !(model->flags & M3D_FLG_MTLLIB)) {
4469 ✗ for(i = 0; i < model->nummaterial; i++)
4470 ✗ if(model->material[i].prop) M3D_FREE(model->material[i].prop);
4471 ✗ M3D_FREE(model->material);
4472 }
4473 ✗ if(model->texture) {
4474 ✗ for(i = 0; i < model->numtexture; i++)
4475 ✗ if(model->texture[i].d) M3D_FREE(model->texture[i].d);
4476 ✗ M3D_FREE(model->texture);
4477 }
4478 ✗ if(model->action) {
4479 ✗ for(i = 0; i < model->numaction; i++) {
4480 ✗ if(model->action[i].frame) {
4481 ✗ for(j = 0; j < model->action[i].numframe; j++)
4482 ✗ if(model->action[i].frame[j].transform) M3D_FREE(model->action[i].frame[j].transform);
4483 ✗ M3D_FREE(model->action[i].frame);
4484 }
4485 }
4486 ✗ M3D_FREE(model->action);
4487 }
4488 ✗ if(model->label) M3D_FREE(model->label);
4489 ✗ if(model->inlined) M3D_FREE(model->inlined);
4490 ✗ if(model->extra) M3D_FREE(model->extra);
4491 ✗ free(model);
4492 }
4493 #endif
4494
4495 #ifdef M3D_EXPORTER
4496 typedef struct {
4497 char *str;
4498 uint32_t offs;
4499 } m3dstr_t;
4500
4501 typedef struct {
4502 m3dti_t data;
4503 M3D_INDEX oldidx;
4504 M3D_INDEX newidx;
4505 } m3dtisave_t;
4506
4507 typedef struct {
4508 m3dv_t data;
4509 M3D_INDEX oldidx;
4510 M3D_INDEX newidx;
4511 unsigned char norm;
4512 } m3dvsave_t;
4513
4514 typedef struct {
4515 m3ds_t data;
4516 M3D_INDEX oldidx;
4517 M3D_INDEX newidx;
4518 } m3dssave_t;
4519
4520 typedef struct {
4521 m3df_t data;
4522 int group;
4523 uint8_t opacity;
4524 } m3dfsave_t;
4525
4526 /* create unique list of strings */
4527 static m3dstr_t *_m3d_addstr(m3dstr_t *str, uint32_t *numstr, char *s)
4528 {
4529 uint32_t i;
4530 if(!s || !*s) return str;
4531 if(str) {
4532 for(i = 0; i < *numstr; i++)
4533 if(str[i].str == s || !strcmp(str[i].str, s)) return str;
4534 }
4535 str = (m3dstr_t*)M3D_REALLOC(str, ((*numstr) + 1) * sizeof(m3dstr_t));
4536 str[*numstr].str = s;
4537 str[*numstr].offs = 0;
4538 (*numstr)++;
4539 return str;
4540 }
4541
4542 /* add strings to header */
4543 m3dhdr_t *_m3d_addhdr(m3dhdr_t *h, m3dstr_t *s)
4544 {
4545 int i;
4546 char *safe = _m3d_safestr(s->str, 0);
4547 i = (int)strlen(safe);
4548 h = (m3dhdr_t*)M3D_REALLOC(h, h->length + i+1);
4549 if(!h) { M3D_FREE(safe); return NULL; }
4550 memcpy((uint8_t*)h + h->length, safe, i+1);
4551 s->offs = h->length - 16;
4552 h->length += i+1;
4553 M3D_FREE(safe);
4554 return h;
4555 }
4556
4557 /* return offset of string */
4558 static uint32_t _m3d_stridx(m3dstr_t *str, uint32_t numstr, char *s)
4559 {
4560 uint32_t i;
4561 char *safe;
4562 if(!s || !*s) return 0;
4563 if(str) {
4564 safe = _m3d_safestr(s, 0);
4565 if(!safe) return 0;
4566 if(!*safe) {
4567 free(safe);
4568 return 0;
4569 }
4570 for(i = 0; i < numstr; i++)
4571 if(!strcmp(str[i].str, s)) {
4572 free(safe);
4573 return str[i].offs;
4574 }
4575 free(safe);
4576 }
4577 return 0;
4578 }
4579
4580 /* compare to faces by their material */
4581 static int _m3d_facecmp(const void *a, const void *b) {
4582 const m3dfsave_t *A = (const m3dfsave_t*)a, *B = (const m3dfsave_t*)b;
4583 return A->group != B->group ? A->group - B->group : (A->opacity != B->opacity ? (int)B->opacity - (int)A->opacity :
4584 (int)A->data.materialid - (int)B->data.materialid);
4585 }
4586 /* compare face groups */
4587 static int _m3d_grpcmp(const void *a, const void *b) { return *((uint32_t*)a) - *((uint32_t*)b); }
4588 /* compare UVs */
4589 static int _m3d_ticmp(const void *a, const void *b) { return memcmp(a, b, sizeof(m3dti_t)); }
4590 /* compare skin groups */
4591 static int _m3d_skincmp(const void *a, const void *b) { return memcmp(a, b, sizeof(m3ds_t)); }
4592 /* compare vertices */
4593 static int _m3d_vrtxcmp(const void *a, const void *b) {
4594 int c = memcmp(a, b, 3 * sizeof(M3D_FLOAT));
4595 if(c) return c;
4596 c = ((m3dvsave_t*)a)->norm - ((m3dvsave_t*)b)->norm;
4597 if(c) return c;
4598 return memcmp(a, b, sizeof(m3dv_t));
4599 }
4600 /* compare labels */
4601 static _inline int _m3d_strcmp(char *a, char *b)
4602 {
4603 if(a == NULL && b != NULL) return -1;
4604 if(a != NULL && b == NULL) return 1;
4605 if(a == NULL && b == NULL) return 0;
4606 return strcmp(a, b);
4607 }
4608 static int _m3d_lblcmp(const void *a, const void *b) {
4609 const m3dl_t *A = (const m3dl_t*)a, *B = (const m3dl_t*)b;
4610 int c = _m3d_strcmp(A->lang, B->lang);
4611 if(!c) c = _m3d_strcmp(A->name, B->name);
4612 if(!c) c = _m3d_strcmp(A->text, B->text);
4613 return c;
4614 }
4615 /* compare two colors by HSV value */
4616 _inline static int _m3d_cmapcmp(const void *a, const void *b)
4617 {
4618 uint8_t *A = (uint8_t*)a, *B = (uint8_t*)b;
4619 _register int m, vA, vB;
4620 /* get HSV value for A */
4621 m = A[2] < A[1]? A[2] : A[1]; if(A[0] < m) m = A[0];
4622 vA = A[2] > A[1]? A[2] : A[1]; if(A[0] > vA) vA = A[0];
4623 /* get HSV value for B */
4624 m = B[2] < B[1]? B[2] : B[1]; if(B[0] < m) m = B[0];
4625 vB = B[2] > B[1]? B[2] : B[1]; if(B[0] > vB) vB = B[0];
4626 return vA - vB;
4627 }
4628
4629 /* create sorted list of colors */
4630 static uint32_t *_m3d_addcmap(uint32_t *cmap, uint32_t *numcmap, uint32_t color)
4631 {
4632 uint32_t i;
4633 if(cmap) {
4634 for(i = 0; i < *numcmap; i++)
4635 if(cmap[i] == color) return cmap;
4636 }
4637 cmap = (uint32_t*)M3D_REALLOC(cmap, ((*numcmap) + 1) * sizeof(uint32_t));
4638 for(i = 0; i < *numcmap && _m3d_cmapcmp(&color, &cmap[i]) > 0; i++);
4639 if(i < *numcmap) memmove(&cmap[i+1], &cmap[i], ((*numcmap) - i)*sizeof(uint32_t));
4640 cmap[i] = color;
4641 (*numcmap)++;
4642 return cmap;
4643 }
4644
4645 /* look up a color and return its index */
4646 static uint32_t _m3d_cmapidx(uint32_t *cmap, uint32_t numcmap, uint32_t color)
4647 {
4648 uint32_t i;
4649 if(numcmap >= 65536)
4650 return color;
4651 for(i = 0; i < numcmap; i++)
4652 if(cmap[i] == color) return i;
4653 return 0;
4654 }
4655
4656 /* add index to output */
4657 static unsigned char *_m3d_addidx(unsigned char *out, char type, uint32_t idx) {
4658 switch(type) {
4659 case 1: *out++ = (uint8_t)(idx); break;
4660 case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
4661 case 4: *((uint32_t*)out) = (uint32_t)(idx); out += 4; break;
4662 /* case 0: case 8: break; */
4663 }
4664 return out;
4665 }
4666
4667 /* round a vertex position */
4668 static void _m3d_round(int quality, m3dv_t *src, m3dv_t *dst)
4669 {
4670 _register int t;
4671 /* copy additional attributes */
4672 if(src != dst) memcpy(dst, src, sizeof(m3dv_t));
4673 /* round according to quality */
4674 switch(quality) {
4675 case M3D_EXP_INT8:
4676 t = (int)(src->x * 127 + (src->x >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->x = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
4677 t = (int)(src->y * 127 + (src->y >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->y = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
4678 t = (int)(src->z * 127 + (src->z >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->z = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
4679 t = (int)(src->w * 127 + (src->w >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->w = (M3D_FLOAT)t / (M3D_FLOAT)127.0;
4680 break;
4681 case M3D_EXP_INT16:
4682 t = (int)(src->x * 32767 + (src->x >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->x = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
4683 t = (int)(src->y * 32767 + (src->y >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->y = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
4684 t = (int)(src->z * 32767 + (src->z >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->z = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
4685 t = (int)(src->w * 32767 + (src->w >= 0 ? (M3D_FLOAT)0.5 : (M3D_FLOAT)-0.5)); dst->w = (M3D_FLOAT)t / (M3D_FLOAT)32767.0;
4686 break;
4687 }
4688 if(dst->x == (M3D_FLOAT)-0.0) dst->x = (M3D_FLOAT)0.0;
4689 if(dst->y == (M3D_FLOAT)-0.0) dst->y = (M3D_FLOAT)0.0;
4690 if(dst->z == (M3D_FLOAT)-0.0) dst->z = (M3D_FLOAT)0.0;
4691 if(dst->w == (M3D_FLOAT)-0.0) dst->w = (M3D_FLOAT)0.0;
4692 }
4693
4694 #ifdef M3D_ASCII
4695 /* add a bone to ascii output */
4696 static char *_m3d_prtbone(char *ptr, m3db_t *bone, M3D_INDEX numbone, M3D_INDEX parent, uint32_t level, M3D_INDEX *vrtxidx)
4697 {
4698 uint32_t i, j;
4699 char *sn;
4700
4701 if(level > M3D_BONEMAXLEVEL || !bone) return ptr;
4702 for(i = 0; i < numbone; i++) {
4703 if(bone[i].parent == parent) {
4704 for(j = 0; j < level; j++) *ptr++ = '/';
4705 sn = _m3d_safestr(bone[i].name, 0);
4706 ptr += sprintf(ptr, "%d %d %s\r\n", vrtxidx[bone[i].pos], vrtxidx[bone[i].ori], sn);
4707 M3D_FREE(sn);
4708 ptr = _m3d_prtbone(ptr, bone, numbone, i, level + 1, vrtxidx);
4709 }
4710 }
4711 return ptr;
4712 }
4713 #endif
4714
4715 /**
4716 * Function to encode an in-memory model into on storage Model 3D format
4717 */
4718 unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size)
4719 {
4720 #ifdef M3D_ASCII
4721 const char *ol;
4722 char *ptr;
4723 #endif
4724 char vc_s, vi_s, si_s, ci_s, ti_s, bi_s, nb_s, sk_s, fc_s, hi_s, fi_s, vd_s, vp_s;
4725 char *sn = NULL, *sl = NULL, *sa = NULL, *sd = NULL;
4726 unsigned char *out = NULL, *z = NULL, weights[M3D_NUMBONE < 8 ? 8 : M3D_NUMBONE], *norm = NULL;
4727 unsigned int i, j, k, l, n, o, len, chunklen, *length;
4728 int maxvox = 0, minvox = 0;
4729 M3D_FLOAT scale = (M3D_FLOAT)0.0, min_x, max_x, min_y, max_y, min_z, max_z;
4730 M3D_INDEX last, *vrtxidx = NULL, *mtrlidx = NULL, *tmapidx = NULL, *skinidx = NULL;
4731 #ifdef M3D_VERTEXMAX
4732 M3D_INDEX lastp;
4733 #endif
4734 uint32_t idx, numcmap = 0, *cmap = NULL, numvrtx = 0, maxvrtx = 0, numtmap = 0, maxtmap = 0, numproc = 0;
4735 uint32_t numskin = 0, maxskin = 0, numstr = 0, maxt = 0, maxbone = 0, numgrp = 0, maxgrp = 0, *grpidx = NULL;
4736 uint8_t *opa;
4737 m3dcd_t *cd;
4738 m3dc_t *cmd;
4739 m3dstr_t *str = NULL;
4740 m3dvsave_t *vrtx = NULL, vertex;
4741 m3dtisave_t *tmap = NULL, tcoord;
4742 m3dssave_t *skin = NULL, sk;
4743 m3dfsave_t *face = NULL;
4744 m3dhdr_t *h = NULL;
4745 m3dm_t *m;
4746 m3da_t *a;
4747
4748 if(!model) {
4749 if(size) *size = 0;
4750 return NULL;
4751 }
4752 model->errcode = M3D_SUCCESS;
4753 #ifdef M3D_ASCII
4754 if(flags & M3D_EXP_ASCII) quality = M3D_EXP_DOUBLE;
4755 #endif
4756 vrtxidx = (M3D_INDEX*)M3D_MALLOC(model->numvertex * sizeof(M3D_INDEX));
4757 if(!vrtxidx) goto memerr;
4758 memset(vrtxidx, 255, model->numvertex * sizeof(M3D_INDEX));
4759 if(model->numvertex && !(flags & M3D_EXP_NONORMAL)){
4760 norm = (unsigned char*)M3D_MALLOC(model->numvertex * sizeof(unsigned char));
4761 if(!norm) goto memerr;
4762 memset(norm, 0, model->numvertex * sizeof(unsigned char));
4763 }
4764 if(model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
4765 mtrlidx = (M3D_INDEX*)M3D_MALLOC(model->nummaterial * sizeof(M3D_INDEX));
4766 if(!mtrlidx) goto memerr;
4767 memset(mtrlidx, 255, model->nummaterial * sizeof(M3D_INDEX));
4768 opa = (uint8_t*)M3D_MALLOC(model->nummaterial * 2 * sizeof(M3D_INDEX));
4769 if(!opa) goto memerr;
4770 memset(opa, 255, model->nummaterial * 2 * sizeof(M3D_INDEX));
4771 }
4772 if(model->numtmap && !(flags & M3D_EXP_NOTXTCRD)) {
4773 tmapidx = (M3D_INDEX*)M3D_MALLOC(model->numtmap * sizeof(M3D_INDEX));
4774 if(!tmapidx) goto memerr;
4775 memset(tmapidx, 255, model->numtmap * sizeof(M3D_INDEX));
4776 }
4777 /** collect array elements that are actually referenced **/
4778 if(!(flags & M3D_EXP_NOFACE)) {
4779 /* face */
4780 if(model->numface && model->face) {
4781 M3D_LOG("Processing mesh face");
4782 face = (m3dfsave_t*)M3D_MALLOC(model->numface * sizeof(m3dfsave_t));
4783 if(!face) goto memerr;
4784 for(i = 0; i < model->numface; i++) {
4785 memcpy(&face[i].data, &model->face[i], sizeof(m3df_t));
4786 face[i].group = 0;
4787 face[i].opacity = 255;
4788 if(!(flags & M3D_EXP_NOMATERIAL) && model->face[i].materialid < model->nummaterial) {
4789 if(model->material[model->face[i].materialid].numprop) {
4790 mtrlidx[model->face[i].materialid] = 0;
4791 if(opa[model->face[i].materialid * 2]) {
4792 m = &model->material[model->face[i].materialid];
4793 for(j = 0; j < m->numprop; j++)
4794 if(m->prop[j].type == m3dp_Kd) {
4795 opa[model->face[i].materialid * 2 + 1] = ((uint8_t*)&m->prop[j].value.color)[3];
4796 break;
4797 }
4798 for(j = 0; j < m->numprop; j++)
4799 if(m->prop[j].type == m3dp_d) {
4800 opa[model->face[i].materialid * 2 + 1] = (uint8_t)(m->prop[j].value.fnum * 255);
4801 break;
4802 }
4803 opa[model->face[i].materialid * 2] = 0;
4804 }
4805 face[i].opacity = opa[model->face[i].materialid * 2 + 1];
4806 } else
4807 face[i].data.materialid = M3D_UNDEF;
4808 }
4809 for(j = 0; j < 3; j++) {
4810 k = model->face[i].vertex[j];
4811 if(k < model->numvertex)
4812 vrtxidx[k] = 0;
4813 if(!(flags & M3D_EXP_NOCMAP)) {
4814 cmap = _m3d_addcmap(cmap, &numcmap, model->vertex[k].color);
4815 if(!cmap) goto memerr;
4816 }
4817 k = model->face[i].normal[j];
4818 if(k < model->numvertex && !(flags & M3D_EXP_NONORMAL)) {
4819 vrtxidx[k] = 0;
4820 norm[k] = 1;
4821 }
4822 k = model->face[i].texcoord[j];
4823 if(k < model->numtmap && !(flags & M3D_EXP_NOTXTCRD))
4824 tmapidx[k] = 0;
4825 #ifdef M3D_VERTEXMAX
4826 k = model->face[i].vertmax[j];
4827 if(k < model->numvertex && !(flags & M3D_EXP_NOVRTMAX))
4828 vrtxidx[k] = 0;
4829 #endif
4830 }
4831 /* convert from CW to CCW */
4832 if(flags & M3D_EXP_IDOSUCK) {
4833 j = face[i].data.vertex[1];
4834 face[i].data.vertex[1] = face[i].data.vertex[2];
4835 face[i].data.vertex[2] = j;
4836 j = face[i].data.normal[1];
4837 face[i].data.normal[1] = face[i].data.normal[2];
4838 face[i].data.normal[2] = j;
4839 j = face[i].data.texcoord[1];
4840 face[i].data.texcoord[1] = face[i].data.texcoord[2];
4841 face[i].data.texcoord[2] = j;
4842 #ifdef M3D_VERTEXMAX
4843 j = face[i].data.vertmax[1];
4844 face[i].data.vertmax[1] = face[i].data.vertmax[2];
4845 face[i].data.vertmax[2] = j;
4846 #endif
4847 }
4848 }
4849 }
4850 if((model->numvoxtype && model->voxtype) || (model->numvoxel && model->voxel)) {
4851 M3D_LOG("Processing voxel face");
4852 for(i = 0; i < model->numvoxtype; i++) {
4853 str = _m3d_addstr(str, &numstr, model->voxtype[i].name);
4854 if(model->voxtype[i].name && !str) goto memerr;
4855 if(!(flags & M3D_EXP_NOCMAP)) {
4856 cmap = _m3d_addcmap(cmap, &numcmap, model->voxtype[i].color);
4857 if(!cmap) goto memerr;
4858 }
4859 for(j = 0; j < model->voxtype[i].numitem; j++) {
4860 str = _m3d_addstr(str, &numstr, model->voxtype[i].item[j].name);
4861 if(model->voxtype[i].item[j].name && !str) goto memerr;
4862 }
4863 }
4864 for(i = 0; i < model->numvoxel; i++) {
4865 str = _m3d_addstr(str, &numstr, model->voxel[i].name);
4866 if(model->voxel[i].name && !str) goto memerr;
4867 if(model->voxel[i].x < minvox) minvox = model->voxel[i].x;
4868 if(model->voxel[i].x + (int)model->voxel[i].w > maxvox) maxvox = model->voxel[i].x + model->voxel[i].w;
4869 if(model->voxel[i].y < minvox) minvox = model->voxel[i].y;
4870 if(model->voxel[i].y + (int)model->voxel[i].h > maxvox) maxvox = model->voxel[i].y + model->voxel[i].h;
4871 if(model->voxel[i].z < minvox) minvox = model->voxel[i].z;
4872 if(model->voxel[i].z + (int)model->voxel[i].d > maxvox) maxvox = model->voxel[i].z + model->voxel[i].d;
4873 }
4874 }
4875 if(model->numshape && model->shape) {
4876 M3D_LOG("Processing shape face");
4877 for(i = 0; i < model->numshape; i++) {
4878 if(!model->shape[i].numcmd) continue;
4879 str = _m3d_addstr(str, &numstr, model->shape[i].name);
4880 if(model->shape[i].name && !str) goto memerr;
4881 for(j = 0; j < model->shape[i].numcmd; j++) {
4882 cmd = &model->shape[i].cmd[j];
4883 if(cmd->type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])) || !cmd->arg)
4884 continue;
4885 if(cmd->type == m3dc_mesh) {
4886 if(numgrp + 2 < maxgrp) {
4887 maxgrp += 1024;
4888 grpidx = (uint32_t*)realloc(grpidx, maxgrp * sizeof(uint32_t));
4889 if(!grpidx) goto memerr;
4890 if(!numgrp) {
4891 grpidx[0] = 0;
4892 grpidx[1] = model->numface;
4893 numgrp += 2;
4894 }
4895 }
4896 grpidx[numgrp + 0] = cmd->arg[0];
4897 grpidx[numgrp + 1] = cmd->arg[0] + cmd->arg[1];
4898 numgrp += 2;
4899 }
4900 cd = &m3d_commandtypes[cmd->type];
4901 for(k = n = 0, l = cd->p; k < l; k++)
4902 switch(cd->a[((k - n) % (cd->p - n)) + n]) {
4903 case m3dcp_mi_t:
4904 if(!(flags & M3D_EXP_NOMATERIAL) && cmd->arg[k] < model->nummaterial)
4905 mtrlidx[cmd->arg[k]] = 0;
4906 break;
4907 case m3dcp_ti_t:
4908 if(!(flags & M3D_EXP_NOTXTCRD) && cmd->arg[k] < model->numtmap)
4909 tmapidx[cmd->arg[k]] = 0;
4910 break;
4911 case m3dcp_qi_t:
4912 case m3dcp_vi_t:
4913 if(cmd->arg[k] < model->numvertex)
4914 vrtxidx[cmd->arg[k]] = 0;
4915 break;
4916 case m3dcp_va_t:
4917 n = k + 1; l += (cmd->arg[k] - 1) * (cd->p - k - 1);
4918 break;
4919 }
4920 }
4921 }
4922 }
4923 if(model->numface && face) {
4924 if(numgrp && grpidx) {
4925 qsort(grpidx, numgrp, sizeof(uint32_t), _m3d_grpcmp);
4926 for(i = j = 0; i < model->numface && j < numgrp; i++) {
4927 while(j < numgrp && grpidx[j] < i) j++;
4928 face[i].group = j;
4929 }
4930 }
4931 qsort(face, model->numface, sizeof(m3dfsave_t), _m3d_facecmp);
4932 }
4933 if(grpidx) { M3D_FREE(grpidx); grpidx = NULL; }
4934 if(model->numlabel && model->label) {
4935 M3D_LOG("Processing annotation labels");
4936 for(i = 0; i < model->numlabel; i++) {
4937 str = _m3d_addstr(str, &numstr, model->label[i].name);
4938 str = _m3d_addstr(str, &numstr, model->label[i].lang);
4939 str = _m3d_addstr(str, &numstr, model->label[i].text);
4940 if(!(flags & M3D_EXP_NOCMAP)) {
4941 cmap = _m3d_addcmap(cmap, &numcmap, model->label[i].color);
4942 if(!cmap) goto memerr;
4943 }
4944 if(model->label[i].vertexid < model->numvertex)
4945 vrtxidx[model->label[i].vertexid] = 0;
4946 }
4947 qsort(model->label, model->numlabel, sizeof(m3dl_t), _m3d_lblcmp);
4948 }
4949 } else if(!(flags & M3D_EXP_NOMATERIAL)) {
4950 /* without a face, simply add all materials, because it can be an mtllib */
4951 for(i = 0; i < model->nummaterial; i++)
4952 mtrlidx[i] = i;
4953 }
4954 /* bind-pose skeleton */
4955 if(model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
4956 M3D_LOG("Processing bones");
4957 for(i = 0; i < model->numbone; i++) {
4958 str = _m3d_addstr(str, &numstr, model->bone[i].name);
4959 if(!str) goto memerr;
4960 k = model->bone[i].pos;
4961 if(k < model->numvertex)
4962 vrtxidx[k] = 0;
4963 k = model->bone[i].ori;
4964 if(k < model->numvertex)
4965 vrtxidx[k] = 0;
4966 }
4967 }
4968 /* actions, animated skeleton poses */
4969 if(model->numaction && model->action && !(flags & M3D_EXP_NOACTION)) {
4970 M3D_LOG("Processing action list");
4971 for(j = 0; j < model->numaction; j++) {
4972 a = &model->action[j];
4973 str = _m3d_addstr(str, &numstr, a->name);
4974 if(!str) goto memerr;
4975 if(a->numframe > 65535) a->numframe = 65535;
4976 for(i = 0; i < a->numframe; i++) {
4977 for(l = 0; l < a->frame[i].numtransform; l++) {
4978 k = a->frame[i].transform[l].pos;
4979 if(k < model->numvertex)
4980 vrtxidx[k] = 0;
4981 k = a->frame[i].transform[l].ori;
4982 if(k < model->numvertex)
4983 vrtxidx[k] = 0;
4984 }
4985 if(l > maxt) maxt = l;
4986 }
4987 }
4988 }
4989 /* add colors to color map and texture names to string table */
4990 if(!(flags & M3D_EXP_NOMATERIAL)) {
4991 M3D_LOG("Processing materials");
4992 for(i = k = 0; i < model->nummaterial; i++) {
4993 if(mtrlidx[i] == M3D_UNDEF || !model->material[i].numprop) continue;
4994 mtrlidx[i] = k++;
4995 m = &model->material[i];
4996 str = _m3d_addstr(str, &numstr, m->name);
4997 if(!str) goto memerr;
4998 if(m->prop)
4999 for(j = 0; j < m->numprop; j++) {
5000 if(!(flags & M3D_EXP_NOCMAP) && m->prop[j].type < 128) {
5001 for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++) {
5002 if(m->prop[j].type == m3d_propertytypes[l].id && m3d_propertytypes[l].format == m3dpf_color) {
5003 ((uint8_t*)&m->prop[j].value.color)[3] = opa[i * 2 + 1];
5004 cmap = _m3d_addcmap(cmap, &numcmap, m->prop[j].value.color);
5005 if(!cmap) goto memerr;
5006 break;
5007 }
5008 }
5009 }
5010 if(m->prop[j].type >= 128 && m->prop[j].value.textureid < model->numtexture &&
5011 model->texture[m->prop[j].value.textureid].name) {
5012 str = _m3d_addstr(str, &numstr, model->texture[m->prop[j].value.textureid].name);
5013 if(!str) goto memerr;
5014 }
5015 }
5016 }
5017 }
5018 /* if there's only one black color, don't store it */
5019 if(numcmap == 1 && cmap && !cmap[0]) numcmap = 0;
5020
5021 /** compress lists **/
5022 if(model->numtmap && !(flags & M3D_EXP_NOTXTCRD)) {
5023 M3D_LOG("Compressing tmap");
5024 tmap = (m3dtisave_t*)M3D_MALLOC(model->numtmap * sizeof(m3dtisave_t));
5025 if(!tmap) goto memerr;
5026 for(i = 0; i < model->numtmap; i++) {
5027 if(tmapidx[i] == M3D_UNDEF) continue;
5028 switch(quality) {
5029 case M3D_EXP_INT8:
5030 l = (unsigned int)(model->tmap[i].u * 255); tcoord.data.u = (M3D_FLOAT)l / (M3D_FLOAT)255.0;
5031 l = (unsigned int)(model->tmap[i].v * 255); tcoord.data.v = (M3D_FLOAT)l / (M3D_FLOAT)255.0;
5032 break;
5033 case M3D_EXP_INT16:
5034 l = (unsigned int)(model->tmap[i].u * 65535); tcoord.data.u = (M3D_FLOAT)l / (M3D_FLOAT)65535.0;
5035 l = (unsigned int)(model->tmap[i].v * 65535); tcoord.data.v = (M3D_FLOAT)l / (M3D_FLOAT)65535.0;
5036 break;
5037 default:
5038 tcoord.data.u = model->tmap[i].u;
5039 tcoord.data.v = model->tmap[i].v;
5040 break;
5041 }
5042 if(flags & M3D_EXP_FLIPTXTCRD)
5043 tcoord.data.v = (M3D_FLOAT)1.0 - tcoord.data.v;
5044 tcoord.oldidx = i;
5045 memcpy(&tmap[numtmap++], &tcoord, sizeof(m3dtisave_t));
5046 }
5047 if(numtmap) {
5048 qsort(tmap, numtmap, sizeof(m3dtisave_t), _m3d_ticmp);
5049 memcpy(&tcoord.data, &tmap[0], sizeof(m3dti_t));
5050 for(i = 0; i < numtmap; i++) {
5051 if(memcmp(&tcoord.data, &tmap[i].data, sizeof(m3dti_t))) {
5052 memcpy(&tcoord.data, &tmap[i].data, sizeof(m3dti_t));
5053 maxtmap++;
5054 }
5055 tmap[i].newidx = maxtmap;
5056 tmapidx[tmap[i].oldidx] = maxtmap;
5057 }
5058 maxtmap++;
5059 }
5060 }
5061 if(model->numskin && model->skin && !(flags & M3D_EXP_NOBONE)) {
5062 M3D_LOG("Compressing skin");
5063 skinidx = (M3D_INDEX*)M3D_MALLOC(model->numskin * sizeof(M3D_INDEX));
5064 if(!skinidx) goto memerr;
5065 skin = (m3dssave_t*)M3D_MALLOC(model->numskin * sizeof(m3dssave_t));
5066 if(!skin) goto memerr;
5067 memset(skinidx, 255, model->numskin * sizeof(M3D_INDEX));
5068 for(i = 0; i < model->numvertex; i++) {
5069 if(vrtxidx[i] != M3D_UNDEF && model->vertex[i].skinid < model->numskin)
5070 skinidx[model->vertex[i].skinid] = 0;
5071 }
5072 for(i = 0; i < model->numskin; i++) {
5073 if(skinidx[i] == M3D_UNDEF) continue;
5074 memset(&sk, 0, sizeof(m3dssave_t));
5075 for(j = 0, min_x = (M3D_FLOAT)0.0; j < M3D_NUMBONE && model->skin[i].boneid[j] != M3D_UNDEF &&
5076 model->skin[i].weight[j] > (M3D_FLOAT)0.0; j++) {
5077 sk.data.boneid[j] = model->skin[i].boneid[j];
5078 sk.data.weight[j] = model->skin[i].weight[j];
5079 min_x += sk.data.weight[j];
5080 }
5081 if(j > maxbone) maxbone = j;
5082 if(min_x != (M3D_FLOAT)1.0 && min_x != (M3D_FLOAT)0.0)
5083 for(j = 0; j < M3D_NUMBONE && sk.data.weight[j] > (M3D_FLOAT)0.0; j++)
5084 sk.data.weight[j] /= min_x;
5085 sk.oldidx = i;
5086 memcpy(&skin[numskin++], &sk, sizeof(m3dssave_t));
5087 }
5088 if(numskin) {
5089 qsort(skin, numskin, sizeof(m3dssave_t), _m3d_skincmp);
5090 memcpy(&sk.data, &skin[0].data, sizeof(m3ds_t));
5091 for(i = 0; i < numskin; i++) {
5092 if(memcmp(&sk.data, &skin[i].data, sizeof(m3ds_t))) {
5093 memcpy(&sk.data, &skin[i].data, sizeof(m3ds_t));
5094 maxskin++;
5095 }
5096 skin[i].newidx = maxskin;
5097 skinidx[skin[i].oldidx] = maxskin;
5098 }
5099 maxskin++;
5100 }
5101 }
5102
5103 M3D_LOG("Compressing vertex list");
5104 min_x = min_y = min_z = (M3D_FLOAT)1e10;
5105 max_x = max_y = max_z = (M3D_FLOAT)-1e10;
5106 if(vrtxidx) {
5107 vrtx = (m3dvsave_t*)M3D_MALLOC(model->numvertex * sizeof(m3dvsave_t));
5108 if(!vrtx) goto memerr;
5109 for(i = numvrtx = 0; i < model->numvertex; i++) {
5110 if(vrtxidx[i] == M3D_UNDEF) continue;
5111 _m3d_round(quality, &model->vertex[i], &vertex.data);
5112 vertex.norm = norm ? norm[i] : 0;
5113 if(vertex.data.skinid != M3D_INDEXMAX && !vertex.norm) {
5114 vertex.data.skinid = vertex.data.skinid != M3D_UNDEF && skinidx ? skinidx[vertex.data.skinid] : M3D_UNDEF;
5115 if(vertex.data.x > max_x) max_x = vertex.data.x;
5116 if(vertex.data.x < min_x) min_x = vertex.data.x;
5117 if(vertex.data.y > max_y) max_y = vertex.data.y;
5118 if(vertex.data.y < min_y) min_y = vertex.data.y;
5119 if(vertex.data.z > max_z) max_z = vertex.data.z;
5120 if(vertex.data.z < min_z) min_z = vertex.data.z;
5121 }
5122 #ifdef M3D_VERTEXTYPE
5123 vertex.data.type = 0;
5124 #endif
5125 vertex.oldidx = i;
5126 memcpy(&vrtx[numvrtx++], &vertex, sizeof(m3dvsave_t));
5127 }
5128 if(numvrtx) {
5129 qsort(vrtx, numvrtx, sizeof(m3dvsave_t), _m3d_vrtxcmp);
5130 memcpy(&vertex.data, &vrtx[0].data, sizeof(m3dv_t));
5131 for(i = 0; i < numvrtx; i++) {
5132 if(memcmp(&vertex.data, &vrtx[i].data, vrtx[i].norm ? 3 * sizeof(M3D_FLOAT) : sizeof(m3dv_t))) {
5133 memcpy(&vertex.data, &vrtx[i].data, sizeof(m3dv_t));
5134 maxvrtx++;
5135 }
5136 vrtx[i].newidx = maxvrtx;
5137 vrtxidx[vrtx[i].oldidx] = maxvrtx;
5138 }
5139 maxvrtx++;
5140 }
5141 }
5142 if(norm) { M3D_FREE(norm); norm = NULL; }
5143
5144 /* normalize to bounding cube */
5145 if(numvrtx && !(flags & M3D_EXP_NORECALC)) {
5146 M3D_LOG("Normalizing coordinates");
5147 if(min_x < (M3D_FLOAT)0.0) min_x = -min_x;
5148 if(max_x < (M3D_FLOAT)0.0) max_x = -max_x;
5149 if(min_y < (M3D_FLOAT)0.0) min_y = -min_y;
5150 if(max_y < (M3D_FLOAT)0.0) max_y = -max_y;
5151 if(min_z < (M3D_FLOAT)0.0) min_z = -min_z;
5152 if(max_z < (M3D_FLOAT)0.0) max_z = -max_z;
5153 scale = min_x;
5154 if(max_x > scale) scale = max_x;
5155 if(min_y > scale) scale = min_y;
5156 if(max_y > scale) scale = max_y;
5157 if(min_z > scale) scale = min_z;
5158 if(max_z > scale) scale = max_z;
5159 if(scale <= (M3D_FLOAT)0.0) scale = (M3D_FLOAT)1.0;
5160 if(scale != (M3D_FLOAT)1.0) {
5161 for(i = 0; i < numvrtx; i++) {
5162 if(vrtx[i].data.skinid == M3D_INDEXMAX) continue;
5163 vrtx[i].data.x /= scale;
5164 vrtx[i].data.y /= scale;
5165 vrtx[i].data.z /= scale;
5166 }
5167 }
5168 }
5169 if(model->scale > (M3D_FLOAT)0.0) scale = model->scale;
5170 if(scale <= (M3D_FLOAT)0.0) scale = (M3D_FLOAT)1.0;
5171
5172 /* meta info */
5173 sn = _m3d_safestr(model->name && *model->name ? model->name : (char*)"(noname)", 2);
5174 sl = _m3d_safestr(model->license ? model->license : (char*)"MIT", 2);
5175 sa = _m3d_safestr(model->author ? model->author : getenv("LOGNAME"), 2);
5176 if(!sn || !sl || !sa) {
5177 memerr: if(vrtxidx) M3D_FREE(vrtxidx);
5178 if(mtrlidx) M3D_FREE(mtrlidx);
5179 if(tmapidx) M3D_FREE(tmapidx);
5180 if(skinidx) M3D_FREE(skinidx);
5181 if(grpidx) M3D_FREE(grpidx);
5182 if(norm) M3D_FREE(norm);
5183 if(face) M3D_FREE(face);
5184 if(cmap) M3D_FREE(cmap);
5185 if(tmap) M3D_FREE(tmap);
5186 if(skin) M3D_FREE(skin);
5187 if(str) M3D_FREE(str);
5188 if(vrtx) M3D_FREE(vrtx);
5189 if(sn) M3D_FREE(sn);
5190 if(sl) M3D_FREE(sl);
5191 if(sa) M3D_FREE(sa);
5192 if(sd) M3D_FREE(sd);
5193 if(out) M3D_FREE(out);
5194 if(h) M3D_FREE(h);
5195 M3D_LOG("Out of memory");
5196 model->errcode = M3D_ERR_ALLOC;
5197 return NULL;
5198 }
5199
5200 M3D_LOG("Serializing model");
5201 #ifdef M3D_ASCII
5202 if(flags & M3D_EXP_ASCII) {
5203 /* use CRLF to make model creators on Win happy... */
5204 sd = _m3d_safestr(model->desc, 1);
5205 if(!sd) goto memerr;
5206 ol = setlocale(LC_NUMERIC, NULL);
5207 setlocale(LC_NUMERIC, "C");
5208 /* header */
5209 len = 64 + (unsigned int)(strlen(sn) + strlen(sl) + strlen(sa) + strlen(sd));
5210 out = (unsigned char*)M3D_MALLOC(len);
5211 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5212 ptr = (char*)out;
5213 ptr += sprintf(ptr, "3dmodel %g\r\n%s\r\n%s\r\n%s\r\n%s\r\n\r\n", scale,
5214 sn, sl, sa, sd);
5215 M3D_FREE(sl); M3D_FREE(sa); M3D_FREE(sd);
5216 sl = sa = sd = NULL;
5217 /* preview chunk */
5218 if(model->preview.data && model->preview.length) {
5219 sl = _m3d_safestr(sn, 0);
5220 if(sl) {
5221 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)20 + strlen(sl));
5222 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5223 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5224 ptr += sprintf(ptr, "Preview\r\n%s.png\r\n\r\n", sl);
5225 M3D_FREE(sl); sl = NULL;
5226 }
5227 }
5228 M3D_FREE(sn); sn = NULL;
5229 /* texture map */
5230 if(numtmap && tmap && !(flags & M3D_EXP_NOTXTCRD) && !(flags & M3D_EXP_NOFACE)) {
5231 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(maxtmap * 32) + (uintptr_t)12);
5232 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5233 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5234 ptr += sprintf(ptr, "Textmap\r\n");
5235 last = M3D_UNDEF;
5236 for(i = 0; i < numtmap; i++) {
5237 if(tmap[i].newidx == last) continue;
5238 last = tmap[i].newidx;
5239 ptr += sprintf(ptr, "%g %g\r\n", tmap[i].data.u, tmap[i].data.v);
5240 }
5241 ptr += sprintf(ptr, "\r\n");
5242 }
5243 /* vertex chunk */
5244 if(numvrtx && vrtx && !(flags & M3D_EXP_NOFACE)) {
5245 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(maxvrtx * 128) + (uintptr_t)10);
5246 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5247 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5248 ptr += sprintf(ptr, "Vertex\r\n");
5249 last = M3D_UNDEF;
5250 for(i = 0; i < numvrtx; i++) {
5251 if(vrtx[i].newidx == last) continue;
5252 last = vrtx[i].newidx;
5253 ptr += sprintf(ptr, "%g %g %g %g", vrtx[i].data.x, vrtx[i].data.y, vrtx[i].data.z, vrtx[i].data.w);
5254 if(!(flags & M3D_EXP_NOCMAP) && vrtx[i].data.color)
5255 ptr += sprintf(ptr, " #%08x", vrtx[i].data.color);
5256 if(!(flags & M3D_EXP_NOBONE) && model->numbone && maxskin && vrtx[i].data.skinid < M3D_INDEXMAX) {
5257 if(skin[vrtx[i].data.skinid].data.weight[0] == (M3D_FLOAT)1.0)
5258 ptr += sprintf(ptr, " %d", skin[vrtx[i].data.skinid].data.boneid[0]);
5259 else
5260 for(j = 0; j < M3D_NUMBONE && skin[vrtx[i].data.skinid].data.boneid[j] != M3D_UNDEF &&
5261 skin[vrtx[i].data.skinid].data.weight[j] > (M3D_FLOAT)0.0; j++)
5262 ptr += sprintf(ptr, " %d:%g", skin[vrtx[i].data.skinid].data.boneid[j],
5263 skin[vrtx[i].data.skinid].data.weight[j]);
5264 }
5265 ptr += sprintf(ptr, "\r\n");
5266 }
5267 ptr += sprintf(ptr, "\r\n");
5268 }
5269 /* bones chunk */
5270 if(model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
5271 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)9);
5272 for(i = 0; i < model->numbone; i++) {
5273 len += (unsigned int)strlen(model->bone[i].name) + 128;
5274 }
5275 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5276 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5277 ptr += sprintf(ptr, "Bones\r\n");
5278 ptr = _m3d_prtbone(ptr, model->bone, model->numbone, M3D_UNDEF, 0, vrtxidx);
5279 ptr += sprintf(ptr, "\r\n");
5280 }
5281 /* materials */
5282 if(model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
5283 for(j = 0; j < model->nummaterial; j++) {
5284 if(mtrlidx[j] == M3D_UNDEF || !model->material[j].numprop || !model->material[j].prop) continue;
5285 m = &model->material[j];
5286 sn = _m3d_safestr(m->name, 0);
5287 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5288 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)12);
5289 for(i = 0; i < m->numprop; i++) {
5290 if(m->prop[i].type < 128)
5291 len += 32;
5292 else if(m->prop[i].value.textureid < model->numtexture && model->texture[m->prop[i].value.textureid].name)
5293 len += (unsigned int)strlen(model->texture[m->prop[i].value.textureid].name) + 16;
5294 }
5295 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5296 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5297 ptr += sprintf(ptr, "Material %s\r\n", sn);
5298 M3D_FREE(sn); sn = NULL;
5299 for(i = 0; i < m->numprop; i++) {
5300 k = 256;
5301 if(m->prop[i].type >= 128) {
5302 for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
5303 if(m->prop[i].type == m3d_propertytypes[l].id) {
5304 sn = m3d_propertytypes[l].key;
5305 break;
5306 }
5307 if(!sn)
5308 for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
5309 if(m->prop[i].type - 128 == m3d_propertytypes[l].id) {
5310 sn = m3d_propertytypes[l].key;
5311 break;
5312 }
5313 k = sn ? m3dpf_map : 256;
5314 } else {
5315 for(l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
5316 if(m->prop[i].type == m3d_propertytypes[l].id) {
5317 sn = m3d_propertytypes[l].key;
5318 k = m3d_propertytypes[l].format;
5319 break;
5320 }
5321 }
5322 switch(k) {
5323 case m3dpf_color: ptr += sprintf(ptr, "%s #%08x\r\n", sn, m->prop[i].value.color); break;
5324 case m3dpf_uint8:
5325 case m3dpf_uint16:
5326 case m3dpf_uint32: ptr += sprintf(ptr, "%s %d\r\n", sn, m->prop[i].value.num); break;
5327 case m3dpf_float: ptr += sprintf(ptr, "%s %g\r\n", sn, m->prop[i].value.fnum); break;
5328 case m3dpf_map:
5329 if(m->prop[i].value.textureid < model->numtexture &&
5330 model->texture[m->prop[i].value.textureid].name) {
5331 sl = _m3d_safestr(model->texture[m->prop[i].value.textureid].name, 0);
5332 if(!sl) { setlocale(LC_NUMERIC, ol); goto memerr; }
5333 if(*sl)
5334 ptr += sprintf(ptr, "map_%s %s\r\n", sn, sl);
5335 M3D_FREE(sn); M3D_FREE(sl); sl = NULL;
5336 }
5337 break;
5338 }
5339 sn = NULL;
5340 }
5341 ptr += sprintf(ptr, "\r\n");
5342 }
5343 }
5344 /* procedural face */
5345 if(model->numinlined && model->inlined && !(flags & M3D_EXP_NOFACE)) {
5346 /* all inlined assets which are not textures should be procedural surfaces */
5347 for(j = 0; j < model->numinlined; j++) {
5348 if(!model->inlined[j].name || !*model->inlined[j].name || !model->inlined[j].length || !model->inlined[j].data ||
5349 (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G'))
5350 continue;
5351 for(i = k = 0; i < model->numtexture; i++) {
5352 if(!strcmp(model->inlined[j].name, model->texture[i].name)) { k = 1; break; }
5353 }
5354 if(k) continue;
5355 sn = _m3d_safestr(model->inlined[j].name, 0);
5356 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5357 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)18);
5358 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5359 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5360 ptr += sprintf(ptr, "Procedural\r\n%s\r\n\r\n", sn);
5361 M3D_FREE(sn); sn = NULL;
5362 }
5363 }
5364 /* mesh face */
5365 if(model->numface && face && !(flags & M3D_EXP_NOFACE)) {
5366 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(model->numface * 128) + (uintptr_t)6);
5367 last = M3D_UNDEF;
5368 #ifdef M3D_VERTEXMAX
5369 lastp = M3D_UNDEF;
5370 #endif
5371 if(!(flags & M3D_EXP_NOMATERIAL))
5372 for(i = 0; i < model->numface; i++) {
5373 j = face[i].data.materialid < model->nummaterial ? face[i].data.materialid : M3D_UNDEF;
5374 if(j != last) {
5375 last = j;
5376 if(last < model->nummaterial)
5377 len += (unsigned int)strlen(model->material[last].name);
5378 len += 6;
5379 }
5380 #ifdef M3D_VERTEXMAX
5381 j = face[i].data.paramid < model->numparam ? face[i].data.paramid : M3D_UNDEF;
5382 if(j != lastp) {
5383 lastp = j;
5384 if(lastp < model->numparam)
5385 len += (unsigned int)strlen(model->param[lastp].name);
5386 len += 6;
5387 }
5388 #endif
5389 }
5390 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5391 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5392 ptr += sprintf(ptr, "Mesh\r\n");
5393 last = M3D_UNDEF;
5394 #ifdef M3D_VERTEXMAX
5395 lastp = M3D_UNDEF;
5396 #endif
5397 for(i = 0; i < model->numface; i++) {
5398 j = face[i].data.materialid < model->nummaterial ? face[i].data.materialid : M3D_UNDEF;
5399 if(!(flags & M3D_EXP_NOMATERIAL) && j != last) {
5400 last = j;
5401 if(last < model->nummaterial) {
5402 sn = _m3d_safestr(model->material[last].name, 0);
5403 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5404 ptr += sprintf(ptr, "use %s\r\n", sn);
5405 M3D_FREE(sn); sn = NULL;
5406 } else
5407 ptr += sprintf(ptr, "use\r\n");
5408 }
5409 #ifdef M3D_VERTEXMAX
5410 j = face[i].data.paramid < model->numparam ? face[i].data.paramid : M3D_UNDEF;
5411 if(!(flags & M3D_EXP_NOVRTMAX) && j != lastp) {
5412 lastp = j;
5413 if(lastp < model->numparam) {
5414 sn = _m3d_safestr(model->param[lastp].name, 0);
5415 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5416 ptr += sprintf(ptr, "par %s\r\n", sn);
5417 M3D_FREE(sn); sn = NULL;
5418 } else
5419 ptr += sprintf(ptr, "par\r\n");
5420 }
5421 #endif
5422 /* hardcoded triangles. Should be repeated as many times as the number of edges in polygon */
5423 for(j = 0; j < 3; j++) {
5424 ptr += sprintf(ptr, "%s%d", j?" ":"", vrtxidx[face[i].data.vertex[j]]);
5425 k = l = M3D_NOTDEFINED;
5426 if(!(flags & M3D_EXP_NOTXTCRD) && (face[i].data.texcoord[j] != M3D_UNDEF) &&
5427 (tmapidx[face[i].data.texcoord[j]] != M3D_UNDEF)) {
5428 k = tmapidx[face[i].data.texcoord[j]];
5429 ptr += sprintf(ptr, "/%d", k);
5430 }
5431 if(!(flags & M3D_EXP_NONORMAL) && (face[i].data.normal[j] != M3D_UNDEF)) {
5432 l = vrtxidx[face[i].data.normal[j]];
5433 ptr += sprintf(ptr, "%s/%d", k == M3D_NOTDEFINED? "/" : "", l);
5434 }
5435 #ifdef M3D_VERTEXMAX
5436 if(!(flags & M3D_EXP_NOVRTMAX) && (face[i].data.vertmax[j] != M3D_UNDEF)) {
5437 ptr += sprintf(ptr, "%s%s/%d", k == M3D_NOTDEFINED? "/" : "", l == M3D_NOTDEFINED? "/" : "",
5438 vrtxidx[face[i].data.vertmax[j]]);
5439 }
5440 #endif
5441 }
5442 ptr += sprintf(ptr, "\r\n");
5443 }
5444 ptr += sprintf(ptr, "\r\n");
5445 }
5446 /* voxel face */
5447 if(model->numvoxtype && model->voxtype && !(flags & M3D_EXP_NOFACE)) {
5448 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)(model->numvoxtype * 128) + (uintptr_t)10);
5449 for(i = 0; i < model->numvoxtype; i++) {
5450 if(model->voxtype[i].name) len += (unsigned int)strlen(model->voxtype[i].name);
5451 for(j = 0; j < model->voxtype[i].numitem; j++)
5452 if(model->voxtype[i].item[j].name)
5453 len += (unsigned int)strlen(model->voxtype[i].item[j].name) + 6;
5454 }
5455 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5456 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5457 ptr += sprintf(ptr, "VoxTypes\r\n");
5458 for(i = 0; i < model->numvoxtype; i++) {
5459 ptr += sprintf(ptr, "#%08x", model->voxtype[i].color);
5460 if(model->voxtype[i].rotation)
5461 ptr += sprintf(ptr, "/%02x", model->voxtype[i].rotation);
5462 if(model->voxtype[i].voxshape)
5463 ptr += sprintf(ptr, "%s/%03x", model->voxtype[i].rotation ? "" : "/", model->voxtype[i].voxshape);
5464 sn = _m3d_safestr(model->voxtype[i].name, 0);
5465 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5466 ptr += sprintf(ptr, " %s", sn && sn[0] ? sn : "-");
5467 M3D_FREE(sn); sn = NULL;
5468 if(!(flags & M3D_EXP_NOBONE) && model->numbone && maxskin && model->voxtype[i].skinid < M3D_INDEXMAX) {
5469 if(skin[skinidx[model->voxtype[i].skinid]].data.weight[0] == (M3D_FLOAT)1.0)
5470 ptr += sprintf(ptr, " %d", skin[skinidx[model->voxtype[i].skinid]].data.boneid[0]);
5471 else
5472 for(j = 0; j < M3D_NUMBONE && skin[skinidx[model->voxtype[i].skinid]].data.boneid[j] != M3D_UNDEF &&
5473 skin[skinidx[model->voxtype[i].skinid]].data.weight[j] > (M3D_FLOAT)0.0; j++)
5474 ptr += sprintf(ptr, " %d:%g", skin[skinidx[model->voxtype[i].skinid]].data.boneid[j],
5475 skin[skinidx[model->voxtype[i].skinid]].data.weight[j]);
5476 }
5477 if(model->voxtype[i].numitem && model->voxtype[i].item) {
5478 for(j = k = 0; j < model->voxtype[i].numitem; j++) {
5479 if(!model->voxtype[i].item[j].count || !model->voxtype[i].item[j].name ||
5480 !model->voxtype[i].item[j].name[0]) continue;
5481 if(!k) { ptr += sprintf(ptr, " {"); k = 1; }
5482 sn = _m3d_safestr(model->voxtype[i].item[j].name, 0);
5483 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5484 ptr += sprintf(ptr, " %d %s", model->voxtype[i].item[j].count, sn);
5485 M3D_FREE(sn); sn = NULL;
5486 }
5487 if(k) ptr += sprintf(ptr, " }");
5488 }
5489 while(ptr[-1] == '-' || ptr[-1] == ' ') ptr--;
5490 ptr += sprintf(ptr, "\r\n");
5491 }
5492 ptr += sprintf(ptr, "\r\n");
5493 }
5494 if(model->numvoxel && model->voxel && !(flags & M3D_EXP_NOFACE)) {
5495 for(i = 0; i < model->numvoxel; i++) {
5496 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)128);
5497 if(model->voxel[i].name) len += (unsigned int)strlen(model->voxel[i].name);
5498 len += model->voxel[i].h * ((model->voxel[i].w * 6 + 2) * model->voxel[i].d + 9);
5499 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5500 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5501 ptr += sprintf(ptr, "Voxel");
5502 sn = _m3d_safestr(model->voxel[i].name, 0);
5503 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5504 if(sn && sn[0])
5505 ptr += sprintf(ptr, " %s", sn);
5506 M3D_FREE(sn); sn = NULL;
5507 ptr += sprintf(ptr, "\r\n");
5508 if(model->voxel[i].uncertain)
5509 ptr += sprintf(ptr, "uncertain %d %d\r\n", (model->voxel[i].uncertain * 100) / 255, model->voxel[i].groupid);
5510 if(model->voxel[i].x || model->voxel[i].y || model->voxel[i].z)
5511 ptr += sprintf(ptr, "pos %d %d %d\r\n", model->voxel[i].x, model->voxel[i].y, model->voxel[i].z);
5512 ptr += sprintf(ptr, "dim %d %d %d\r\n", model->voxel[i].w, model->voxel[i].h, model->voxel[i].d);
5513 for(j = n = 0; j < model->voxel[i].h; j++) {
5514 ptr += sprintf(ptr, "layer\r\n");
5515 for(k = 0; k < model->voxel[i].d; k++) {
5516 for(l = 0; l < model->voxel[i].w; l++, n++) {
5517 switch(model->voxel[i].data[n]) {
5518 case M3D_VOXCLEAR: *ptr++ = '-'; break;
5519 case M3D_VOXUNDEF: *ptr++ = '.'; break;
5520 default: ptr += sprintf(ptr, "%d", model->voxel[i].data[n]); break;
5521 }
5522 *ptr++ = ' ';
5523 }
5524 ptr--;
5525 ptr += sprintf(ptr, "\r\n");
5526 }
5527 }
5528 ptr += sprintf(ptr, "\r\n");
5529 }
5530 }
5531 /* mathematical shapes face */
5532 if(model->numshape && model->numshape && !(flags & M3D_EXP_NOFACE)) {
5533 for(j = 0; j < model->numshape; j++) {
5534 sn = _m3d_safestr(model->shape[j].name, 0);
5535 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5536 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)33);
5537 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5538 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5539 ptr += sprintf(ptr, "Shape %s\r\n", sn);
5540 M3D_FREE(sn); sn = NULL;
5541 if(model->shape[j].group != M3D_UNDEF && !(flags & M3D_EXP_NOBONE))
5542 ptr += sprintf(ptr, "group %d\r\n", model->shape[j].group);
5543 for(i = 0; i < model->shape[j].numcmd; i++) {
5544 cmd = &model->shape[j].cmd[i];
5545 if(cmd->type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])) || !cmd->arg)
5546 continue;
5547 cd = &m3d_commandtypes[cmd->type];
5548 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(cd->key) + (uintptr_t)3);
5549 for(k = 0; k < cd->p; k++)
5550 switch(cd->a[k]) {
5551 case m3dcp_mi_t: if(cmd->arg[k] != M3D_NOTDEFINED) { len += (unsigned int)strlen(model->material[cmd->arg[k]].name) + 1; } break;
5552 case m3dcp_va_t: len += cmd->arg[k] * (cd->p - k - 1) * 16; k = cd->p; break;
5553 default: len += 16; break;
5554 }
5555 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5556 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5557 ptr += sprintf(ptr, "%s", cd->key);
5558 for(k = n = 0, l = cd->p; k < l; k++) {
5559 switch(cd->a[((k - n) % (cd->p - n)) + n]) {
5560 case m3dcp_mi_t:
5561 if(cmd->arg[k] != M3D_NOTDEFINED) {
5562 sn = _m3d_safestr(model->material[cmd->arg[k]].name, 0);
5563 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5564 ptr += sprintf(ptr, " %s", sn);
5565 M3D_FREE(sn); sn = NULL;
5566 }
5567 break;
5568 case m3dcp_vc_t: ptr += sprintf(ptr, " %g", *((float*)&cmd->arg[k])); break;
5569 case m3dcp_va_t: ptr += sprintf(ptr, " %d[", cmd->arg[k]);
5570 n = k + 1; l += (cmd->arg[k] - 1) * (cd->p - k - 1);
5571 break;
5572 default: ptr += sprintf(ptr, " %d", cmd->arg[k]); break;
5573 }
5574 }
5575 ptr += sprintf(ptr, "%s\r\n", l > cd->p ? " ]" : "");
5576 }
5577 ptr += sprintf(ptr, "\r\n");
5578 }
5579 }
5580 /* annotation labels */
5581 if(model->numlabel && model->label && !(flags & M3D_EXP_NOFACE)) {
5582 for(i = 0, j = 3, length = NULL; i < model->numlabel; i++) {
5583 if(model->label[i].name) j += (unsigned int)strlen(model->label[i].name);
5584 if(model->label[i].lang) j += (unsigned int)strlen(model->label[i].lang);
5585 if(model->label[i].text) j += (unsigned int)strlen(model->label[i].text);
5586 j += 40;
5587 }
5588 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)j);
5589 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5590 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5591 for(i = 0; i < model->numlabel; i++) {
5592 if(!i || _m3d_strcmp(sl, model->label[i].lang) || _m3d_strcmp(sn, model->label[i].name)) {
5593 sl = model->label[i].lang;
5594 sn = model->label[i].name;
5595 sd = _m3d_safestr(sn, 0);
5596 if(!sd) { setlocale(LC_NUMERIC, ol); sn = sl = NULL; goto memerr; }
5597 if(i) ptr += sprintf(ptr, "\r\n");
5598 ptr += sprintf(ptr, "Labels %s\r\n", sd);
5599 M3D_FREE(sd); sd = NULL;
5600 if(model->label[i].color)
5601 ptr += sprintf(ptr, "color #0x%08x\r\n", model->label[i].color);
5602 if(sl && *sl) {
5603 sd = _m3d_safestr(sl, 0);
5604 if(!sd) { setlocale(LC_NUMERIC, ol); sn = sl = NULL; goto memerr; }
5605 ptr += sprintf(ptr, "lang %s\r\n", sd);
5606 M3D_FREE(sd); sd = NULL;
5607 }
5608 }
5609 sd = _m3d_safestr(model->label[i].text, 2);
5610 if(!sd) { setlocale(LC_NUMERIC, ol); sn = sl = NULL; goto memerr; }
5611 ptr += sprintf(ptr, "%d %s\r\n", model->label[i].vertexid, sd);
5612 M3D_FREE(sd); sd = NULL;
5613 }
5614 ptr += sprintf(ptr, "\r\n");
5615 sn = sl = NULL;
5616 }
5617 /* actions */
5618 if(model->numaction && model->action && !(flags & M3D_EXP_NOACTION)) {
5619 for(j = 0; j < model->numaction; j++) {
5620 a = &model->action[j];
5621 sn = _m3d_safestr(a->name, 0);
5622 if(!sn) { setlocale(LC_NUMERIC, ol); goto memerr; }
5623 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)strlen(sn) + (uintptr_t)48);
5624 for(i = 0; i < a->numframe; i++)
5625 len += a->frame[i].numtransform * 128 + 8;
5626 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5627 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5628 ptr += sprintf(ptr, "Action %d %s\r\n", a->durationmsec, sn);
5629 M3D_FREE(sn); sn = NULL;
5630 for(i = 0; i < a->numframe; i++) {
5631 ptr += sprintf(ptr, "frame %d\r\n", a->frame[i].msec);
5632 for(k = 0; k < a->frame[i].numtransform; k++) {
5633 ptr += sprintf(ptr, "%d %d %d\r\n", a->frame[i].transform[k].boneid,
5634 vrtxidx[a->frame[i].transform[k].pos], vrtxidx[a->frame[i].transform[k].ori]);
5635 }
5636 }
5637 ptr += sprintf(ptr, "\r\n");
5638 }
5639 }
5640 /* inlined assets */
5641 if(model->numinlined && model->inlined) {
5642 for(i = j = 0; i < model->numinlined; i++)
5643 if(model->inlined[i].name)
5644 j += (unsigned int)strlen(model->inlined[i].name) + 6;
5645 if(j > 0) {
5646 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)j + (uintptr_t)16);
5647 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5648 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5649 ptr += sprintf(ptr, "Assets\r\n");
5650 for(i = 0; i < model->numinlined; i++)
5651 if(model->inlined[i].name)
5652 ptr += sprintf(ptr, "%s%s\r\n", model->inlined[i].name, strrchr(model->inlined[i].name, '.') ? "" : ".png");
5653 ptr += sprintf(ptr, "\r\n");
5654 }
5655 }
5656 /* extra info */
5657 if(model->numextra && (flags & M3D_EXP_EXTRA)) {
5658 for(i = 0; i < model->numextra; i++) {
5659 if(model->extra[i]->length < 9) continue;
5660 ptr -= (uintptr_t)out; len = (unsigned int)((uintptr_t)ptr + (uintptr_t)17 + (uintptr_t)(model->extra[i]->length * 3));
5661 out = (unsigned char*)M3D_REALLOC(out, len); ptr += (uintptr_t)out;
5662 if(!out) { setlocale(LC_NUMERIC, ol); goto memerr; }
5663 ptr += sprintf(ptr, "Extra %c%c%c%c\r\n",
5664 model->extra[i]->magic[0] > ' ' ? model->extra[i]->magic[0] : '_',
5665 model->extra[i]->magic[1] > ' ' ? model->extra[i]->magic[1] : '_',
5666 model->extra[i]->magic[2] > ' ' ? model->extra[i]->magic[2] : '_',
5667 model->extra[i]->magic[3] > ' ' ? model->extra[i]->magic[3] : '_');
5668 for(j = 0; j < model->extra[i]->length; j++)
5669 ptr += sprintf(ptr, "%02x ", *((unsigned char *)model->extra + sizeof(m3dchunk_t) + j));
5670 ptr--;
5671 ptr += sprintf(ptr, "\r\n\r\n");
5672 }
5673 }
5674 setlocale(LC_NUMERIC, ol);
5675 len = (unsigned int)((uintptr_t)ptr - (uintptr_t)out);
5676 out = (unsigned char*)M3D_REALLOC(out, len + 1);
5677 if(!out) goto memerr;
5678 out[len] = 0;
5679 } else
5680 #endif
5681 {
5682 /* stricly only use LF (newline) in binary */
5683 sd = _m3d_safestr(model->desc, 3);
5684 if(!sd) goto memerr;
5685 /* header */
5686 h = (m3dhdr_t*)M3D_MALLOC(sizeof(m3dhdr_t) + strlen(sn) + strlen(sl) + strlen(sa) + strlen(sd) + 4);
5687 if(!h) goto memerr;
5688 memcpy((uint8_t*)h, "HEAD", 4);
5689 h->length = sizeof(m3dhdr_t);
5690 h->scale = scale;
5691 i = (unsigned int)strlen(sn); memcpy((uint8_t*)h + h->length, sn, i+1); h->length += i+1; M3D_FREE(sn);
5692 i = (unsigned int)strlen(sl); memcpy((uint8_t*)h + h->length, sl, i+1); h->length += i+1; M3D_FREE(sl);
5693 i = (unsigned int)strlen(sa); memcpy((uint8_t*)h + h->length, sa, i+1); h->length += i+1; M3D_FREE(sa);
5694 i = (unsigned int)strlen(sd); memcpy((uint8_t*)h + h->length, sd, i+1); h->length += i+1; M3D_FREE(sd);
5695 sn = sl = sa = sd = NULL;
5696 if(model->inlined)
5697 for(i = 0; i < model->numinlined; i++) {
5698 if(model->inlined[i].name && *model->inlined[i].name && model->inlined[i].length > 0) {
5699 str = _m3d_addstr(str, &numstr, model->inlined[i].name);
5700 if(!str) goto memerr;
5701 }
5702 }
5703 if(str)
5704 for(i = 0; i < numstr; i++) {
5705 h = _m3d_addhdr(h, &str[i]);
5706 if(!h) goto memerr;
5707 }
5708 vc_s = quality == M3D_EXP_INT8? 1 : (quality == M3D_EXP_INT16? 2 : (quality == M3D_EXP_DOUBLE? 8 : 4));
5709 vi_s = maxvrtx < 254 ? 1 : (maxvrtx < 65534 ? 2 : 4);
5710 si_s = h->length - 16 < 254 ? 1 : (h->length - 16 < 65534 ? 2 : 4);
5711 ci_s = !numcmap || !cmap ? 0 : (numcmap < 254 ? 1 : (numcmap < 65534 ? 2 : 4));
5712 ti_s = !maxtmap || !tmap ? 0 : (maxtmap < 254 ? 1 : (maxtmap < 65534 ? 2 : 4));
5713 bi_s = !model->numbone || !model->bone || (flags & M3D_EXP_NOBONE)? 0 : (model->numbone < 254 ? 1 :
5714 (model->numbone < 65534 ? 2 : 4));
5715 nb_s = maxbone < 2 ? 1 : (maxbone == 2 ? 2 : (maxbone <= 4 ? 4 : 8));
5716 sk_s = !bi_s || !maxskin || !skin ? 0 : (maxskin < 254 ? 1 : (maxskin < 65534 ? 2 : 4));
5717 fc_s = maxt < 254 ? 1 : (maxt < 65534 ? 2 : 4);
5718 hi_s = !model->numshape || !model->shape || (flags & M3D_EXP_NOFACE)? 0 : (model->numshape < 254 ? 1 :
5719 (model->numshape < 65534 ? 2 : 4));
5720 fi_s = !model->numface || !model->face || (flags & M3D_EXP_NOFACE)? 0 : (model->numface < 254 ? 1 :
5721 (model->numface < 65534 ? 2 : 4));
5722 vd_s = !model->numvoxel || !model->voxel || (flags & M3D_EXP_NOFACE)? 0 : (minvox >= -128 && maxvox <= 127 ? 1 :
5723 (minvox >= -32768 && maxvox <= 32767 ? 2 : 4));
5724 vp_s = !model->numvoxtype || !model->voxtype || (flags & M3D_EXP_NOFACE)? 0 : (model->numvoxtype < 254 ? 1 :
5725 (model->numvoxtype < 65534 ? 2 : 4));
5726 h->types = (vc_s == 8 ? (3<<0) : (vc_s == 2 ? (1<<0) : (vc_s == 1 ? (0<<0) : (2<<0)))) |
5727 (vi_s == 2 ? (1<<2) : (vi_s == 1 ? (0<<2) : (2<<2))) |
5728 (si_s == 2 ? (1<<4) : (si_s == 1 ? (0<<4) : (2<<4))) |
5729 (ci_s == 2 ? (1<<6) : (ci_s == 1 ? (0<<6) : (ci_s == 4 ? (2<<6) : (3<<6)))) |
5730 (ti_s == 2 ? (1<<8) : (ti_s == 1 ? (0<<8) : (ti_s == 4 ? (2<<8) : (3<<8)))) |
5731 (bi_s == 2 ? (1<<10): (bi_s == 1 ? (0<<10): (bi_s == 4 ? (2<<10) : (3<<10)))) |
5732 (nb_s == 2 ? (1<<12): (nb_s == 1 ? (0<<12): (2<<12))) |
5733 (sk_s == 2 ? (1<<14): (sk_s == 1 ? (0<<14): (sk_s == 4 ? (2<<14) : (3<<14)))) |
5734 (fc_s == 2 ? (1<<16): (fc_s == 1 ? (0<<16): (2<<16))) |
5735 (hi_s == 2 ? (1<<18): (hi_s == 1 ? (0<<18): (hi_s == 4 ? (2<<18) : (3<<18)))) |
5736 (fi_s == 2 ? (1<<20): (fi_s == 1 ? (0<<20): (fi_s == 4 ? (2<<20) : (3<<20)))) |
5737 (vd_s == 2 ? (1<<22): (vd_s == 1 ? (0<<22): (vd_s == 4 ? (2<<22) : (3<<22)))) |
5738 (vp_s == 2 ? (1<<24): (vp_s == 1 ? (0<<24): (vp_s == 4 ? (2<<24) : (3<<24))));
5739 len = h->length;
5740 /* color map */
5741 if(numcmap && cmap && ci_s < 4 && !(flags & M3D_EXP_NOCMAP)) {
5742 chunklen = 8 + numcmap * sizeof(uint32_t);
5743 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5744 if(!h) goto memerr;
5745 memcpy((uint8_t*)h + len, "CMAP", 4);
5746 *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
5747 memcpy((uint8_t*)h + len + 8, cmap, chunklen - 8);
5748 len += chunklen;
5749 } else numcmap = 0;
5750 /* texture map */
5751 if(numtmap && tmap && !(flags & M3D_EXP_NOTXTCRD) && !(flags & M3D_EXP_NOFACE)) {
5752 chunklen = 8 + maxtmap * vc_s * 2;
5753 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5754 if(!h) goto memerr;
5755 memcpy((uint8_t*)h + len, "TMAP", 4);
5756 length = (uint32_t*)((uint8_t*)h + len + 4);
5757 out = (uint8_t*)h + len + 8;
5758 last = M3D_UNDEF;
5759 for(i = 0; i < numtmap; i++) {
5760 if(tmap[i].newidx == last) continue;
5761 last = tmap[i].newidx;
5762 switch(vc_s) {
5763 case 1: *out++ = (uint8_t)(tmap[i].data.u * 255); *out++ = (uint8_t)(tmap[i].data.v * 255); break;
5764 case 2:
5765 *((uint16_t*)out) = (uint16_t)(tmap[i].data.u * 65535); out += 2;
5766 *((uint16_t*)out) = (uint16_t)(tmap[i].data.v * 65535); out += 2;
5767 break;
5768 case 4: *((float*)out) = tmap[i].data.u; out += 4; *((float*)out) = tmap[i].data.v; out += 4; break;
5769 case 8: *((double*)out) = tmap[i].data.u; out += 8; *((double*)out) = tmap[i].data.v; out += 8; break;
5770 }
5771 }
5772 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
5773 out = NULL;
5774 len += *length;
5775 }
5776 /* vertex */
5777 if(numvrtx && vrtx) {
5778 chunklen = 8 + maxvrtx * (ci_s + sk_s + 4 * vc_s);
5779 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5780 if(!h) goto memerr;
5781 memcpy((uint8_t*)h + len, "VRTS", 4);
5782 length = (uint32_t*)((uint8_t*)h + len + 4);
5783 out = (uint8_t*)h + len + 8;
5784 last = M3D_UNDEF;
5785 for(i = 0; i < numvrtx; i++) {
5786 if(vrtx[i].newidx == last) continue;
5787 last = vrtx[i].newidx;
5788 switch(vc_s) {
5789 case 1:
5790 *out++ = (int8_t)(vrtx[i].data.x * 127);
5791 *out++ = (int8_t)(vrtx[i].data.y * 127);
5792 *out++ = (int8_t)(vrtx[i].data.z * 127);
5793 *out++ = (int8_t)(vrtx[i].data.w * 127);
5794 break;
5795 case 2:
5796 *((int16_t*)out) = (int16_t)(vrtx[i].data.x * 32767); out += 2;
5797 *((int16_t*)out) = (int16_t)(vrtx[i].data.y * 32767); out += 2;
5798 *((int16_t*)out) = (int16_t)(vrtx[i].data.z * 32767); out += 2;
5799 *((int16_t*)out) = (int16_t)(vrtx[i].data.w * 32767); out += 2;
5800 break;
5801 case 4:
5802 *((float*)out) = vrtx[i].data.x; out += 4;
5803 *((float*)out) = vrtx[i].data.y; out += 4;
5804 *((float*)out) = vrtx[i].data.z; out += 4;
5805 *((float*)out) = vrtx[i].data.w; out += 4;
5806 break;
5807 case 8:
5808 *((double*)out) = vrtx[i].data.x; out += 8;
5809 *((double*)out) = vrtx[i].data.y; out += 8;
5810 *((double*)out) = vrtx[i].data.z; out += 8;
5811 *((double*)out) = vrtx[i].data.w; out += 8;
5812 break;
5813 }
5814 idx = _m3d_cmapidx(cmap, numcmap, vrtx[i].data.color);
5815 switch(ci_s) {
5816 case 1: *out++ = (uint8_t)(idx); break;
5817 case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
5818 case 4: *((uint32_t*)out) = vrtx[i].data.color; out += 4; break;
5819 }
5820 out = _m3d_addidx(out, sk_s, vrtx[i].data.skinid);
5821 }
5822 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
5823 out = NULL;
5824 len += *length;
5825 }
5826 /* bones chunk */
5827 if(model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
5828 i = 8 + bi_s + sk_s + model->numbone * (bi_s + si_s + 2*vi_s);
5829 chunklen = i + numskin * nb_s * (bi_s + 1);
5830 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5831 if(!h) goto memerr;
5832 memcpy((uint8_t*)h + len, "BONE", 4);
5833 length = (uint32_t*)((uint8_t*)h + len + 4);
5834 out = (uint8_t*)h + len + 8;
5835 out = _m3d_addidx(out, bi_s, model->numbone);
5836 out = _m3d_addidx(out, sk_s, maxskin);
5837 for(i = 0; i < model->numbone; i++) {
5838 out = _m3d_addidx(out, bi_s, model->bone[i].parent);
5839 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->bone[i].name));
5840 out = _m3d_addidx(out, vi_s, vrtxidx[model->bone[i].pos]);
5841 out = _m3d_addidx(out, vi_s, vrtxidx[model->bone[i].ori]);
5842 }
5843 if(numskin && skin && sk_s) {
5844 last = M3D_UNDEF;
5845 for(i = 0; i < numskin; i++) {
5846 if(skin[i].newidx == last) continue;
5847 last = skin[i].newidx;
5848 memset(&weights, 0, nb_s);
5849 for(j = 0; j < (uint32_t)nb_s && skin[i].data.boneid[j] != M3D_UNDEF &&
5850 skin[i].data.weight[j] > (M3D_FLOAT)0.0; j++)
5851 weights[j] = (uint8_t)(skin[i].data.weight[j] * 255);
5852 switch(nb_s) {
5853 case 1: weights[0] = 255; break;
5854 case 2: memcpy(out, weights, 2); out += 2; break;
5855 case 4: memcpy(out, weights, 4); out += 4; break;
5856 case 8: memcpy(out, weights, 8); out += 8; break;
5857 }
5858 for(j = 0; j < (uint32_t)nb_s && skin[i].data.boneid[j] != M3D_UNDEF && weights[j]; j++) {
5859 out = _m3d_addidx(out, bi_s, skin[i].data.boneid[j]);
5860 *length += bi_s;
5861 }
5862 }
5863 }
5864 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
5865 out = NULL;
5866 len += *length;
5867 }
5868 /* materials */
5869 if(model->nummaterial && !(flags & M3D_EXP_NOMATERIAL)) {
5870 for(j = 0; j < model->nummaterial; j++) {
5871 if(mtrlidx[j] == M3D_UNDEF || !model->material[j].numprop || !model->material[j].prop) continue;
5872 m = &model->material[j];
5873 chunklen = 12 + si_s + m->numprop * 5;
5874 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5875 if(!h) goto memerr;
5876 memcpy((uint8_t*)h + len, "MTRL", 4);
5877 length = (uint32_t*)((uint8_t*)h + len + 4);
5878 out = (uint8_t*)h + len + 8;
5879 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, m->name));
5880 for(i = 0; i < m->numprop; i++) {
5881 if(m->prop[i].type >= 128) {
5882 if(m->prop[i].value.textureid >= model->numtexture ||
5883 !model->texture[m->prop[i].value.textureid].name) continue;
5884 k = m3dpf_map;
5885 } else {
5886 for(k = 256, l = 0; l < sizeof(m3d_propertytypes)/sizeof(m3d_propertytypes[0]); l++)
5887 if(m->prop[i].type == m3d_propertytypes[l].id) { k = m3d_propertytypes[l].format; break; }
5888 }
5889 if(k == 256) continue;
5890 *out++ = m->prop[i].type;
5891 switch(k) {
5892 case m3dpf_color:
5893 if(!(flags & M3D_EXP_NOCMAP)) {
5894 idx = _m3d_cmapidx(cmap, numcmap, m->prop[i].value.color);
5895 switch(ci_s) {
5896 case 1: *out++ = (uint8_t)(idx); break;
5897 case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
5898 case 4: *((uint32_t*)out) = (uint32_t)(m->prop[i].value.color); out += 4; break;
5899 }
5900 } else out--;
5901 break;
5902 case m3dpf_uint8: *out++ = m->prop[i].value.num; break;
5903 case m3dpf_uint16: *((uint16_t*)out) = m->prop[i].value.num; out += 2; break;
5904 case m3dpf_uint32: *((uint32_t*)out) = m->prop[i].value.num; out += 4; break;
5905 case m3dpf_float: *((float*)out) = m->prop[i].value.fnum; out += 4; break;
5906
5907 case m3dpf_map:
5908 idx = _m3d_stridx(str, numstr, model->texture[m->prop[i].value.textureid].name);
5909 out = _m3d_addidx(out, si_s, idx);
5910 break;
5911 }
5912 }
5913 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
5914 len += *length;
5915 out = NULL;
5916 }
5917 }
5918 /* procedural face */
5919 if(model->numinlined && model->inlined && !(flags & M3D_EXP_NOFACE)) {
5920 /* all inlined assets which are not textures should be procedural surfaces */
5921 for(j = 0; j < model->numinlined; j++) {
5922 if(!model->inlined[j].name || !model->inlined[j].name[0] || model->inlined[j].length < 4 ||
5923 !model->inlined[j].data || (model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' &&
5924 model->inlined[j].data[3] == 'G'))
5925 continue;
5926 for(i = k = 0; i < model->numtexture; i++) {
5927 if(!strcmp(model->inlined[j].name, model->texture[i].name)) { k = 1; break; }
5928 }
5929 if(k) continue;
5930 numproc++;
5931 chunklen = 8 + si_s;
5932 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5933 if(!h) goto memerr;
5934 memcpy((uint8_t*)h + len, "PROC", 4);
5935 *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
5936 out = (uint8_t*)h + len + 8;
5937 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->inlined[j].name));
5938 out = NULL;
5939 len += chunklen;
5940 }
5941 }
5942 /* mesh face */
5943 if(model->numface && face && !(flags & M3D_EXP_NOFACE)) {
5944 chunklen = 8 + si_s + model->numface * (6 * vi_s + 3 * ti_s + si_s + 1);
5945 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
5946 if(!h) goto memerr;
5947 memcpy((uint8_t*)h + len, "MESH", 4);
5948 length = (uint32_t*)((uint8_t*)h + len + 4);
5949 out = (uint8_t*)h + len + 8;
5950 last = M3D_UNDEF;
5951 #ifdef M3D_VERTEXMAX
5952 lastp = M3D_UNDEF;
5953 #endif
5954 for(i = 0; i < model->numface; i++) {
5955 if(!(flags & M3D_EXP_NOMATERIAL) && face[i].data.materialid != last) {
5956 last = face[i].data.materialid;
5957 idx = last < model->nummaterial ? _m3d_stridx(str, numstr, model->material[last].name) : 0;
5958 *out++ = 0;
5959 out = _m3d_addidx(out, si_s, idx);
5960 }
5961 #ifdef M3D_VERTEXMAX
5962 if(!(flags & M3D_EXP_NOVRTMAX) && face[i].data.paramid != lastp) {
5963 lastp = face[i].data.paramid;
5964 idx = lastp < model->numparam ? _m3d_stridx(str, numstr, model->param[lastp].name) : 0;
5965 *out++ = 0;
5966 out = _m3d_addidx(out, si_s, idx);
5967 }
5968 #endif
5969 /* hardcoded triangles. */
5970 k = (3 << 4) |
5971 (((flags & M3D_EXP_NOTXTCRD) || !ti_s || face[i].data.texcoord[0] == M3D_UNDEF ||
5972 face[i].data.texcoord[1] == M3D_UNDEF || face[i].data.texcoord[2] == M3D_UNDEF) ? 0 : 1) |
5973 (((flags & M3D_EXP_NONORMAL) || face[i].data.normal[0] == M3D_UNDEF ||
5974 face[i].data.normal[1] == M3D_UNDEF || face[i].data.normal[2] == M3D_UNDEF) ? 0 : 2)
5975 #ifdef M3D_VERTEXMAX
5976 | (((flags & M3D_EXP_NOVRTMAX) || face[i].data.vertmax[0] == M3D_UNDEF ||
5977 face[i].data.vertmax[1] == M3D_UNDEF || face[i].data.vertmax[2] == M3D_UNDEF) ? 0 : 4)
5978 #endif
5979 ;
5980 *out++ = k;
5981 for(j = 0; j < 3; j++) {
5982 out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.vertex[j]]);
5983 if(k & 1)
5984 out = _m3d_addidx(out, ti_s, tmapidx[face[i].data.texcoord[j]]);
5985 if(k & 2)
5986 out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.normal[j]]);
5987 #ifdef M3D_VERTEXMAX
5988 if(k & 4)
5989 out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.vertmax[j]]);
5990 #endif
5991 }
5992 }
5993 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
5994 len += *length;
5995 out = NULL;
5996 }
5997 /* voxel face */
5998 if(model->numvoxtype && model->voxtype && !(flags & M3D_EXP_NOFACE)) {
5999 chunklen = 8 + si_s + model->numvoxtype * (ci_s + si_s + 3 + sk_s);
6000 for(i = 0; i < model->numvoxtype; i++)
6001 chunklen += model->voxtype[i].numitem * (2 + si_s);
6002 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6003 if(!h) goto memerr;
6004 memcpy((uint8_t*)h + len, "VOXT", 4);
6005 length = (uint32_t*)((uint8_t*)h + len + 4);
6006 out = (uint8_t*)h + len + 8;
6007 for(i = 0; i < model->numvoxtype; i++) {
6008 if(!(flags & M3D_EXP_NOCMAP)) {
6009 idx = _m3d_cmapidx(cmap, numcmap, model->voxtype[i].color);
6010 switch(ci_s) {
6011 case 1: *out++ = (uint8_t)(idx); break;
6012 case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
6013 case 4: *((uint32_t*)out) = (uint32_t)(model->voxtype[i].color); out += 4; break;
6014 }
6015 }
6016 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->voxtype[i].name));
6017 *out++ = (model->voxtype[i].rotation & 0xBF) | (((model->voxtype[i].voxshape >> 8) & 1) << 6);
6018 *out++ = model->voxtype[i].voxshape;
6019 *out++ = model->voxtype[i].numitem;
6020 if(!(flags & M3D_EXP_NOBONE) && model->numbone && maxskin)
6021 out = _m3d_addidx(out, sk_s, skinidx[model->voxtype[i].skinid]);
6022 for(j = 0; j < model->voxtype[i].numitem; j++) {
6023 out = _m3d_addidx(out, 2, model->voxtype[i].item[j].count);
6024 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->voxtype[i].item[j].name));
6025 }
6026 }
6027 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
6028 len += *length;
6029 out = NULL;
6030 }
6031 if(model->numvoxel && model->voxel && !(flags & M3D_EXP_NOFACE)) {
6032 for(j = 0; j < model->numvoxel; j++) {
6033 chunklen = 8 + si_s + 6 * vd_s + 2 + model->voxel[j].w * model->voxel[j].h * model->voxel[j].d * 3;
6034 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6035 if(!h) goto memerr;
6036 memcpy((uint8_t*)h + len, "VOXD", 4);
6037 length = (uint32_t*)((uint8_t*)h + len + 4);
6038 out = (uint8_t*)h + len + 8;
6039 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->voxel[j].name));
6040 out = _m3d_addidx(out, vd_s, model->voxel[j].x);
6041 out = _m3d_addidx(out, vd_s, model->voxel[j].y);
6042 out = _m3d_addidx(out, vd_s, model->voxel[j].z);
6043 out = _m3d_addidx(out, vd_s, model->voxel[j].w);
6044 out = _m3d_addidx(out, vd_s, model->voxel[j].h);
6045 out = _m3d_addidx(out, vd_s, model->voxel[j].d);
6046 *out++ = model->voxel[j].uncertain;
6047 *out++ = model->voxel[j].groupid;
6048 /* RLE compress voxel data */
6049 n = model->voxel[j].w * model->voxel[j].h * model->voxel[j].d;
6050 k = o = 0; out[o++] = 0;
6051 for(i = 0; i < n; i++) {
6052 for(l = 1; l < 128 && i + l < n && model->voxel[j].data[i] == model->voxel[j].data[i + l]; l++);
6053 if(l > 1) {
6054 l--;
6055 if(out[k]) { out[k]--; out[o++] = 0x80 | l; }
6056 else out[k] = 0x80 | l;
6057 switch(vp_s) {
6058 case 1: out[o++] = model->voxel[j].data[i]; break;
6059 default: *((uint16_t*)(out + o)) = model->voxel[j].data[i]; o += 2; break;
6060 }
6061 k = o; out[o++] = 0;
6062 i += l;
6063 continue;
6064 }
6065 out[k]++;
6066 switch(vp_s) {
6067 case 1: out[o++] = model->voxel[j].data[i]; break;
6068 default: *((uint16_t*)(out + o)) = model->voxel[j].data[i]; o += 2; break;
6069 }
6070 if(out[k] > 127) { out[k]--; k = o; out[o++] = 0; }
6071 }
6072 if(!(out[k] & 0x80)) { if(out[k]) out[k]--; else o--; }
6073 *length = (uint32_t)((uintptr_t)out + (uintptr_t)o - (uintptr_t)((uint8_t*)h + len));
6074 len += *length;
6075 out = NULL;
6076 }
6077 }
6078 /* mathematical shapes face */
6079 if(model->numshape && model->shape && !(flags & M3D_EXP_NOFACE)) {
6080 for(j = 0; j < model->numshape; j++) {
6081 chunklen = 12 + si_s + model->shape[j].numcmd * (M3D_CMDMAXARG + 1) * 4;
6082 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6083 if(!h) goto memerr;
6084 memcpy((uint8_t*)h + len, "SHPE", 4);
6085 length = (uint32_t*)((uint8_t*)h + len + 4);
6086 out = (uint8_t*)h + len + 8;
6087 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->shape[j].name));
6088 out = _m3d_addidx(out, bi_s, model->shape[j].group);
6089 for(i = 0; i < model->shape[j].numcmd; i++) {
6090 cmd = &model->shape[j].cmd[i];
6091 if(cmd->type >= (unsigned int)(sizeof(m3d_commandtypes)/sizeof(m3d_commandtypes[0])) || !cmd->arg)
6092 continue;
6093 cd = &m3d_commandtypes[cmd->type];
6094 *out++ = (cmd->type & 0x7F) | (cmd->type > 127 ? 0x80 : 0);
6095 if(cmd->type > 127) *out++ = (cmd->type >> 7) & 0xff;
6096 for(k = n = 0, l = cd->p; k < l; k++) {
6097 switch(cd->a[((k - n) % (cd->p - n)) + n]) {
6098 case m3dcp_mi_t:
6099 out = _m3d_addidx(out, si_s, cmd->arg[k] < model->nummaterial ?
6100 _m3d_stridx(str, numstr, model->material[cmd->arg[k]].name) : 0);
6101 break;
6102 case m3dcp_vc_t:
6103 min_x = *((float*)&cmd->arg[k]);
6104 switch(vc_s) {
6105 case 1: *out++ = (int8_t)(min_x * 127); break;
6106 case 2: *((int16_t*)out) = (int16_t)(min_x * 32767); out += 2; break;
6107 case 4: *((float*)out) = min_x; out += 4; break;
6108 case 8: *((double*)out) = min_x; out += 8; break;
6109 }
6110 break;
6111 case m3dcp_hi_t: out = _m3d_addidx(out, hi_s, cmd->arg[k]); break;
6112 case m3dcp_fi_t: out = _m3d_addidx(out, fi_s, cmd->arg[k]); break;
6113 case m3dcp_ti_t: out = _m3d_addidx(out, ti_s, cmd->arg[k]); break;
6114 case m3dcp_qi_t:
6115 case m3dcp_vi_t: out = _m3d_addidx(out, vi_s, cmd->arg[k]); break;
6116 case m3dcp_i1_t: out = _m3d_addidx(out, 1, cmd->arg[k]); break;
6117 case m3dcp_i2_t: out = _m3d_addidx(out, 2, cmd->arg[k]); break;
6118 case m3dcp_i4_t: out = _m3d_addidx(out, 4, cmd->arg[k]); break;
6119 case m3dcp_va_t: out = _m3d_addidx(out, 4, cmd->arg[k]);
6120 n = k + 1; l += (cmd->arg[k] - 1) * (cd->p - k - 1);
6121 break;
6122 }
6123 }
6124 }
6125 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
6126 len += *length;
6127 out = NULL;
6128 }
6129 }
6130 /* annotation labels */
6131 if(model->numlabel && model->label) {
6132 for(i = 0, length = NULL; i < model->numlabel; i++) {
6133 if(!i || _m3d_strcmp(sl, model->label[i].lang) || _m3d_strcmp(sn, model->label[i].name)) {
6134 sl = model->label[i].lang;
6135 sn = model->label[i].name;
6136 if(length) {
6137 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
6138 len += *length;
6139 }
6140 chunklen = 8 + 2 * si_s + ci_s + model->numlabel * (vi_s + si_s);
6141 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6142 if(!h) { sn = NULL; sl = NULL; goto memerr; }
6143 memcpy((uint8_t*)h + len, "LBLS", 4);
6144 length = (uint32_t*)((uint8_t*)h + len + 4);
6145 out = (uint8_t*)h + len + 8;
6146 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].name));
6147 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].lang));
6148 idx = _m3d_cmapidx(cmap, numcmap, model->label[i].color);
6149 switch(ci_s) {
6150 case 1: *out++ = (uint8_t)(idx); break;
6151 case 2: *((uint16_t*)out) = (uint16_t)(idx); out += 2; break;
6152 case 4: *((uint32_t*)out) = model->label[i].color; out += 4; break;
6153 }
6154 }
6155 out = _m3d_addidx(out, vi_s, vrtxidx[model->label[i].vertexid]);
6156 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].text));
6157 }
6158 if(length) {
6159 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
6160 len += *length;
6161 }
6162 out = NULL;
6163 sn = sl = NULL;
6164 }
6165 /* actions */
6166 if(model->numaction && model->action && model->numbone && model->bone && !(flags & M3D_EXP_NOACTION)) {
6167 for(j = 0; j < model->numaction; j++) {
6168 a = &model->action[j];
6169 chunklen = 14 + si_s + a->numframe * (4 + fc_s + maxt * (bi_s + 2 * vi_s));
6170 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6171 if(!h) goto memerr;
6172 memcpy((uint8_t*)h + len, "ACTN", 4);
6173 length = (uint32_t*)((uint8_t*)h + len + 4);
6174 out = (uint8_t*)h + len + 8;
6175 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, a->name));
6176 *((uint16_t*)out) = (uint16_t)(a->numframe); out += 2;
6177 *((uint32_t*)out) = (uint32_t)(a->durationmsec); out += 4;
6178 for(i = 0; i < a->numframe; i++) {
6179 *((uint32_t*)out) = (uint32_t)(a->frame[i].msec); out += 4;
6180 out = _m3d_addidx(out, fc_s, a->frame[i].numtransform);
6181 for(k = 0; k < a->frame[i].numtransform; k++) {
6182 out = _m3d_addidx(out, bi_s, a->frame[i].transform[k].boneid);
6183 out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].pos]);
6184 out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].ori]);
6185 }
6186 }
6187 *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t*)h + len));
6188 len += *length;
6189 out = NULL;
6190 }
6191 }
6192 /* inlined assets */
6193 if(model->numinlined && model->inlined && (numproc || (flags & M3D_EXP_INLINE))) {
6194 for(j = 0; j < model->numinlined; j++) {
6195 if(!model->inlined[j].name || !model->inlined[j].name[0] || model->inlined[j].length<4 || !model->inlined[j].data)
6196 continue;
6197 if(!(flags & M3D_EXP_INLINE)) {
6198 if(model->inlined[j].data[1] == 'P' && model->inlined[j].data[2] == 'N' && model->inlined[j].data[3] == 'G')
6199 continue;
6200 for(i = k = 0; i < model->numtexture; i++) {
6201 if(!strcmp(model->inlined[j].name, model->texture[i].name)) { k = 1; break; }
6202 }
6203 if(k) continue;
6204 }
6205 chunklen = 8 + si_s + model->inlined[j].length;
6206 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6207 if(!h) goto memerr;
6208 memcpy((uint8_t*)h + len, "ASET", 4);
6209 *((uint32_t*)((uint8_t*)h + len + 4)) = chunklen;
6210 out = (uint8_t*)h + len + 8;
6211 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->inlined[j].name));
6212 memcpy(out, model->inlined[j].data, model->inlined[j].length);
6213 out = NULL;
6214 len += chunklen;
6215 }
6216 }
6217 /* extra chunks */
6218 if(model->numextra && model->extra && (flags & M3D_EXP_EXTRA)) {
6219 for(j = 0; j < model->numextra; j++) {
6220 if(!model->extra[j] || model->extra[j]->length < 8)
6221 continue;
6222 chunklen = model->extra[j]->length;
6223 h = (m3dhdr_t*)M3D_REALLOC(h, len + chunklen);
6224 if(!h) goto memerr;
6225 memcpy((uint8_t*)h + len, model->extra[j], chunklen);
6226 len += chunklen;
6227 }
6228 }
6229 /* add end chunk */
6230 h = (m3dhdr_t*)M3D_REALLOC(h, len + 4);
6231 if(!h) goto memerr;
6232 memcpy((uint8_t*)h + len, "OMD3", 4);
6233 len += 4;
6234 /* zlib compress */
6235 if(!(flags & M3D_EXP_NOZLIB)) {
6236 M3D_LOG("Deflating chunks");
6237 z = stbi_zlib_compress((unsigned char *)h, len, (int*)&l, 9);
6238 if(z && l > 0 && l < len) { len = l; M3D_FREE(h); h = (m3dhdr_t*)z; }
6239 }
6240 /* add file header at the begining */
6241 len += 8;
6242 out = (unsigned char*)M3D_MALLOC(len);
6243 if(!out) goto memerr;
6244 memcpy(out, "3DMO", 4);
6245 *((uint32_t*)(out + 4)) = len;
6246 /* preview image chunk, must be the first if exists */
6247 if(model->preview.data && model->preview.length) {
6248 chunklen = 8 + model->preview.length;
6249 out = (unsigned char*)M3D_REALLOC(out, len + chunklen);
6250 if(!out) goto memerr;
6251 memcpy((uint8_t*)out + 8, "PRVW", 4);
6252 *((uint32_t*)((uint8_t*)out + 8 + 4)) = chunklen;
6253 memcpy((uint8_t*)out + 8 + 8, model->preview.data, model->preview.length);
6254 *((uint32_t*)(out + 4)) += chunklen;
6255 } else
6256 chunklen = 0;
6257 memcpy(out + 8 + chunklen, h, len - 8);
6258 }
6259 if(size) *size = out ? len : 0;
6260 if(vrtxidx) M3D_FREE(vrtxidx);
6261 if(mtrlidx) M3D_FREE(mtrlidx);
6262 if(tmapidx) M3D_FREE(tmapidx);
6263 if(skinidx) M3D_FREE(skinidx);
6264 if(norm) M3D_FREE(norm);
6265 if(face) M3D_FREE(face);
6266 if(cmap) M3D_FREE(cmap);
6267 if(tmap) M3D_FREE(tmap);
6268 if(skin) M3D_FREE(skin);
6269 if(str) M3D_FREE(str);
6270 if(vrtx) M3D_FREE(vrtx);
6271 if(h) M3D_FREE(h);
6272 return out;
6273 }
6274 #endif
6275
6276 #endif
6277
6278 #ifdef __cplusplus
6279 }
6280 #ifdef M3D_CPPWRAPPER
6281 #include <vector>
6282 #include <string>
6283 #include <memory>
6284
6285 /*** C++ wrapper class ***/
6286 namespace M3D {
6287 #ifdef M3D_IMPLEMENTATION
6288
6289 class Model {
6290 public:
6291 m3d_t *model;
6292
6293 public:
6294 Model() {
6295 this->model = (m3d_t*)malloc(sizeof(m3d_t)); memset(this->model, 0, sizeof(m3d_t));
6296 }
6297 Model(_unused const std::string &data, _unused m3dread_t ReadFileCB,
6298 _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
6299 #ifndef M3D_NOIMPORTER
6300 this->model = m3d_load((unsigned char *)data.data(), ReadFileCB, FreeCB, mtllib.model);
6301 #else
6302 Model();
6303 #endif
6304 }
6305 Model(_unused const std::vector<unsigned char> data, _unused m3dread_t ReadFileCB,
6306 _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
6307 #ifndef M3D_NOIMPORTER
6308 this->model = m3d_load((unsigned char *)&data[0], ReadFileCB, FreeCB, mtllib.model);
6309 #else
6310 Model();
6311 #endif
6312 }
6313 Model(_unused const unsigned char *data, _unused m3dread_t ReadFileCB,
6314 _unused m3dfree_t FreeCB, _unused M3D::Model mtllib) {
6315 #ifndef M3D_NOIMPORTER
6316 this->model = m3d_load((unsigned char*)data, ReadFileCB, FreeCB, mtllib.model);
6317 #else
6318 Model();
6319 #endif
6320 }
6321 ~Model() { m3d_free(this->model); }
6322
6323 public:
6324 m3d_t *getCStruct() { return this->model; }
6325 std::string getName() { return std::string(this->model->name); }
6326 void setName(std::string name) { this->model->name = (char*)name.c_str(); }
6327 std::string getLicense() { return std::string(this->model->license); }
6328 void setLicense(std::string license) { this->model->license = (char*)license.c_str(); }
6329 std::string getAuthor() { return std::string(this->model->author); }
6330 void setAuthor(std::string author) { this->model->author = (char*)author.c_str(); }
6331 std::string getDescription() { return std::string(this->model->desc); }
6332 void setDescription(std::string desc) { this->model->desc = (char*)desc.c_str(); }
6333 float getScale() { return this->model->scale; }
6334 void setScale(float scale) { this->model->scale = scale; }
6335 std::vector<unsigned char> getPreview() { return this->model->preview.data ?
6336 std::vector<unsigned char>(this->model->preview.data, this->model->preview.data + this->model->preview.length) :
6337 std::vector<unsigned char>(); }
6338 std::vector<uint32_t> getColorMap() { return this->model->cmap ? std::vector<uint32_t>(this->model->cmap,
6339 this->model->cmap + this->model->numcmap) : std::vector<uint32_t>(); }
6340 std::vector<m3dti_t> getTextureMap() { return this->model->tmap ? std::vector<m3dti_t>(this->model->tmap,
6341 this->model->tmap + this->model->numtmap) : std::vector<m3dti_t>(); }
6342 std::vector<m3dtx_t> getTextures() { return this->model->texture ? std::vector<m3dtx_t>(this->model->texture,
6343 this->model->texture + this->model->numtexture) : std::vector<m3dtx_t>(); }
6344 std::string getTextureName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numtexture ?
6345 std::string(this->model->texture[idx].name) : nullptr; }
6346 std::vector<m3db_t> getBones() { return this->model->bone ? std::vector<m3db_t>(this->model->bone, this->model->bone +
6347 this->model->numbone) : std::vector<m3db_t>(); }
6348 std::string getBoneName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numbone ?
6349 std::string(this->model->bone[idx].name) : nullptr; }
6350 std::vector<m3dm_t> getMaterials() { return this->model->material ? std::vector<m3dm_t>(this->model->material,
6351 this->model->material + this->model->nummaterial) : std::vector<m3dm_t>(); }
6352 std::string getMaterialName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->nummaterial ?
6353 std::string(this->model->material[idx].name) : nullptr; }
6354 int getMaterialPropertyInt(int idx, int type) {
6355 if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 0 || type >= 127 ||
6356 !this->model->material[idx].prop) return -1;
6357 for (int i = 0; i < this->model->material[idx].numprop; i++) {
6358 if (this->model->material[idx].prop[i].type == type)
6359 return this->model->material[idx].prop[i].value.num;
6360 }
6361 return -1;
6362 }
6363 uint32_t getMaterialPropertyColor(int idx, int type) { return this->getMaterialPropertyInt(idx, type); }
6364 float getMaterialPropertyFloat(int idx, int type) {
6365 if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 0 || type >= 127 ||
6366 !this->model->material[idx].prop) return -1.0f;
6367 for (int i = 0; i < this->model->material[idx].numprop; i++) {
6368 if (this->model->material[idx].prop[i].type == type)
6369 return this->model->material[idx].prop[i].value.fnum;
6370 }
6371 return -1.0f;
6372 }
6373 m3dtx_t* getMaterialPropertyMap(int idx, int type) {
6374 if (idx < 0 || (unsigned int)idx >= this->model->nummaterial || type < 128 || type > 255 ||
6375 !this->model->material[idx].prop) return nullptr;
6376 for (int i = 0; i < this->model->material[idx].numprop; i++) {
6377 if (this->model->material[idx].prop[i].type == type)
6378 return this->model->material[idx].prop[i].value.textureid < this->model->numtexture ?
6379 &this->model->texture[this->model->material[idx].prop[i].value.textureid] : nullptr;
6380 }
6381 return nullptr;
6382 }
6383 std::vector<m3dv_t> getVertices() { return this->model->vertex ? std::vector<m3dv_t>(this->model->vertex,
6384 this->model->vertex + this->model->numvertex) : std::vector<m3dv_t>(); }
6385 std::vector<m3df_t> getFace() { return this->model->face ? std::vector<m3df_t>(this->model->face, this->model->face +
6386 this->model->numface) : std::vector<m3df_t>(); }
6387 std::vector<m3dvt_t> getVoxelTypes() { return this->model->voxtype ? std::vector<m3dvt_t>(this->model->voxtype,
6388 this->model->voxtype + this->model->numvoxtype) : std::vector<m3dvt_t>(); }
6389 std::string getVoxelTypeName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numvoxtype &&
6390 this->model->voxtype[idx].name && this->model->voxtype[idx].name[0] ?
6391 std::string(this->model->voxtype[idx].name) : nullptr; }
6392 std::vector<m3dvi_t> getVoxelTypeItems(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numvoxtype &&
6393 this->model->voxtype[idx].item ? std::vector<m3dvi_t>(this->model->voxtype[idx].item,
6394 this->model->voxtype[idx].item + this->model->voxtype[idx].numitem) : std::vector<m3dvi_t>(); }
6395 std::vector<m3dvx_t> getVoxelBlocks() { return this->model->voxel ? std::vector<m3dvx_t>(this->model->voxel,
6396 this->model->voxel + this->model->numvoxel) : std::vector<m3dvx_t>(); }
6397 std::string getVoxelBlockName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numvoxel &&
6398 this->model->voxel[idx].name && this->model->voxel[idx].name[0] ?
6399 std::string(this->model->voxel[idx].name) : nullptr; }
6400 std::vector<M3D_VOXEL> getVoxelBlockData(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numvoxel &&
6401 this->model->voxel[idx].data ? std::vector<M3D_VOXEL>(this->model->voxel[idx].data,
6402 this->model->voxel[idx].data + this->model->voxel[idx].w*this->model->voxel[idx].h*this->model->voxel[idx].d) :
6403 std::vector<M3D_VOXEL>(); }
6404 std::vector<m3dh_t> getShape() { return this->model->shape ? std::vector<m3dh_t>(this->model->shape,
6405 this->model->shape + this->model->numshape) : std::vector<m3dh_t>(); }
6406 std::string getShapeName(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape &&
6407 this->model->shape[idx].name && this->model->shape[idx].name[0] ?
6408 std::string(this->model->shape[idx].name) : nullptr; }
6409 unsigned int getShapeGroup(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape ?
6410 this->model->shape[idx].group : 0xFFFFFFFF; }
6411 std::vector<m3dc_t> getShapeCommands(int idx) { return idx >= 0 && (unsigned int)idx < this->model->numshape &&
6412 this->model->shape[idx].cmd ? std::vector<m3dc_t>(this->model->shape[idx].cmd, this->model->shape[idx].cmd +
6413 this->model->shape[idx].numcmd) : std::vector<m3dc_t>(); }
6414 std::vector<m3dl_t> getAnnotationLabels() { return this->model->label ? std::vector<m3dl_t>(this->model->label,
6415 this->model->label + this->model->numlabel) : std::vector<m3dl_t>(); }
6416 std::vector<m3ds_t> getSkin() { return this->model->skin ? std::vector<m3ds_t>(this->model->skin, this->model->skin +
6417 this->model->numskin) : std::vector<m3ds_t>(); }
6418 std::vector<m3da_t> getActions() { return this->model->action ? std::vector<m3da_t>(this->model->action,
6419 this->model->action + this->model->numaction) : std::vector<m3da_t>(); }
6420 std::string getActionName(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
6421 std::string(this->model->action[aidx].name) : nullptr; }
6422 unsigned int getActionDuration(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
6423 this->model->action[aidx].durationmsec : 0; }
6424 std::vector<m3dfr_t> getActionFrames(int aidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction ?
6425 std::vector<m3dfr_t>(this->model->action[aidx].frame, this->model->action[aidx].frame +
6426 this->model->action[aidx].numframe) : std::vector<m3dfr_t>(); }
6427 unsigned int getActionFrameTimestamp(int aidx, int fidx) { return aidx >= 0 && (unsigned int)aidx < this->model->numaction?
6428 (fidx >= 0 && (unsigned int)fidx < this->model->action[aidx].numframe ?
6429 this->model->action[aidx].frame[fidx].msec : 0) : 0; }
6430 std::vector<m3dtr_t> getActionFrameTransforms(int aidx, int fidx) {
6431 return aidx >= 0 && (unsigned int)aidx < this->model->numaction ? (
6432 fidx >= 0 && (unsigned int)fidx < this->model->action[aidx].numframe ?
6433 std::vector<m3dtr_t>(this->model->action[aidx].frame[fidx].transform,
6434 this->model->action[aidx].frame[fidx].transform + this->model->action[aidx].frame[fidx].numtransform) :
6435 std::vector<m3dtr_t>()) : std::vector<m3dtr_t>(); }
6436 std::vector<m3dtr_t> getActionFrame(int aidx, int fidx, std::vector<m3dtr_t> skeleton) {
6437 m3dtr_t *pose = m3d_frame(this->model, (unsigned int)aidx, (unsigned int)fidx,
6438 skeleton.size() ? &skeleton[0] : nullptr);
6439 return std::vector<m3dtr_t>(pose, pose + this->model->numbone); }
6440 std::vector<m3db_t> getActionPose(int aidx, unsigned int msec) {
6441 m3db_t *pose = m3d_pose(this->model, (unsigned int)aidx, (unsigned int)msec);
6442 return std::vector<m3db_t>(pose, pose + this->model->numbone); }
6443 std::vector<m3di_t> getInlinedAssets() { return this->model->inlined ? std::vector<m3di_t>(this->model->inlined,
6444 this->model->inlined + this->model->numinlined) : std::vector<m3di_t>(); }
6445 std::vector<std::unique_ptr<m3dchunk_t>> getExtras() { return this->model->extra ?
6446 std::vector<std::unique_ptr<m3dchunk_t>>(this->model->extra,
6447 this->model->extra + this->model->numextra) : std::vector<std::unique_ptr<m3dchunk_t>>(); }
6448 std::vector<unsigned char> Save(_unused int quality, _unused int flags) {
6449 #ifdef M3D_EXPORTER
6450 unsigned int size;
6451 unsigned char *ptr = m3d_save(this->model, quality, flags, &size);
6452 return ptr && size ? std::vector<unsigned char>(ptr, ptr + size) : std::vector<unsigned char>();
6453 #else
6454 return std::vector<unsigned char>();
6455 #endif
6456 }
6457 };
6458
6459 #else
6460 class Model {
6461 private:
6462 m3d_t *model;
6463
6464 public:
6465 Model(const std::string &data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
6466 Model(const std::vector<unsigned char> data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
6467 Model(const unsigned char *data, m3dread_t ReadFileCB, m3dfree_t FreeCB);
6468 Model();
6469 ~Model();
6470
6471 public:
6472 m3d_t *getCStruct();
6473 std::string getName();
6474 void setName(std::string name);
6475 std::string getLicense();
6476 void setLicense(std::string license);
6477 std::string getAuthor();
6478 void setAuthor(std::string author);
6479 std::string getDescription();
6480 void setDescription(std::string desc);
6481 float getScale();
6482 void setScale(float scale);
6483 std::vector<unsigned char> getPreview();
6484 std::vector<uint32_t> getColorMap();
6485 std::vector<m3dti_t> getTextureMap();
6486 std::vector<m3dtx_t> getTextures();
6487 std::string getTextureName(int idx);
6488 std::vector<m3db_t> getBones();
6489 std::string getBoneName(int idx);
6490 std::vector<m3dm_t> getMaterials();
6491 std::string getMaterialName(int idx);
6492 int getMaterialPropertyInt(int idx, int type);
6493 uint32_t getMaterialPropertyColor(int idx, int type);
6494 float getMaterialPropertyFloat(int idx, int type);
6495 m3dtx_t* getMaterialPropertyMap(int idx, int type);
6496 std::vector<m3dv_t> getVertices();
6497 std::vector<m3df_t> getFace();
6498 std::vector<m3dvt_t> getVoxelTypes();
6499 std::string getVoxelTypeName(int idx);
6500 std::vector<m3dvi_t> getVoxelTypeItems(int idx);
6501 std::vector<m3dvx_t> getVoxelBlocks();
6502 std::string getVoxelBlockName(int idx);
6503 std::vector<M3D_VOXEL> getVoxelBlockData(int idx);
6504 std::vector<m3dh_t> getShape();
6505 std::string getShapeName(int idx);
6506 unsigned int getShapeGroup(int idx);
6507 std::vector<m3dc_t> getShapeCommands(int idx);
6508 std::vector<m3dl_t> getAnnotationLabels();
6509 std::vector<m3ds_t> getSkin();
6510 std::vector<m3da_t> getActions();
6511 std::string getActionName(int aidx);
6512 unsigned int getActionDuration(int aidx);
6513 std::vector<m3dfr_t> getActionFrames(int aidx);
6514 unsigned int getActionFrameTimestamp(int aidx, int fidx);
6515 std::vector<m3dtr_t> getActionFrameTransforms(int aidx, int fidx);
6516 std::vector<m3dtr_t> getActionFrame(int aidx, int fidx, std::vector<m3dtr_t> skeleton);
6517 std::vector<m3db_t> getActionPose(int aidx, unsigned int msec);
6518 std::vector<m3di_t> getInlinedAssets();
6519 std::vector<std::unique_ptr<m3dchunk_t>> getExtras();
6520 std::vector<unsigned char> Save(int quality, int flags);
6521 };
6522
6523 #endif /* impl */
6524 }
6525 #endif
6526
6527 #endif /* __cplusplus */
6528
6529 #endif
6530