ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/mesh.c
(Generate patch)

Comparing ray/src/common/mesh.c (file contents):
Revision 2.2 by greg, Wed Mar 12 04:59:04 2003 UTC vs.
Revision 2.24 by greg, Tue Nov 6 01:04:23 2012 UTC

# Line 5 | Line 5 | static const char RCSid[] = "$Id$";
5   * Mesh support routines
6   */
7  
8 < #include "standard.h"
8 > #include <string.h>
9 >
10 > #include "rtio.h"
11 > #include "rtmath.h"
12 > #include "rterror.h"
13 > #include "paths.h"
14   #include "octree.h"
15   #include "object.h"
16 + #include "otypes.h"
17   #include "mesh.h"
12 – #include "lookup.h"
18  
19   /* An encoded mesh vertex */
20   typedef struct {
21          int             fl;
22 <        uint4           xyz[3];
23 <        int4            norm;
24 <        uint4           uv[2];
22 >        uint32          xyz[3];
23 >        int32           norm;
24 >        uint32          uv[2];
25   } MCVERT;
26  
27   #define  MPATCHBLKSIZ   128             /* patch allocation block size */
# Line 27 | Line 32 | static MESH    *mlist = NULL;          /* list of loaded meshes *
32  
33  
34   static unsigned long
35 < cvhash(cvp)                             /* hash an encoded vertex */
31 < MCVERT  *cvp;
35 > cvhash(const char *p)                   /* hash an encoded vertex */
36   {
37 +        const MCVERT    *cvp = (const MCVERT *)p;
38          unsigned long   hval;
39          
40          if (!(cvp->fl & MT_V))
# Line 44 | Line 49 | MCVERT *cvp;
49  
50  
51   static int
52 < cvcmp(v1, v2)                           /* compare encoded vertices */
48 < register MCVERT *v1, *v2;
52 > cvcmp(const char *vv1, const char *vv2)         /* compare encoded vertices */
53   {
54 +        const MCVERT    *v1 = (const MCVERT *)vv1, *v2 = (const MCVERT *)vv2;
55          if (v1->fl != v2->fl)
56                  return(1);
57          if (v1->xyz[0] != v2->xyz[0])
# Line 68 | Line 73 | register MCVERT        *v1, *v2;
73  
74  
75   MESH *
76 < getmesh(mname, flags)                   /* get mesh data */
77 < char    *mname;
78 < int     flags;
76 > getmesh(                                /* get new mesh data reference */
77 >        char    *mname,
78 >        int     flags
79 > )
80   {
81          char  *pathname;
82 <        register MESH  *ms;
82 >        MESH  *ms;
83  
84          flags &= IO_LEGAL;
85          for (ms = mlist; ms != NULL; ms = ms->next)
86                  if (!strcmp(mname, ms->name)) {
87 <                        if ((ms->ldflags & flags) == flags) {
88 <                                ms->nref++;
83 <                                return(ms);             /* loaded */
84 <                        }
85 <                        break;                  /* load the rest */
87 >                        ms->nref++;     /* increase reference count */
88 >                        break;
89                  }
90 <        if (ms == NULL) {
90 >        if (ms == NULL) {               /* load first time */
91                  ms = (MESH *)calloc(1, sizeof(MESH));
92                  if (ms == NULL)
93                          error(SYSTEM, "out of memory in getmesh");
# Line 94 | Line 97 | int    flags;
97                  ms->next = mlist;
98                  mlist = ms;
99          }
100 <        if ((pathname = getpath(mname, getlibpath(), R_OK)) == NULL) {
100 >        if ((pathname = getpath(mname, getrlibpath(), R_OK)) == NULL) {
101                  sprintf(errmsg, "cannot find mesh file \"%s\"", mname);
102                  error(USER, errmsg);
103          }
# Line 106 | Line 109 | int    flags;
109  
110  
111   MESHINST *
112 < getmeshinst(o, flags)                   /* create mesh instance */
113 < OBJREC  *o;
114 < int     flags;
112 > getmeshinst(                            /* create mesh instance */
113 >        OBJREC  *o,
114 >        int     flags
115 > )
116   {
117 <        register MESHINST  *ins;
117 >        MESHINST  *ins;
118  
119          flags &= IO_LEGAL;
120          if ((ins = (MESHINST *)o->os) == NULL) {
# Line 128 | Line 132 | int    flags;
132                  ins->msh = NULL;
133                  o->os = (char *)ins;
134          }
135 <        if (ins->msh == NULL || (ins->msh->ldflags & flags) != flags)
135 >        if (ins->msh == NULL)
136                  ins->msh = getmesh(o->oargs.sarg[0], flags);
137 +        else if ((flags &= ~ins->msh->ldflags))
138 +                readmesh(ins->msh,
139 +                        getpath(o->oargs.sarg[0], getrlibpath(), R_OK),
140 +                                flags);
141          return(ins);
142   }
143  
144  
145   int
146 < getmeshtrivid(tvid, mp, ti)             /* get triangle vertex ID's */
147 < int4            tvid[3];
148 < register MESH   *mp;
149 < OBJECT          ti;
146 > nextmeshtri(                            /* get next triangle ID */
147 >        OBJECT *tip,
148 >        MESH *mp
149 > )
150   {
151 +        int             pn;
152 +        MESHPATCH       *pp;
153 +
154 +        if (*tip == OVOID) {                    /* check for first index */
155 +                *tip = 0;
156 +                return(mp->npatches > 0);       /* assumes 1 local triangle */
157 +        }
158 +        pn = *tip >> 10;
159 +        if (pn >= mp->npatches)                 /* past end? */
160 +                return(0);
161 +        pp = &mp->patch[pn];
162 +        if (!(*tip & 0x200)) {                  /* local triangle? */
163 +                if ((*tip & 0x1ff) < pp->ntris-1) {
164 +                        ++*tip;
165 +                        return(1);
166 +                }
167 +                *tip &= ~0x1ff;                 /* move on to single-joiners */
168 +                *tip |= 0x200;
169 +                if (pp->nj1tris)                /* is there at least one? */
170 +                        return(1);
171 +        }
172 +        if (!(*tip & 0x100)) {                  /* single joiner? */
173 +                if ((*tip & 0xff) < pp->nj1tris-1) {
174 +                        ++*tip;
175 +                        return(1);
176 +                }
177 +                *tip &= ~0xff;                  /* move on to double-joiners */
178 +                *tip |= 0x100;
179 +                if (pp->nj2tris)                /* is there one? */
180 +                        return(1);
181 +        }
182 +        if ((*tip & 0xff) < pp->nj2tris-1) {    /* double-joiner? */
183 +                ++*tip;
184 +                return(1);
185 +        }
186 +        *tip = ++pn << 10;                      /* first in next patch */
187 +        return(pn < mp->npatches);
188 + }
189 +
190 + int
191 + getmeshtrivid(                          /* get triangle vertex ID's */
192 +        int32   tvid[3],
193 +        OBJECT  *mo,
194 +        MESH    *mp,
195 +        OBJECT  ti
196 + )
197 + {
198          int             pn = ti >> 10;
199 +        MESHPATCH       *pp;
200  
201          if (pn >= mp->npatches)
202                  return(0);
203 +        pp = &mp->patch[pn];
204          ti &= 0x3ff;
205          if (!(ti & 0x200)) {            /* local triangle */
206                  struct PTri     *tp;
207 <                if (ti >= mp->patch[pn].ntris)
207 >                if (ti >= pp->ntris)
208                          return(0);
209 <                tp = &mp->patch[pn].tri[ti];
209 >                tp = &pp->tri[ti];
210                  tvid[0] = tvid[1] = tvid[2] = pn << 8;
211                  tvid[0] |= tp->v1;
212                  tvid[1] |= tp->v2;
213                  tvid[2] |= tp->v3;
214 +                if (pp->trimat != NULL)
215 +                        *mo = pp->trimat[ti];
216 +                else
217 +                        *mo = pp->solemat;
218 +                if (*mo != OVOID)
219 +                        *mo += mp->mat0;
220                  return(1);
221          }
222          ti &= ~0x200;
223          if (!(ti & 0x100)) {            /* single link vertex */
224                  struct PJoin1   *tp1;
225 <                if (ti >= mp->patch[pn].nj1tris)
225 >                if (ti >= pp->nj1tris)
226                          return(0);
227 <                tp1 = &mp->patch[pn].j1tri[ti];
227 >                tp1 = &pp->j1tri[ti];
228                  tvid[0] = tp1->v1j;
229                  tvid[1] = tvid[2] = pn << 8;
230                  tvid[1] |= tp1->v2;
231                  tvid[2] |= tp1->v3;
232 +                if ((*mo = tp1->mat) != OVOID)
233 +                        *mo += mp->mat0;
234                  return(1);
235          }
236          ti &= ~0x100;
237          {                               /* double link vertex */
238                  struct PJoin2   *tp2;
239 <                if (ti >= mp->patch[pn].nj2tris)
239 >                if (ti >= pp->nj2tris)
240                          return(0);
241 <                tp2 = &mp->patch[pn].j2tri[ti];
241 >                tp2 = &pp->j2tri[ti];
242                  tvid[0] = tp2->v1j;
243                  tvid[1] = tp2->v2j;
244                  tvid[2] = pn << 8 | tp2->v3;
245 +                if ((*mo = tp2->mat) != OVOID)
246 +                        *mo += mp->mat0;
247          }
248          return(1);
249   }
250  
251  
252   int
253 < getmeshvert(vp, mp, vid, what)  /* get triangle vertex from ID */
254 < MESHVERT        *vp;
255 < register MESH   *mp;
256 < int4            vid;
257 < int             what;
253 > getmeshvert(                            /* get triangle vertex from ID */
254 >        MESHVERT        *vp,
255 >        MESH            *mp,
256 >        int32           vid,
257 >        int             what
258 > )
259   {
260          int             pn = vid >> 8;
261          MESHPATCH       *pp;
262          double          vres;
263 <        register int    i;
263 >        int     i;
264          
265          vp->fl = 0;
266          if (pn >= mp->npatches)
# Line 226 | Line 294 | int            what;
294   }
295  
296  
297 + OBJREC *
298 + getmeshpseudo(                  /* get mesh pseudo object for material */
299 +        MESH    *mp,
300 +        OBJECT  mo
301 + )
302 + {
303 +        if (mo < mp->mat0 || mo >= mp->mat0 + mp->nmats)
304 +                error(INTERNAL, "modifier out of range in getmeshpseudo");
305 +        if (mp->pseudo == NULL) {
306 +                int     i;
307 +                mp->pseudo = (OBJREC *)calloc(mp->nmats, sizeof(OBJREC));
308 +                if (mp->pseudo == NULL)
309 +                        error(SYSTEM, "out of memory in getmeshpseudo");
310 +                for (i = mp->nmats; i--; ) {
311 +                        mp->pseudo[i].omod = mp->mat0 + i;
312 +                        mp->pseudo[i].otype = OBJ_FACE;
313 +                        mp->pseudo[i].oname = "M-Tri";
314 +                }
315 +        }
316 +        return(&mp->pseudo[mo - mp->mat0]);
317 + }
318 +
319 +
320   int
321 < getmeshtri(tv, mp, ti, what)    /* get triangle vertices */
322 < MESHVERT        tv[3];
323 < MESH            *mp;
324 < OBJECT          ti;
325 < int             what;
321 > getmeshtri(                     /* get triangle vertices */
322 >        MESHVERT        tv[3],
323 >        OBJECT          *mo,
324 >        MESH            *mp,
325 >        OBJECT          ti,
326 >        int             wha
327 > )
328   {
329 <        int4    tvid[3];
329 >        int32   tvid[3];
330  
331 <        if (!getmeshtrivid(tvid, mp, ti))
331 >        if (!getmeshtrivid(tvid, mo, mp, ti))
332                  return(0);
333  
334 <        getmeshvert(&tv[0], mp, tvid[0], what);
335 <        getmeshvert(&tv[1], mp, tvid[1], what);
336 <        getmeshvert(&tv[2], mp, tvid[2], what);
334 >        getmeshvert(&tv[0], mp, tvid[0], wha);
335 >        getmeshvert(&tv[1], mp, tvid[1], wha);
336 >        getmeshvert(&tv[2], mp, tvid[2], wha);
337  
338          return(tv[0].fl & tv[1].fl & tv[2].fl);
339   }
340  
341  
342 < int4
343 < addmeshvert(mp, vp)             /* find/add a mesh vertex */
344 < register MESH   *mp;
345 < MESHVERT        *vp;
342 > int32
343 > addmeshvert(                    /* find/add a mesh vertex */
344 >        MESH    *mp,
345 >        MESHVERT        *vp
346 > )
347   {
254 –        LUTAB           *ltp;
348          LUENT           *lvp;
349          MCVERT          cv;
350 <        register int    i;
350 >        int     i;
351  
352          if (!(vp->fl & MT_V))
353                  return(-1);
# Line 264 | Line 357 | MESHVERT       *vp;
357                          return(-1);
358                  if (vp->v[i] >= mp->mcube.cuorg[i] + mp->mcube.cusize)
359                          return(-1);
360 <                cv.xyz[i] = (uint4)(4294967296. *
360 >                cv.xyz[i] = (uint32)(4294967296. *
361                                  (vp->v[i] - mp->mcube.cuorg[i]) /
362                                  mp->mcube.cusize);
363          }
364 <        if (vp->fl & MT_N)
364 >        if (vp->fl & MT_N)              /* assumes normalized! */
365                  cv.norm = encodedir(vp->n);
366          if (vp->fl & MT_UV)
367                  for (i = 0; i < 2; i++) {
# Line 276 | Line 369 | MESHVERT       *vp;
369                                  return(-1);
370                          if (vp->uv[i] >= mp->uvlim[1][i])
371                                  return(-1);
372 <                        cv.uv[i] = (uint4)(4294967296. *
372 >                        cv.uv[i] = (uint32)(4294967296. *
373                                          (vp->uv[i] - mp->uvlim[0][i]) /
374                                          (mp->uvlim[1][i] - mp->uvlim[0][i]));
375                  }
376          cv.fl = vp->fl;
377 <        ltp = (LUTAB *)mp->cdata;       /* get lookup table */
378 <        if (ltp == NULL) {
379 <                ltp = (LUTAB *)calloc(1, sizeof(LUTAB));
380 <                if (ltp == NULL)
377 >        if (mp->lut.tsiz == 0) {
378 >                mp->lut.hashf = cvhash;
379 >                mp->lut.keycmp = cvcmp;
380 >                mp->lut.freek = free;
381 >                if (!lu_init(&mp->lut, 50000))
382                          goto nomem;
289 –                ltp->hashf = cvhash;
290 –                ltp->keycmp = cvcmp;
291 –                ltp->freek = free;
292 –                if (!lu_init(ltp, 50000))
293 –                        goto nomem;
294 –                mp->cdata = (char *)ltp;
383          }
384                                          /* find entry */
385 <        lvp = lu_find(ltp, (char *)&cv);
385 >        lvp = lu_find(&mp->lut, (char *)&cv);
386          if (lvp == NULL)
387                  goto nomem;
388          if (lvp->key == NULL) {
389 <                lvp->key = (char *)malloc(sizeof(MCVERT)+sizeof(int4));
390 <                bcopy((void *)&cv, (void *)lvp->key, sizeof(MCVERT));
389 >                lvp->key = (char *)malloc(sizeof(MCVERT)+sizeof(int32));
390 >                memcpy((void *)lvp->key, (void *)&cv, sizeof(MCVERT));
391          }
392          if (lvp->data == NULL) {        /* new vertex */
393 <                register MESHPATCH      *pp;
393 >                MESHPATCH       *pp;
394                  if (mp->npatches <= 0) {
395                          mp->patch = (MESHPATCH *)calloc(MPATCHBLKSIZ,
396                                          sizeof(MESHPATCH));
# Line 315 | Line 403 | MESHVERT       *vp;
403                                                  (void *)mp->patch,
404                                          (mp->npatches + MPATCHBLKSIZ)*
405                                                  sizeof(MESHPATCH));
406 <                                bzero((void *)(mp->patch + mp->npatches),
406 >                                memset((void *)(mp->patch + mp->npatches), '\0',
407                                          MPATCHBLKSIZ*sizeof(MESHPATCH));
408                          }
409                          if (mp->npatches++ >= 1L<<22)
# Line 323 | Line 411 | MESHVERT       *vp;
411                  }
412                  pp = &mp->patch[mp->npatches-1];
413                  if (pp->xyz == NULL) {
414 <                        pp->xyz = (uint4 (*)[3])calloc(256, 3*sizeof(int4));
414 >                        pp->xyz = (uint32 (*)[3])calloc(256, 3*sizeof(int32));
415                          if (pp->xyz == NULL)
416                                  goto nomem;
417                  }
# Line 331 | Line 419 | MESHVERT       *vp;
419                          pp->xyz[pp->nverts][i] = cv.xyz[i];
420                  if (cv.fl & MT_N) {
421                          if (pp->norm == NULL) {
422 <                                pp->norm = (int4 *)calloc(256, sizeof(int4));
422 >                                pp->norm = (int32 *)calloc(256, sizeof(int32));
423                                  if (pp->norm == NULL)
424                                          goto nomem;
425                          }
# Line 339 | Line 427 | MESHVERT       *vp;
427                  }
428                  if (cv.fl & MT_UV) {
429                          if (pp->uv == NULL) {
430 <                                pp->uv = (uint4 (*)[2])calloc(256,
431 <                                                2*sizeof(uint4));
430 >                                pp->uv = (uint32 (*)[2])calloc(256,
431 >                                                2*sizeof(uint32));
432                                  if (pp->uv == NULL)
433                                          goto nomem;
434                          }
# Line 349 | Line 437 | MESHVERT       *vp;
437                  }
438                  pp->nverts++;
439                  lvp->data = lvp->key + sizeof(MCVERT);
440 <                *(int4 *)lvp->data = (mp->npatches-1) << 8 | (pp->nverts-1);
440 >                *(int32 *)lvp->data = (mp->npatches-1) << 8 | (pp->nverts-1);
441          }
442 <        return(*(int4 *)lvp->data);
442 >        return(*(int32 *)lvp->data);
443   nomem:
444          error(SYSTEM, "out of memory in addmeshvert");
445          return(-1);
# Line 359 | Line 447 | nomem:
447  
448  
449   OBJECT
450 < addmeshtri(mp, tv)              /* add a new mesh triangle */
451 < MESH            *mp;
452 < MESHVERT        tv[3];
450 > addmeshtri(                     /* add a new mesh triangle */
451 >        MESH            *mp,
452 >        MESHVERT        tv[3],
453 >        OBJECT          mo
454 > )
455   {
456 <        int4                    vid[3], t;
456 >        int32                   vid[3], t;
457          int                     pn[3], i;
458 <        register MESHPATCH      *pp;
458 >        MESHPATCH       *pp;
459  
460          if (!(tv[0].fl & tv[1].fl & tv[2].fl & MT_V))
461                  return(OVOID);
# Line 375 | Line 465 | MESHVERT       tv[3];
465                          return(OVOID);
466                  pn[i] = vid[i] >> 8;
467          }
468 +                                /* normalize material index */
469 +        if (mo != OVOID) {
470 +                if ((mo -= mp->mat0) >= mp->nmats)
471 +                        mp->nmats = mo+1;
472 +                else if (mo < 0)
473 +                        error(INTERNAL, "modifier range error in addmeshtri");
474 +        }
475                                  /* assign triangle */
476          if (pn[0] == pn[1] && pn[1] == pn[2]) { /* local case */
477                  pp = &mp->patch[pn[0]];
# Line 388 | Line 485 | MESHVERT       tv[3];
485                          pp->tri[pp->ntris].v1 = vid[0] & 0xff;
486                          pp->tri[pp->ntris].v2 = vid[1] & 0xff;
487                          pp->tri[pp->ntris].v3 = vid[2] & 0xff;
488 +                        if (pp->ntris == 0)
489 +                                pp->solemat = mo;
490 +                        else if (pp->trimat == NULL && mo != pp->solemat) {
491 +                                pp->trimat = (int16 *)malloc(
492 +                                                512*sizeof(int16));
493 +                                if (pp->trimat == NULL)
494 +                                        goto nomem;
495 +                                for (i = pp->ntris; i--; )
496 +                                        pp->trimat[i] = pp->solemat;
497 +                        }
498 +                        if (pp->trimat != NULL)
499 +                                pp->trimat[pp->ntris] = mo;
500                          return(pn[0] << 10 | pp->ntris++);
501                  }
502          }
# Line 410 | Line 519 | MESHVERT       tv[3];
519                          pp->j1tri[pp->nj1tris].v1j = vid[0];
520                          pp->j1tri[pp->nj1tris].v2 = vid[1] & 0xff;
521                          pp->j1tri[pp->nj1tris].v3 = vid[2] & 0xff;
522 +                        pp->j1tri[pp->nj1tris].mat = mo;
523                          return(pn[1] << 10 | 0x200 | pp->nj1tris++);
524                  }
525          }
# Line 426 | Line 536 | MESHVERT       tv[3];
536          pp->j2tri[pp->nj2tris].v1j = vid[0];
537          pp->j2tri[pp->nj2tris].v2j = vid[1];
538          pp->j2tri[pp->nj2tris].v3 = vid[2] & 0xff;
539 +        pp->j2tri[pp->nj2tris].mat = mo;
540          return(pn[2] << 10 | 0x300 | pp->nj2tris++);
541   nomem:
542          error(SYSTEM, "out of memory in addmeshtri");
# Line 433 | Line 544 | nomem:
544   }
545  
546  
547 + char *
548 + checkmesh(MESH *mp)                     /* validate mesh data */
549 + {
550 +        static char     embuf[128];
551 +        int             nouvbounds = 1;
552 +        int     i;
553 +                                        /* basic checks */
554 +        if (mp == NULL)
555 +                return("NULL mesh pointer");
556 +        if (!mp->ldflags)
557 +                return("unassigned mesh");
558 +        if (mp->name == NULL)
559 +                return("missing mesh name");
560 +        if (mp->nref <= 0)
561 +                return("unreferenced mesh");
562 +                                        /* check boundaries */
563 +        if (mp->ldflags & IO_BOUNDS) {
564 +                if (mp->mcube.cusize <= FTINY)
565 +                        return("illegal octree bounds in mesh");
566 +                nouvbounds = (mp->uvlim[1][0] - mp->uvlim[0][0] <= FTINY ||
567 +                                mp->uvlim[1][1] - mp->uvlim[0][1] <= FTINY);
568 +        }
569 +                                        /* check octree */
570 +        if (mp->ldflags & IO_TREE) {
571 +                if (isempty(mp->mcube.cutree))
572 +                        error(WARNING, "empty mesh octree");
573 +        }
574 +                                        /* check scene data */
575 +        if (mp->ldflags & IO_SCENE) {
576 +                if (!(mp->ldflags & IO_BOUNDS))
577 +                        return("unbounded scene in mesh");
578 +                if (mp->mat0 < 0 || mp->mat0+mp->nmats > nobjects)
579 +                        return("bad mesh modifier range");
580 +                for (i = mp->mat0+mp->nmats; i-- > mp->mat0; ) {
581 +                        int     otyp = objptr(i)->otype;
582 +                        if (!ismodifier(otyp)) {
583 +                                sprintf(embuf,
584 +                                        "non-modifier in mesh (%s \"%s\")",
585 +                                        ofun[otyp].funame, objptr(i)->oname);
586 +                                return(embuf);
587 +                        }
588 +                }
589 +                if (mp->npatches <= 0)
590 +                        error(WARNING, "no patches in mesh");
591 +                for (i = 0; i < mp->npatches; i++) {
592 +                        MESHPATCH       *pp = &mp->patch[i];
593 +                        if (pp->nverts <= 0)
594 +                                error(WARNING, "no vertices in patch");
595 +                        else {
596 +                                if (pp->xyz == NULL)
597 +                                        return("missing patch vertex list");
598 +                                if (nouvbounds && pp->uv != NULL)
599 +                                        return("unreferenced uv coordinates");
600 +                        }
601 +                        if (pp->ntris > 0 && pp->tri == NULL)
602 +                                return("missing patch triangle list");
603 +                        if (pp->nj1tris > 0 && pp->j1tri == NULL)
604 +                                return("missing patch joiner triangle list");
605 +                        if (pp->nj2tris > 0 && pp->j2tri == NULL)
606 +                                return("missing patch double-joiner list");
607 +                }
608 +        }
609 +        return(NULL);                   /* seems OK */
610 + }
611 +
612 +
613   static void
614 < tallyoctree(ot, ecp, lcp, ocp)  /* tally octree size */
615 < OCTREE  ot;
616 < int     *ecp, *lcp, *ocp;
614 > tallyoctree(                    /* tally octree size */
615 >        OCTREE  ot,
616 >        int     *ecp,
617 >        int     *lcp,
618 >        int     *ocp
619 > )
620   {
621          int     i;
622  
# Line 457 | Line 637 | int    *ecp, *lcp, *ocp;
637  
638  
639   void
640 < printmeshstats(ms, fp)          /* print out mesh statistics */
641 < MESH    *ms;
642 < FILE    *fp;
640 > printmeshstats(                 /* print out mesh statistics */
641 >        MESH    *ms,
642 >        FILE    *fp
643 > )
644   {
645          int     lfcnt=0, lecnt=0, locnt=0;
646          int     vcnt=0, ncnt=0, uvcnt=0;
# Line 469 | Line 650 | FILE   *fp;
650          
651          tallyoctree(ms->mcube.cutree, &lecnt, &lfcnt, &locnt);
652          for (i = 0; i < ms->npatches; i++) {
653 <                register MESHPATCH      *pp = &ms->patch[i];
653 >                MESHPATCH       *pp = &ms->patch[i];
654                  vcnt += pp->nverts;
655                  if (pp->norm != NULL) {
656                          for (j = pp->nverts; j--; )
# Line 488 | Line 669 | FILE   *fp;
669                  t2cnt += pp->nj2tris;
670          }
671          fprintf(fp, "Mesh statistics:\n");
672 +        fprintf(fp, "\t%ld materials\n", (long)ms->nmats);
673          fprintf(fp, "\t%d patches (%.2f MBytes)\n", ms->npatches,
674                          (ms->npatches*sizeof(MESHPATCH) +
675 <                        vcnt*3*sizeof(uint4) +
676 <                        nscnt*sizeof(int4) +
677 <                        uvscnt*2*sizeof(uint4) +
675 >                        vcnt*3*sizeof(uint32) +
676 >                        nscnt*sizeof(int32) +
677 >                        uvscnt*2*sizeof(uint32) +
678                          tcnt*sizeof(struct PTri) +
679                          t1cnt*sizeof(struct PJoin1) +
680                          t2cnt*sizeof(struct PJoin2))/(1024.*1024.));
# Line 510 | Line 692 | FILE   *fp;
692  
693  
694   void
695 < freemesh(ms)                    /* free mesh data */
514 < MESH    *ms;
695 > freemesh(MESH *ms)              /* free mesh data */
696   {
697          MESH    mhead;
698          MESH    *msp;
# Line 537 | Line 718 | MESH   *ms;
718                                  /* free mesh data */
719          freestr(ms->name);
720          octfree(ms->mcube.cutree);
721 <        if (ms->cdata != NULL)
541 <                lu_done((LUTAB *)ms->cdata);
721 >        lu_done(&ms->lut);
722          if (ms->npatches > 0) {
723 <                register MESHPATCH      *pp = ms->patch + ms->npatches;
723 >                MESHPATCH       *pp = ms->patch + ms->npatches;
724                  while (pp-- > ms->patch) {
725                          if (pp->j2tri != NULL)
726                                  free((void *)pp->j2tri);
# Line 557 | Line 737 | MESH   *ms;
737                  }
738                  free((void *)ms->patch);
739          }
740 +        if (ms->pseudo != NULL)
741 +                free((void *)ms->pseudo);
742          free((void *)ms);
743   }
744  
745  
746   void
747 < freemeshinst(o)                 /* free mesh instance */
566 < OBJREC  *o;
747 > freemeshinst(OBJREC *o)         /* free mesh instance */
748   {
749          if (o->os == NULL)
750                  return;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines