implement -nomusic for linux hmiplay (d1x r1.8)
[btb/d2x.git] / arch / ggi / gr.c
1 /*
2  * $Source: /cvs/cvsroot/d2x/arch/ggi/gr.c,v $
3  * $Revision: 1.1 $
4  * $Author: bradleyb $
5  * $Date: 2001-10-25 08:25:34 $
6  *
7  * Graphics functions for GGI.
8  *
9  * $Log: not supported by cvs2svn $
10  * Revision 1.3  2001/01/29 13:47:51  bradleyb
11  * Fixed build, some minor cleanups.
12  *
13  */
14
15 #ifdef HAVE_CONFIG_H
16 #include <conf.h>
17 #endif
18
19 #include <ggi/ggi.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include "gr.h"
24 #include "grdef.h"
25 #include "palette.h"
26 #include "u_mem.h"
27 #include "error.h"
28 #include "console.h"
29
30 #include "gamefont.h"
31
32 int gr_installed = 0;
33 void *screenbuffer;
34
35 ggi_visual_t *screenvis;
36 const ggi_directbuffer *dbuffer;
37 ggi_mode init_mode;
38
39 ubyte use_directbuffer;
40
41 void gr_update()
42 {
43         ggiFlush(screenvis);
44         if (!use_directbuffer)
45                 ggiPutBox(screenvis, 0, 0, grd_curscreen->sc_w, grd_curscreen->sc_h, screenbuffer);
46 }
47
48 int gr_set_mode(u_int32_t mode)
49 {
50         unsigned int w, h;
51         ggi_mode other_mode;
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         
63         gr_palette_clear();
64
65         if(ggiCheckGraphMode(screenvis, w, h, GGI_AUTO, GGI_AUTO, GT_8BIT, &other_mode))
66                 ggiSetMode(screenvis, &other_mode);
67         else
68                 ggiSetGraphMode(screenvis, w, h, GGI_AUTO, GGI_AUTO, GT_8BIT);
69
70         ggiSetFlags(screenvis, GGIFLAG_ASYNC);
71                 
72         if (!ggiDBGetNumBuffers(screenvis))
73                 use_directbuffer = 0;
74         else
75         {       
76                 dbuffer = ggiDBGetBuffer(screenvis, 0);
77                 if (!(dbuffer->type & GGI_DB_SIMPLE_PLB))
78                         use_directbuffer = 0;
79                 else
80                         use_directbuffer = 1;
81         }
82
83         memset(grd_curscreen, 0, sizeof(grs_screen));
84
85         grd_curscreen->sc_mode = mode;
86         grd_curscreen->sc_w = w;
87         grd_curscreen->sc_h = h;
88         grd_curscreen->sc_aspect = fixdiv(grd_curscreen->sc_w*3,grd_curscreen->sc_h*4);
89         grd_curscreen->sc_canvas.cv_bitmap.bm_x = 0;
90         grd_curscreen->sc_canvas.cv_bitmap.bm_y = 0;
91         grd_curscreen->sc_canvas.cv_bitmap.bm_w = w;
92         grd_curscreen->sc_canvas.cv_bitmap.bm_h = h;
93         grd_curscreen->sc_canvas.cv_bitmap.bm_type = BM_LINEAR;
94
95         if (use_directbuffer)
96         {
97                 grd_curscreen->sc_canvas.cv_bitmap.bm_data = dbuffer->write;
98                 grd_curscreen->sc_canvas.cv_bitmap.bm_rowsize = dbuffer->buffer.plb.stride;
99         }
100         else
101         {
102                 d_free(screenbuffer);
103                 screenbuffer = d_malloc (w * h);
104                 grd_curscreen->sc_canvas.cv_bitmap.bm_data = screenbuffer;
105                 grd_curscreen->sc_canvas.cv_bitmap.bm_rowsize = w;
106         }
107
108         gr_set_current_canvas(NULL);
109         
110         //gamefont_choose_game_font(w,h);
111         
112         return 0;
113 }
114
115 int gr_init(void)
116 {
117         int retcode;
118         int mode = SM(648,480);
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         ggiInit();
126         screenvis = ggiOpen(NULL);
127         ggiGetMode(screenvis, &init_mode);
128
129         if ((retcode=gr_set_mode(mode)))
130                 return retcode;
131         
132         grd_curscreen->sc_canvas.cv_color = 0;
133         grd_curscreen->sc_canvas.cv_drawmode = 0;
134         grd_curscreen->sc_canvas.cv_font = NULL;
135         grd_curscreen->sc_canvas.cv_font_fg_color = 0;
136         grd_curscreen->sc_canvas.cv_font_bg_color = 0;
137         gr_set_current_canvas( &grd_curscreen->sc_canvas );
138
139         gr_installed = 1;
140         atexit(gr_close);
141         return 0;
142 }
143
144 void gr_close ()
145 {
146         if (gr_installed==1)
147         {
148                 ggiSetMode(screenvis, &init_mode);
149                 ggiClose(screenvis);
150                 ggiExit();
151                 gr_installed = 0;
152                 d_free(grd_curscreen);
153         }
154 }
155
156 // Palette functions follow.
157
158 static int last_r=0, last_g=0, last_b=0;
159
160 void gr_palette_clear()
161 {
162         ggi_color *colors = calloc (256, sizeof(ggi_color));
163
164         ggiSetPalette (screenvis, 0, 256, colors);
165
166         gr_palette_faded_out = 1;
167 }
168
169
170 void gr_palette_step_up (int r, int g, int b)
171 {
172         int i;
173         ubyte *p = gr_palette;
174         int temp;
175
176         ggi_color colors[256];
177
178         if (gr_palette_faded_out) return;
179
180         if ((r==last_r) && (g==last_g) && (b==last_b)) return;
181
182         last_r = r;
183         last_g = g;
184         last_b = b;
185
186         for (i = 0; i < 256; i++)
187         {
188                 temp = (int)(*p++) + r + gr_palette_gamma;
189                 if (temp<0) temp=0;
190                 else if (temp>63) temp=63;
191                 colors[i].r = temp * 0x3ff;
192                 temp = (int)(*p++) + g + gr_palette_gamma;
193                 if (temp<0) temp=0;
194                 else if (temp>63) temp=63;
195                 colors[i].g = temp * 0x3ff;
196                 temp = (int)(*p++) + b + gr_palette_gamma;
197                 if (temp<0) temp=0;
198                 else if (temp>63) temp=63;
199                 colors[i].b = temp * 0x3ff;
200         }
201         ggiSetPalette (screenvis, 0, 256, colors);
202 }
203
204 //added on 980913 by adb to fix palette problems
205 // need a min without side effects...
206 #undef min
207 static inline int min(int x, int y) { return x < y ? x : y; }
208 //end changes by adb
209
210 void gr_palette_load (ubyte *pal)       
211 {
212         int i, j;
213         ggi_color colors[256];
214
215         for (i = 0, j = 0; j < 256; j++)
216         {
217                 gr_current_pal[i] = pal[i];
218                 if (gr_current_pal[i] > 63) gr_current_pal[i] = 63;
219                 colors[j].r = (min(gr_current_pal[i] + gr_palette_gamma, 63)) * 0x3ff;
220                 i++;
221                 gr_current_pal[i] = pal[i];
222                 if (gr_current_pal[i] > 63) gr_current_pal[i] = 63;
223                 colors[j].g = (min(gr_current_pal[i] + gr_palette_gamma, 63)) * 0x3ff;
224                 i++;
225                 gr_current_pal[i] = pal[i];
226                 if (gr_current_pal[i] > 63) gr_current_pal[i] = 63;
227                 colors[j].b = (min(gr_current_pal[i] + gr_palette_gamma, 63)) * 0x3ff;
228                 i++;
229         }
230
231         ggiSetPalette(screenvis, 0, 256, colors);
232
233         gr_palette_faded_out = 0;
234         init_computed_colors();
235 }
236
237
238
239 int gr_palette_fade_out (ubyte *pal, int nsteps, int allow_keys)
240 {
241         int i, j, k;
242         ubyte c;
243         fix fade_palette[768];
244         fix fade_palette_delta[768];
245
246         ggi_color fade_colors[256];
247
248         if (gr_palette_faded_out) return 0;
249
250         if (pal==NULL) pal=gr_current_pal;
251
252         for (i=0; i<768; i++)
253         {
254                 gr_current_pal[i] = pal[i];
255                 fade_palette[i] = i2f(pal[i]);
256                 fade_palette_delta[i] = fade_palette[i] / nsteps;
257         }
258
259         for (j=0; j<nsteps; j++)
260         {
261                 for (i = 0; i < 768; i++)
262                 {
263                         fade_palette[i] -= fade_palette_delta[i];
264                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma))
265                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
266                 }
267                 for (i = 0, k = 0; k < 256; k++)
268                 {
269                         c = f2i(fade_palette[i++]);
270                         if (c > 63) c = 63;
271                         fade_colors[k].r = c * 0x3ff;
272                         c = f2i(fade_palette[i++]);
273                         if (c > 63) c = 63;
274                         fade_colors[k].g = c * 0x3ff;
275                         c = f2i(fade_palette[i++]);
276                         if (c > 63) c = 63;
277                         fade_colors[k].b = c * 0x3ff;
278                 }
279                 ggiSetPalette (screenvis, 0, 256, fade_colors);
280                 gr_update();
281         }
282
283         gr_palette_faded_out = 1;
284         return 0;
285 }
286
287
288
289 int gr_palette_fade_in (ubyte *pal, int nsteps, int allow_keys)
290 {
291         int i, j, k;
292         ubyte c;
293         fix fade_palette[768];
294         fix fade_palette_delta[768];
295
296         ggi_color fade_colors[256];
297
298         if (!gr_palette_faded_out) return 0;
299
300         for (i=0; i<768; i++)
301         {
302                 gr_current_pal[i] = pal[i];
303                 fade_palette[i] = 0;
304                 fade_palette_delta[i] = i2f(pal[i] + gr_palette_gamma) / nsteps;
305         }
306
307         for (j=0; j<nsteps; j++ )
308         {
309                 for (i = 0; i < 768; i++ )
310                 {
311                         fade_palette[i] += fade_palette_delta[i];
312                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma))
313                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
314                 }
315                 for (i = 0, k = 0; k < 256; k++)
316                 {
317                         c = f2i(fade_palette[i++]);
318                         if (c > 63) c = 63;
319                         fade_colors[k].r = c * 0x3ff;
320                         c = f2i(fade_palette[i++]);
321                         if (c > 63) c = 63;
322                         fade_colors[k].g = c * 0x3ff;
323                         c = f2i(fade_palette[i++]);
324                         if (c > 63) c = 63;
325                         fade_colors[k].b = c * 0x3ff;
326                 }
327                 ggiSetPalette (screenvis, 0, 256, fade_colors);
328                 gr_update();
329         }
330
331         gr_palette_faded_out = 0;
332         return 0;
333 }
334
335
336
337 void gr_palette_read (ubyte *pal)
338 {
339         ggi_color colors[256];
340         int i, j;
341
342         ggiGetPalette (screenvis, 0, 256, colors);
343
344         for (i = 0, j = 0; i < 256; i++)
345         {
346                 pal[j++] = colors[i].r / 0x3ff;
347                 pal[j++] = colors[i].g / 0x3ff;
348                 pal[j++] = colors[i].b / 0x3ff;
349         }
350 }