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