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.22 by greg, Wed Dec 15 17:27:52 2010 UTC vs.
Revision 2.30 by greg, Tue Nov 27 01:04:33 2018 UTC

# Line 30 | Line 30 | typedef struct {
30  
31   static MESH     *mlist = NULL;          /* list of loaded meshes */
32  
33 – static lut_keycmpf_t cvcmp;
34 – static lut_hashf_t cvhash;
33  
36 –
34   static unsigned long
35 < cvhash(p)                               /* hash an encoded vertex */
39 < /* MCVERT       *cvp; */
40 < const void      *p;
35 > cvhash(const char *p)                   /* hash an encoded vertex */
36   {
37          const MCVERT    *cvp = (const MCVERT *)p;
38          unsigned long   hval;
# Line 54 | Line 49 | const void     *p;
49  
50  
51   static int
52 < cvcmp(vv1, vv2)                         /* compare encoded vertices */
58 < /* register MCVERT      *v1, *v2; */
59 < const void      *vv1, *vv2;
52 > cvcmp(const char *vv1, const char *vv2)         /* compare encoded vertices */
53   {
54 <        const MCVERT    *v1 = vv1, *v2 = vv2;
54 >        const MCVERT    *v1 = (const MCVERT *)vv1, *v2 = (const MCVERT *)vv2;
55 >
56          if (v1->fl != v2->fl)
57                  return(1);
58          if (v1->xyz[0] != v2->xyz[0])
# Line 80 | Line 74 | const void     *vv1, *vv2;
74  
75  
76   MESH *
77 < getmesh(mname, flags)                   /* get new mesh data reference */
78 < char    *mname;
79 < int     flags;
77 > getmesh(                                /* get new mesh data reference */
78 >        char    *mname,
79 >        int     flags
80 > )
81   {
82          char  *pathname;
83 <        register MESH  *ms;
83 >        MESH  *ms;
84  
85          flags &= IO_LEGAL;
86          for (ms = mlist; ms != NULL; ms = ms->next)
# Line 105 | Line 100 | int    flags;
100          }
101          if ((pathname = getpath(mname, getrlibpath(), R_OK)) == NULL) {
102                  sprintf(errmsg, "cannot find mesh file \"%s\"", mname);
103 <                error(USER, errmsg);
103 >                error(SYSTEM, errmsg);
104          }
105          flags &= ~ms->ldflags;
106          if (flags)
# Line 115 | Line 110 | int    flags;
110  
111  
112   MESHINST *
113 < getmeshinst(o, flags)                   /* create mesh instance */
114 < OBJREC  *o;
115 < int     flags;
113 > getmeshinst(                            /* create mesh instance */
114 >        OBJREC  *o,
115 >        int     flags
116 > )
117   {
118 <        register MESHINST  *ins;
118 >        MESHINST  *ins;
119  
120          flags &= IO_LEGAL;
121          if ((ins = (MESHINST *)o->os) == NULL) {
# Line 148 | Line 144 | int    flags;
144  
145  
146   int
147 < getmeshtrivid(tvid, mo, mp, ti)         /* get triangle vertex ID's */
148 < int32   tvid[3];
149 < OBJECT  *mo;
150 < MESH    *mp;
155 < OBJECT  ti;
147 > nextmeshtri(                            /* get next triangle ID */
148 >        OBJECT *tip,
149 >        MESH *mp
150 > )
151   {
152 +        int             pn;
153 +        MESHPATCH       *pp;
154 +
155 +        pn = ++(*tip) >> 10;                    /* next triangle (OVOID init) */
156 +        while (pn < mp->npatches) {
157 +                pp = &mp->patch[pn];
158 +                if (!(*tip & 0x200)) {          /* local triangle? */
159 +                        if ((*tip & 0x1ff) < pp->ntris)
160 +                                return(1);
161 +                        *tip &= ~0x1ff;         /* move on to single-joiners */
162 +                        *tip |= 0x200;
163 +                }
164 +                if (!(*tip & 0x100)) {          /* single joiner? */
165 +                        if ((*tip & 0xff) < pp->nj1tris)
166 +                                return(1);
167 +                        *tip &= ~0xff;          /* move on to double-joiners */
168 +                        *tip |= 0x100;
169 +                }
170 +                if ((*tip & 0xff) < pp->nj2tris)
171 +                        return(1);
172 +                *tip = ++pn << 10;              /* first in next patch */
173 +        }
174 +        return(0);                              /* out of patches */
175 + }
176 +
177 + int
178 + getmeshtrivid(                          /* get triangle vertex ID's */
179 +        int32   tvid[3],
180 +        OBJECT  *mo,
181 +        MESH    *mp,
182 +        OBJECT  ti
183 + )
184 + {
185          int             pn = ti >> 10;
186          MESHPATCH       *pp;
187  
# Line 209 | Line 237 | OBJECT ti;
237  
238  
239   int
240 < getmeshvert(vp, mp, vid, what)  /* get triangle vertex from ID */
241 < MESHVERT        *vp;
242 < MESH            *mp;
243 < int32           vid;
244 < int             what;
240 > getmeshvert(                            /* get triangle vertex from ID */
241 >        MESHVERT        *vp,
242 >        MESH            *mp,
243 >        int32           vid,
244 >        int             what
245 > )
246   {
247          int             pn = vid >> 8;
248          MESHPATCH       *pp;
249          double          vres;
250 <        register int    i;
250 >        int     i;
251          
252          vp->fl = 0;
253          if (pn >= mp->npatches)
# Line 253 | Line 282 | int            what;
282  
283  
284   OBJREC *
285 < getmeshpseudo(mp, mo)           /* get mesh pseudo object for material */
286 < MESH    *mp;
287 < OBJECT  mo;
285 > getmeshpseudo(                  /* get mesh pseudo object for material */
286 >        MESH    *mp,
287 >        OBJECT  mo
288 > )
289   {
290          if (mo < mp->mat0 || mo >= mp->mat0 + mp->nmats)
291                  error(INTERNAL, "modifier out of range in getmeshpseudo");
292          if (mp->pseudo == NULL) {
293 <                register int    i;
293 >                int     i;
294                  mp->pseudo = (OBJREC *)calloc(mp->nmats, sizeof(OBJREC));
295                  if (mp->pseudo == NULL)
296                          error(SYSTEM, "out of memory in getmeshpseudo");
# Line 275 | Line 305 | OBJECT mo;
305  
306  
307   int
308 < getmeshtri(tv, mo, mp, ti, wha) /* get triangle vertices */
309 < MESHVERT        tv[3];
310 < OBJECT          *mo;
311 < MESH            *mp;
312 < OBJECT          ti;
313 < int             wha;
308 > getmeshtri(                     /* get triangle vertices */
309 >        MESHVERT        tv[3],
310 >        OBJECT          *mo,
311 >        MESH            *mp,
312 >        OBJECT          ti,
313 >        int             wha
314 > )
315   {
316          int32   tvid[3];
317  
# Line 296 | Line 327 | int            wha;
327  
328  
329   int32
330 < addmeshvert(mp, vp)             /* find/add a mesh vertex */
331 < register MESH   *mp;
332 < MESHVERT        *vp;
330 > addmeshvert(                    /* find/add a mesh vertex */
331 >        MESH            *mp,
332 >        MESHVERT        *vp
333 > )
334   {
335 <        LUENT           *lvp;
336 <        MCVERT          cv;
337 <        register int    i;
335 >        LUENT   *lvp;
336 >        MCVERT  cv;
337 >        int     i;
338  
339          if (!(vp->fl & MT_V))
340                  return(-1);
# Line 345 | Line 377 | MESHVERT       *vp;
377                  memcpy((void *)lvp->key, (void *)&cv, sizeof(MCVERT));
378          }
379          if (lvp->data == NULL) {        /* new vertex */
380 <                register MESHPATCH      *pp;
380 >                MESHPATCH       *pp;
381                  if (mp->npatches <= 0) {
382                          mp->patch = (MESHPATCH *)calloc(MPATCHBLKSIZ,
383                                          sizeof(MESHPATCH));
# Line 402 | Line 434 | nomem:
434  
435  
436   OBJECT
437 < addmeshtri(mp, tv, mo)          /* add a new mesh triangle */
438 < MESH            *mp;
439 < MESHVERT        tv[3];
440 < OBJECT          mo;
437 > addmeshtri(                     /* add a new mesh triangle */
438 >        MESH            *mp,
439 >        MESHVERT        tv[3],
440 >        OBJECT          mo
441 > )
442   {
443 <        int32                   vid[3], t;
444 <        int                     pn[3], i;
445 <        register MESHPATCH      *pp;
443 >        int32           vid[3], t;
444 >        int             pn[3], i;
445 >        MESHPATCH       *pp;
446  
447          if (!(tv[0].fl & tv[1].fl & tv[2].fl & MT_V))
448                  return(OVOID);
# Line 427 | Line 460 | OBJECT         mo;
460                          error(INTERNAL, "modifier range error in addmeshtri");
461          }
462                                  /* assign triangle */
463 <        if (pn[0] == pn[1] && pn[1] == pn[2]) { /* local case */
463 >        if ((pn[0] == pn[1]) & (pn[1] == pn[2])) {      /* local case */
464                  pp = &mp->patch[pn[0]];
465                  if (pp->tri == NULL) {
466                          pp->tri = (struct PTri *)malloc(
# Line 453 | Line 486 | OBJECT         mo;
486                                  pp->trimat[pp->ntris] = mo;
487                          return(pn[0] << 10 | pp->ntris++);
488                  }
489 <        }
457 <        if (pn[0] == pn[1]) {
489 >        } else if (pn[0] == pn[1]) {
490                  t = vid[2]; vid[2] = vid[1]; vid[1] = vid[0]; vid[0] = t;
491                  i = pn[2]; pn[2] = pn[1]; pn[1] = pn[0]; pn[0] = i;
492          } else if (pn[0] == pn[2]) {
# Line 478 | Line 510 | OBJECT         mo;
510                  }
511          }
512                                                  /* double link */
513 <        pp = &mp->patch[pn[2]];
513 >        pp = &mp->patch[pn[i=0]];
514 >        if (pp->nj2tris >= 256)
515 >                pp = &mp->patch[pn[i=1]];
516 >        if (pp->nj2tris >= 256)
517 >                pp = &mp->patch[pn[i=2]];
518 >        if (pp->nj2tris >= 256)
519 >                error(INTERNAL, "too many patch triangles in addmeshtri");
520          if (pp->j2tri == NULL) {
521                  pp->j2tri = (struct PJoin2 *)malloc(
522                                          256*sizeof(struct PJoin2));
523                  if (pp->j2tri == NULL)
524                          goto nomem;
525          }
488 –        if (pp->nj2tris >= 256)
489 –                error(INTERNAL, "too many patch triangles in addmeshtri");
490 –        pp->j2tri[pp->nj2tris].v1j = vid[0];
491 –        pp->j2tri[pp->nj2tris].v2j = vid[1];
492 –        pp->j2tri[pp->nj2tris].v3 = vid[2] & 0xff;
526          pp->j2tri[pp->nj2tris].mat = mo;
527 <        return(pn[2] << 10 | 0x300 | pp->nj2tris++);
527 >        switch (i) {
528 >        case 0:
529 >                pp->j2tri[pp->nj2tris].v3 = vid[0] & 0xff;
530 >                pp->j2tri[pp->nj2tris].v1j = vid[1];
531 >                pp->j2tri[pp->nj2tris].v2j = vid[2];
532 >                return(pn[0] << 10 | 0x300 | pp->nj2tris++);
533 >        case 1:
534 >                pp->j2tri[pp->nj2tris].v2j = vid[0];
535 >                pp->j2tri[pp->nj2tris].v3 = vid[1] & 0xff;
536 >                pp->j2tri[pp->nj2tris].v1j = vid[2];
537 >                return(pn[1] << 10 | 0x300 | pp->nj2tris++);
538 >        case 2:
539 >                pp->j2tri[pp->nj2tris].v1j = vid[0];
540 >                pp->j2tri[pp->nj2tris].v2j = vid[1];
541 >                pp->j2tri[pp->nj2tris].v3 = vid[2] & 0xff;
542 >                return(pn[2] << 10 | 0x300 | pp->nj2tris++);
543 >        }
544   nomem:
545          error(SYSTEM, "out of memory in addmeshtri");
546          return(OVOID);
# Line 499 | Line 548 | nomem:
548  
549  
550   char *
551 < checkmesh(mp)                           /* validate mesh data */
503 < register MESH   *mp;
551 > checkmesh(MESH *mp)                     /* validate mesh data */
552   {
553          static char     embuf[128];
554          int             nouvbounds = 1;
555 <        register int    i;
555 >        int             i;
556                                          /* basic checks */
557          if (mp == NULL)
558                  return("NULL mesh pointer");
# Line 544 | 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 566 | 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 589 | 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 601 | 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 643 | Line 695 | FILE   *fp;
695  
696  
697   void
698 < freemesh(ms)                    /* free mesh data */
647 < register MESH   *ms;
698 > freemesh(MESH *ms)              /* free mesh data */
699   {
700          MESH    mhead;
701          MESH    *msp;
# Line 672 | 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);
# Line 696 | Line 747 | register MESH  *ms;
747  
748  
749   void
750 < freemeshinst(o)                 /* free mesh instance */
700 < OBJREC  *o;
750 > freemeshinst(OBJREC *o)         /* free mesh instance */
751   {
752          if (o->os == NULL)
753                  return;

Diff Legend

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