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

Comparing ray/src/hd/rhd_odraw.c (file contents):
Revision 3.15 by greg, Fri Jun 20 00:25:49 2003 UTC vs.
Revision 3.16 by schorsch, Thu Jan 1 11:21:55 2004 UTC

# Line 49 | Line 49 | static int     needmapping;    /* what needs doing with tone
49   #define SAMP32  (32*(2*sizeof(short)+sizeof(union ODfunion)+sizeof(TMbright)+\
50                          6*sizeof(BYTE))+sizeof(int32))
51  
52 < int
53 < odInit(n)                               /* initialize drawing routines */
54 < int     n;
52 > static int sampcmp(const void *s0, const void *s1);
53 > static int odAllocBlockSamp(int vn, int hh, int vh, double prox);
54 > static int make_arms(GLshort ar[MAXFAN][3], short cp[2], struct ODview *vp,
55 >                double sz);
56 > static int depthchange(struct ODview *vp, int x0, int y0, int x1, int y1);
57 > static void clip_edge(GLshort p[3], short o[2], struct ODview *vp);
58 > static int getblock(struct ODview *vp, int h, int v);
59 > static int blockedge(struct ODview *vp, int bi0, int bi1);
60 > static void odDrawSamp(int vn, int id);
61 >
62 >
63 > extern int
64 > odInit(                         /* initialize drawing routines */
65 >        int     n
66 > )
67   {
68          int     nbytes, i, j, k, nextsamp, count, blockdiv;
69          int     res[2];
# Line 157 | Line 169 | int    n;
169  
170  
171   int
172 < sampcmp(s0, s1)                 /* sample order, descending proximity */
173 < int     *s0, *s1;
172 > sampcmp(                        /* sample order, descending proximity */
173 >        const void      *s0,
174 >        const void      *s1
175 > )
176   {
177 <        register double diff = odS.closeness(*s1) - odS.closeness(*s0);
177 >        register double diff = odS.closeness(*(int*)s1) - odS.closeness(*(int*)s0);
178  
179          return (diff > FTINY ? 1 : diff < -FTINY ? -1 : 0);
180   }
181  
182  
183   int
184 < odAllocBlockSamp(vn, hh, vh, prox)      /* allocate sample from block */
185 < int     vn, hh, vh;
186 < double  prox;
184 > odAllocBlockSamp(       /* allocate sample from block */
185 >        int     vn,
186 >        int     hh,
187 >        int     vh,
188 >        double  prox
189 > )
190   {
191          int     si[SAMPSPERBLOCK+SAMPSPERBLOCK/4];
192          int     hl, vl;
193          VIEW    *vw;
177 –        FVECT   ro, rd;
194          int     res[2];
195          register struct ODblock *bp;
196          register int    i, j;
# Line 209 | Line 225 | double prox;
225                  }
226          if (bp->free != ENDFREE) {      /* allocate from free list */
227                  i = bp->free;
228 <                if (odS.ip[i][0] >= 0 & odS.ip[i][1] >= 0)
228 >                if ((odS.ip[i][0] >= 0) & (odS.ip[i][1] >= 0))
229                          CLR4(odView[vn].pmap, odS.ip[i][1]*odView[vn].hhi +
230                                                          odS.ip[i][0]);
231                  bp->free = odS.nextfree(i);
# Line 245 | Line 261 | gotit:
261   }
262  
263  
264 < odSample(c, d, p)                       /* add a sample value */
265 < COLR    c;
266 < FVECT   d, p;
264 > extern void
265 > odSample(                       /* add a sample value */
266 >        COLR    c,
267 >        FVECT   d,
268 >        FVECT   p
269 > )
270   {
271          FVECT   disp;
272          double  d0, d1, h, v, prox;
# Line 308 | Line 327 | FVECT  d, p;
327   }
328  
329  
330 < odRemap(newhist)                        /* recompute tone mapping */
331 < int     newhist;
330 > extern void
331 > odRemap(                        /* recompute tone mapping */
332 >        int     newhist
333 > )
334   {
335          needmapping |= NEWMAP|NEWRGB;
336          if (newhist)
# Line 317 | Line 338 | int    newhist;
338   }
339  
340  
341 < odRedrawAll()                           /* mark all samples for redraw */
341 > extern void
342 > odRedrawAll(void)                               /* mark all samples for redraw */
343   {
344          register int    i;
345  
# Line 332 | Line 354 | odRedrawAll()                          /* mark all samples for redraw */
354   }
355  
356  
357 < odRedraw(vn, hmin, vmin, hmax, vmax)    /* redraw view region */
358 < int     vn, hmin, vmin, hmax, vmax;
357 > extern void
358 > odRedraw(       /* redraw view region */
359 >        int     vn,
360 >        int     hmin,
361 >        int     vmin,
362 >        int     hmax,
363 >        int     vmax
364 > )
365   {
366          int     i, j;
367          register struct ODblock *bp;
368          register int    k;
369  
370 <        if (vn<0 | vn>=odNViews)
370 >        if ((vn<0) | (vn>=odNViews))
371                  return;
372                                  /* check view limits */
373          if (hmin < 0) hmin = 0;
374          if (hmax >= odView[vn].hhi) hmax = odView[vn].hhi-1;
375          if (vmin < 0) vmin = 0;
376          if (vmax >= odView[vn].vhi) vmax = odView[vn].vhi-1;
377 <        if (hmax <= hmin | vmax <= vmin)
377 >        if ((hmax <= hmin) | (vmax <= vmin))
378                  return;
379                                  /* convert to low resolution */
380          hmin = hmin * odView[vn].hlow / odView[vn].hhi;
# Line 366 | Line 394 | int    vn, hmin, vmin, hmax, vmax;
394   }
395  
396  
397 < odDepthMap(vn, dm)                      /* assign depth map for view */
398 < int     vn;
399 < GLfloat *dm;
397 > extern void
398 > odDepthMap(                     /* assign depth map for view */
399 >        int     vn,
400 >        GLfloat *dm
401 > )
402   {
403          double  d0, d1;
404          int     i, j, hmin, hmax, vmin, vmax;
405          register int    k, l;
406  
407          if (dm == NULL) {                       /* free edge map */
408 <                if (vn<0 | vn>=odNViews)
408 >                if ((vn<0) | (vn>=odNViews))
409                          return;                 /* too late -- they're gone! */
410                  if (odView[vn].emap != NULL)
411                          free((void *)odView[vn].emap);
# Line 439 | Line 469 | GLfloat        *dm;
469   }
470  
471  
472 < odUpdate(vn)                            /* update this view */
473 < int     vn;
472 > extern void
473 > odUpdate(                               /* update this view */
474 >        int     vn
475 > )
476   {
477          static short    primes[] = {9431,6803,4177,2659,1609,887,587,251,47,1};
478          int     myprime;
# Line 545 | Line 577 | register struct ODview *vp;
577  
578  
579   static int
580 < make_arms(ar, cp, vp, sz)               /* make arms for triangle fan */
581 < GLshort ar[MAXFAN][3];
582 < short   cp[2];
583 < register struct ODview  *vp;
584 < double  sz;
580 > make_arms(              /* make arms for triangle fan */
581 >        GLshort ar[MAXFAN][3],
582 >        short   cp[2],
583 >        register struct ODview  *vp,
584 >        double  sz
585 > )
586   {
587          int     na, dv;
588          double  hrad, vrad, phi;
# Line 575 | Line 608 | double sz;
608  
609  
610   static int
611 < depthchange(vp, x0, y0, x1, y1)         /* check depth discontinuity */
612 < register struct ODview  *vp;
613 < int     x0, y0, x1, y1;
611 > depthchange(            /* check depth discontinuity */
612 >        register struct ODview  *vp,
613 >        int     x0,
614 >        int     y0,
615 >        int     x1,
616 >        int     y1
617 > )
618   {
619          register double d0, d1;
620  
621          DCHECK(x0<0 | x0>=vp->hhi | y0<0 | y0>=vp->vhi,
622                          CONSISTENCY, "coordinates off view in depthchange");
623  
624 <        if (x1<0 | x1>=vp->hhi | y1<0 | y1>=vp->vhi)
624 >        if ((x1<0) | (x1>=vp->hhi) | (y1<0) | (y1>=vp->vhi))
625                  return(1);
626  
627          d0 = vp->dmap[y0*vp->hhi + x0];
# Line 594 | Line 631 | int    x0, y0, x1, y1;
631   }
632  
633  
634 < static
635 < clip_edge(p, o, vp)                     /* clip line segment to depth edge */
636 < GLshort p[3];
637 < short   o[2];
638 < register struct ODview  *vp;
634 > static void
635 > clip_edge(                      /* clip line segment to depth edge */
636 >        GLshort p[3],
637 >        short   o[2],
638 >        register struct ODview  *vp
639 > )
640   {
641          int     x, y, xstep, ystep, rise, rise2, run, run2, n;
642  
# Line 639 | Line 677 | register struct ODview *vp;
677  
678  
679   static int
680 < getblock(vp, h, v)                      /* get block index */
681 < register struct ODview  *vp;
682 < register int    h, v;
680 > getblock(                       /* get block index */
681 >        register struct ODview  *vp,
682 >        register int    h,
683 >        register int    v
684 > )
685   {
686 <        if (h<0 | h>=vp->hhi | v<0 | v>=vp->vhi)
686 >        if ((h<0) | (h>=vp->hhi) | (v<0) | (v>=vp->vhi))
687                  return(-1);
688          return(h*vp->hlow/vp->hhi + v*vp->vlow/vp->vhi*vp->hlow);
689   }
690  
691  
692   static int
693 < blockedge(vp, bi0, bi1)                 /* check for edge between blocks? */
694 < register struct ODview  *vp;
695 < register int    bi0, bi1;
693 > blockedge(                      /* check for edge between blocks? */
694 >        register struct ODview  *vp,
695 >        register int    bi0,
696 >        register int    bi1
697 > )
698   {
699          if (bi1 == bi0)
700                  return(0);              /* same block */
# Line 667 | Line 709 | register int   bi0, bi1;
709   }
710  
711  
712 < odDrawSamp(vn, id)                      /* draw view sample */
713 < int     vn;
714 < register int    id;
712 > static void
713 > odDrawSamp(                     /* draw view sample */
714 >        int     vn,
715 >        register int    id
716 > )
717   {
718          GLshort arm[MAXFAN][3];
719          int     narms, blockindex;

Diff Legend

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