arch/svgalib/gr.c

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