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.12 by greg, Tue May 13 17:58:33 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 22 | Line 19 | int    (*dobj_lightsamp)() = NULL;     /* pointer to function
19  
20   #define AVGREFL         0.5             /* assumed average reflectance */
21  
22 < #define MAXAC           64              /* maximum number of args */
22 > #define MAXAC           512             /* maximum number of args */
23  
24   #ifndef MINTHRESH
25 < #define MINTHRESH       7.0             /* source threshold w.r.t. mean */
25 > #define MINTHRESH       5.0             /* source threshold w.r.t. mean */
26   #endif
27  
28   #ifndef NALT
# Line 55 | Line 52 | typedef struct dobject {
52          FVECT   center;                 /* orig. object center */
53          FLOAT   radius;                 /* orig. object radius */
54          int     listid;                 /* GL display list identifier */
55 +        int     nlists;                 /* number of lists allocated */
56          int     rtp[3];                 /* associated rtrace process */
57          DLIGHTS *ol;                    /* object lights */
58          FULLXF  xfb;                    /* coordinate transform */
# Line 69 | Line 67 | static DOBJECT *curobj;                /* current (last referred) ob
67   static int      lastxfac;               /* last number of transform args */
68   static char     *lastxfav[MAXAC+1];     /* saved transform arguments */
69  
70 + #define getdcent(c,op)  multp3(c,(op)->center,(op)->xfb.f.xfm)
71 + #define getdrad(op)     ((op)->radius*(op)->xfb.f.sca)
72 +
73   #define RTARGC  8
74   static char     *rtargv[RTARGC+1] = {"rtrace", "-h-", "-w-", "-fdd",
75                                          "-x", "1", "-oL"};
# Line 116 | Line 117 | register DOBJECT       *op;
117          }
118          dobjects = ohead.next;
119          if (!foundlink) {
120 <                glDeleteLists(op->listid, 1);
120 >                glDeleteLists(op->listid, op->nlists);
121                  close_process(op->rtp);
122          }
123          while (op->xfac)
124                  freestr(op->xfav[--op->xfac]);
125 <        free((char *)op);
125 >        free((void *)op);
126          return(1);
127   }
128  
# Line 279 | Line 280 | ssph_compute()                 /* compute source set from sphere sam
280                                  ncells++;
281                          }
282          if (dlightsets == NULL | ncells < NALT*NAZI/4) {
283 <                bzero((char *)ssamp, sizeof(ssamp));
284 <                return(0);
283 >                ncells = 0;
284 >                goto done;
285          }
286                                                  /* harmonic mean distance */
287          if (dlightsets->ravg > FTINY)
# Line 289 | Line 290 | ssph_compute()                 /* compute source set from sphere sam
290                  dlightsets->ravg = FHUGE;
291                                                  /* light source threshold */
292          thresh = MINTHRESH*bright(csum)/ncells;
293 +        if (thresh <= FTINY) {
294 +                ncells = 0;
295 +                goto done;
296 +        }
297                                                  /* avg. reflected brightness */
298          d = AVGREFL / (double)ncells;  
299          scalecolor(csum, d);
300 <        if (tmCvColors(&dlightsets->larb, TM_NOCHROM, csum, 1) != TM_E_OK)
301 <                error(CONSISTENCY, "bad tone mapping in ssph_compute");
300 >        if (tmCvColors(&dlightsets->larb, TM_NOCHROM, &csum, 1) != TM_E_OK)
301 >                error(CONSISTENCY, "tone mapping problem in ssph_compute");
302                                          /* greedy light source clustering */
303          while (dlightsets->nl < MAXLIGHTS) {
304                  maxbr = 0.;                     /* find brightest cell */
# Line 313 | Line 318 | ssph_compute()                 /* compute source set from sphere sam
318                                  continue;               /* too dim */
319                          ssph_direc(v, alt, azi);        /* else add it in */
320                          VSUM(ls->direc, ls->direc, v, d);
321 <                        ls->omega++;
321 >                        ls->omega += 1.;
322                          addcolor(ls->val, ssamp[alt][azi].val);
323 +                                                        /* remove from list */
324                          setcolor(ssamp[alt][azi].val, 0., 0., 0.);
325 +                        ssamp[alt][azi].nsamp = 0;
326                  }
327                  d = 1./ls->omega;                       /* avg. brightness */
328                  scalecolor(ls->val, d);
# Line 329 | Line 336 | ssph_compute()                 /* compute source set from sphere sam
336                                  addcolor(dlightsets->lamb, ssamp[alt][azi].val);
337          d = 1.0/ncells;
338          scalecolor(dlightsets->lamb, d);
339 <                                        /* clear sphere sample array */
340 <        bzero((char *)ssamp, sizeof(ssamp));
339 > done:                                   /* clear sphere sample array */
340 >        bzero((void *)ssamp, sizeof(ssamp));
341          return(ncells);
342   }
343  
# Line 349 | Line 356 | int    force;
356          if (op->drawcode != DO_LIGHT)
357                  return(0);
358                                          /* check for usable light set */
359 <        multp3(ocent, op->center, op->xfb.f.xfm);
359 >        getdcent(ocent, op);
360          for (dl = dlightsets; dl != NULL; dl = dl->next)
361                  if ((d2 = dist2(dl->lcent, ocent)) < mind2) {
362                          op->ol = dl;
363                          mind2 = d2;
364                  }
365                                          /* the following is heuristic */
366 <        d2 = 2.*op->radius*op->xfb.f.sca; d2 *= d2;
366 >        d2 = 2.*getdrad(op); d2 *= d2;
367          if ((dl = op->ol) != NULL && (mind2 < 0.0625*dl->ravg*dl->ravg ||
368 <                mind2 < 4.*op->radius*op->xfb.f.sca*op->radius*op->xfb.f.sca))
368 >                        mind2 < 4.*getdrad(op)*getdrad(op)))
369                  return(1);
370          if (!force)
371                  return(0);
# Line 397 | Line 404 | int    force;
404                          quit(0);
405          if (!ssph_compute()) {          /* compute light sources from sphere */
406                  dlightsets = dl->next;
407 <                free((char *)dl);
407 >                free((void *)dl);
408                  return(0);
409          }
410          op->ol = dl;
# Line 407 | Line 414 | memerr:
414   }
415  
416  
417 < static int
417 > static
418   cmderror(cn, err)               /* report command error */
419   int     cn;
420   char    *err;
421   {
422          sprintf(errmsg, "%s: %s", rhdcmd[cn], err);
423          error(COMMAND, errmsg);
417 –        return(cn);
424   }
425  
426  
# Line 423 | Line 429 | dobj_command(cmd, args)                /* run object display command
429   char    *cmd;
430   register char   *args;
431   {
432 +        int     somechange = 0;
433          int     cn, na, doxfm;
434          register int    nn;
435          char    *alist[MAXAC+1], *nm;
# Line 450 | Line 457 | register char  *args;
457                          dobj_load(alist[0], alist[0]);
458                  else if (na == 2)
459                          dobj_load(alist[0], alist[1]);
460 <                else
461 <                        return(cmderror(cn, "need octree [name]"));
460 >                else {
461 >                        cmderror(cn, "need octree [name]");
462 >                        return(0);
463 >                }
464                  break;
465 <        case DO_UNLOAD:                         /* unload an object */
465 >        case DO_UNLOAD:                         /* clear an object */
466                  if (na > 1) goto toomany;
467                  if (na && alist[0][0] == '*')
468 <                        dobj_cleanup();
468 >                        somechange += dobj_cleanup();
469                  else
470 <                        dobj_unload(na ? alist[0] : curname);
470 >                        somechange += dobj_unload(na ? alist[0] : curname);
471                  break;
472          case DO_XFORM:                          /* transform object */
473          case DO_MOVE:
# Line 467 | Line 476 | register char  *args;
476                  } else {
477                          nm = curname; nn = 0;
478                  }
479 <                if (cn == DO_MOVE && nn >= na)
480 <                        return(cmderror(cn, "missing transform"));
481 <                dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
479 >                if (cn == DO_MOVE && nn >= na) {
480 >                        cmderror(cn, "missing transform");
481 >                        return(0);
482 >                }
483 >                somechange += dobj_xform(nm, cn==DO_MOVE, na-nn, alist+nn);
484                  break;
485          case DO_UNMOVE:                         /* undo last transform */
486 <                dobj_unmove();
486 >                somechange += dobj_unmove();
487                  break;
488          case DO_OBJECT:                         /* print object statistics */
489 <                dobj_putstats(na ? alist[0] : curname, sstdout);
489 >                if (dobj_putstats(na ? alist[0] : curname, sstdout))
490 >                        if (na && alist[0][0] != '*' && (curobj == NULL ||
491 >                                        strcmp(alist[0], curobj->name)))
492 >                                savedxf(curobj = getdobj(alist[0]));
493                  break;
494          case DO_DUP:                            /* duplicate object */
495                  for (nn = 0; nn < na; nn++)
# Line 483 | Line 497 | register char  *args;
497                                  break;
498                  switch (nn) {
499                  case 0:
500 <                        return(cmderror(cn, "need new object name"));
500 >                        cmderror(cn, "need new object name");
501 >                        return(0);
502                  case 1:
503                          nm = curname;
504                          break;
# Line 496 | Line 511 | register char  *args;
511                  if (!dobj_dup(nm, alist[nn-1]))
512                          break;
513                  if (na > nn)
514 <                        dobj_xform(curname, 1, na-nn, alist+nn);
514 >                        somechange += dobj_xform(curname, 1, na-nn, alist+nn);
515                  else
516                          curobj->drawcode = DO_HIDE;
517 +                savedxf(curobj);
518                  break;
519          case DO_SHOW:                           /* change rendering option */
520          case DO_LIGHT:
521          case DO_HIDE:
522                  if (na > 1) goto toomany;
523                  dobj_lighting(na ? alist[0] : curname, cn);
524 +                somechange++;
525                  break;
526          default:
527                  error(CONSISTENCY, "bad command id in dobj_command");
528          }
529 <        dev_view(&odev.v);                      /* redraw */
513 <        return(cn);
529 >        return(somechange);
530   toomany:
531          return(cmderror(cn, "too many arguments"));
532   }
# Line 519 | Line 535 | toomany:
535   dobj_load(oct, nam)             /* create/load an octree object */
536   char    *oct, *nam;
537   {
522 –        extern char     *getlibpath(), *getpath();
538          char    *fpp, fpath[128];
539          register DOBJECT        *op;
540                                          /* check arguments */
# Line 535 | Line 550 | char   *oct, *nam;
550                  error(COMMAND, "illegal name");
551                  return(0);
552          }
553 +        if (getdobj(nam) != NULL) {
554 +                error(COMMAND, "name already taken (clear first)");
555 +                return(0);
556 +        }
557                                          /* get octree path */
558 <        if ((fpp = getpath(oct, getlibpath(), R_OK)) == NULL) {
558 >        if ((fpp = getpath(oct, getrlibpath(), R_OK)) == NULL) {
559                  sprintf(errmsg, "cannot find octree \"%s\"", oct);
560                  error(COMMAND, errmsg);
561                  return(0);
562          }
563          strcpy(fpath, fpp);
545 –        freedobj(getdobj(nam));         /* free previous use of nam */
564          op = (DOBJECT *)malloc(sizeof(DOBJECT));
565          if (op == NULL)
566                  error(SYSTEM, "out of memory in dobj_load");
# Line 555 | Line 573 | char   *oct, *nam;
573          op->xfav[op->xfac=0] = NULL;
574                                          /* load octree into display list */
575          dolights = 0;
576 <        op->listid = rgl_octlist(fpath, op->center, &op->radius);
576 >        domats = 1;
577 >        op->listid = rgl_octlist(fpath, op->center, &op->radius, &op->nlists);
578                                          /* start rtrace */
579          rtargv[RTARGC-1] = fpath;
580          rtargv[RTARGC] = NULL;
# Line 592 | Line 611 | dobj_cleanup()                         /* free all resources */
611          savedxf(curobj = NULL);
612          while ((lp = dlightsets) != NULL) {
613                  dlightsets = lp->next;
614 <                free((char *)lp);
614 >                free((void *)lp);
615          }
616          return(1);
617   }
618  
619  
620 < dobj_xform(nam, add, ac, av)            /* set/add transform for nam */
620 > dobj_xform(nam, rel, ac, av)            /* set/add transform for nam */
621   char    *nam;
622 < int     add, ac;
622 > int     rel, ac;
623   char    **av;
624   {
625          register DOBJECT        *op;
626 +        FVECT   cent;
627 +        double  rad;
628 +        char    scoord[16];
629 +        int     i;
630  
631          if ((op = getdobj(nam)) == NULL) {
632                  error(COMMAND, "no object");
633                  return(0);
634          }
635 <        if (add) add = op->xfac;
636 <        if (ac + add > MAXAC) {
635 >        if (rel)
636 >                rel = op->xfac + 8;
637 >        if (ac + rel > MAXAC) {
638                  error(COMMAND, "too many transform arguments");
639                  return(0);
640          }
641 <        savedxf(curobj = op);
642 <        if (!add)
641 >        savedxf(curobj = op);           /* remember current transform */
642 >        if (rel && ac == 4 && !strcmp(av[0], "-t"))
643 >                rel = -1;                       /* don't move for translate */
644 >        else {
645 >                getdcent(cent, op);             /* don't move if near orig. */
646 >                rad = getdrad(op);
647 >                if (DOT(cent,cent) < rad*rad)
648 >                        rel = -1;
649 >        }
650 >        if (!rel) {                             /* remove old transform */
651                  while (op->xfac)
652                          freestr(op->xfav[--op->xfac]);
653 +        } else if (rel > 0) {                   /* relative move */
654 +                op->xfav[op->xfac++] = savestr("-t");
655 +                for (i = 0; i < 3; i++) {
656 +                        sprintf(scoord, "%.4e", -cent[i]);
657 +                        op->xfav[op->xfac++] = savestr(scoord);
658 +                }
659 +        }
660          while (ac--)
661                  op->xfav[op->xfac++] = savestr(*av++);
662 +        if (rel > 0) {                          /* move back */
663 +                op->xfav[op->xfac++] = savestr("-t");
664 +                for (i = 0; i < 3; i++) {
665 +                        sprintf(scoord, "%.4e", cent[i]);
666 +                        op->xfav[op->xfac++] = savestr(scoord);
667 +                }
668 +        }
669          op->xfav[op->xfac] = NULL;
670          if (fullxf(&op->xfb, op->xfac, op->xfav) != op->xfac) {
671                  error(COMMAND, "bad transform arguments");
# Line 655 | Line 701 | FILE   *fp;
701                  error(COMMAND, "unknown object");
702                  return(0);
703          }
704 <        multp3(ocent, op->center, op->xfb.f.xfm);
705 <        fprintf(fp, "%s: %s, center [%f %f %f], radius %f", op->name,
706 <                        op->drawcode==DO_HIDE ? "hid" :
707 <                        op->drawcode==DO_LIGHT && op->ol!=NULL ? "lit" :
704 >        getdcent(ocent, op);
705 >        fprintf(fp, "%s: %s, center [%g %g %g], radius %g", op->name,
706 >                        op->drawcode==DO_HIDE ? "hidden" :
707 >                        op->drawcode==DO_LIGHT && op->ol!=NULL ? "lighted" :
708                          "shown",
709 <                        ocent[0],ocent[1],ocent[2], op->radius*op->xfb.f.sca);
709 >                        ocent[0],ocent[1],ocent[2], getdrad(op));
710          if (op->xfac)
711                  fputs(", (xform", fp);
712          for (i = 0; i < op->xfac; i++) {
# Line 684 | Line 730 | dobj_unmove()                          /* undo last transform change */
730                  return(0);
731          }
732                                          /* hold last transform */
733 <        bcopy((char *)lastxfav, (char *)txfav,
733 >        bcopy((void *)lastxfav, (void *)txfav,
734                          (txfac=lastxfac)*sizeof(char *));
735                                          /* save this transform */
736 <        bcopy((char *)curobj->xfav, (char *)lastxfav,
736 >        bcopy((void *)curobj->xfav, (void *)lastxfav,
737                          (lastxfac=curobj->xfac)*sizeof(char *));
738                                          /* copy back last transform */
739 <        bcopy((char *)txfav, (char *)curobj->xfav,
739 >        bcopy((void *)txfav, (void *)curobj->xfav,
740                          (curobj->xfac=txfac)*sizeof(char *));
741                                          /* set matrices */
742          fullxf(&curobj->xfb, curobj->xfac, curobj->xfav);
# Line 717 | Line 763 | char   *oldnm, *nam;
763                  error(COMMAND, "illegal name");
764                  return(0);
765          }
766 +        if (getdobj(nam) != NULL) {
767 +                error(COMMAND, "name already taken (clear first)");
768 +                return(0);
769 +        }
770                                          /* allocate and copy struct */
771          opdup = (DOBJECT *)malloc(sizeof(DOBJECT));
772          if (opdup == NULL)
# Line 756 | Line 806 | int    cn;
806          } else if ((op = getdobj(nam)) == NULL) {
807                  error(COMMAND, "unknown object");
808                  return(0);
809 <        } else if ((op->drawcode = cn) == DO_LIGHT)
810 <                getdlights(op, 1);
811 <        else
809 >        } else if ((op->drawcode = cn) == DO_LIGHT) {
810 >                if (!getdlights(op, 1))
811 >                        error(COMMAND, "insufficient samples to light object");
812 >        } else
813                  op->ol = NULL;
814  
815          if (dobj_lightsamp != NULL) {           /* restore beam set */
# Line 772 | Line 823 | int    cn;
823  
824  
825   double
826 < dobj_trace(rorg, rdir)          /* check for ray intersection with objects */
826 > dobj_trace(nm, rorg, rdir)      /* check for ray intersection with object(s) */
827 > char    nm[];
828   FVECT   rorg, rdir;
829   {
830          register DOBJECT        *op;
831          FVECT   xorg, xdir;
832 <        double  darr[6], mindist = FHUGE;
833 <                                        /* check each visible object */
834 <        for (op = dobjects; op != NULL; op = op->next) {
835 <                if (op->drawcode == DO_HIDE)
836 <                        continue;
837 <                if (op->xfac) {         /* transform ray */
838 <                        multp3(xorg, rorg, op->xfb.b.xfm);
839 <                        multv3(xdir, rdir, op->xfb.b.xfm);
840 <                        VCOPY(darr, xorg); VCOPY(darr+3, xdir);
841 <                } else {
842 <                        VCOPY(darr, rorg); VCOPY(darr+3, rdir);
832 >        double  darr[6];
833 >                                        /* check each visible object? */
834 >        if (nm == NULL || *nm == '*') {
835 >                double  dist, mindist = 1.01*FHUGE;
836 >
837 >                if (nm != NULL) nm[0] = '\0';
838 >                for (op = dobjects; op != NULL; op = op->next) {
839 >                        if (op->drawcode == DO_HIDE)
840 >                                continue;
841 >                        dist = dobj_trace(op->name, rorg, rdir);
842 >                        if (dist < mindist) {
843 >                                if (nm != NULL) strcpy(nm, op->name);
844 >                                mindist = dist;
845 >                        }
846                  }
847 <                                        /* 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];
847 >                return(mindist);
848          }
849 <        return(mindist);
849 >                                        /* else check particular object */
850 >        if ((op = getdobj(nm)) == NULL) {
851 >                error(COMMAND, "unknown object");
852 >                return(FHUGE);
853 >        }
854 >        if (op->xfac) {         /* put ray in local coordinates */
855 >                multp3(xorg, rorg, op->xfb.b.xfm);
856 >                multv3(xdir, rdir, op->xfb.b.xfm);
857 >                VCOPY(darr, xorg); VCOPY(darr+3, xdir);
858 >        } else {
859 >                VCOPY(darr, rorg); VCOPY(darr+3, rdir);
860 >        }
861 >                                /* trace it */
862 >        if (process(op->rtp, (char *)darr, (char *)darr, sizeof(double),
863 >                        6*sizeof(double)) != sizeof(double))
864 >                error(SYSTEM, "rtrace communication error");
865 >                                /* return distance */
866 >        if (darr[0] >= .99*FHUGE)
867 >                return(FHUGE);
868 >        return(darr[0]*op->xfb.f.sca);
869   }
870  
871  
872 + int
873   dobj_render()                   /* render our objects in OpenGL */
874   {
875 +        int     nrendered = 0;
876          GLboolean       normalizing;
877          GLfloat vec[4];
878 +        FVECT   v1;
879          register DOBJECT        *op;
880          register int    i;
881                                          /* anything to render? */
# Line 812 | Line 883 | dobj_render()                  /* render our objects in OpenGL */
883                  if (op->drawcode != DO_HIDE)
884                          break;
885          if (op == NULL)
886 <                return(1);
886 >                return(0);
887                                          /* set up general rendering params */
888          glGetBooleanv(GL_NORMALIZE, &normalizing);
889 <        glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|
890 <                        GL_DEPTH_BUFFER_BIT|GL_POLYGON_BIT);
889 >        glPushAttrib(GL_LIGHTING_BIT|GL_TRANSFORM_BIT|GL_ENABLE_BIT|
890 >                GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_POLYGON_BIT);
891          glDepthFunc(GL_LESS);
892          glEnable(GL_DEPTH_TEST);
893          glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
# Line 836 | Line 907 | dobj_render()                  /* render our objects in OpenGL */
907                  if (op->drawcode == DO_LIGHT && op->ol != NULL) {
908                          BYTE    pval;
909                          double  expval, d;
910 <
910 >                                                /* use computed sources */
911                          if (tmMapPixels(&pval, &op->ol->larb, TM_NOCHROM, 1)
912                                          != TM_E_OK)
913                                  error(CONSISTENCY, "dobj_render w/o tone map");
# Line 862 | Line 933 | dobj_render()                  /* render our objects in OpenGL */
933                                  glLightfv(glightid[i], GL_AMBIENT, vec);
934                                  glEnable(glightid[i]);
935                          }
936 <                } else {
937 <                        vec[0] = vec[1] = vec[2] = 1.; vec[3] = 1.;
936 >                } else {                        /* fake lighting */
937 >                        vec[0] = vec[1] = vec[2] = 0.; vec[3] = 1.;
938                          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vec);
939 +                        getdcent(v1, op);
940 +                        VSUB(v1, odev.v.vp, v1);
941 +                        if (normalize(v1) <= getdrad(op)) {
942 +                                vec[0] = -odev.v.vdir[0];
943 +                                vec[1] = -odev.v.vdir[1];
944 +                                vec[2] = -odev.v.vdir[2];
945 +                        } else
946 +                                VCOPY(vec, v1);
947 +                        vec[3] = 0.;
948 +                        glLightfv(GL_LIGHT0, GL_POSITION, vec);
949 +                        vec[0] = vec[1] = vec[2] = .7; vec[3] = 1.;
950 +                        glLightfv(GL_LIGHT0, GL_SPECULAR, vec);
951 +                        glLightfv(GL_LIGHT0, GL_DIFFUSE, vec);
952 +                        vec[0] = vec[1] = vec[2] = .3; vec[3] = 1.;
953 +                        glLightfv(GL_LIGHT0, GL_AMBIENT, vec);
954 +                        glEnable(GL_LIGHT0);
955                  }
956                                          /* set up object transform */
957                  if (op->xfac) {
# Line 882 | Line 969 | dobj_render()                  /* render our objects in OpenGL */
969                  }
970                                          /* render the display list */
971                  glCallList(op->listid);
972 +                nrendered++;
973                                          /* restore matrix */
974                  if (op->xfac) {
975                          glMatrixMode(GL_MODELVIEW);
# Line 893 | Line 981 | dobj_render()                  /* render our objects in OpenGL */
981                  if (op->drawcode == DO_LIGHT && op->ol != NULL)
982                          for (i = op->ol->nl; i--; )
983                                  glDisable(glightid[i]);
984 +                else
985 +                        glDisable(GL_LIGHT0);
986                                          /* check errors */
897 –                rgl_checkerr("rendering object in dobj_render");
987          }
988          glPopAttrib();                  /* restore rendering params */
989 <        return(1);
989 >        rgl_checkerr("rendering objects in dobj_render");
990 >        return(nrendered);
991   }

Diff Legend

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