arch/linux/svgalib/gr.c

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