arch/svgalib/gr.c

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