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

Comparing ray/src/cv/mgflib/context.c (file contents):
Revision 1.7 by greg, Sat Jun 25 09:48:01 1994 UTC vs.
Revision 1.9 by greg, Sat Jun 25 16:33:14 1994 UTC

# Line 63 | Line 63 | register char  **av;
63                  lp = lu_find(&clr_tab, av[1]);  /* lookup context */
64                  if (lp == NULL)
65                          return(MG_EMEM);
66 +                c_ccolor = (C_COLOR *)lp->data;
67                  if (ac == 2) {          /* reestablish previous context */
68 <                        if (lp->data == NULL)
68 >                        if (c_ccolor == NULL)
69                                  return(MG_EUNDEF);
69 –                        c_ccolor = (C_COLOR *)lp->data;
70                          return(MG_OK);
71                  }
72                  if (av[2][0] != '=' || av[2][1])
73                          return(MG_ETYPE);
74 <                if (lp->key == NULL) {  /* create new color context */
74 >                if (c_ccolor == NULL) { /* create new color context */
75                          lp->key = (char *)malloc(strlen(av[1])+1);
76                          if (lp->key == NULL)
77                                  return(MG_EMEM);
# Line 79 | Line 79 | register char  **av;
79                          lp->data = (char *)malloc(sizeof(C_COLOR));
80                          if (lp->data == NULL)
81                                  return(MG_EMEM);
82 +                        c_ccolor = (C_COLOR *)lp->data;
83 +                        c_ccolor->clock = 0;
84                  }
83 –                c_ccolor = (C_COLOR *)lp->data;
85                  if (ac == 3) {          /* use default template */
86 +                        i = c_ccolor->clock;
87                          *c_ccolor = c_dfcolor;
88 +                        c_ccolor->name = av[1];
89 +                        c_ccolor->clock = i + 1;
90                          return(MG_OK);
91                  }
92                  lp = lu_find(&clr_tab, av[3]);  /* lookup template */
# Line 90 | Line 94 | register char  **av;
94                          return(MG_EMEM);
95                  if (lp->data == NULL)
96                          return(MG_EUNDEF);
97 +                i = c_ccolor->clock;
98                  *c_ccolor = *(C_COLOR *)lp->data;
99 <                if (ac > 4)
100 <                        return(MG_EARGC);
99 >                c_ccolor->name = av[1];
100 >                c_ccolor->clock = i + 1;
101                  return(MG_OK);
102          case MG_E_CXY:          /* assign CIE XY value */
103                  if (ac != 3)
# Line 105 | Line 110 | register char  **av;
110                  if (c_ccolor->cx < 0. | c_ccolor->cy < 0. |
111                                  c_ccolor->cx + c_ccolor->cy > 1.)
112                          return(MG_EILL);
113 +                c_ccolor->clock++;
114                  return(MG_OK);
115          case MG_E_CSPEC:        /* assign spectral values */
116                  if (ac < 5)
# Line 151 | Line 157 | c_hmaterial(ac, av)            /* handle material entity */
157   int     ac;
158   register char   **av;
159   {
160 +        int     i;
161          register LUENT  *lp;
162  
163          switch (mg_entity(av[0])) {
# Line 165 | Line 172 | register char  **av;
172                  lp = lu_find(&mat_tab, av[1]);  /* lookup context */
173                  if (lp == NULL)
174                          return(MG_EMEM);
175 +                c_cmaterial = (C_MATERIAL *)lp->data;
176                  if (ac == 2) {          /* reestablish previous context */
177 <                        if (lp->data == NULL)
177 >                        if (c_cmaterial == NULL)
178                                  return(MG_EUNDEF);
171 –                        c_cmaterial = (C_MATERIAL *)lp->data;
179                          return(MG_OK);
180                  }
181                  if (av[2][0] != '=' || av[2][1])
182                          return(MG_ETYPE);
183 <                if (lp->key == NULL) {  /* create new material context */
183 >                if (c_cmaterial == NULL) {      /* create new material */
184                          lp->key = (char *)malloc(strlen(av[1])+1);
185                          if (lp->key == NULL)
186                                  return(MG_EMEM);
# Line 181 | Line 188 | register char  **av;
188                          lp->data = (char *)malloc(sizeof(C_MATERIAL));
189                          if (lp->data == NULL)
190                                  return(MG_EMEM);
191 +                        c_cmaterial = (C_MATERIAL *)lp->data;
192 +                        c_cmaterial->clock = 0;
193                  }
185 –                c_cmaterial = (C_MATERIAL *)lp->data;
194                  if (ac == 3) {          /* use default template */
195 +                        i = c_cmaterial->clock;
196                          *c_cmaterial = c_dfmaterial;
197 <                        c_cmaterial->name = lp->key;
197 >                        c_cmaterial->name = av[1];
198 >                        c_cmaterial->clock = i + 1;
199                          return(MG_OK);
200                  }
201                  lp = lu_find(&mat_tab, av[3]);  /* lookup template */
# Line 193 | Line 203 | register char  **av;
203                          return(MG_EMEM);
204                  if (lp->data == NULL)
205                          return(MG_EUNDEF);
206 +                i = c_cmaterial->clock;
207                  *c_cmaterial = *(C_MATERIAL *)lp->data;
208 <                c_cmaterial->name = lp->key;
209 <                c_cmaterial->clock = 1;
199 <                if (ac > 4)
200 <                        return(MG_EARGC);
208 >                c_cmaterial->name = av[1];
209 >                c_cmaterial->clock = i + 1;
210                  return(MG_OK);
211          case MG_E_RD:           /* set diffuse reflectance */
212                  if (ac != 2)
# Line 230 | Line 239 | register char  **av;
239                  if (c_cmaterial->td < 0. | c_cmaterial->td > 1.)
240                          return(MG_EILL);
241                  c_cmaterial->td_c = *c_ccolor;
242 +                c_cmaterial->clock++;
243                  return(MG_OK);
244          case MG_E_RS:           /* set specular reflectance */
245                  if (ac != 3)
# Line 267 | Line 277 | c_hvertex(ac, av)              /* handle a vertex entity */
277   int     ac;
278   register char   **av;
279   {
280 +        int     i;
281          register LUENT  *lp;
282  
283          switch (mg_entity(av[0])) {
# Line 281 | Line 292 | register char  **av;
292                  lp = lu_find(&vtx_tab, av[1]);  /* lookup context */
293                  if (lp == NULL)
294                          return(MG_EMEM);
295 +                c_cvertex = (C_VERTEX *)lp->data;
296                  if (ac == 2) {          /* reestablish previous context */
297 <                        if (lp->data == NULL)
297 >                        if (c_cvertex == NULL)
298                                  return(MG_EUNDEF);
287 –                        c_cvertex = (C_VERTEX *)lp->data;
299                          return(MG_OK);
300                  }
301                  if (av[2][0] != '=' || av[2][1])
302                          return(MG_ETYPE);
303 <                if (lp->key == NULL) {  /* create new vertex context */
303 >                if (c_cvertex == NULL) {        /* create new vertex context */
304                          lp->key = (char *)malloc(strlen(av[1])+1);
305                          if (lp->key == NULL)
306                                  return(MG_EMEM);
# Line 297 | Line 308 | register char  **av;
308                          lp->data = (char *)malloc(sizeof(C_VERTEX));
309                          if (lp->data == NULL)
310                                  return(MG_EMEM);
311 +                        c_cvertex = (C_VERTEX *)lp->data;
312                  }
301 –                c_cvertex = (C_VERTEX *)lp->data;
313                  if (ac == 3) {          /* use default template */
314 +                        i = c_cvertex->clock;
315                          *c_cvertex = c_dfvertex;
316 +                        c_cvertex->name = av[1];
317 +                        c_cvertex->clock = i + 1;
318                          return(MG_OK);
319                  }
320                  lp = lu_find(&vtx_tab, av[3]);  /* lookup template */
# Line 308 | Line 322 | register char  **av;
322                          return(MG_EMEM);
323                  if (lp->data == NULL)
324                          return(MG_EUNDEF);
325 +                i = c_cvertex->clock;
326                  *c_cvertex = *(C_VERTEX *)lp->data;
327 <                if (ac > 4)
328 <                        return(MG_EARGC);
327 >                c_cvertex->name = av[1];
328 >                c_cvertex->clock = i + 1;
329                  return(MG_OK);
330          case MG_E_POINT:        /* set point */
331                  if (ac != 4)
# Line 320 | Line 335 | register char  **av;
335                  c_cvertex->p[0] = atof(av[1]);
336                  c_cvertex->p[1] = atof(av[2]);
337                  c_cvertex->p[2] = atof(av[3]);
338 +                c_cvertex->clock++;
339                  return(MG_OK);
340          case MG_E_NORMAL:       /* set normal */
341                  if (ac != 4)
# Line 330 | Line 346 | register char  **av;
346                  c_cvertex->n[1] = atof(av[2]);
347                  c_cvertex->n[2] = atof(av[3]);
348                  (void)normalize(c_cvertex->n);
349 +                c_cvertex->clock++;
350                  return(MG_OK);
351          }
352          return(MG_EUNK);
# Line 379 | Line 396 | int
396   c_isgrey(clr)                   /* check if color is grey */
397   register C_COLOR        *clr;
398   {
399 <        if (!clr->flags)
399 >        if (!(clr->flags & (C_CSXY|C_CSSPEC)))
400                  return(1);              /* no settings == grey */
401          c_ccvt(clr, C_CSXY);
402          return(clr->cx >= .323 && clr->cx <= .343 &&
# Line 397 | Line 414 | int    fl;
414  
415          if (clr->flags & fl)            /* already done */
416                  return;
417 <        if (!(clr->flags & (C_CSXY|C_CSSPEC)))  /* nothing set */
417 >        if (!(clr->flags & (C_CSXY|C_CSSPEC)))  /* nothing set! */
418                  *clr = c_dfcolor;
419          else if (fl & C_CSXY) {         /* cspec -> cxy */
420                  x = y = z = 0.;
# Line 477 | Line 494 | char   **av;
494                          clr->ssum += clr->ssamp[i];
495                  }
496          clr->flags = C_CDSPEC|C_CSSPEC;
497 +        clr->clock++;
498          free((MEM_PTR)va);
499          return(MG_OK);
500   }
# Line 515 | Line 533 | double w1, w2;
533                  cres->cy = (w1 + w2) * scale;
534                  cres->flags = C_CDXY|C_CSXY;
535          }
536 +        cres->clock++;                  /* record the change */
537   }

Diff Legend

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