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 */