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

Comparing ray/src/hd/rhdobj.c (file contents):
Revision 3.1 by gwlarson, Wed Aug 19 17:45:24 1998 UTC vs.
Revision 3.22 by greg, Fri Feb 28 05:18:49 2020 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 <string.h>
9 + #include <ctype.h>
10 +
11   #include "radogl.h"
12   #include "tonemap.h"
13   #include "rhdisp.h"
14   #include "rhdriver.h"
15   #include "rhdobj.h"
16 + #include "rtprocess.h"
17  
18   extern FILE     *sstdout;               /* user standard output */
19  
20   char    rhdcmd[DO_NCMDS][8] = DO_INIT;  /* user command list */
21  
22 < int     (*dobj_lightsamp)() = NULL;     /* pointer to function to get lights */
22 > /* pointer to function to get lights */
23 > void    (*dobj_lightsamp)(COLR clr, FVECT direc, FVECT pos) = NULL;
24  
25   #define AVGREFL         0.5             /* assumed average reflectance */
26  
27 < #define MAXAC           64              /* maximum number of args */
27 > #define MAXAC           512             /* maximum number of args */
28  
29   #ifndef MINTHRESH
30 < #define MINTHRESH       7.0             /* source threshold w.r.t. mean */
30 > #define MINTHRESH       5.0             /* source threshold w.r.t. mean */
31   #endif
32  
33   #ifndef NALT
34   #define NALT            11              /* # sampling altitude angles */
35   #endif
36   #ifndef NAZI
37 < #define NAZI            ((int)(PI/2.*NALT+.5))
37 > #define NAZI            17
38   #endif
39  
40   typedef struct dlights {
# Line 53 | Line 55 | typedef struct dobject {
55          struct dobject  *next;          /* next object in list */
56          char    name[64];               /* object name */
57          FVECT   center;                 /* orig. object center */
58 <        FLOAT   radius;                 /* orig. object radius */
58 >        RREAL   radius;                 /* orig. object radius */
59          int     listid;                 /* GL display list identifier */
60 <        int     rtp[3];                 /* associated rtrace process */
60 >        int     nlists;                 /* number of lists allocated */
61 >        SUBPROC rtp;                    /* associated rtrace process */
62          DLIGHTS *ol;                    /* object lights */
63          FULLXF  xfb;                    /* coordinate transform */
64          short   drawcode;               /* drawing code */
# Line 69 | Line 72 | static DOBJECT *curobj;                /* current (last referred) ob
72   static int      lastxfac;               /* last number of transform args */
73   static char     *lastxfav[MAXAC+1];     /* saved transform arguments */
74  
75 + #define getdcent(c,op)  multp3(c,(op)->center,(op)->xfb.f.xfm)
76 + #define getdrad(op)     ((op)->radius*(op)->xfb.f.sca)
77 +
78   #define RTARGC  8
79   static char     *rtargv[RTARGC+1] = {"rtrace", "-h-", "-w-", "-fdd",
80                                          "-x", "1", "-oL"};
# Line 80 | Line 86 | static struct {
86  
87   #define curname         (curobj==NULL ? (char *)NULL : curobj->name)
88  
89 + static DOBJECT *getdobj(char *nm);
90 + static int freedobj(DOBJECT *op);
91 + static int savedxf(DOBJECT *op);
92 + static void ssph_sample(COLR clr, FVECT direc, FVECT pos);
93 + static void ssph_direc(FVECT direc, int alt, int azi);
94 + static int ssph_neigh(int sp[2], int next);
95 + static int ssph_compute(void);
96 + static int getdlights(DOBJECT *op, int force);
97 + static void cmderror(int cn, char *err);
98  
99 +
100   static DOBJECT *
101 < getdobj(nm)                     /* get object from list by name */
102 < char    *nm;
101 > getdobj(                        /* get object from list by name */
102 >        char    *nm
103 > )
104   {
105 <        register DOBJECT        *op;
105 >        DOBJECT *op;
106  
107          if (nm == NULL)
108                  return(NULL);
# Line 98 | Line 115 | char   *nm;
115   }
116  
117  
118 < static
119 < freedobj(op)                    /* free resources and memory assoc. with op */
120 < register DOBJECT        *op;
118 > static int
119 > freedobj(                       /* free resources and memory assoc. with op */
120 >        DOBJECT *op
121 > )
122   {
123          int     foundlink = 0;
124          DOBJECT ohead;
125 <        register DOBJECT        *opl;
125 >        DOBJECT *opl;
126  
127          if (op == NULL)
128                  return(0);
# Line 116 | Line 134 | register DOBJECT       *op;
134          }
135          dobjects = ohead.next;
136          if (!foundlink) {
137 <                glDeleteLists(op->listid, 1);
138 <                close_process(op->rtp);
137 >                glDeleteLists(op->listid, op->nlists);
138 >                close_process(&op->rtp);
139          }
140          while (op->xfac)
141                  freestr(op->xfav[--op->xfac]);
142 <        free((char *)op);
142 >        free((void *)op);
143          return(1);
144   }
145  
146  
147 < static
148 < savedxf(op)                     /* save transform for display object */
149 < register DOBJECT        *op;
147 > static int
148 > savedxf(                        /* save transform for display object */
149 >        DOBJECT *op
150 > )
151   {
152                                          /* free old */
153          while (lastxfac)
# Line 146 | Line 165 | register DOBJECT       *op;
165   }
166  
167  
168 < static
169 < ssph_sample(clr, direc, pos)    /* add sample to current source sphere */
170 < COLR    clr;
171 < FVECT   direc, pos;
168 > static void
169 > ssph_sample(    /* add sample to current source sphere */
170 >        COLR    clr,
171 >        FVECT   direc,
172 >        FVECT   pos
173 > )
174   {
175          COLOR   col;
176          double  d;
177 <        register int    alt, azi;
177 >        int     alt, azi;
178  
179          if (dlightsets == NULL)
180                  return;
# Line 173 | Line 194 | FVECT  direc, pos;
194   }
195  
196  
197 < static
198 < ssph_direc(direc, alt, azi)     /* compute sphere sampling direction */
199 < FVECT   direc;
200 < int     alt, azi;
197 > static void
198 > ssph_direc(     /* compute sphere sampling direction */
199 >        FVECT   direc,
200 >        int     alt,
201 >        int     azi
202 > )
203   {
204          double  phi, d;
205  
# Line 189 | Line 212 | int    alt, azi;
212  
213  
214   static int
215 < ssph_neigh(sp, next)            /* neighbor counter on sphere */
216 < register int    sp[2];
217 < int     next;
215 > ssph_neigh(             /* neighbor counter on sphere */
216 >        int     sp[2],
217 >        int     next
218 > )
219   {
220          static short    nneigh = 0;             /* neighbor count */
221          static short    neighlist[NAZI+6][2];   /* neighbor list (0 is home) */
222 <        register int    i;
222 >        int     i;
223  
224          if (next) {
225                  if (nneigh <= 0)
# Line 204 | Line 228 | int    next;
228                  sp[1] = neighlist[nneigh][1];
229                  return(1);
230          }
231 <        if (sp[0] < 0 | sp[0] >= NALT | sp[1] < 0 | sp[1] >= NAZI)
231 >        if ((sp[0] < 0) | (sp[0] >= NALT) | (sp[1] < 0) | (sp[1] >= NAZI))
232                  return(nneigh=0);
233          neighlist[0][0] = sp[0]; neighlist[0][1] = sp[1];
234          nneigh = 1;
# Line 254 | Line 278 | int    next;
278   }
279  
280  
281 < static
282 < ssph_compute()                  /* compute source set from sphere samples */
281 > static int
282 > ssph_compute(void)                      /* compute source set from sphere samples */
283   {
284          int     ncells, nsamps;
285          COLOR   csum;
286          FVECT   v;
287          double  d, thresh, maxbr;
288          int     maxalt, maxazi, spos[2];
289 <        register int    alt, azi;
290 <        register struct lsource *ls;
289 >        int     alt, azi;
290 >        struct lsource  *ls;
291                                          /* count & average sampled cells */
292          setcolor(csum, 0., 0., 0.);
293          ncells = nsamps = 0;
# Line 278 | Line 302 | ssph_compute()                 /* compute source set from sphere sam
302                                  nsamps += ssamp[alt][azi].nsamp;
303                                  ncells++;
304                          }
305 <        if (dlightsets == NULL | ncells < NALT*NAZI/4) {
306 <                bzero((char *)ssamp, sizeof(ssamp));
307 <                return(0);
305 >        if ((dlightsets == NULL) | (ncells < NALT*NAZI/4)) {
306 >                ncells = 0;
307 >                goto done;
308          }
309                                                  /* harmonic mean distance */
310          if (dlightsets->ravg > FTINY)
# Line 289 | Line 313 | ssph_compute()                 /* compute source set from sphere sam
313                  dlightsets->ravg = FHUGE;
314                                                  /* light source threshold */
315          thresh = MINTHRESH*bright(csum)/ncells;
316 +        if (thresh <= FTINY) {
317 +                ncells = 0;
318 +                goto done;
319 +        }
320                                                  /* avg. reflected brightness */
321          d = AVGREFL / (double)ncells;  
322          scalecolor(csum, d);
323 <        if (tmCvColors(&dlightsets->larb, TM_NOCHROM, csum, 1) != TM_E_OK)
324 <                error(CONSISTENCY, "bad tone mapping in ssph_compute");
323 >        if (tmCvColors(tmGlobal, &dlightsets->larb,
324 >                        TM_NOCHROM, &csum, 1) != TM_E_OK)
325 >                error(CONSISTENCY, "tone mapping problem in ssph_compute");
326                                          /* greedy light source clustering */
327          while (dlightsets->nl < MAXLIGHTS) {
328                  maxbr = 0.;                     /* find brightest cell */
# Line 313 | Line 342 | ssph_compute()                 /* compute source set from sphere sam
342                                  continue;               /* too dim */
343                          ssph_direc(v, alt, azi);        /* else add it in */
344                          VSUM(ls->direc, ls->direc, v, d);
345 <                        ls->omega++;
345 >                        ls->omega += 1.;
346                          addcolor(ls->val, ssamp[alt][azi].val);
347 +                                                        /* remove from list */
348                          setcolor(ssamp[alt][azi].val, 0., 0., 0.);
349 +                        ssamp[alt][azi].nsamp = 0;
350                  }
351                  d = 1./ls->omega;                       /* avg. brightness */
352                  scalecolor(ls->val, d);
# Line 329 | Line 360 | ssph_compute()                 /* compute source set from sphere sam
360                                  addcolor(dlightsets->lamb, ssamp[alt][azi].val);
361          d = 1.0/ncells;
362          scalecolor(dlightsets->lamb, d);
363 <                                        /* clear sphere sample array */
364 <        bzero((char *)ssamp, sizeof(ssamp));
363 > done:                                   /* clear sphere sample array */
364 >        memset((void *)ssamp, '\0', sizeof(ssamp));
365          return(ncells);
366   }
367  
368  
369 < static
370 < getdlights(op, force)           /* get lights for display object */
371 < register DOBJECT        *op;
372 < int     force;
369 > static int
370 > getdlights(             /* get lights for display object */
371 >        DOBJECT *op,
372 >        int     force
373 > )
374   {
375          double  d2, mind2 = FHUGE*FHUGE;
376          FVECT   ocent;
377          VIEW    cvw;
378 <        register DLIGHTS        *dl;
378 >        DLIGHTS *dl;
379  
380          op->ol = NULL;
381          if (op->drawcode != DO_LIGHT)
382                  return(0);
383                                          /* check for usable light set */
384 <        multp3(ocent, op->center, op->xfb.f.xfm);
384 >        getdcent(ocent, op);
385          for (dl = dlightsets; dl != NULL; dl = dl->next)
386                  if ((d2 = dist2(dl->lcent, ocent)) < mind2) {
387                          op->ol = dl;
388                          mind2 = d2;
389                  }
390                                          /* the following is heuristic */
391 <        d2 = 2.*op->radius*op->xfb.f.sca; d2 *= d2;
391 >        d2 = 2.*getdrad(op); d2 *= d2;
392          if ((dl = op->ol) != NULL && (mind2 < 0.0625*dl->ravg*dl->ravg ||
393 <                mind2 < 4.*op->radius*op->xfb.f.sca*op->radius*op->xfb.f.sca))
393 >                        mind2 < 4.*getdrad(op)*getdrad(op)))
394                  return(1);
395          if (!force)
396                  return(0);
397                                          /* need to compute new light set */
398 <        copystruct(&cvw, &stdview);
398 >        cvw = stdview;
399          cvw.type = VT_PER;
400          VCOPY(cvw.vp, ocent);
401          cvw.vup[0] = 1.; cvw.vup[1] = cvw.vup[2] = 0.;
# Line 397 | Line 429 | int    force;
429                          quit(0);
430          if (!ssph_compute()) {          /* compute light sources from sphere */
431                  dlightsets = dl->next;
432 <                free((char *)dl);
432 >                free((void *)dl);
433                  return(0);
434          }
435          op->ol = dl;
436          return(1);
437   memerr:
438          error(SYSTEM, "out of memory in getdlights");
439 +        return 0; /* pro forma return */
440   }
441  
442  
443 < static int
444 < cmderror(cn, err)               /* report command error */
445 < int     cn;
446 < char    *err;
443 > static void
444 > cmderror(               /* report command error */
445 >        int     cn,
446 >        char    *err
447 > )
448   {
449          sprintf(errmsg, "%s: %s", rhdcmd[cn], err);
450          error(COMMAND, errmsg);
417 –        return(cn);
451   }
452  
453  
454   int
455 < dobj_command(cmd, args)         /* run object display command */
456 < char    *cmd;
457 < register char   *args;
455 > dobj_command(           /* run object display command */
456 >        char    *cmd,
457 >        char    *args
458 > )
459   {
460 <        int     cn, na, doxfm;
461 <        register int    nn;
460 >        int     somechange = 0;
461 >        int     cn, na;
462 >        int     nn;
463          char    *alist[MAXAC+1], *nm;
464                                          /* find command */
465          for (cn = 0; cn < DO_NCMDS; cn++)
# Line 450 | Line 485 | register char  *args;
485                          dobj_load(alist[0], alist[0]);
486                  else if (na == 2)
487                          dobj_load(alist[0], alist[1]);
488 <                else
489 <                        return(cmderror(cn, "need octree [name]"));
488 >                else {
489 >                        cmderror(cn, "need octree [name]");
490 >                        return(0);
491 >                }
492                  break;
493 <        case DO_UNLOAD:                         /* unload an object */
493 >        case DO_UNLOAD:                         /* clear an object */
494                  if (na > 1) goto toomany;
495                  if (na && alist[0][0] == '*')
496 <                        dobj_cleanup();
496 >                        somechange += dobj_cleanup();
497                  else
498 <                        dobj_unload(na ? alist[0] : curname);
498 >                        somechange += dobj_unload(na ? alist[0] : curname);
499                  break;
500          case DO_XFORM:                          /* transform object */
501          case DO_MOVE:
# Line 467 | Line 504 | register char  *args;
504                  } else {
505                          nm = curname; nn = 0;
506                  }
507 <                if (cn == DO_MOVE && nn >= na)
508 <                        return(cmderror(cn, "missing transform"));
509 <                dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
507 >                if (cn == DO_MOVE && nn >= na) {
508 >                        cmderror(cn, "missing transform");
509 >                        return(0);
510 >                }
511 >                somechange += dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
512                  break;
513          case DO_UNMOVE:                         /* undo last transform */
514 <                dobj_unmove();
514 >                somechange += dobj_unmove();
515                  break;
516          case DO_OBJECT:                         /* print object statistics */
517 <                dobj_putstats(na ? alist[0] : curname, sstdout);
517 >                if (dobj_putstats(na ? alist[0] : curname, sstdout))
518 >                        if (na && alist[0][0] != '*' && (curobj == NULL ||
519 >                                        strcmp(alist[0], curobj->name)))
520 >                                savedxf(curobj = getdobj(alist[0]));
521                  break;
522          case DO_DUP:                            /* duplicate object */
523                  for (nn = 0; nn < na; nn++)
# Line 483 | Line 525 | register char  *args;
525                                  break;
526                  switch (nn) {
527                  case 0:
528 <                        return(cmderror(cn, "need new object name"));
528 >                        cmderror(cn, "need new object name");
529 >                        return(0);
530                  case 1:
531                          nm = curname;
532                          break;
# Line 496 | Line 539 | register char  *args;
539                  if (!dobj_dup(nm, alist[nn-1]))
540                          break;
541                  if (na > nn)
542 <                        dobj_xform(curname, 1, na-nn, alist+nn);
542 >                        somechange += dobj_xform(curname, 1, na-nn, alist+nn);
543                  else
544                          curobj->drawcode = DO_HIDE;
545 +                savedxf(curobj);
546                  break;
547          case DO_SHOW:                           /* change rendering option */
548          case DO_LIGHT:
549          case DO_HIDE:
550                  if (na > 1) goto toomany;
551                  dobj_lighting(na ? alist[0] : curname, cn);
552 +                somechange++;
553                  break;
554          default:
555                  error(CONSISTENCY, "bad command id in dobj_command");
556          }
557 <        dev_view(&odev.v);                      /* redraw */
513 <        return(cn);
557 >        return(somechange);
558   toomany:
559 <        return(cmderror(cn, "too many arguments"));
559 >        cmderror(cn, "too many arguments");
560 >        return(-1);
561   }
562  
563  
564 < dobj_load(oct, nam)             /* create/load an octree object */
565 < char    *oct, *nam;
564 > int
565 > dobj_load(              /* create/load an octree object */
566 >        char    *oct,
567 >        char    *nam
568 > )
569   {
522 –        extern char     *getlibpath(), *getpath();
570          char    *fpp, fpath[128];
571 <        register DOBJECT        *op;
571 >        DOBJECT *op;
572                                          /* check arguments */
573          if (oct == NULL) {
574                  error(COMMAND, "missing octree");
# Line 531 | Line 578 | char   *oct, *nam;
578                  error(COMMAND, "missing name");
579                  return(0);
580          }
581 <        if (*nam == '*' | *nam == '-') {
581 >        if ((*nam == '*') | (*nam == '-')) {
582                  error(COMMAND, "illegal name");
583                  return(0);
584          }
585 +        if (getdobj(nam) != NULL) {
586 +                error(COMMAND, "name already taken (clear first)");
587 +                return(0);
588 +        }
589                                          /* get octree path */
590 <        if ((fpp = getpath(oct, getlibpath(), R_OK)) == NULL) {
590 >        if ((fpp = getpath(oct, getrlibpath(), R_OK)) == NULL) {
591                  sprintf(errmsg, "cannot find octree \"%s\"", oct);
592                  error(COMMAND, errmsg);
593                  return(0);
594          }
595          strcpy(fpath, fpp);
545 –        freedobj(getdobj(nam));         /* free previous use of nam */
596          op = (DOBJECT *)malloc(sizeof(DOBJECT));
597          if (op == NULL)
598                  error(SYSTEM, "out of memory in dobj_load");
# Line 555 | Line 605 | char   *oct, *nam;
605          op->xfav[op->xfac=0] = NULL;
606                                          /* load octree into display list */
607          dolights = 0;
608 <        op->listid = rgl_octlist(fpath, op->center, &op->radius);
608 >        domats = 1;
609 >        op->listid = rgl_octlist(fpath, op->center, &op->radius, &op->nlists);
610                                          /* start rtrace */
611          rtargv[RTARGC-1] = fpath;
612          rtargv[RTARGC] = NULL;
613 <        open_process(op->rtp, rtargv);
613 >        op->rtp = sp_inactive;
614 >        open_process(&op->rtp, rtargv);
615                                          /* insert into main list */
616          op->next = dobjects;
617          curobj = dobjects = op;
# Line 568 | Line 620 | char   *oct, *nam;
620   }
621  
622  
623 < dobj_unload(nam)                        /* free the named object */
624 < char    *nam;
623 > int
624 > dobj_unload(                    /* free the named object */
625 >        char    *nam
626 > )
627   {
628 <        register DOBJECT        *op;
628 >        DOBJECT *op;
629  
630          if ((op = getdobj(nam)) == NULL) {
631                  error(COMMAND, "no object");
# Line 583 | Line 637 | char   *nam;
637   }
638  
639  
640 < dobj_cleanup()                          /* free all resources */
640 > int
641 > dobj_cleanup(void)                              /* free all resources */
642   {
643 <        register DLIGHTS        *lp;
643 >        DLIGHTS *lp;
644  
645          while (dobjects != NULL)
646                  freedobj(dobjects);
647          savedxf(curobj = NULL);
648          while ((lp = dlightsets) != NULL) {
649                  dlightsets = lp->next;
650 <                free((char *)lp);
650 >                free((void *)lp);
651          }
652          return(1);
653   }
654  
655  
656 < dobj_xform(nam, add, ac, av)            /* set/add transform for nam */
657 < char    *nam;
658 < int     add, ac;
659 < char    **av;
656 > int
657 > dobj_xform(             /* set/add transform for nam */
658 >        char    *nam,
659 >        int     rel,
660 >        int     ac,
661 >        char    **av
662 > )
663   {
664 <        register DOBJECT        *op;
664 >        DOBJECT *op;
665 >        FVECT   cent;
666 >        double  rad;
667 >        char    scoord[16];
668 >        int     i;
669  
670          if ((op = getdobj(nam)) == NULL) {
671                  error(COMMAND, "no object");
672                  return(0);
673          }
674 <        if (add) add = op->xfac;
675 <        if (ac + add > MAXAC) {
674 >        if (rel)
675 >                rel = op->xfac + 8;
676 >        if (ac + rel > MAXAC) {
677                  error(COMMAND, "too many transform arguments");
678                  return(0);
679          }
680 <        savedxf(curobj = op);
681 <        if (!add)
680 >        savedxf(curobj = op);           /* remember current transform */
681 >        if (rel && ac == 4 && !strcmp(av[0], "-t"))
682 >                rel = -1;                       /* don't move for translate */
683 >        else {
684 >                getdcent(cent, op);             /* don't move if near orig. */
685 >                rad = getdrad(op);
686 >                if (DOT(cent,cent) < rad*rad)
687 >                        rel = -1;
688 >        }
689 >        if (!rel) {                             /* remove old transform */
690                  while (op->xfac)
691                          freestr(op->xfav[--op->xfac]);
692 +        } else if (rel > 0) {                   /* relative move */
693 +                op->xfav[op->xfac++] = savestr("-t");
694 +                for (i = 0; i < 3; i++) {
695 +                        sprintf(scoord, "%.4e", -cent[i]);
696 +                        op->xfav[op->xfac++] = savestr(scoord);
697 +                }
698 +        }
699          while (ac--)
700                  op->xfav[op->xfac++] = savestr(*av++);
701 +        if (rel > 0) {                          /* move back */
702 +                op->xfav[op->xfac++] = savestr("-t");
703 +                for (i = 0; i < 3; i++) {
704 +                        sprintf(scoord, "%.4e", cent[i]);
705 +                        op->xfav[op->xfac++] = savestr(scoord);
706 +                }
707 +        }
708          op->xfav[op->xfac] = NULL;
709          if (fullxf(&op->xfb, op->xfac, op->xfav) != op->xfac) {
710                  error(COMMAND, "bad transform arguments");
# Line 633 | Line 718 | char   **av;
718   }
719  
720  
721 < dobj_putstats(nam, fp)                  /* put out statistics for nam */
722 < char    *nam;
723 < FILE    *fp;
721 > int
722 > dobj_putstats(                  /* put out statistics for nam */
723 >        char    *nam,
724 >        FILE    *fp
725 > )
726   {
727          FVECT   ocent;
728 <        register DOBJECT        *op;
729 <        register int    i;
728 >        DOBJECT *op;
729 >        int     i;
730  
731          if (nam == NULL) {
732                  error(COMMAND, "no current object");
# Line 655 | Line 742 | FILE   *fp;
742                  error(COMMAND, "unknown object");
743                  return(0);
744          }
745 <        multp3(ocent, op->center, op->xfb.f.xfm);
746 <        fprintf(fp, "%s: %s, center [%f %f %f], radius %f", op->name,
747 <                        op->drawcode==DO_HIDE ? "hid" :
748 <                        op->drawcode==DO_LIGHT && op->ol!=NULL ? "lit" :
745 >        getdcent(ocent, op);
746 >        fprintf(fp, "%s: %s, center [%g %g %g], radius %g", op->name,
747 >                        op->drawcode==DO_HIDE ? "hidden" :
748 >                        op->drawcode==DO_LIGHT && op->ol!=NULL ? "lighted" :
749                          "shown",
750 <                        ocent[0],ocent[1],ocent[2], op->radius*op->xfb.f.sca);
750 >                        ocent[0],ocent[1],ocent[2], getdrad(op));
751          if (op->xfac)
752                  fputs(", (xform", fp);
753          for (i = 0; i < op->xfac; i++) {
# Line 674 | Line 761 | FILE   *fp;
761   }
762  
763  
764 < dobj_unmove()                           /* undo last transform change */
764 > int
765 > dobj_unmove(void)                               /* undo last transform change */
766   {
767          int     txfac;
768          char    *txfav[MAXAC+1];
# Line 684 | Line 772 | dobj_unmove()                          /* undo last transform change */
772                  return(0);
773          }
774                                          /* hold last transform */
775 <        bcopy((char *)lastxfav, (char *)txfav,
775 >        memcpy((void *)txfav, (void *)lastxfav,
776                          (txfac=lastxfac)*sizeof(char *));
777                                          /* save this transform */
778 <        bcopy((char *)curobj->xfav, (char *)lastxfav,
778 >        memcpy((void *)lastxfav, (void *)curobj->xfav,
779                          (lastxfac=curobj->xfac)*sizeof(char *));
780                                          /* copy back last transform */
781 <        bcopy((char *)txfav, (char *)curobj->xfav,
781 >        memcpy((void *)curobj->xfav, (void *)txfav,
782                          (curobj->xfac=txfac)*sizeof(char *));
783                                          /* set matrices */
784          fullxf(&curobj->xfb, curobj->xfac, curobj->xfav);
# Line 700 | Line 788 | dobj_unmove()                          /* undo last transform change */
788   }
789  
790  
791 < dobj_dup(oldnm, nam)                    /* duplicate object oldnm as nam */
792 < char    *oldnm, *nam;
791 > int
792 > dobj_dup(                       /* duplicate object oldnm as nam */
793 >        char    *oldnm,
794 >        char    *nam
795 > )
796   {
797 <        register DOBJECT        *op, *opdup;
797 >        DOBJECT *op, *opdup;
798                                          /* check arguments */
799          if ((op = getdobj(oldnm)) == NULL) {
800                  error(COMMAND, "no object");
# Line 713 | Line 804 | char   *oldnm, *nam;
804                  error(COMMAND, "missing name");
805                  return(0);
806          }
807 <        if (*nam == '*' | *nam == '-') {
807 >        if ((*nam == '*') | (*nam == '-')) {
808                  error(COMMAND, "illegal name");
809                  return(0);
810          }
811 +        if (getdobj(nam) != NULL) {
812 +                error(COMMAND, "name already taken (clear first)");
813 +                return(0);
814 +        }
815                                          /* allocate and copy struct */
816          opdup = (DOBJECT *)malloc(sizeof(DOBJECT));
817          if (opdup == NULL)
818                  error(SYSTEM, "out of memory in dobj_dup");
819 <        copystruct(opdup, op);
819 >        *opdup = *op;
820                                          /* rename */
821          strcpy(opdup->name, nam);
822                                          /* get our own copy of transform */
# Line 735 | Line 830 | char   *oldnm, *nam;
830   }
831  
832  
833 < dobj_lighting(nam, cn)          /* set up lighting for display object */
834 < char    *nam;
835 < int     cn;
833 > int
834 > dobj_lighting(          /* set up lighting for display object */
835 >        char    *nam,
836 >        int     cn
837 > )
838   {
839          int     i, res[2];
840          VIEW    *dv;
841 <        register DOBJECT        *op;
841 >        DOBJECT *op;
842  
843          if (nam == NULL) {
844                  error(COMMAND, "no current object");
# Line 756 | Line 853 | int    cn;
853          } else if ((op = getdobj(nam)) == NULL) {
854                  error(COMMAND, "unknown object");
855                  return(0);
856 <        } else if ((op->drawcode = cn) == DO_LIGHT)
857 <                getdlights(op, 1);
858 <        else
856 >        } else if ((op->drawcode = cn) == DO_LIGHT) {
857 >                if (!getdlights(op, 1))
858 >                        error(COMMAND, "insufficient samples to light object");
859 >        } else
860                  op->ol = NULL;
861  
862          if (dobj_lightsamp != NULL) {           /* restore beam set */
# Line 768 | Line 866 | int    cn;
866                          beam_view(dv, res[0], res[1]);
867                  beam_sync(1);                   /* update server */
868          }
869 +        return 0; /* XXX not sure if this is the right value */
870   }
871  
872  
873   double
874 < dobj_trace(rorg, rdir)          /* check for ray intersection with objects */
875 < FVECT   rorg, rdir;
874 > dobj_trace(     /* check for ray intersection with object(s) */
875 >        char    nm[],
876 >        FVECT  rorg,
877 >        FVECT  rdir
878 > )
879   {
880 <        register DOBJECT        *op;
880 >        DOBJECT *op;
881          FVECT   xorg, xdir;
882 <        double  darr[6], mindist = FHUGE;
883 <                                        /* check each visible object */
884 <        for (op = dobjects; op != NULL; op = op->next) {
885 <                if (op->drawcode == DO_HIDE)
886 <                        continue;
887 <                if (op->xfac) {         /* transform ray */
888 <                        multp3(xorg, rorg, op->xfb.b.xfm);
889 <                        multv3(xdir, rdir, op->xfb.b.xfm);
890 <                        VCOPY(darr, xorg); VCOPY(darr+3, xdir);
891 <                } else {
892 <                        VCOPY(darr, rorg); VCOPY(darr+3, rdir);
882 >        double  darr[6];
883 >                                        /* check each visible object? */
884 >        if (nm == NULL || *nm == '*') {
885 >                double  dist, mindist = 1.01*FHUGE;
886 >
887 >                if (nm != NULL) nm[0] = '\0';
888 >                for (op = dobjects; op != NULL; op = op->next) {
889 >                        if (op->drawcode == DO_HIDE)
890 >                                continue;
891 >                        dist = dobj_trace(op->name, rorg, rdir);
892 >                        if (dist < mindist) {
893 >                                if (nm != NULL) strcpy(nm, op->name);
894 >                                mindist = dist;
895 >                        }
896                  }
897 <                                        /* trace it */
793 <                if (process(op->rtp, darr, darr, sizeof(double),
794 <                                6*sizeof(double)) != sizeof(double))
795 <                        error(SYSTEM, "rtrace communication error");
796 <                                        /* get closest */
797 <                if ((darr[0] *= op->xfb.f.sca) < mindist)
798 <                        mindist = darr[0];
897 >                return(mindist);
898          }
899 <        return(mindist);
899 >                                        /* else check particular object */
900 >        if ((op = getdobj(nm)) == NULL) {
901 >                error(COMMAND, "unknown object");
902 >                return(FHUGE);
903 >        }
904 >        if (op->xfac) {         /* put ray in local coordinates */
905 >                multp3(xorg, rorg, op->xfb.b.xfm);
906 >                multv3(xdir, rdir, op->xfb.b.xfm);
907 >                VCOPY(darr, xorg); VCOPY(darr+3, xdir);
908 >        } else {
909 >                VCOPY(darr, rorg); VCOPY(darr+3, rdir);
910 >        }
911 >                                /* trace it */
912 >        if (process(&op->rtp, (char *)darr, (char *)darr, sizeof(double),
913 >                        6*sizeof(double)) != sizeof(double))
914 >                error(SYSTEM, "rtrace communication error");
915 >                                /* return distance */
916 >        if (darr[0] >= .99*FHUGE)
917 >                return(FHUGE);
918 >        return(darr[0]*op->xfb.f.sca);
919   }
920  
921  
922 < dobj_render()                   /* render our objects in OpenGL */
922 > int
923 > dobj_render(void)                       /* render our objects in OpenGL */
924   {
925 +        int     nrendered = 0;
926          GLboolean       normalizing;
927          GLfloat vec[4];
928 <        register DOBJECT        *op;
929 <        register int    i;
928 >        FVECT   v1;
929 >        DOBJECT *op;
930 >        int     i;
931                                          /* anything to render? */
932          for (op = dobjects; op != NULL; op = op->next)
933                  if (op->drawcode != DO_HIDE)
934                          break;
935          if (op == NULL)
936 <                return(1);
936 >                return(0);
937                                          /* set up general rendering params */
938          glGetBooleanv(GL_NORMALIZE, &normalizing);
939 <        glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|
940 <                        GL_DEPTH_BUFFER_BIT|GL_POLYGON_BIT);
939 >        glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|GL_ENABLE_BIT|
940 >                GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_POLYGON_BIT);
941          glDepthFunc(GL_LESS);
942          glEnable(GL_DEPTH_TEST);
943          glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
# Line 834 | Line 955 | dobj_render()                  /* render our objects in OpenGL */
955                          continue;
956                                          /* set up lighting */
957                  if (op->drawcode == DO_LIGHT && op->ol != NULL) {
958 <                        BYTE    pval;
958 >                        uby8    pval;
959                          double  expval, d;
960 <
961 <                        if (tmMapPixels(&pval, &op->ol->larb, TM_NOCHROM, 1)
962 <                                        != TM_E_OK)
960 >                                                /* use computed sources */
961 >                        if (tmMapPixels(tmGlobal, &pval, &op->ol->larb,
962 >                                        TM_NOCHROM, 1) != TM_E_OK)
963                                  error(CONSISTENCY, "dobj_render w/o tone map");
964                          expval = pval * (WHTEFFICACY/256.) /
965                                          tmLuminance(op->ol->larb);
# Line 862 | Line 983 | dobj_render()                  /* render our objects in OpenGL */
983                                  glLightfv(glightid[i], GL_AMBIENT, vec);
984                                  glEnable(glightid[i]);
985                          }
986 <                } else {
987 <                        vec[0] = vec[1] = vec[2] = 1.; vec[3] = 1.;
986 >                } else {                        /* fake lighting */
987 >                        vec[0] = vec[1] = vec[2] = 0.; vec[3] = 1.;
988                          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vec);
989 +                        getdcent(v1, op);
990 +                        VSUB(v1, odev.v.vp, v1);
991 +                        if (normalize(v1) <= getdrad(op)) {
992 +                                vec[0] = -odev.v.vdir[0];
993 +                                vec[1] = -odev.v.vdir[1];
994 +                                vec[2] = -odev.v.vdir[2];
995 +                        } else
996 +                                VCOPY(vec, v1);
997 +                        vec[3] = 0.;
998 +                        glLightfv(GL_LIGHT0, GL_POSITION, vec);
999 +                        vec[0] = vec[1] = vec[2] = .7; vec[3] = 1.;
1000 +                        glLightfv(GL_LIGHT0, GL_SPECULAR, vec);
1001 +                        glLightfv(GL_LIGHT0, GL_DIFFUSE, vec);
1002 +                        vec[0] = vec[1] = vec[2] = .3; vec[3] = 1.;
1003 +                        glLightfv(GL_LIGHT0, GL_AMBIENT, vec);
1004 +                        glEnable(GL_LIGHT0);
1005                  }
1006                                          /* set up object transform */
1007                  if (op->xfac) {
1008 <                        if (!normalizing && op->xfb.f.sca < 1.-FTINY |
1009 <                                                op->xfb.f.sca > 1.+FTINY)
1008 >                        if (!normalizing && (op->xfb.f.sca < 1.-FTINY) |
1009 >                                                (op->xfb.f.sca > 1.+FTINY))
1010                                  glEnable(GL_NORMALIZE);
1011                          glMatrixMode(GL_MODELVIEW);
1012                          glPushMatrix();
# Line 882 | Line 1019 | dobj_render()                  /* render our objects in OpenGL */
1019                  }
1020                                          /* render the display list */
1021                  glCallList(op->listid);
1022 +                nrendered++;
1023                                          /* restore matrix */
1024                  if (op->xfac) {
1025                          glMatrixMode(GL_MODELVIEW);
# Line 893 | Line 1031 | dobj_render()                  /* render our objects in OpenGL */
1031                  if (op->drawcode == DO_LIGHT && op->ol != NULL)
1032                          for (i = op->ol->nl; i--; )
1033                                  glDisable(glightid[i]);
1034 +                else
1035 +                        glDisable(GL_LIGHT0);
1036                                          /* check errors */
897 –                rgl_checkerr("rendering object in dobj_render");
1037          }
1038          glPopAttrib();                  /* restore rendering params */
1039 <        return(1);
1039 >        rgl_checkerr("rendering objects in dobj_render");
1040 >        return(nrendered);
1041   }

Diff Legend

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