video/svgalib_gr.c

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