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.8 by greg, Fri Jun 20 00:25:49 2003 UTC vs.
Revision 2.15 by schorsch, Fri Nov 14 17:22:06 2003 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 >
14   #include "octree.h"
15   #include "object.h"
16   #include "otypes.h"
# Line 16 | Line 21 | typedef struct {
21          int             fl;
22          uint32          xyz[3];
23          int32           norm;
24 <        uint32          uv[2];
24 >        uint16          uv[2];
25   } MCVERT;
26  
27   #define  MPATCHBLKSIZ   128             /* patch allocation block size */
# Line 68 | Line 73 | register MCVERT        *v1, *v2;
73  
74  
75   MESH *
76 < getmesh(mname, flags)                   /* get mesh data */
76 > getmesh(mname, flags)                   /* get new mesh data reference */
77   char    *mname;
78   int     flags;
79   {
# Line 78 | Line 83 | int    flags;
83          flags &= IO_LEGAL;
84          for (ms = mlist; ms != NULL; ms = ms->next)
85                  if (!strcmp(mname, ms->name)) {
86 <                        if ((ms->ldflags & flags) == flags) {
87 <                                ms->nref++;
83 <                                return(ms);             /* loaded */
84 <                        }
85 <                        break;                  /* load the rest */
86 >                        ms->nref++;     /* increase reference count */
87 >                        break;
88                  }
89 <        if (ms == NULL) {
89 >        if (ms == NULL) {               /* load first time */
90                  ms = (MESH *)calloc(1, sizeof(MESH));
91                  if (ms == NULL)
92                          error(SYSTEM, "out of memory in getmesh");
# Line 128 | Line 130 | int    flags;
130                  ins->msh = NULL;
131                  o->os = (char *)ins;
132          }
133 <        if (ins->msh == NULL || (ins->msh->ldflags & flags) != flags)
133 >        if (ins->msh == NULL)
134                  ins->msh = getmesh(o->oargs.sarg[0], flags);
135 +        else if ((flags &= ~ins->msh->ldflags))
136 +                readmesh(ins->msh,
137 +                        getpath(o->oargs.sarg[0], getrlibpath(), R_OK),
138 +                                flags);
139          return(ins);
140   }
141  
# Line 232 | Line 238 | int            what;
238                  for (i = 0; i < 2; i++)
239                          vp->uv[i] = mp->uvlim[0][i] +
240                                  (mp->uvlim[1][i] - mp->uvlim[0][i])*
241 <                                (pp->uv[vid][i] + .5)*(1./4294967296.);
241 >                                (pp->uv[vid][i] + .5)*(1./65536.);
242                  vp->fl |= MT_UV;
243          }
244          return(vp->fl);
# Line 311 | Line 317 | MESHVERT       *vp;
317                                  return(-1);
318                          if (vp->uv[i] >= mp->uvlim[1][i])
319                                  return(-1);
320 <                        cv.uv[i] = (uint32)(4294967296. *
320 >                        cv.uv[i] = (uint32)(65536. *
321                                          (vp->uv[i] - mp->uvlim[0][i]) /
322                                          (mp->uvlim[1][i] - mp->uvlim[0][i]));
323                  }
# Line 329 | Line 335 | MESHVERT       *vp;
335                  goto nomem;
336          if (lvp->key == NULL) {
337                  lvp->key = (char *)malloc(sizeof(MCVERT)+sizeof(int32));
338 <                bcopy((void *)&cv, (void *)lvp->key, sizeof(MCVERT));
338 >                memcpy((void *)lvp->key, (void *)&cv, sizeof(MCVERT));
339          }
340          if (lvp->data == NULL) {        /* new vertex */
341                  register MESHPATCH      *pp;
# Line 345 | Line 351 | MESHVERT       *vp;
351                                                  (void *)mp->patch,
352                                          (mp->npatches + MPATCHBLKSIZ)*
353                                                  sizeof(MESHPATCH));
354 <                                bzero((void *)(mp->patch + mp->npatches),
354 >                                memset((void *)(mp->patch + mp->npatches), '\0',
355                                          MPATCHBLKSIZ*sizeof(MESHPATCH));
356                          }
357                          if (mp->npatches++ >= 1L<<22)
# Line 369 | Line 375 | MESHVERT       *vp;
375                  }
376                  if (cv.fl & MT_UV) {
377                          if (pp->uv == NULL) {
378 <                                pp->uv = (uint32 (*)[2])calloc(256,
379 <                                                2*sizeof(uint32));
378 >                                pp->uv = (uint16 (*)[2])calloc(256,
379 >                                                2*sizeof(uint16));
380                                  if (pp->uv == NULL)
381                                          goto nomem;
382                          }
# Line 407 | Line 413 | OBJECT         mo;
413                  pn[i] = vid[i] >> 8;
414          }
415                                  /* normalize material index */
416 <        if (mo != OVOID)
416 >        if (mo != OVOID) {
417                  if ((mo -= mp->mat0) >= mp->nmats)
418                          mp->nmats = mo+1;
419                  else if (mo < 0)
420                          error(INTERNAL, "modifier range error in addmeshtri");
421 +        }
422                                  /* assign triangle */
423          if (pn[0] == pn[1] && pn[1] == pn[2]) { /* local case */
424                  pp = &mp->patch[pn[0]];
# Line 608 | Line 615 | FILE   *fp;
615                  t2cnt += pp->nj2tris;
616          }
617          fprintf(fp, "Mesh statistics:\n");
618 <        fprintf(fp, "\t%d materials\n", ms->nmats);
618 >        fprintf(fp, "\t%ld materials\n", ms->nmats);
619          fprintf(fp, "\t%d patches (%.2f MBytes)\n", ms->npatches,
620                          (ms->npatches*sizeof(MESHPATCH) +
621                          vcnt*3*sizeof(uint32) +
622                          nscnt*sizeof(int32) +
623 <                        uvscnt*2*sizeof(uint32) +
623 >                        uvscnt*2*sizeof(uint16) +
624                          tcnt*sizeof(struct PTri) +
625                          t1cnt*sizeof(struct PJoin1) +
626                          t2cnt*sizeof(struct PJoin2))/(1024.*1024.));

Diff Legend

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