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

Comparing ray/src/rt/aed.c (file contents):
Revision 1.1 by greg, Thu Feb 2 10:41:16 1989 UTC vs.
Revision 2.5 by schorsch, Wed Aug 20 10:00:09 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1987 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  aed.c - driver for AED 512 terminal.
9 – *
10 – *     2/2/87
6   */
7  
8 + #include "copyright.h"
9 +
10   #include  <stdio.h>
11  
12 + #include  "rterror.h"
13 + #include  "color.h"
14   #include  "driver.h"
15  
17 – #include  "color.h"
16  
19 –
17          /* AED command characters */
18  
19   #define AEDFMT  "1888N" /* Format string to send to AED */
# Line 46 | Line 43 | static char SCCSid[] = "$SunId$ LBL";
43   #define string(s)       fputs(s, stdout)
44   #define flush()         fflush(stdout)
45  
46 < #define  GAMMA          2.0             /* exponent for color correction */
46 > #define  GAMMA          2.5             /* exponent for color correction */
47  
48 < #define  MINCOLOR       8               /* start of device color table */
48 > #define  NCOLORS        248             /* our color table size */
49 > #define  MINPIX         8               /* minimum hardware color */
50  
53 – #define  NCOLORS        241             /* our color table size (prime) */
54 –
55 – #define  hashcolr(c)    ((67*(c)[RED]+59*(c)[GRN]+71*(c)[BLU])%NCOLORS)
56 –
51   #define  NCOLS          512             /* maximum # columns for output */
52 < #define  NROWS          512-COMHT       /* maximum # rows for output */
52 > #define  NROWS          483-COMHT       /* maximum # rows for output */
53   #define  COMHT          16              /* height of command line */
54   #define  COMCW          63              /* maximum chars on command line */
55  
56 < static COLR  colrmap[256];              /* our color map */
56 > static void  aed_close(void);
57 > static void aed_errout(char*);
58 > static void longwait(int t);
59 > static void aedgetcap(int  *xp, int *yp);
60 > static void aedsetcap(int  x, int y);
61 > static void anewcolr(int  index, int  r,int g,int b);
62 > static void aed_paintr(COLOR  col, int  xmin, int ymin, int xmax, int ymax);
63 > static void aedcoord(int  x, int y);
64 > static void aed_comout(char  *out);
65 > static int aed_getcur(int  *xp, int *yp);
66 > static aed_clear(int  x, int y);
67  
64 – static COLR  colrtbl[NCOLORS];          /* our color table */
65 –
66 – static int  colres = 64;                /* color resolution */
67 –
68 – int  aed_close(), aed_clear(), aed_paintr(),
69 –                aed_getcur(), aed_comout(), aed_errout();
70 –
68   static struct driver  aed_driver = {
69          aed_close, aed_clear, aed_paintr, aed_getcur,
70 <        aed_comout, NULL,
71 <        NCOLS, NROWS
70 >        aed_comout, NULL, NULL,
71 >        1.0, NCOLS, NROWS
72   };
73  
74  
75   struct driver *
76 < aed_init(name)                          /* open AED */
77 < char  *name;
76 > aed_init(name, id)                      /* open AED */
77 > char  *name, *id;
78   {
79          if (ttyset(&aed_driver, fileno(stdin)) < 0) {   /* set tty driver */
80 <                stderr_v("cannot access terminal\n");
80 >                eputs("cannot access terminal\n");
81                  return(NULL);
82          }
83          command(RST);                                   /* reset AED */
# Line 95 | Line 92 | char  *name;
92          byte(BLK); byte(WHT); byte(15);
93          command(SCP);
94          byte('+'); byte(0); byte(1);
95 <        errvec = aed_errout;                            /* set error vector */
96 <        cmdvec = aed_errout;
97 <        if (wrnvec != NULL)
98 <                wrnvec = aed_errout;
95 >        make_gmap(GAMMA);                               /* make color map */
96 >        erract[USER].pf =                               /* set error vector */
97 >        erract[SYSTEM].pf =
98 >        erract[INTERNAL].pf =
99 >        erract[CONSISTENCY].pf = aed_errout;
100 >        erract[COMMAND].pf = aed_errout;
101 >        if (erract[WARNING].pf != NULL)
102 >                erract[WARNING].pf = aed_errout;
103          return(&aed_driver);
104   }
105  
106  
107 < static
108 < aed_close()                                     /* close AED */
107 > static void
108 > aed_close(void)                                 /* close AED */
109   {
110 <        errvec = stderr_v;                      /* reset error vector */
111 <        cmdvec = NULL;
112 <        if (wrnvec != NULL)
113 <                wrnvec = stderr_v;
110 >        erract[USER].pf =                       /* reset error vector */
111 >        erract[SYSTEM].pf =
112 >        erract[INTERNAL].pf =
113 >        erract[CONSISTENCY].pf = eputs;
114 >        erract[COMMAND].pf = NULL;
115 >        if (erract[WARNING].pf != NULL)
116 >                erract[WARNING].pf = wputs;
117          aedsetcap(0, 0);                        /* go to bottom */
118          command(SEC);
119          byte(WHT);                              /* white text */
# Line 125 | Line 129 | aed_clear(x, y)                                        /* clear AED */
129   int  x, y;
130   {
131          command(FFD);
132 +        new_ctab(NCOLORS);                      /* init color table */
133          flush();
129 –        makemap();                              /* init color map */
134   }
135  
136  
137 < static
137 > static void
138   aed_paintr(col, xmin, ymin, xmax, ymax)         /* paint a rectangle */
139   COLOR  col;
140   int  xmin, ymin, xmax, ymax;
141   {
142          int  ndx;
143  
144 <        if ((ndx = colindex(col)) < 0) {                /* full table? */
145 <                colres >>= 1;
146 <                redraw();
143 <                return;
144 <        }
145 <        command(SEC);                                   /* draw rectangle */
146 <        byte(ndx+MINCOLOR);
144 >        ndx = get_pixel(col, anewcolr);         /* calls anewcolr() */
145 >        command(SEC);                           /* draw rectangle */
146 >        byte(ndx+MINPIX);
147          aedsetcap(xmin, ymin+COMHT);
148          command(DFR);
149          aedcoord(xmax-1, ymax+(-1+COMHT));
# Line 166 | Line 166 | int  *xp, *yp;
166   }
167  
168  
169 < static
169 > static void
170   aed_comout(out)                         /* output to command line */
171   register char  *out;
172   {
# Line 209 | Line 209 | register char  *out;
209   }
210  
211  
212 < static
212 > static void
213   aed_errout(msg)                         /* print an error message */
214   char  *msg;
215   {
# Line 223 | Line 223 | char  *msg;
223   * aedsetcap - sets AED's current access pointer to (x, y).
224   */
225  
226 < static
226 > static void
227   aedsetcap(x, y)
228   register int  x, y;
229   {
# Line 235 | Line 235 | register int  x, y;
235   * aedcoord - puts out an (x, y) coordinate in AED 8 bit format.
236   */
237  
238 < static
238 > static void
239   aedcoord(x, y)
240   register int  x, y;
241   {
# Line 245 | Line 245 | register int  x, y;
245   }
246  
247  
248 < static
248 > static void
249   aedgetcap(xp, yp)               /* get cursor postion */
250   int  *xp, *yp;
251   {
# Line 261 | Line 261 | int  *xp, *yp;
261   }
262  
263  
264 < static int
265 < colindex(col)                   /* return table index for color */
266 < COLOR  col;
267 < {
268 <        static COLR  clr;
269 <        int  hval;
270 <        register int  ndx, i;
271 <        
272 <        mapcolor(clr, col);
273 <
274 <        hval = ndx = hashcolr(clr);
275 <        
276 <        for (i = 1; i < NCOLORS; i++) {
277 <                if (colrtbl[ndx][EXP] == 0) {
278 <                        colrtbl[ndx][RED] = clr[RED];
279 <                        colrtbl[ndx][GRN] = clr[GRN];
280 <                        colrtbl[ndx][BLU] = clr[BLU];
281 <                        colrtbl[ndx][EXP] = COLXS;
282 <                        newcolr(ndx, clr);
283 <                        return(ndx);
284 <                }
285 <                if (            colrtbl[ndx][RED] == clr[RED] &&
286 <                                colrtbl[ndx][GRN] == clr[GRN] &&
287 <                                colrtbl[ndx][BLU] == clr[BLU]   )
288 <                        return(ndx);
289 <                ndx = (hval + i*i) % NCOLORS;
290 <        }
291 <        return(-1);
292 < }
293 <
294 <
295 < static
296 < newcolr(index, clr)             /* enter a color into our table */
264 > static void
265 > anewcolr(index, r, g, b)                /* enter a color into our table */
266   int  index;
267 < COLR  clr;
267 > int  r, g, b;
268   {
269          command(SCT);
270 <        byte(index+MINCOLOR);
270 >        byte((index+MINPIX)&255);
271          byte(1);
272 <        byte(clr[RED]);
273 <        byte(clr[GRN]);
274 <        byte(clr[BLU]);
272 >        byte(r);
273 >        byte(g);
274 >        byte(b);
275          flush();
276   }
277  
278  
279 < static
311 < mapcolor(clr, col)                      /* map to our color space */
312 < COLR  clr;
313 < COLOR  col;
314 < {
315 <        register int  i, p;
316 <                                        /* compute color table value */
317 <        for (i = 0; i < 3; i++) {
318 <                p = colval(col,i) * 256.0;
319 <                if (p < 0) p = 0;
320 <                else if (p >= 256) p = 255;
321 <                clr[i] = colrmap[p][i];
322 <        }
323 <        clr[EXP] = COLXS;
324 < }
325 <
326 <
327 < static
328 < makemap()                               /* initialize the color map */
329 < {
330 <        double  pow();
331 <        int  val;
332 <        register int  i;
333 <
334 <        for (i = 0; i < 256; i++) {
335 <                val = pow(i/256.0, 1.0/GAMMA) * colres;
336 <                val = (val*256 + 128) / colres;
337 <                colrmap[i][RED] = colrmap[i][GRN] = colrmap[i][BLU] = val;
338 <                colrmap[i][EXP] = COLXS;
339 <        }
340 <        for (i = 0; i < NCOLORS; i++)
341 <                colrtbl[i][EXP] = 0;
342 < }
343 <
344 <
345 < static
279 > static void
280   longwait(t)             /* longer wait */
281   int  t;
282   {

Diff Legend

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