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.23 by greg, Fri Feb 18 00:40:25 2011 UTC vs.
Revision 2.33 by greg, Sat Apr 4 04:34:08 2020 UTC

# Line 5 | Line 5 | static const char RCSid[] = "$Id$";
5   * Mesh support routines
6   */
7  
8 – #include <string.h>
9 –
8   #include "rtio.h"
9   #include "rtmath.h"
10   #include "rterror.h"
# Line 52 | Line 50 | static int
50   cvcmp(const char *vv1, const char *vv2)         /* compare encoded vertices */
51   {
52          const MCVERT    *v1 = (const MCVERT *)vv1, *v2 = (const MCVERT *)vv2;
53 +
54          if (v1->fl != v2->fl)
55                  return(1);
56          if (v1->xyz[0] != v2->xyz[0])
# Line 73 | Line 72 | cvcmp(const char *vv1, const char *vv2)                /* compare en
72  
73  
74   MESH *
75 < getmesh(mname, flags)                   /* get new mesh data reference */
76 < char    *mname;
77 < int     flags;
75 > getmesh(                                /* get new mesh data reference */
76 >        char    *mname,
77 >        int     flags
78 > )
79   {
80          char  *pathname;
81 <        register MESH  *ms;
81 >        MESH  *ms;
82  
83          flags &= IO_LEGAL;
84          for (ms = mlist; ms != NULL; ms = ms->next)
# Line 98 | Line 98 | int    flags;
98          }
99          if ((pathname = getpath(mname, getrlibpath(), R_OK)) == NULL) {
100                  sprintf(errmsg, "cannot find mesh file \"%s\"", mname);
101 <                error(USER, errmsg);
101 >                error(SYSTEM, errmsg);
102          }
103          flags &= ~ms->ldflags;
104          if (flags)
# Line 108 | Line 108 | int    flags;
108  
109  
110   MESHINST *
111 < getmeshinst(o, flags)                   /* create mesh instance */
112 < OBJREC  *o;
113 < int     flags;
111 > getmeshinst(                            /* create mesh instance */
112 >        OBJREC  *o,
113 >        int     flags
114 > )
115   {
116 <        register MESHINST  *ins;
116 >        MESHINST  *ins;
117  
118          flags &= IO_LEGAL;
119          if ((ins = (MESHINST *)o->os) == NULL) {
# Line 141 | Line 142 | int    flags;
142  
143  
144   int
145 < getmeshtrivid(tvid, mo, mp, ti)         /* get triangle vertex ID's */
146 < int32   tvid[3];
147 < OBJECT  *mo;
148 < MESH    *mp;
148 < OBJECT  ti;
145 > nextmeshtri(                            /* get next triangle ID */
146 >        OBJECT *tip,
147 >        MESH *mp
148 > )
149   {
150 +        int             pn;
151 +        MESHPATCH       *pp;
152 +
153 +        pn = ++(*tip) >> 10;                    /* next triangle (OVOID init) */
154 +        while (pn < mp->npatches) {
155 +                pp = &mp->patch[pn];
156 +                if (!(*tip & 0x200)) {          /* local triangle? */
157 +                        if ((*tip & 0x1ff) < pp->ntris)
158 +                                return(1);
159 +                        *tip &= ~0x1ff;         /* move on to single-joiners */
160 +                        *tip |= 0x200;
161 +                }
162 +                if (!(*tip & 0x100)) {          /* single joiner? */
163 +                        if ((*tip & 0xff) < pp->nj1tris)
164 +                                return(1);
165 +                        *tip &= ~0xff;          /* move on to double-joiners */
166 +                        *tip |= 0x100;
167 +                }
168 +                if ((*tip & 0xff) < pp->nj2tris)
169 +                        return(1);
170 +                *tip = ++pn << 10;              /* first in next patch */
171 +        }
172 +        return(0);                              /* out of patches */
173 + }
174 +
175 + int
176 + getmeshtrivid(                          /* get triangle vertex ID's */
177 +        int32   tvid[3],
178 +        OBJECT  *mo,
179 +        MESH    *mp,
180 +        OBJECT  ti
181 + )
182 + {
183          int             pn = ti >> 10;
184          MESHPATCH       *pp;
185  
# Line 202 | Line 235 | OBJECT ti;
235  
236  
237   int
238 < getmeshvert(vp, mp, vid, what)  /* get triangle vertex from ID */
239 < MESHVERT        *vp;
240 < MESH            *mp;
241 < int32           vid;
242 < int             what;
238 > getmeshvert(                            /* get triangle vertex from ID */
239 >        MESHVERT        *vp,
240 >        MESH            *mp,
241 >        int32           vid,
242 >        int             what
243 > )
244   {
245          int             pn = vid >> 8;
246          MESHPATCH       *pp;
247          double          vres;
248 <        register int    i;
248 >        int     i;
249          
250          vp->fl = 0;
251          if (pn >= mp->npatches)
# Line 246 | Line 280 | int            what;
280  
281  
282   OBJREC *
283 < getmeshpseudo(mp, mo)           /* get mesh pseudo object for material */
284 < MESH    *mp;
285 < OBJECT  mo;
283 > getmeshpseudo(                  /* get mesh pseudo object for material */
284 >        MESH    *mp,
285 >        OBJECT  mo
286 > )
287   {
288 <        if (mo < mp->mat0 || mo >= mp->mat0 + mp->nmats)
288 >        if ((mo < mp->mat0) | (mo >= mp->mat0 + mp->nmats))
289                  error(INTERNAL, "modifier out of range in getmeshpseudo");
290          if (mp->pseudo == NULL) {
291 <                register int    i;
291 >                int     i;
292                  mp->pseudo = (OBJREC *)calloc(mp->nmats, sizeof(OBJREC));
293                  if (mp->pseudo == NULL)
294                          error(SYSTEM, "out of memory in getmeshpseudo");
# Line 268 | Line 303 | OBJECT mo;
303  
304  
305   int
306 < getmeshtri(tv, mo, mp, ti, wha) /* get triangle vertices */
307 < MESHVERT        tv[3];
308 < OBJECT          *mo;
309 < MESH            *mp;
310 < OBJECT          ti;
311 < int             wha;
306 > getmeshtri(                     /* get triangle vertices */
307 >        MESHVERT        tv[3],
308 >        OBJECT          *mo,
309 >        MESH            *mp,
310 >        OBJECT          ti,
311 >        int             wha
312 > )
313   {
314          int32   tvid[3];
315  
# Line 289 | Line 325 | int            wha;
325  
326  
327   int32
328 < addmeshvert(mp, vp)             /* find/add a mesh vertex */
329 < register MESH   *mp;
330 < MESHVERT        *vp;
328 > addmeshvert(                    /* find/add a mesh vertex */
329 >        MESH            *mp,
330 >        MESHVERT        *vp
331 > )
332   {
333 <        LUENT           *lvp;
334 <        MCVERT          cv;
335 <        register int    i;
333 >        LUENT   *lvp;
334 >        MCVERT  cv;
335 >        int     i;
336  
337          if (!(vp->fl & MT_V))
338                  return(-1);
# Line 335 | Line 372 | MESHVERT       *vp;
372                  goto nomem;
373          if (lvp->key == NULL) {
374                  lvp->key = (char *)malloc(sizeof(MCVERT)+sizeof(int32));
375 <                memcpy((void *)lvp->key, (void *)&cv, sizeof(MCVERT));
375 >                memcpy(lvp->key, &cv, sizeof(MCVERT));
376          }
377          if (lvp->data == NULL) {        /* new vertex */
378 <                register MESHPATCH      *pp;
378 >                MESHPATCH       *pp;
379                  if (mp->npatches <= 0) {
380                          mp->patch = (MESHPATCH *)calloc(MPATCHBLKSIZ,
381                                          sizeof(MESHPATCH));
# Line 346 | Line 383 | MESHVERT       *vp;
383                                  goto nomem;
384                          mp->npatches = 1;
385                  } else if (mp->patch[mp->npatches-1].nverts >= 256) {
386 +                        if (mp->npatches >= 1L<<22)
387 +                                error(INTERNAL, "too many mesh patches");
388                          if (mp->npatches % MPATCHBLKSIZ == 0) {
389 <                                mp->patch = (MESHPATCH *)realloc(
390 <                                                (void *)mp->patch,
391 <                                        (mp->npatches + MPATCHBLKSIZ)*
392 <                                                sizeof(MESHPATCH));
354 <                                memset((void *)(mp->patch + mp->npatches), '\0',
389 >                                mp->patch = (MESHPATCH *)realloc(mp->patch,
390 >                                                (mp->npatches + MPATCHBLKSIZ)*
391 >                                                        sizeof(MESHPATCH));
392 >                                memset((mp->patch + mp->npatches), '\0',
393                                          MPATCHBLKSIZ*sizeof(MESHPATCH));
394                          }
395 <                        if (mp->npatches++ >= 1L<<22)
358 <                                error(INTERNAL, "too many mesh patches");
395 >                        mp->npatches++;
396                  }
397                  pp = &mp->patch[mp->npatches-1];
398                  if (pp->xyz == NULL) {
# Line 395 | Line 432 | nomem:
432  
433  
434   OBJECT
435 < addmeshtri(mp, tv, mo)          /* add a new mesh triangle */
436 < MESH            *mp;
437 < MESHVERT        tv[3];
438 < OBJECT          mo;
435 > addmeshtri(                     /* add a new mesh triangle */
436 >        MESH            *mp,
437 >        MESHVERT        tv[3],
438 >        OBJECT          mo
439 > )
440   {
441 <        int32                   vid[3], t;
442 <        int                     pn[3], i;
443 <        register MESHPATCH      *pp;
441 >        int32           vid[3], t;
442 >        int             pn[3], i;
443 >        MESHPATCH       *pp;
444  
445          if (!(tv[0].fl & tv[1].fl & tv[2].fl & MT_V))
446                  return(OVOID);
# Line 420 | Line 458 | OBJECT         mo;
458                          error(INTERNAL, "modifier range error in addmeshtri");
459          }
460                                  /* assign triangle */
461 <        if (pn[0] == pn[1] && pn[1] == pn[2]) { /* local case */
461 >        if ((pn[0] == pn[1]) & (pn[1] == pn[2])) {      /* local case */
462                  pp = &mp->patch[pn[0]];
463                  if (pp->tri == NULL) {
464                          pp->tri = (struct PTri *)malloc(
# Line 446 | Line 484 | OBJECT         mo;
484                                  pp->trimat[pp->ntris] = mo;
485                          return(pn[0] << 10 | pp->ntris++);
486                  }
487 <        }
450 <        if (pn[0] == pn[1]) {
487 >        } else if (pn[0] == pn[1]) {
488                  t = vid[2]; vid[2] = vid[1]; vid[1] = vid[0]; vid[0] = t;
489                  i = pn[2]; pn[2] = pn[1]; pn[1] = pn[0]; pn[0] = i;
490          } else if (pn[0] == pn[2]) {
# Line 471 | Line 508 | OBJECT         mo;
508                  }
509          }
510                                                  /* double link */
511 <        pp = &mp->patch[pn[2]];
511 >        pp = &mp->patch[pn[i=0]];
512 >        if (pp->nj2tris >= 256)
513 >                pp = &mp->patch[pn[i=1]];
514 >        if (pp->nj2tris >= 256)
515 >                pp = &mp->patch[pn[i=2]];
516 >        if (pp->nj2tris >= 256)
517 >                error(INTERNAL, "too many patch triangles in addmeshtri");
518          if (pp->j2tri == NULL) {
519                  pp->j2tri = (struct PJoin2 *)malloc(
520                                          256*sizeof(struct PJoin2));
521                  if (pp->j2tri == NULL)
522                          goto nomem;
523          }
481 –        if (pp->nj2tris >= 256)
482 –                error(INTERNAL, "too many patch triangles in addmeshtri");
483 –        pp->j2tri[pp->nj2tris].v1j = vid[0];
484 –        pp->j2tri[pp->nj2tris].v2j = vid[1];
485 –        pp->j2tri[pp->nj2tris].v3 = vid[2] & 0xff;
524          pp->j2tri[pp->nj2tris].mat = mo;
525 <        return(pn[2] << 10 | 0x300 | pp->nj2tris++);
525 >        switch (i) {
526 >        case 0:
527 >                pp->j2tri[pp->nj2tris].v3 = vid[0] & 0xff;
528 >                pp->j2tri[pp->nj2tris].v1j = vid[1];
529 >                pp->j2tri[pp->nj2tris].v2j = vid[2];
530 >                return(pn[0] << 10 | 0x300 | pp->nj2tris++);
531 >        case 1:
532 >                pp->j2tri[pp->nj2tris].v2j = vid[0];
533 >                pp->j2tri[pp->nj2tris].v3 = vid[1] & 0xff;
534 >                pp->j2tri[pp->nj2tris].v1j = vid[2];
535 >                return(pn[1] << 10 | 0x300 | pp->nj2tris++);
536 >        case 2:
537 >                pp->j2tri[pp->nj2tris].v1j = vid[0];
538 >                pp->j2tri[pp->nj2tris].v2j = vid[1];
539 >                pp->j2tri[pp->nj2tris].v3 = vid[2] & 0xff;
540 >                return(pn[2] << 10 | 0x300 | pp->nj2tris++);
541 >        }
542   nomem:
543          error(SYSTEM, "out of memory in addmeshtri");
544          return(OVOID);
# Line 492 | Line 546 | nomem:
546  
547  
548   char *
549 < checkmesh(mp)                           /* validate mesh data */
496 < register MESH   *mp;
549 > checkmesh(MESH *mp)                     /* validate mesh data */
550   {
551          static char     embuf[128];
552          int             nouvbounds = 1;
553 <        register int    i;
553 >        int             i;
554                                          /* basic checks */
555          if (mp == NULL)
556                  return("NULL mesh pointer");
# Line 525 | Line 578 | register MESH  *mp;
578                          return("unbounded scene in mesh");
579                  if (mp->mat0 < 0 || mp->mat0+mp->nmats > nobjects)
580                          return("bad mesh modifier range");
581 +                if (mp->nmats > 0)      /* allocate during preload_objs()! */
582 +                        getmeshpseudo(mp, mp->mat0);
583                  for (i = mp->mat0+mp->nmats; i-- > mp->mat0; ) {
584                          int     otyp = objptr(i)->otype;
585                          if (!ismodifier(otyp)) {
# Line 537 | Line 592 | register MESH  *mp;
592                  if (mp->npatches <= 0)
593                          error(WARNING, "no patches in mesh");
594                  for (i = 0; i < mp->npatches; i++) {
595 <                        register MESHPATCH      *pp = &mp->patch[i];
595 >                        MESHPATCH       *pp = &mp->patch[i];
596                          if (pp->nverts <= 0)
597                                  error(WARNING, "no vertices in patch");
598                          else {
# Line 559 | Line 614 | register MESH  *mp;
614  
615  
616   static void
617 < tallyoctree(ot, ecp, lcp, ocp)  /* tally octree size */
618 < OCTREE  ot;
619 < int     *ecp, *lcp, *ocp;
617 > tallyoctree(                    /* tally octree size */
618 >        OCTREE  ot,
619 >        int     *ecp,
620 >        int     *lcp,
621 >        int     *ocp
622 > )
623   {
624          int     i;
625  
# Line 582 | Line 640 | int    *ecp, *lcp, *ocp;
640  
641  
642   void
643 < printmeshstats(ms, fp)          /* print out mesh statistics */
644 < MESH    *ms;
645 < FILE    *fp;
643 > printmeshstats(                 /* print out mesh statistics */
644 >        MESH    *ms,
645 >        FILE    *fp
646 > )
647   {
648          int     lfcnt=0, lecnt=0, locnt=0;
649          int     vcnt=0, ncnt=0, uvcnt=0;
# Line 594 | Line 653 | FILE   *fp;
653          
654          tallyoctree(ms->mcube.cutree, &lecnt, &lfcnt, &locnt);
655          for (i = 0; i < ms->npatches; i++) {
656 <                register MESHPATCH      *pp = &ms->patch[i];
656 >                MESHPATCH       *pp = &ms->patch[i];
657                  vcnt += pp->nverts;
658                  if (pp->norm != NULL) {
659                          for (j = pp->nverts; j--; )
# Line 636 | Line 695 | FILE   *fp;
695  
696  
697   void
698 < freemesh(ms)                    /* free mesh data */
640 < register MESH   *ms;
698 > freemesh(MESH *ms)              /* free mesh data */
699   {
700          MESH    mhead;
701          MESH    *msp;
# Line 665 | Line 723 | register MESH  *ms;
723          octfree(ms->mcube.cutree);
724          lu_done(&ms->lut);
725          if (ms->npatches > 0) {
726 <                register MESHPATCH      *pp = ms->patch + ms->npatches;
726 >                MESHPATCH       *pp = ms->patch + ms->npatches;
727                  while (pp-- > ms->patch) {
728                          if (pp->j2tri != NULL)
729 <                                free((void *)pp->j2tri);
729 >                                free(pp->j2tri);
730                          if (pp->j1tri != NULL)
731 <                                free((void *)pp->j1tri);
731 >                                free(pp->j1tri);
732                          if (pp->tri != NULL)
733 <                                free((void *)pp->tri);
733 >                                free(pp->tri);
734                          if (pp->uv != NULL)
735 <                                free((void *)pp->uv);
735 >                                free(pp->uv);
736                          if (pp->norm != NULL)
737 <                                free((void *)pp->norm);
737 >                                free(pp->norm);
738                          if (pp->xyz != NULL)
739 <                                free((void *)pp->xyz);
739 >                                free(pp->xyz);
740 >                        if (pp->trimat != NULL)
741 >                                free(pp->trimat);
742                  }
743 <                free((void *)ms->patch);
743 >                free(ms->patch);
744          }
745          if (ms->pseudo != NULL)
746 <                free((void *)ms->pseudo);
747 <        free((void *)ms);
746 >                free(ms->pseudo);
747 >        free(ms);
748   }
749  
750  
751   void
752 < freemeshinst(o)                 /* free mesh instance */
693 < OBJREC  *o;
752 > freemeshinst(OBJREC *o)         /* free mesh instance */
753   {
754          if (o->os == NULL)
755                  return;
756          freemesh((*(MESHINST *)o->os).msh);
757 <        free((void *)o->os);
757 >        free(o->os);
758          o->os = NULL;
759   }

Diff Legend

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