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

Comparing src/hd/rhdobj.c (file contents):
Revision 3.2 by gwlarson, Fri Aug 21 11:38:22 1998 UTC vs.
Revision 3.13 by schorsch, Thu Jun 26 00:58:10 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5 < * Routines for loading and displaying Radiance objects under OpenGL in rholo.
5 > * Routines for loading and displaying Radiance objects in rholo with GLX.
6   */
7  
8   #include "radogl.h"
# Line 13 | Line 10 | static char SCCSid[] = "$SunId$ SGI";
10   #include "rhdisp.h"
11   #include "rhdriver.h"
12   #include "rhdobj.h"
13 + #include "rtprocess.h"
14  
15   extern FILE     *sstdout;               /* user standard output */
16  
# Line 22 | Line 20 | int    (*dobj_lightsamp)() = NULL;     /* pointer to function
20  
21   #define AVGREFL         0.5             /* assumed average reflectance */
22  
23 < #define MAXAC           64              /* maximum number of args */
23 > #define MAXAC           512             /* maximum number of args */
24  
25   #ifndef MINTHRESH
26   #define MINTHRESH       5.0             /* source threshold w.r.t. mean */
# Line 53 | Line 51 | typedef struct dobject {
51          struct dobject  *next;          /* next object in list */
52          char    name[64];               /* object name */
53          FVECT   center;                 /* orig. object center */
54 <        FLOAT   radius;                 /* orig. object radius */
54 >        RREAL   radius;                 /* orig. object radius */
55          int     listid;                 /* GL display list identifier */
56 <        int     rtp[3];                 /* associated rtrace process */
56 >        int     nlists;                 /* number of lists allocated */
57 >        SUBPROC rtp;                    /* associated rtrace process */
58          DLIGHTS *ol;                    /* object lights */
59          FULLXF  xfb;                    /* coordinate transform */
60          short   drawcode;               /* drawing code */
# Line 119 | Line 118 | register DOBJECT       *op;
118          }
119          dobjects = ohead.next;
120          if (!foundlink) {
121 <                glDeleteLists(op->listid, 1);
122 <                close_process(op->rtp);
121 >                glDeleteLists(op->listid, op->nlists);
122 >                close_process(&(op->rtp));
123          }
124          while (op->xfac)
125                  freestr(op->xfav[--op->xfac]);
126 <        free((char *)op);
126 >        free((void *)op);
127          return(1);
128   }
129  
# Line 299 | Line 298 | ssph_compute()                 /* compute source set from sphere sam
298                                                  /* avg. reflected brightness */
299          d = AVGREFL / (double)ncells;  
300          scalecolor(csum, d);
301 <        if (tmCvColors(&dlightsets->larb, TM_NOCHROM, csum, 1) != TM_E_OK)
301 >        if (tmCvColors(&dlightsets->larb, TM_NOCHROM, &csum, 1) != TM_E_OK)
302                  error(CONSISTENCY, "tone mapping problem in ssph_compute");
303                                          /* greedy light source clustering */
304          while (dlightsets->nl < MAXLIGHTS) {
# Line 320 | Line 319 | ssph_compute()                 /* compute source set from sphere sam
319                                  continue;               /* too dim */
320                          ssph_direc(v, alt, azi);        /* else add it in */
321                          VSUM(ls->direc, ls->direc, v, d);
322 <                        ls->omega++;
322 >                        ls->omega += 1.;
323                          addcolor(ls->val, ssamp[alt][azi].val);
324 +                                                        /* remove from list */
325                          setcolor(ssamp[alt][azi].val, 0., 0., 0.);
326 +                        ssamp[alt][azi].nsamp = 0;
327                  }
328                  d = 1./ls->omega;                       /* avg. brightness */
329                  scalecolor(ls->val, d);
# Line 337 | Line 338 | ssph_compute()                 /* compute source set from sphere sam
338          d = 1.0/ncells;
339          scalecolor(dlightsets->lamb, d);
340   done:                                   /* clear sphere sample array */
341 <        bzero((char *)ssamp, sizeof(ssamp));
341 >        bzero((void *)ssamp, sizeof(ssamp));
342          return(ncells);
343   }
344  
# Line 404 | Line 405 | int    force;
405                          quit(0);
406          if (!ssph_compute()) {          /* compute light sources from sphere */
407                  dlightsets = dl->next;
408 <                free((char *)dl);
408 >                free((void *)dl);
409                  return(0);
410          }
411          op->ol = dl;
# Line 414 | Line 415 | memerr:
415   }
416  
417  
418 < static int
418 > static
419   cmderror(cn, err)               /* report command error */
420   int     cn;
421   char    *err;
422   {
423          sprintf(errmsg, "%s: %s", rhdcmd[cn], err);
424          error(COMMAND, errmsg);
424 –        return(cn);
425   }
426  
427  
# Line 430 | Line 430 | dobj_command(cmd, args)                /* run object display command
430   char    *cmd;
431   register char   *args;
432   {
433 +        int     somechange = 0;
434          int     cn, na, doxfm;
435          register int    nn;
436          char    *alist[MAXAC+1], *nm;
# Line 457 | Line 458 | register char  *args;
458                          dobj_load(alist[0], alist[0]);
459                  else if (na == 2)
460                          dobj_load(alist[0], alist[1]);
461 <                else
462 <                        return(cmderror(cn, "need octree [name]"));
461 >                else {
462 >                        cmderror(cn, "need octree [name]");
463 >                        return(0);
464 >                }
465                  break;
466 <        case DO_UNLOAD:                         /* unload an object */
466 >        case DO_UNLOAD:                         /* clear an object */
467                  if (na > 1) goto toomany;
468                  if (na && alist[0][0] == '*')
469 <                        dobj_cleanup();
469 >                        somechange += dobj_cleanup();
470                  else
471 <                        dobj_unload(na ? alist[0] : curname);
471 >                        somechange += dobj_unload(na ? alist[0] : curname);
472                  break;
473          case DO_XFORM:                          /* transform object */
474          case DO_MOVE:
# Line 474 | Line 477 | register char  *args;
477                  } else {
478                          nm = curname; nn = 0;
479                  }
480 <                if (cn == DO_MOVE && nn >= na)
481 <                        return(cmderror(cn, "missing transform"));
482 <                dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
480 >                if (cn == DO_MOVE && nn >= na) {
481 >                        cmderror(cn, "missing transform");
482 >                        return(0);
483 >                }
484 >                somechange += dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
485                  break;
486          case DO_UNMOVE:                         /* undo last transform */
487 <                dobj_unmove();
487 >                somechange += dobj_unmove();
488                  break;
489          case DO_OBJECT:                         /* print object statistics */
490 <                dobj_putstats(na ? alist[0] : curname, sstdout);
490 >                if (dobj_putstats(na ? alist[0] : curname, sstdout))
491 >                        if (na && alist[0][0] != '*' && (curobj == NULL ||
492 >                                        strcmp(alist[0], curobj->name)))
493 >                                savedxf(curobj = getdobj(alist[0]));
494                  break;
495          case DO_DUP:                            /* duplicate object */
496                  for (nn = 0; nn < na; nn++)
# Line 490 | Line 498 | register char  *args;
498                                  break;
499                  switch (nn) {
500                  case 0:
501 <                        return(cmderror(cn, "need new object name"));
501 >                        cmderror(cn, "need new object name");
502 >                        return(0);
503                  case 1:
504                          nm = curname;
505                          break;
# Line 503 | Line 512 | register char  *args;
512                  if (!dobj_dup(nm, alist[nn-1]))
513                          break;
514                  if (na > nn)
515 <                        dobj_xform(curname, 1, na-nn, alist+nn);
515 >                        somechange += dobj_xform(curname, 1, na-nn, alist+nn);
516                  else
517                          curobj->drawcode = DO_HIDE;
518 +                savedxf(curobj);
519                  break;
520          case DO_SHOW:                           /* change rendering option */
521          case DO_LIGHT:
522          case DO_HIDE:
523                  if (na > 1) goto toomany;
524                  dobj_lighting(na ? alist[0] : curname, cn);
525 +                somechange++;
526                  break;
527          default:
528                  error(CONSISTENCY, "bad command id in dobj_command");
529          }
530 <        dev_view(&odev.v);                      /* redraw */
520 <        return(cn);
530 >        return(somechange);
531   toomany:
532          return(cmderror(cn, "too many arguments"));
533   }
# Line 526 | Line 536 | toomany:
536   dobj_load(oct, nam)             /* create/load an octree object */
537   char    *oct, *nam;
538   {
529 –        extern char     *getlibpath(), *getpath();
539          char    *fpp, fpath[128];
540          register DOBJECT        *op;
541                                          /* check arguments */
# Line 542 | Line 551 | char   *oct, *nam;
551                  error(COMMAND, "illegal name");
552                  return(0);
553          }
554 +        if (getdobj(nam) != NULL) {
555 +                error(COMMAND, "name already taken (clear first)");
556 +                return(0);
557 +        }
558                                          /* get octree path */
559 <        if ((fpp = getpath(oct, getlibpath(), R_OK)) == NULL) {
559 >        if ((fpp = getpath(oct, getrlibpath(), R_OK)) == NULL) {
560                  sprintf(errmsg, "cannot find octree \"%s\"", oct);
561                  error(COMMAND, errmsg);
562                  return(0);
563          }
564          strcpy(fpath, fpp);
552 –        freedobj(getdobj(nam));         /* free previous use of nam */
565          op = (DOBJECT *)malloc(sizeof(DOBJECT));
566          if (op == NULL)
567                  error(SYSTEM, "out of memory in dobj_load");
# Line 562 | Line 574 | char   *oct, *nam;
574          op->xfav[op->xfac=0] = NULL;
575                                          /* load octree into display list */
576          dolights = 0;
577 <        op->listid = rgl_octlist(fpath, op->center, &op->radius);
577 >        domats = 1;
578 >        op->listid = rgl_octlist(fpath, op->center, &op->radius, &op->nlists);
579                                          /* start rtrace */
580          rtargv[RTARGC-1] = fpath;
581          rtargv[RTARGC] = NULL;
582 <        open_process(op->rtp, rtargv);
582 >        open_process(&(op->rtp), rtargv);
583                                          /* insert into main list */
584          op->next = dobjects;
585          curobj = dobjects = op;
# Line 599 | Line 612 | dobj_cleanup()                         /* free all resources */
612          savedxf(curobj = NULL);
613          while ((lp = dlightsets) != NULL) {
614                  dlightsets = lp->next;
615 <                free((char *)lp);
615 >                free((void *)lp);
616          }
617          return(1);
618   }
619  
620  
621 < dobj_xform(nam, add, ac, av)            /* set/add transform for nam */
621 > dobj_xform(nam, rel, ac, av)            /* set/add transform for nam */
622   char    *nam;
623 < int     add, ac;
623 > int     rel, ac;
624   char    **av;
625   {
626          register DOBJECT        *op;
627 +        FVECT   cent;
628 +        double  rad;
629 +        char    scoord[16];
630 +        int     i;
631  
632          if ((op = getdobj(nam)) == NULL) {
633                  error(COMMAND, "no object");
634                  return(0);
635          }
636 <        if (add) add = op->xfac;
637 <        if (ac + add > MAXAC) {
636 >        if (rel)
637 >                rel = op->xfac + 8;
638 >        if (ac + rel > MAXAC) {
639                  error(COMMAND, "too many transform arguments");
640                  return(0);
641          }
642 <        savedxf(curobj = op);
643 <        if (!add)
642 >        savedxf(curobj = op);           /* remember current transform */
643 >        if (rel && ac == 4 && !strcmp(av[0], "-t"))
644 >                rel = -1;                       /* don't move for translate */
645 >        else {
646 >                getdcent(cent, op);             /* don't move if near orig. */
647 >                rad = getdrad(op);
648 >                if (DOT(cent,cent) < rad*rad)
649 >                        rel = -1;
650 >        }
651 >        if (!rel) {                             /* remove old transform */
652                  while (op->xfac)
653                          freestr(op->xfav[--op->xfac]);
654 +        } else if (rel > 0) {                   /* relative move */
655 +                op->xfav[op->xfac++] = savestr("-t");
656 +                for (i = 0; i < 3; i++) {
657 +                        sprintf(scoord, "%.4e", -cent[i]);
658 +                        op->xfav[op->xfac++] = savestr(scoord);
659 +                }
660 +        }
661          while (ac--)
662                  op->xfav[op->xfac++] = savestr(*av++);
663 +        if (rel > 0) {                          /* move back */
664 +                op->xfav[op->xfac++] = savestr("-t");
665 +                for (i = 0; i < 3; i++) {
666 +                        sprintf(scoord, "%.4e", cent[i]);
667 +                        op->xfav[op->xfac++] = savestr(scoord);
668 +                }
669 +        }
670          op->xfav[op->xfac] = NULL;
671          if (fullxf(&op->xfb, op->xfac, op->xfav) != op->xfac) {
672                  error(COMMAND, "bad transform arguments");
# Line 663 | Line 703 | FILE   *fp;
703                  return(0);
704          }
705          getdcent(ocent, op);
706 <        fprintf(fp, "%s: %s, center [%f %f %f], radius %f", op->name,
707 <                        op->drawcode==DO_HIDE ? "hid" :
708 <                        op->drawcode==DO_LIGHT && op->ol!=NULL ? "lit" :
706 >        fprintf(fp, "%s: %s, center [%g %g %g], radius %g", op->name,
707 >                        op->drawcode==DO_HIDE ? "hidden" :
708 >                        op->drawcode==DO_LIGHT && op->ol!=NULL ? "lighted" :
709                          "shown",
710                          ocent[0],ocent[1],ocent[2], getdrad(op));
711          if (op->xfac)
# Line 691 | Line 731 | dobj_unmove()                          /* undo last transform change */
731                  return(0);
732          }
733                                          /* hold last transform */
734 <        bcopy((char *)lastxfav, (char *)txfav,
734 >        bcopy((void *)lastxfav, (void *)txfav,
735                          (txfac=lastxfac)*sizeof(char *));
736                                          /* save this transform */
737 <        bcopy((char *)curobj->xfav, (char *)lastxfav,
737 >        bcopy((void *)curobj->xfav, (void *)lastxfav,
738                          (lastxfac=curobj->xfac)*sizeof(char *));
739                                          /* copy back last transform */
740 <        bcopy((char *)txfav, (char *)curobj->xfav,
740 >        bcopy((void *)txfav, (void *)curobj->xfav,
741                          (curobj->xfac=txfac)*sizeof(char *));
742                                          /* set matrices */
743          fullxf(&curobj->xfb, curobj->xfac, curobj->xfav);
# Line 724 | Line 764 | char   *oldnm, *nam;
764                  error(COMMAND, "illegal name");
765                  return(0);
766          }
767 +        if (getdobj(nam) != NULL) {
768 +                error(COMMAND, "name already taken (clear first)");
769 +                return(0);
770 +        }
771                                          /* allocate and copy struct */
772          opdup = (DOBJECT *)malloc(sizeof(DOBJECT));
773          if (opdup == NULL)
# Line 763 | Line 807 | int    cn;
807          } else if ((op = getdobj(nam)) == NULL) {
808                  error(COMMAND, "unknown object");
809                  return(0);
810 <        } else if ((op->drawcode = cn) == DO_LIGHT)
811 <                getdlights(op, 1);
812 <        else
810 >        } else if ((op->drawcode = cn) == DO_LIGHT) {
811 >                if (!getdlights(op, 1))
812 >                        error(COMMAND, "insufficient samples to light object");
813 >        } else
814                  op->ol = NULL;
815  
816          if (dobj_lightsamp != NULL) {           /* restore beam set */
# Line 786 | Line 831 | FVECT   rorg, rdir;
831          register DOBJECT        *op;
832          FVECT   xorg, xdir;
833          double  darr[6];
834 <
834 >                                        /* check each visible object? */
835          if (nm == NULL || *nm == '*') {
836                  double  dist, mindist = 1.01*FHUGE;
837 <                                        /* check each visible object */
837 >
838 >                if (nm != NULL) nm[0] = '\0';
839                  for (op = dobjects; op != NULL; op = op->next) {
840                          if (op->drawcode == DO_HIDE)
841                                  continue;
842                          dist = dobj_trace(op->name, rorg, rdir);
843                          if (dist < mindist) {
844 <                                dist = mindist;
845 <                                if (nm != NULL)
800 <                                        strcpy(nm, op->name);
844 >                                if (nm != NULL) strcpy(nm, op->name);
845 >                                mindist = dist;
846                          }
847                  }
848                  return(mindist);
# Line 807 | Line 852 | FVECT   rorg, rdir;
852                  error(COMMAND, "unknown object");
853                  return(FHUGE);
854          }
855 <        if (op->xfac) {         /* transform ray */
855 >        if (op->xfac) {         /* put ray in local coordinates */
856                  multp3(xorg, rorg, op->xfb.b.xfm);
857                  multv3(xdir, rdir, op->xfb.b.xfm);
858                  VCOPY(darr, xorg); VCOPY(darr+3, xdir);
# Line 815 | Line 860 | FVECT   rorg, rdir;
860                  VCOPY(darr, rorg); VCOPY(darr+3, rdir);
861          }
862                                  /* trace it */
863 <        if (process(op->rtp, darr, darr, sizeof(double),
863 >        if (process(&(op->rtp), (char *)darr, (char *)darr, sizeof(double),
864                          6*sizeof(double)) != sizeof(double))
865                  error(SYSTEM, "rtrace communication error");
866                                  /* return distance */
867          if (darr[0] >= .99*FHUGE)
868                  return(FHUGE);
869 <        return(darr[0] * op->xfb.f.sca);
869 >        return(darr[0]*op->xfb.f.sca);
870   }
871  
872  
873 + int
874   dobj_render()                   /* render our objects in OpenGL */
875   {
876 +        int     nrendered = 0;
877          GLboolean       normalizing;
878          GLfloat vec[4];
879          FVECT   v1;
# Line 837 | Line 884 | dobj_render()                  /* render our objects in OpenGL */
884                  if (op->drawcode != DO_HIDE)
885                          break;
886          if (op == NULL)
887 <                return(1);
887 >                return(0);
888                                          /* set up general rendering params */
889          glGetBooleanv(GL_NORMALIZE, &normalizing);
890 <        glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|
891 <                        GL_DEPTH_BUFFER_BIT|GL_POLYGON_BIT);
890 >        glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|GL_ENABLE_BIT|
891 >                GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_POLYGON_BIT);
892          glDepthFunc(GL_LESS);
893          glEnable(GL_DEPTH_TEST);
894          glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
# Line 887 | Line 934 | dobj_render()                  /* render our objects in OpenGL */
934                                  glLightfv(glightid[i], GL_AMBIENT, vec);
935                                  glEnable(glightid[i]);
936                          }
937 <                } else {                        /* no sources to draw on */
937 >                } else {                        /* fake lighting */
938                          vec[0] = vec[1] = vec[2] = 0.; vec[3] = 1.;
939                          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vec);
940                          getdcent(v1, op);
# Line 923 | Line 970 | dobj_render()                  /* render our objects in OpenGL */
970                  }
971                                          /* render the display list */
972                  glCallList(op->listid);
973 +                nrendered++;
974                                          /* restore matrix */
975                  if (op->xfac) {
976                          glMatrixMode(GL_MODELVIEW);
# Line 937 | Line 985 | dobj_render()                  /* render our objects in OpenGL */
985                  else
986                          glDisable(GL_LIGHT0);
987                                          /* check errors */
940 –                rgl_checkerr("rendering object in dobj_render");
988          }
989          glPopAttrib();                  /* restore rendering params */
990 <        return(1);
990 >        rgl_checkerr("rendering objects in dobj_render");
991 >        return(nrendered);
992   }

Diff Legend

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