Removed automake stuff from "inert" subdirs. And there was much rejoicing.
[btb/d2x.git] / video / svgalib_gr.c
1 /*
2  * $Source: /cvs/cvsroot/d2x/video/svgalib_gr.c,v $
3  * $Revision: 1.2 $
4  * $Author: bradleyb $
5  * $Date: 2001-01-29 13:47:52 $
6  *
7  * SVGALib video functions
8  *
9  * $Log: not supported by cvs2svn $
10  */
11
12 #ifdef HAVE_CONFIG_H
13 #include <conf.h>
14 #endif
15
16 #include <stdlib.h>
17 #include <stdio.h>
18 #include <string.h>
19 #include <vga.h>
20 #include <vgagl.h>
21 #include "gr.h"
22 #include "grdef.h"
23 #include "palette.h"
24 #include "u_mem.h"
25 #include "error.h"
26 #ifdef SVGALIB_INPUT
27 #include <vgamouse.h>
28 #endif
29
30 #include "gamefont.h"
31
32 int gr_installed = 0;
33 int usebuffer;
34
35 extern void mouse_handler (int button, int dx, int dy, int dz, int drx, int dry, int drz);
36
37 GraphicsContext *physicalscreen, *screenbuffer;
38
39 void gr_update()
40 {
41         if (usebuffer)
42                 gl_copyscreen(physicalscreen);
43 }
44
45 int gr_set_mode(u_int32_t mode)
46 {
47         unsigned int w, h;
48         char vgamode[16];
49         vga_modeinfo *modeinfo;
50         int modenum, rowsize;
51         void *framebuffer;
52         
53 #ifdef NOGRAPH
54         return 0;
55 #endif
56         if (mode<=0)
57                 return 0;
58
59         w=SM_W(mode);
60         h=SM_H(mode);
61
62         gr_palette_clear();
63
64         sprintf(vgamode, "G%dx%dx256", w, h);
65         modenum = vga_getmodenumber(vgamode);   
66         vga_setmode(modenum);
67 #ifdef SVGALIB_INPUT
68         mouse_seteventhandler(mouse_handler);
69 #endif
70         modeinfo = vga_getmodeinfo(modenum);
71
72         if (modeinfo->flags & CAPABLE_LINEAR)
73         {
74                 usebuffer = 0;
75
76                 vga_setlinearaddressing();
77
78                 // Set up physical screen only
79                 gl_setcontextvga(modenum);
80                 physicalscreen = gl_allocatecontext();
81                 gl_getcontext(physicalscreen);
82                 screenbuffer = physicalscreen;
83
84                 framebuffer = physicalscreen->vbuf;
85                 rowsize = physicalscreen->bytewidth;
86         }
87         else
88         {
89                 usebuffer = 1;
90
91                 // Set up the physical screen
92                 gl_setcontextvga(modenum);
93                 physicalscreen = gl_allocatecontext();
94                 gl_getcontext(physicalscreen);
95
96                 // Set up the virtual screen
97                 gl_setcontextvgavirtual(modenum);
98                 screenbuffer = gl_allocatecontext();
99                 gl_getcontext(screenbuffer);
100
101                 framebuffer = screenbuffer->vbuf;
102                 rowsize = screenbuffer->bytewidth;
103         }
104
105         memset(grd_curscreen, 0, sizeof(grs_screen));
106         grd_curscreen->sc_mode = mode;
107         grd_curscreen->sc_w = w;
108         grd_curscreen->sc_h = h;
109         grd_curscreen->sc_aspect = fixdiv(grd_curscreen->sc_w*3,grd_curscreen->sc_h*4);
110         grd_curscreen->sc_canvas.cv_bitmap.bm_x = 0;
111         grd_curscreen->sc_canvas.cv_bitmap.bm_y = 0;
112         grd_curscreen->sc_canvas.cv_bitmap.bm_w = w;
113         grd_curscreen->sc_canvas.cv_bitmap.bm_h = h;
114         grd_curscreen->sc_canvas.cv_bitmap.bm_rowsize = rowsize;
115         grd_curscreen->sc_canvas.cv_bitmap.bm_type = BM_LINEAR;
116         grd_curscreen->sc_canvas.cv_bitmap.bm_data = framebuffer;
117         gr_set_current_canvas(NULL);
118         
119         //gamefont_choose_game_font(w,h);
120         
121         return 0;
122 }
123
124 int gr_init(void)
125 {
126         int retcode;
127         int mode = SM(320,200);
128
129         // Only do this function once!
130         if (gr_installed==1)
131                 return -1;
132         MALLOC(grd_curscreen,grs_screen, 1);
133         memset(grd_curscreen, 0, sizeof(grs_screen));
134         
135         vga_init();
136
137         if ((retcode=gr_set_mode(mode)))
138                 return retcode;
139         
140         grd_curscreen->sc_canvas.cv_color = 0;
141         grd_curscreen->sc_canvas.cv_drawmode = 0;
142         grd_curscreen->sc_canvas.cv_font = NULL;
143         grd_curscreen->sc_canvas.cv_font_fg_color = 0;
144         grd_curscreen->sc_canvas.cv_font_bg_color = 0;
145         gr_set_current_canvas( &grd_curscreen->sc_canvas );
146
147         gr_installed = 1;
148         atexit(gr_close);
149         return 0;
150 }
151
152 void gr_close ()
153 {
154         if (gr_installed==1)
155         {
156                 gr_installed = 0;
157                 free(grd_curscreen);
158                 gl_freecontext(screenbuffer);
159                 gl_freecontext(physicalscreen);
160         }
161 }
162
163 // Palette functions follow.
164
165 static int last_r=0, last_g=0, last_b=0;
166
167 void gr_palette_clear ()
168 {
169         int colors[768];
170
171         memset (colors, 0, 768 * sizeof(int));
172         vga_setpalvec (0, 256, colors);
173
174         gr_palette_faded_out = 1;
175 }
176
177
178 void gr_palette_step_up (int r, int g, int b)
179 {
180         int i = 0;
181         ubyte *p = gr_palette;
182         int temp;
183
184         int colors[768];
185
186         if (gr_palette_faded_out) return;
187
188         if ((r==last_r) && (g==last_g) && (b==last_b)) return;
189
190         last_r = r;
191         last_g = g;
192         last_b = b;
193
194         while (i < 768)
195         {
196                 temp = (int)(*p++) + r + gr_palette_gamma;
197                 if (temp<0) temp=0;
198                 else if (temp>63) temp=63;
199                 colors[i++] = temp;
200                 temp = (int)(*p++) + g + gr_palette_gamma;
201                 if (temp<0) temp=0;
202                 else if (temp>63) temp=63;
203                 colors[i++] = temp;
204                 temp = (int)(*p++) + b + gr_palette_gamma;
205                 if (temp<0) temp=0;
206                 else if (temp>63) temp=63;
207                 colors[i++] = temp;
208         }
209         vga_setpalvec (0, 256, colors);
210 }
211
212 //added on 980913 by adb to fix palette problems
213 // need a min without side effects...
214 #undef min
215 static inline int min(int x, int y) { return x < y ? x : y; }
216 //end changes by adb
217
218 void gr_palette_load (ubyte *pal)       
219 {
220         int i;
221         int colors[768];
222
223         for (i = 0; i < 768; i++)
224         {
225                 gr_current_pal[i] = pal[i];
226                 if (gr_current_pal[i] > 63) gr_current_pal[i] = 63;
227                 colors[i] = (min(gr_current_pal[i] + gr_palette_gamma, 63));
228         }
229
230         vga_setpalvec (0, 256, colors);
231
232         gr_palette_faded_out = 0;
233         init_computed_colors();
234 }
235
236
237
238 int gr_palette_fade_out (ubyte *pal, int nsteps, int allow_keys)
239 {
240         int i, j;
241         ubyte c;
242         fix fade_palette[768];
243         fix fade_palette_delta[768];
244
245         int fade_colors[768];
246
247         if (gr_palette_faded_out) return 0;
248
249         if (pal==NULL) pal=gr_current_pal;
250
251         for (i=0; i<768; i++)
252         {
253                 gr_current_pal[i] = pal[i];
254                 fade_palette[i] = i2f(pal[i]);
255                 fade_palette_delta[i] = fade_palette[i] / nsteps;
256         }
257
258         for (j=0; j<nsteps; j++)
259         {
260                 for (i = 0; i < 768; i++)
261                 {
262                         fade_palette[i] -= fade_palette_delta[i];
263                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma))
264                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
265                         c = f2i(fade_palette[i]);
266                         if (c > 63) c = 63;
267                         fade_colors[i] = c;
268                 }
269                 vga_setpalvec (0, 256, fade_colors);
270         }
271
272         gr_palette_faded_out = 1;
273         return 0;
274 }
275
276
277
278 int gr_palette_fade_in (ubyte *pal, int nsteps, int allow_keys)
279 {
280         int i, j;
281         ubyte c;
282         fix fade_palette[768];
283         fix fade_palette_delta[768];
284
285         int fade_colors[768];
286
287         if (!gr_palette_faded_out) return 0;
288
289         for (i=0; i<768; i++)
290         {
291                 gr_current_pal[i] = pal[i];
292                 fade_palette[i] = 0;
293                 fade_palette_delta[i] = i2f(pal[i] + gr_palette_gamma) / nsteps;
294         }
295
296         for (j=0; j<nsteps; j++ )
297         {
298                 for (i = 0; i < 768; i++ )
299                 {
300                         fade_palette[i] += fade_palette_delta[i];
301                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma))
302                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
303                         c = f2i(fade_palette[i]);
304                         if (c > 63) c = 63;
305                         fade_colors[i] = c;
306                 }
307                 vga_setpalvec (0, 256, fade_colors);
308         }
309
310         gr_palette_faded_out = 0;
311         return 0;
312 }
313
314
315
316 void gr_palette_read (ubyte *pal)
317 {
318         int colors[768];
319         int i;
320
321         vga_getpalvec (0, 256, colors);
322
323         for (i = 0; i < 768; i++)
324                 pal[i] = colors[i];
325 }