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

Comparing ray/src/util/ranimove1.c (file contents):
Revision 3.8 by schorsch, Fri Mar 26 21:36:20 2004 UTC vs.
Revision 3.16 by greg, Fri Nov 5 04:36:24 2010 UTC

# Line 4 | Line 4 | static const char      RCSid[] = "$Id$";
4   /*
5   *  ranimove1.c
6   *
7 < *  Basic frame rendering routines for ranimate(1).
7 > *  Basic frame rendering routines for ranimove(1).
8   *
9   *  Created by Gregory Ward on Wed Jan 08 2003.
10   */
# Line 54 | Line 54 | static void setmotion(int      n, FVECT        wpos);
54   static void init_frame_sample(void);
55  
56  
57 + #if 0
58   extern void
59   write_map(              /* write out float map (debugging) */
60          float   *mp,
# Line 79 | Line 80 | write_map(             /* write out float map (debugging) */
80          }
81          fclose(fp);
82   }
83 + #endif
84  
85  
86   static void
# Line 105 | Line 107 | next_frame(void)                       /* prepare next frame buffer */
107                  error(USER, errmsg);
108          }
109          if (cbuffer == NULL) {
110 +                int     n;
111                                          /* compute resolution and allocate */
112                  switch (sscanf(vval(RESOLUTION), "%d %d %lf",
113                                  &hres, &vres, &pixaspect)) {
# Line 140 | Line 143 | next_frame(void)                       /* prepare next frame buffer */
143                                  (cprev==NULL) | (zprev == NULL) |
144                                  (oprev==NULL) | (aprev==NULL))
145                          error(SYSTEM, "out of memory in init_frame");
146 +                for (n = hres*vres; n--; ) {
147 +                        zprev[n] = -1.f;
148 +                        oprev[n] = OVOID;
149 +                }
150                  frm_stop = getTime() + rtperfrm;
151          } else {
152                  COLOR   *cp;            /* else just swap buffers */
# Line 367 | Line 374 | init_frame_sample(void)                /* sample our initial frame *
374                          continue;
375                  }
376                  if (!sample_here(x, y)) {       /* just cast */
377 <                        rayorigin(&ir, NULL, PRIMARY, 1.0);
377 >                        rayorigin(&ir, PRIMARY, NULL, NULL);
378                          if (!localhit(&ir, &thescene)) {
379 <                                if (ir.ro != &Aftplane)
380 <                                        sourcehit(&ir);
379 >                                if (ir.ro != &Aftplane && sourcehit(&ir)) {
380 >                                        rayshade(&ir, ir.ro->omod);
381 >                                        rayparticipate(&ir);
382 >                                }
383                                  copycolor(cbuffer[n], ir.rcol);
384                                  zbuffer[n] = ir.rot;
385                                  obuffer[n] = ir.robj;
# Line 385 | Line 394 | init_frame_sample(void)                /* sample our initial frame *
394                  }
395                  if (nprocs > 1) {               /* get sample */
396                          int     rval;
397 <                        rayorigin(&ir, NULL, PRIMARY, 1.0);
397 >                        rayorigin(&ir, PRIMARY, NULL, NULL);
398                          ir.rno = n;
399                          rval = ray_pqueue(&ir);
400                          if (!rval)
# Line 399 | Line 408 | init_frame_sample(void)                /* sample our initial frame *
408                  zbuffer[n] = ir.rot;
409                  obuffer[n] = ir.robj;
410                  sbuffer[n] = 1;
411 <                if (ir.rot >= FHUGE)
411 >                if (ir.rot >= 0.99*FHUGE)
412                          abuffer[n] = ADISTANT;
413                  else {
414                          abuffer[n] = ALOWQ;
# Line 452 | Line 461 | getambcolor(           /* get ambient color for object if we ca
461  
462          if (obj == OVOID)
463                  return(0);
464 <        op = objptr(obj);
465 <        if ((op->otype == OBJ_INSTANCE) & (op->omod == OVOID))
464 >        op = objptr(obj);               /* search for material */
465 >        if (op->omod == OVOID)
466                  return(0);
467 <                                        /* search for material */
468 <        do {
469 <                if (op->omod == OVOID || ofun[op->otype].flags & T_X)
461 <                        return(0);
462 <                op = objptr(op->omod);
463 <        } while (!ismaterial(op->otype));
467 >        op = findmaterial(objptr(op->omod));
468 >        if (op == NULL)
469 >                return(0);
470          /*
471           * Since this routine is called to compute the difference
472           * from rendering with and without interreflections,
# Line 474 | Line 480 | getambcolor(           /* get ambient color for object if we ca
480                          if (lv[0] == op->oname[0] &&
481                                          !strcmp(lv+1, op->oname+1))
482                                  break;
483 <                if ((lv != NULL) != hirendparams.ambincl)
483 >                if ((lv != NULL) ^ hirendparams.ambincl)
484                          return(0);
485          }
486          switch (op->otype) {
# Line 658 | Line 664 | extern void
664   init_frame(void)                        /* render base (low quality) frame */
665   {
666          int     restart;
661 –
667                                          /* allocate/swap buffers */
668          next_frame();
669                                          /* check rendering status */
670          restart = (!nobjects || vdef(MOVE));
671          if (!restart && curparams != &lorendparams && nprocs > 1)
672                  restart = -1;
668 –        if (restart > 0) {
669 –                if (nprocs > 1)
670 –                        ray_pdone(1);
671 –                else
672 –                        ray_done(1);
673 –        }
673                                          /* post low quality parameters */
674          if (curparams != &lorendparams)
675                  ray_restore(curparams = &lorendparams);
# Line 702 | Line 701 | init_frame(void)                       /* render base (low quality) frame
701          init_frame_sample();
702                                          /* initialize frame error */
703          comp_frame_error();
704 < return;
704 > #if 0
705   {
706          float   *ebuf = (float *)malloc(sizeof(float)*hres*vres);
707          char    fnm[256];
# Line 714 | Line 713 | return;
713          write_map(ebuf, fnm);
714          free((void *)ebuf);
715   }
716 + #endif
717   }
718  
719  
# Line 745 | Line 745 | filter_frame(void)                     /* interpolation, motion-blur, an
745                  printf("\tFiltering frame\n");
746                  fflush(stdout);
747          }
748 <        /* normalize samples */
749 <        for (y = vres; y--; ) {
750 <                for (x = hres; x--; ) {
751 <                        n = fndx(x, y);
752 <                        if (sbuffer[n] <= 1)
748 >                                        /* normalize samples */
749 >        for (y = vres; y--; )
750 >            for (x = hres; x--; ) {
751 >                n = fndx(x, y);
752 >                if (sbuffer[n] <= 1)
753 >                        continue;
754 >                w = 1.0/(double)sbuffer[n];
755 >                scalecolor(cbuffer[n], w);
756 >            }
757 >                                        /* interpolate samples */
758 >        for (y = vres; y--; )
759 >            for (x = hres; x--; ) {
760 >                n = fndx(x, y);
761 >                if (sbuffer[n])
762 >                        continue;
763 >                nc = getclosest(neigh, NPINTERP, x, y);
764 >                setcolor(cbuffer[n], 0., 0., 0.);
765 >                if (nc <= 0) {          /* no acceptable neighbors */
766 >                        if (y < vres-1)
767 >                                nc = fndx(x, y+1);
768 >                        else if (x < hres-1)
769 >                                nc = fndx(x+1, y);
770 >                        else
771                                  continue;
772 <                        w = 1.0/(double)sbuffer[n];
773 <                        scalecolor(cbuffer[n], w);
772 >                        copycolor(cbuffer[n], cbuffer[nc]);
773 >                        continue;
774                  }
775 <        }
776 <        /* interpolate samples */
777 <        for (y = vres; y--; ) {
778 <                for (x = hres; x--; ) {
779 <                        n = fndx(x, y);
780 <                        if (sbuffer[n])
781 <                                continue;
782 <                        nc = getclosest(neigh, NPINTERP, x, y);
765 <                        setcolor(cbuffer[n], 0., 0., 0.);
766 <                        wsum = 0.;
767 <                        while (nc-- > 0) {
768 <                                copycolor(cval, cbuffer[neigh[nc]]);
769 <                                w = sample_wt((neigh[nc]%hres) - x,
770 <                                                (neigh[nc]/hres) - y);
771 <                                scalecolor(cval, w);
772 <                                addcolor(cbuffer[n], cval);
773 <                                wsum += w;
774 <                        }
775 <                        if (wsum > FTINY) {
776 <                                w = 1.0/wsum;
777 <                                scalecolor(cbuffer[n], w);
778 <                        }
775 >                wsum = 0.;
776 >                while (nc-- > 0) {
777 >                        copycolor(cval, cbuffer[neigh[nc]]);
778 >                        w = sample_wt((neigh[nc]%hres) - x,
779 >                                        (neigh[nc]/hres) - y);
780 >                        scalecolor(cval, w);
781 >                        addcolor(cbuffer[n], cval);
782 >                        wsum += w;
783                  }
784 <        }
785 <        /* motion blur if requested */
784 >                w = 1.0/wsum;
785 >                scalecolor(cbuffer[n], w);
786 >            }
787 >                                        /* motion blur if requested */
788          if (mblur > .02) {
789 <            int xs, ys, xl, yl;
790 <            int rise, run;
791 <            long        rise2, run2;
792 <            int n2;
793 <            int cnt;
794 <            /* sum in motion streaks */
795 <            memset(outbuffer, '\0', sizeof(COLOR)*hres*vres);
796 <            memset(wbuffer, '\0', sizeof(float)*hres*vres);
797 <            for (y = vres; y--; ) {
798 <                for (x = hres; x--; ) {
789 >                int     xs, ys, xl, yl;
790 >                int     rise, run;
791 >                long    rise2, run2;
792 >                int     n2;
793 >                int     cnt;
794 >                                        /* sum in motion streaks */
795 >                memset(outbuffer, '\0', sizeof(COLOR)*hres*vres);
796 >                memset(wbuffer, '\0', sizeof(float)*hres*vres);
797 >                for (y = vres; y--; )
798 >                    for (x = hres; x--; ) {
799                          n = fndx(x, y);
800                          if (xmbuffer[n] == MO_UNK) {
801                                  run = rise = 0;
# Line 810 | Line 816 | filter_frame(void)                     /* interpolation, motion-blur, an
816                          else ys = 1;
817                          rise2 = run2 = 0L;
818                          if (rise > run) {
819 <                            cnt = rise + 1;
820 <                            w = 1./cnt;
821 <                            copycolor(cval, cbuffer[n]);
822 <                            scalecolor(cval, w);
823 <                            while (cnt) {
824 <                                if (rise2 >= run2) {
825 <                                    if ((xl >= 0) & (xl < hres) &
819 >                                cnt = rise + 1;
820 >                                w = 1./cnt;
821 >                                copycolor(cval, cbuffer[n]);
822 >                                scalecolor(cval, w);
823 >                                while (cnt)
824 >                                        if (rise2 >= run2) {
825 >                                                if ((xl >= 0) & (xl < hres) &
826                                                      (yl >= 0) & (yl < vres)) {
827 <                                            n2 = fndx(xl, yl);
828 <                                            addcolor(outbuffer[n2], cval);
829 <                                            wbuffer[n2] += w;
830 <                                    }
831 <                                    yl += ys;
832 <                                    run2 += run;
833 <                                    cnt--;
834 <                                } else {
835 <                                        xl += xs;
836 <                                        rise2 += rise;
837 <                                }
838 <                            }
827 >                                                        n2 = fndx(xl, yl);
828 >                                                        addcolor(outbuffer[n2],
829 >                                                                        cval);
830 >                                                        wbuffer[n2] += w;
831 >                                                }
832 >                                                yl += ys;
833 >                                                run2 += run;
834 >                                                cnt--;
835 >                                        } else {
836 >                                                xl += xs;
837 >                                                rise2 += rise;
838 >                                        }
839                          } else {
840                                  cnt = run + 1;
841                                  w = 1./cnt;
842                                  copycolor(cval, cbuffer[n]);
843                                  scalecolor(cval, w);
844 <                                while (cnt) {
845 <                                    if (run2 >= rise2) {
846 <                                        if ((xl >= 0) & (xl < hres) &
844 >                                while (cnt)
845 >                                        if (run2 >= rise2) {
846 >                                                if ((xl >= 0) & (xl < hres) &
847                                                      (yl >= 0) & (yl < vres)) {
848 <                                                n2 = fndx(xl, yl);
849 <                                                addcolor(outbuffer[n2],
850 <                                                                cval);
851 <                                                wbuffer[n2] += w;
848 >                                                        n2 = fndx(xl, yl);
849 >                                                        addcolor(outbuffer[n2],
850 >                                                                        cval);
851 >                                                        wbuffer[n2] += w;
852 >                                                }
853 >                                                xl += xs;
854 >                                                rise2 += rise;
855 >                                                cnt--;
856 >                                        } else {
857 >                                                yl += ys;
858 >                                                run2 += run;
859                                          }
847 –                                        xl += xs;
848 –                                        rise2 += rise;
849 –                                        cnt--;
850 –                                    } else {
851 –                                            yl += ys;
852 –                                            run2 += run;
853 –                                    }
854 –                                }
860                          }
861 <                }
862 <                /* compute final results */
863 <                for (y = vres; y--; ) {
864 <                        for (x = hres; x--; ) {
865 <                                n = fndx(x, y);
866 <                                if (wbuffer[n] <= FTINY)
867 <                                        continue;
868 <                                w = 1./wbuffer[n];
869 <                                scalecolor(outbuffer[n], w);
870 <                        }
871 <                }
872 <            }
868 <        } else {
869 <                for (n = hres*vres; n--; ) {
861 >                    }
862 >                                        /* compute final results */
863 >                for (y = vres; y--; )
864 >                    for (x = hres; x--; ) {
865 >                        n = fndx(x, y);
866 >                        if (wbuffer[n] <= FTINY)
867 >                                continue;
868 >                        w = 1./wbuffer[n];
869 >                        scalecolor(outbuffer[n], w);
870 >                    }
871 >        } else
872 >                for (n = hres*vres; n--; )
873                          copycolor(outbuffer[n], cbuffer[n]);
871 –                }
872 –        }
874          /*
875             for (n = hres*vres; n--; )
876 <           if (!sbuffer[n])
877 <           setcolor(outbuffer[n], 0., 0., 0.);
876 >                   if (!sbuffer[n])
877 >                           setcolor(outbuffer[n], 0., 0., 0.);
878           */
879          /* adjust exposure */
880          if ((expval < 0.99) | (expval > 1.01))
881                  for (n = hres*vres; n--; )
882                          scalecolor(outbuffer[n], expval);
883 <        return;
883 > #if 0
884          {
885                  float   *sbuf = (float *)malloc(sizeof(float)*hres*vres);
886                  char    fnm[256];
# Line 890 | Line 891 | filter_frame(void)                     /* interpolation, motion-blur, an
891                  write_map(sbuf, fnm);
892                  free((void *)sbuf);
893          }
894 + #endif
895   }
896  
897  
# Line 902 | Line 904 | send_frame(void)                       /* send frame to destination */
904          int     y;
905                                          /* open output picture */
906          sprintf(pfname, vval(BASENAME), fcur);
907 <        strcat(pfname, ".pic");
907 >        strcat(pfname, ".hdr");
908          fp = fopen(pfname, "w");
909          if (fp == NULL) {
910                  sprintf(errmsg, "cannot open output frame \"%s\"", pfname);

Diff Legend

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