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.4 by gwlarson, Wed Aug 26 17:26:26 1998 UTC vs.
Revision 3.17 by greg, Tue Mar 30 20:40:04 2004 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       5.0             /* source threshold w.r.t. mean */
# 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 83 | 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;
106  
# Line 101 | 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 >        register DOBJECT        *op
121 > )
122   {
123          int     foundlink = 0;
124          DOBJECT ohead;
# Line 119 | 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 >        register DOBJECT        *op
150 > )
151   {
152                                          /* free old */
153          while (lastxfac)
# Line 149 | 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;
# Line 176 | 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 192 | 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 >        register 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) */
# Line 207 | 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 257 | 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;
# Line 281 | 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) {
305 >        if ((dlightsets == NULL) | (ncells < NALT*NAZI/4)) {
306                  ncells = 0;
307                  goto done;
308          }
# Line 299 | Line 320 | ssph_compute()                 /* compute source set from sphere sam
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)
323 >        if (tmCvColors(&dlightsets->larb, TM_NOCHROM, &csum, 1) != TM_E_OK)
324                  error(CONSISTENCY, "tone mapping problem in ssph_compute");
325                                          /* greedy light source clustering */
326          while (dlightsets->nl < MAXLIGHTS) {
# Line 320 | Line 341 | ssph_compute()                 /* compute source set from sphere sam
341                                  continue;               /* too dim */
342                          ssph_direc(v, alt, azi);        /* else add it in */
343                          VSUM(ls->direc, ls->direc, v, d);
344 <                        ls->omega++;
344 >                        ls->omega += 1.;
345                          addcolor(ls->val, ssamp[alt][azi].val);
346 +                                                        /* remove from list */
347                          setcolor(ssamp[alt][azi].val, 0., 0., 0.);
348 +                        ssamp[alt][azi].nsamp = 0;
349                  }
350                  d = 1./ls->omega;                       /* avg. brightness */
351                  scalecolor(ls->val, d);
# Line 337 | Line 360 | ssph_compute()                 /* compute source set from sphere sam
360          d = 1.0/ncells;
361          scalecolor(dlightsets->lamb, d);
362   done:                                   /* clear sphere sample array */
363 <        bzero((char *)ssamp, sizeof(ssamp));
363 >        memset((void *)ssamp, '\0', sizeof(ssamp));
364          return(ncells);
365   }
366  
367  
368 < static
369 < getdlights(op, force)           /* get lights for display object */
370 < register DOBJECT        *op;
371 < int     force;
368 > static int
369 > getdlights(             /* get lights for display object */
370 >        register DOBJECT        *op,
371 >        int     force
372 > )
373   {
374          double  d2, mind2 = FHUGE*FHUGE;
375          FVECT   ocent;
# Line 370 | Line 394 | int    force;
394          if (!force)
395                  return(0);
396                                          /* need to compute new light set */
397 <        copystruct(&cvw, &stdview);
397 >        cvw = stdview;
398          cvw.type = VT_PER;
399          VCOPY(cvw.vp, ocent);
400          cvw.vup[0] = 1.; cvw.vup[1] = cvw.vup[2] = 0.;
# Line 404 | Line 428 | int    force;
428                          quit(0);
429          if (!ssph_compute()) {          /* compute light sources from sphere */
430                  dlightsets = dl->next;
431 <                free((char *)dl);
431 >                free((void *)dl);
432                  return(0);
433          }
434          op->ol = dl;
435          return(1);
436   memerr:
437          error(SYSTEM, "out of memory in getdlights");
438 +        return 0; /* pro forma return */
439   }
440  
441  
442 < static int
443 < cmderror(cn, err)               /* report command error */
444 < int     cn;
445 < char    *err;
442 > static void
443 > cmderror(               /* report command error */
444 >        int     cn,
445 >        char    *err
446 > )
447   {
448          sprintf(errmsg, "%s: %s", rhdcmd[cn], err);
449          error(COMMAND, errmsg);
424 –        return(cn);
450   }
451  
452  
453 < int
454 < dobj_command(cmd, args)         /* run object display command */
455 < char    *cmd;
456 < register char   *args;
453 > extern int
454 > dobj_command(           /* run object display command */
455 >        char    *cmd,
456 >        register char   *args
457 > )
458   {
459 <        int     cn, na, doxfm;
459 >        int     somechange = 0;
460 >        int     cn, na;
461          register int    nn;
462          char    *alist[MAXAC+1], *nm;
463                                          /* find command */
# Line 457 | Line 484 | register char  *args;
484                          dobj_load(alist[0], alist[0]);
485                  else if (na == 2)
486                          dobj_load(alist[0], alist[1]);
487 <                else
488 <                        return(cmderror(cn, "need octree [name]"));
487 >                else {
488 >                        cmderror(cn, "need octree [name]");
489 >                        return(0);
490 >                }
491                  break;
492 <        case DO_UNLOAD:                         /* unload an object */
492 >        case DO_UNLOAD:                         /* clear an object */
493                  if (na > 1) goto toomany;
494                  if (na && alist[0][0] == '*')
495 <                        dobj_cleanup();
495 >                        somechange += dobj_cleanup();
496                  else
497 <                        dobj_unload(na ? alist[0] : curname);
497 >                        somechange += dobj_unload(na ? alist[0] : curname);
498                  break;
499          case DO_XFORM:                          /* transform object */
500          case DO_MOVE:
# Line 474 | Line 503 | register char  *args;
503                  } else {
504                          nm = curname; nn = 0;
505                  }
506 <                if (cn == DO_MOVE && nn >= na)
507 <                        return(cmderror(cn, "missing transform"));
508 <                dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
506 >                if (cn == DO_MOVE && nn >= na) {
507 >                        cmderror(cn, "missing transform");
508 >                        return(0);
509 >                }
510 >                somechange += dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
511                  break;
512          case DO_UNMOVE:                         /* undo last transform */
513 <                dobj_unmove();
513 >                somechange += dobj_unmove();
514                  break;
515          case DO_OBJECT:                         /* print object statistics */
516                  if (dobj_putstats(na ? alist[0] : curname, sstdout))
517 <                        if (na && alist[0][0] != '*' &&
518 <                                        strcmp(alist[0], curname))
517 >                        if (na && alist[0][0] != '*' && (curobj == NULL ||
518 >                                        strcmp(alist[0], curobj->name)))
519                                  savedxf(curobj = getdobj(alist[0]));
520                  break;
521          case DO_DUP:                            /* duplicate object */
# Line 493 | Line 524 | register char  *args;
524                                  break;
525                  switch (nn) {
526                  case 0:
527 <                        return(cmderror(cn, "need new object name"));
527 >                        cmderror(cn, "need new object name");
528 >                        return(0);
529                  case 1:
530                          nm = curname;
531                          break;
# Line 506 | Line 538 | register char  *args;
538                  if (!dobj_dup(nm, alist[nn-1]))
539                          break;
540                  if (na > nn)
541 <                        dobj_xform(curname, 1, na-nn, alist+nn);
541 >                        somechange += dobj_xform(curname, 1, na-nn, alist+nn);
542                  else
543                          curobj->drawcode = DO_HIDE;
544                  savedxf(curobj);
# Line 516 | Line 548 | register char  *args;
548          case DO_HIDE:
549                  if (na > 1) goto toomany;
550                  dobj_lighting(na ? alist[0] : curname, cn);
551 +                somechange++;
552                  break;
553          default:
554                  error(CONSISTENCY, "bad command id in dobj_command");
555          }
556 <        dev_view(&odev.v);                      /* redraw */
524 <        return(cn);
556 >        return(somechange);
557   toomany:
558 <        return(cmderror(cn, "too many arguments"));
558 >        cmderror(cn, "too many arguments");
559 >        return(-1);
560   }
561  
562  
563 < dobj_load(oct, nam)             /* create/load an octree object */
564 < char    *oct, *nam;
563 > extern int
564 > dobj_load(              /* create/load an octree object */
565 >        char    *oct,
566 >        char    *nam
567 > )
568   {
533 –        extern char     *getlibpath(), *getpath();
569          char    *fpp, fpath[128];
570          register DOBJECT        *op;
571                                          /* check arguments */
# Line 542 | Line 577 | char   *oct, *nam;
577                  error(COMMAND, "missing name");
578                  return(0);
579          }
580 <        if (*nam == '*' | *nam == '-') {
580 >        if ((*nam == '*') | (*nam == '-')) {
581                  error(COMMAND, "illegal name");
582                  return(0);
583          }
584          if (getdobj(nam) != NULL) {
585 <                error(COMMAND, "name already taken (unload first)");
585 >                error(COMMAND, "name already taken (clear first)");
586                  return(0);
587          }
588                                          /* get octree path */
589 <        if ((fpp = getpath(oct, getlibpath(), R_OK)) == NULL) {
589 >        if ((fpp = getpath(oct, getrlibpath(), R_OK)) == NULL) {
590                  sprintf(errmsg, "cannot find octree \"%s\"", oct);
591                  error(COMMAND, errmsg);
592                  return(0);
# Line 569 | Line 604 | char   *oct, *nam;
604          op->xfav[op->xfac=0] = NULL;
605                                          /* load octree into display list */
606          dolights = 0;
607 <        op->listid = rgl_octlist(fpath, op->center, &op->radius);
607 >        domats = 1;
608 >        op->listid = rgl_octlist(fpath, op->center, &op->radius, &op->nlists);
609                                          /* start rtrace */
610          rtargv[RTARGC-1] = fpath;
611          rtargv[RTARGC] = NULL;
612 <        open_process(op->rtp, rtargv);
612 >        open_process(&(op->rtp), rtargv);
613                                          /* insert into main list */
614          op->next = dobjects;
615          curobj = dobjects = op;
# Line 582 | Line 618 | char   *oct, *nam;
618   }
619  
620  
621 < dobj_unload(nam)                        /* free the named object */
622 < char    *nam;
621 > extern int
622 > dobj_unload(                    /* free the named object */
623 >        char    *nam
624 > )
625   {
626          register DOBJECT        *op;
627  
# Line 597 | Line 635 | char   *nam;
635   }
636  
637  
638 < dobj_cleanup()                          /* free all resources */
638 > extern int
639 > dobj_cleanup(void)                              /* free all resources */
640   {
641          register DLIGHTS        *lp;
642  
# Line 606 | Line 645 | dobj_cleanup()                         /* free all resources */
645          savedxf(curobj = NULL);
646          while ((lp = dlightsets) != NULL) {
647                  dlightsets = lp->next;
648 <                free((char *)lp);
648 >                free((void *)lp);
649          }
650          return(1);
651   }
652  
653  
654 < dobj_xform(nam, add, ac, av)            /* set/add transform for nam */
655 < char    *nam;
656 < int     add, ac;
657 < char    **av;
654 > extern int
655 > dobj_xform(             /* set/add transform for nam */
656 >        char    *nam,
657 >        int     rel,
658 >        int     ac,
659 >        char    **av
660 > )
661   {
662          register DOBJECT        *op;
663 +        FVECT   cent;
664 +        double  rad;
665 +        char    scoord[16];
666 +        int     i;
667  
668          if ((op = getdobj(nam)) == NULL) {
669                  error(COMMAND, "no object");
670                  return(0);
671          }
672 <        if (add) add = op->xfac;
673 <        if (ac + add > MAXAC) {
672 >        if (rel)
673 >                rel = op->xfac + 8;
674 >        if (ac + rel > MAXAC) {
675                  error(COMMAND, "too many transform arguments");
676                  return(0);
677          }
678 <        savedxf(curobj = op);
679 <        if (!add)
678 >        savedxf(curobj = op);           /* remember current transform */
679 >        if (rel && ac == 4 && !strcmp(av[0], "-t"))
680 >                rel = -1;                       /* don't move for translate */
681 >        else {
682 >                getdcent(cent, op);             /* don't move if near orig. */
683 >                rad = getdrad(op);
684 >                if (DOT(cent,cent) < rad*rad)
685 >                        rel = -1;
686 >        }
687 >        if (!rel) {                             /* remove old transform */
688                  while (op->xfac)
689                          freestr(op->xfav[--op->xfac]);
690 +        } else if (rel > 0) {                   /* relative move */
691 +                op->xfav[op->xfac++] = savestr("-t");
692 +                for (i = 0; i < 3; i++) {
693 +                        sprintf(scoord, "%.4e", -cent[i]);
694 +                        op->xfav[op->xfac++] = savestr(scoord);
695 +                }
696 +        }
697          while (ac--)
698                  op->xfav[op->xfac++] = savestr(*av++);
699 +        if (rel > 0) {                          /* move back */
700 +                op->xfav[op->xfac++] = savestr("-t");
701 +                for (i = 0; i < 3; i++) {
702 +                        sprintf(scoord, "%.4e", cent[i]);
703 +                        op->xfav[op->xfac++] = savestr(scoord);
704 +                }
705 +        }
706          op->xfav[op->xfac] = NULL;
707          if (fullxf(&op->xfb, op->xfac, op->xfav) != op->xfac) {
708                  error(COMMAND, "bad transform arguments");
# Line 647 | Line 716 | char   **av;
716   }
717  
718  
719 < dobj_putstats(nam, fp)                  /* put out statistics for nam */
720 < char    *nam;
721 < FILE    *fp;
719 > extern int
720 > dobj_putstats(                  /* put out statistics for nam */
721 >        char    *nam,
722 >        FILE    *fp
723 > )
724   {
725          FVECT   ocent;
726          register DOBJECT        *op;
# Line 670 | Line 741 | FILE   *fp;
741                  return(0);
742          }
743          getdcent(ocent, op);
744 <        fprintf(fp, "%s: %s, center [%f %f %f], radius %f", op->name,
744 >        fprintf(fp, "%s: %s, center [%g %g %g], radius %g", op->name,
745                          op->drawcode==DO_HIDE ? "hidden" :
746                          op->drawcode==DO_LIGHT && op->ol!=NULL ? "lighted" :
747                          "shown",
# Line 688 | Line 759 | FILE   *fp;
759   }
760  
761  
762 < dobj_unmove()                           /* undo last transform change */
762 > extern int
763 > dobj_unmove(void)                               /* undo last transform change */
764   {
765          int     txfac;
766          char    *txfav[MAXAC+1];
# Line 698 | Line 770 | dobj_unmove()                          /* undo last transform change */
770                  return(0);
771          }
772                                          /* hold last transform */
773 <        bcopy((char *)lastxfav, (char *)txfav,
773 >        memcpy((void *)txfav, (void *)lastxfav,
774                          (txfac=lastxfac)*sizeof(char *));
775                                          /* save this transform */
776 <        bcopy((char *)curobj->xfav, (char *)lastxfav,
776 >        memcpy((void *)lastxfav, (void *)curobj->xfav,
777                          (lastxfac=curobj->xfac)*sizeof(char *));
778                                          /* copy back last transform */
779 <        bcopy((char *)txfav, (char *)curobj->xfav,
779 >        memcpy((void *)curobj->xfav, (void *)txfav,
780                          (curobj->xfac=txfac)*sizeof(char *));
781                                          /* set matrices */
782          fullxf(&curobj->xfb, curobj->xfac, curobj->xfav);
# Line 714 | Line 786 | dobj_unmove()                          /* undo last transform change */
786   }
787  
788  
789 < dobj_dup(oldnm, nam)                    /* duplicate object oldnm as nam */
790 < char    *oldnm, *nam;
789 > extern int
790 > dobj_dup(                       /* duplicate object oldnm as nam */
791 >        char    *oldnm,
792 >        char    *nam
793 > )
794   {
795          register DOBJECT        *op, *opdup;
796                                          /* check arguments */
# Line 727 | Line 802 | char   *oldnm, *nam;
802                  error(COMMAND, "missing name");
803                  return(0);
804          }
805 <        if (*nam == '*' | *nam == '-') {
805 >        if ((*nam == '*') | (*nam == '-')) {
806                  error(COMMAND, "illegal name");
807                  return(0);
808          }
809          if (getdobj(nam) != NULL) {
810 <                error(COMMAND, "name already taken (unload first)");
810 >                error(COMMAND, "name already taken (clear first)");
811                  return(0);
812          }
813                                          /* allocate and copy struct */
814          opdup = (DOBJECT *)malloc(sizeof(DOBJECT));
815          if (opdup == NULL)
816                  error(SYSTEM, "out of memory in dobj_dup");
817 <        copystruct(opdup, op);
817 >        *opdup = *op;
818                                          /* rename */
819          strcpy(opdup->name, nam);
820                                          /* get our own copy of transform */
# Line 753 | Line 828 | char   *oldnm, *nam;
828   }
829  
830  
831 < dobj_lighting(nam, cn)          /* set up lighting for display object */
832 < char    *nam;
833 < int     cn;
831 > extern int
832 > dobj_lighting(          /* set up lighting for display object */
833 >        char    *nam,
834 >        int     cn
835 > )
836   {
837          int     i, res[2];
838          VIEW    *dv;
# Line 787 | Line 864 | int    cn;
864                          beam_view(dv, res[0], res[1]);
865                  beam_sync(1);                   /* update server */
866          }
867 +        return 0; /* XXX not sure if this is the right value */
868   }
869  
870  
871 < double
872 < dobj_trace(nm, rorg, rdir)      /* check for ray intersection with object(s) */
873 < char    nm[];
874 < FVECT   rorg, rdir;
871 > extern double
872 > dobj_trace(     /* check for ray intersection with object(s) */
873 >        char    nm[],
874 >        FVECT  rorg,
875 >        FVECT  rdir
876 > )
877   {
878          register DOBJECT        *op;
879          FVECT   xorg, xdir;
# Line 827 | Line 907 | FVECT   rorg, rdir;
907                  VCOPY(darr, rorg); VCOPY(darr+3, rdir);
908          }
909                                  /* trace it */
910 <        if (process(op->rtp, darr, darr, sizeof(double),
910 >        if (process(&(op->rtp), (char *)darr, (char *)darr, sizeof(double),
911                          6*sizeof(double)) != sizeof(double))
912                  error(SYSTEM, "rtrace communication error");
913                                  /* return distance */
# Line 837 | Line 917 | FVECT   rorg, rdir;
917   }
918  
919  
920 < dobj_render()                   /* render our objects in OpenGL */
920 > extern int
921 > dobj_render(void)                       /* render our objects in OpenGL */
922   {
923 +        int     nrendered = 0;
924          GLboolean       normalizing;
925          GLfloat vec[4];
926          FVECT   v1;
# Line 849 | Line 931 | dobj_render()                  /* render our objects in OpenGL */
931                  if (op->drawcode != DO_HIDE)
932                          break;
933          if (op == NULL)
934 <                return(1);
934 >                return(0);
935                                          /* set up general rendering params */
936          glGetBooleanv(GL_NORMALIZE, &normalizing);
937          glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|GL_ENABLE_BIT|
# Line 921 | Line 1003 | dobj_render()                  /* render our objects in OpenGL */
1003                  }
1004                                          /* set up object transform */
1005                  if (op->xfac) {
1006 <                        if (!normalizing && op->xfb.f.sca < 1.-FTINY |
1007 <                                                op->xfb.f.sca > 1.+FTINY)
1006 >                        if (!normalizing && (op->xfb.f.sca < 1.-FTINY) |
1007 >                                                (op->xfb.f.sca > 1.+FTINY))
1008                                  glEnable(GL_NORMALIZE);
1009                          glMatrixMode(GL_MODELVIEW);
1010                          glPushMatrix();
# Line 935 | Line 1017 | dobj_render()                  /* render our objects in OpenGL */
1017                  }
1018                                          /* render the display list */
1019                  glCallList(op->listid);
1020 +                nrendered++;
1021                                          /* restore matrix */
1022                  if (op->xfac) {
1023                          glMatrixMode(GL_MODELVIEW);
# Line 952 | Line 1035 | dobj_render()                  /* render our objects in OpenGL */
1035          }
1036          glPopAttrib();                  /* restore rendering params */
1037          rgl_checkerr("rendering objects in dobj_render");
1038 <        return(1);
1038 >        return(nrendered);
1039   }

Diff Legend

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