Return to uip-svgalib.c CVS log

Up to [Generator SEGA Genesis emulator] / generator / src

0.31

/* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */

/* user interface for svgalib (15/16 bit) */

#include <stdio.h>
#include <unistd.h>

#include "generator.h"
#include <vga.h>
#include <vgakeyboard.h>

#include "uip.h"
#include "ui.h"
#include "ui-console.h"
#include "vdp.h"
#include "mem68k.h"

#define BANKSIZE 640*480*2

/*** forward reference declarations ***/

static int uip_getshifts(t_uipinfo *uipinfo);

/*** static variables ***/

static uint8 uip_vga = 0;             /* flag for whether in VGA more or not */
static uint8 uip_displaybanknum = 0;  /* view this one, write to other one */
static t_uipinfo *uip_uipinfo = NULL; /* uipinfo */
static uint8 uip_key[256];            /* keyboard state */
static int uip_forceredshift = -1;    /* if set, forces red shift position */
static int uip_forcegreenshift = -1;  /* if set, forces green shift position */
static int uip_forceblueshift = -1;   /* if set, forces blue shift position */

/*** Code ***/

static void uip_keyboardhandler(int scancode, int press) {
  if (scancode >= 256)
    return;
  if (uip_key[scancode] == press)
    return;
  uip_key[scancode] = press;
  if (press) {
    if (scancode == SCANCODE_F1) {
      ui_fkeys|= 1<<1;
    } else if (scancode == SCANCODE_F2) {
      ui_fkeys|= 1<<2;
    } else if (scancode == SCANCODE_F3) {
      ui_fkeys|= 1<<3;
    } else if (scancode == SCANCODE_F4) {
      ui_fkeys|= 1<<4;
    } else if (scancode == SCANCODE_F5) {
      ui_fkeys|= 1<<5;
    } else if (scancode == SCANCODE_F6) {
      ui_fkeys|= 1<<6;
    } else if (scancode == SCANCODE_F7) {
      ui_fkeys|= 1<<7;
    } else if (scancode == SCANCODE_F8) {
      ui_fkeys|= 1<<8;
    } else if (scancode == SCANCODE_F9) {
      ui_fkeys|= 1<<9;
    } else if (scancode == SCANCODE_F10) {
      ui_fkeys|= 1<<10;
    } else if (scancode == SCANCODE_F11) {
      ui_fkeys|= 1<<11;
    } else if (scancode == SCANCODE_F12) {
      ui_fkeys|= 1<<12;
    }
  }
}

int uip_init(t_uipinfo *uipinfo)
{
  uip_uipinfo = uipinfo;
  printf("Initialising svgalib...\n");
  sleep(1);
  if (vga_init()) {
    LOG_CRITICAL(("Failed to initialise SVGALib"));
    return 1;
  }
  return 0;
}

int uip_vgamode(void)
{
  vga_modeinfo *modeinfo;
  int cardmemory;

  uip_vga = 1;
  if (vga_setmode(G640x480x32K) == -1) {
    LOG_CRITICAL(("640x480 @ 32K colours not supported by hardware"));
    LOG_CRITICAL(("Trying 640x480 @ 64K colours..."));
    if (vga_setmode(G640x480x64K) == -1) {
      LOG_CRITICAL(("640x480 @ 64K colours not supported by hardware"));
      uip_textmode();
      LOG_CRITICAL(("Unable to change SVGA mode, mode not supported by "
		    "hardware?"));
      LOG_CRITICAL(("Check /etc/vga/libvga.config to ensure your card "
		    "is not commented out"));
      return 1;
    }
  }
  if (vga_claimvideomemory(2*BANKSIZE) == -1) {
    uip_textmode();
    LOG_CRITICAL(("Unable to allocated video memory - 2MB video card "
		  "required."));
    return 1;
  }
  if ((modeinfo = vga_getmodeinfo(vga_getcurrentmode())) == NULL) {
    uip_textmode();
    LOG_CRITICAL(("Unable to get current mode information"));
    return 1;
  }
  LOG_VERBOSE(("Resolution %dx%d bytesperpixel %d linewidth %d",
	       modeinfo->width, modeinfo->height, modeinfo->bytesperpixel,
	       modeinfo->linewidth));
  if (modeinfo->width != 640 || modeinfo->height != 480 ||
      modeinfo->bytesperpixel != 2 || modeinfo->linewidth*480 > BANKSIZE ||
      (modeinfo->startaddressrange & BANKSIZE) != BANKSIZE) {
    uip_textmode();
    LOG_CRITICAL(("Unexpected mode settings"));
    return 1;
  }
  uip_uipinfo->linewidth = modeinfo->linewidth;
  if (vga_setlinearaddressing() == -1) {
    uip_textmode();
    LOG_CRITICAL(("Linear addressing mode not supported by hardware"));
    return 1;
  }
  if ((uip_uipinfo->screenmem0 = vga_getgraphmem()) == NULL) {
    uip_textmode();
    LOG_CRITICAL(("Failed to find start of screen memory"));
    return 1;
  }
  uip_uipinfo->screenmem1 = uip_uipinfo->screenmem0+BANKSIZE;
  if (uip_forceredshift != -1 && uip_forcegreenshift != -1 &&
      uip_forceblueshift != -1) {
    uip_uipinfo->redshift = uip_forceredshift;
    uip_uipinfo->greenshift = uip_forcegreenshift;
    uip_uipinfo->blueshift = uip_forceblueshift;
  } else {
    switch (modeinfo->colors) {
    case 32768:
      LOG_VERBOSE(("Assuming colour bit positions 10,5,0 for 32k colour mode"));
      uip_uipinfo->blueshift = 0;
      uip_uipinfo->greenshift = 5;
      uip_uipinfo->redshift = 10;
      break;
    case 65536:
      LOG_VERBOSE(("Assuming colour bit positions 11,6,0 for 64k colour mode"));
      uip_uipinfo->blueshift = 0;
      uip_uipinfo->greenshift = 6;
      uip_uipinfo->redshift = 11;
      break;
    default:
      LOG_CRITICAL(("Unknown mode - %d colours?? use -c", modeinfo->colors));
      return 1;
    }
  }
  uip_displaybank(0); /* set current to 0th bank */
  uip_clearscreen(); /* clear bank */
  ui_setupscreen(); /* setup bank */
  uip_displaybank(-1); /* toggle bank */
  uip_clearscreen(); /* clear bank */
  ui_setupscreen(); /* setup bank */
  if (keyboard_init() == -1) {
    uip_textmode();
    LOG_CRITICAL(("Unable to initialise keyboard"));
    return 1;
  }
  memset(uip_key, 0, sizeof(uip_key));
  keyboard_seteventhandler(uip_keyboardhandler);
  return 0;
}

int uip_setcolourbits(int red, int green, int blue)
{
  uip_forceredshift = red;
  uip_forcegreenshift = green;
  uip_forceblueshift = blue;
  return 0;
}

void uip_displaybank(int bank) {
  if (bank == -1)
    bank = uip_displaybanknum ^ 1;
  vga_setdisplaystart(bank ? BANKSIZE : 0);
  uip_uipinfo->screenmem_w = bank ? uip_uipinfo->screenmem0 :
    uip_uipinfo->screenmem1;
  uip_displaybanknum = bank;
}

void uip_clearscreen(void) {
  memset(uip_uipinfo->screenmem_w, 0, BANKSIZE);
}

void uip_clearmiddle(void) {
  int i;

  for (i = 0; i < 240; i++) {
    memset(uip_uipinfo->screenmem_w+(uip_uipinfo->linewidth)*(120+i)+
        160*2, 0, 2*320);
  }
}

/* uip_singlebank sets write address to the current display screen */

void uip_singlebank(void) {
  uip_uipinfo->screenmem_w = uip_displaybanknum ? uip_uipinfo->screenmem1 :
    uip_uipinfo->screenmem0;
}

/* uip_doublebank sets write address to hidden display screen */

void uip_doublebank(void) {
  uip_uipinfo->screenmem_w = uip_displaybanknum ? uip_uipinfo->screenmem0 :
    uip_uipinfo->screenmem1;
}

void uip_textmode(void)
{
  if (uip_vga) {
    keyboard_setdefaulteventhandler();
    vga_setmode(0);
  }
  uip_vga = 0;
}

int uip_checkkeyboard(void)
{
  keyboard_update();
  mem68k_cont1_a = uip_key[SCANCODE_A] ? 1 : 0;
  mem68k_cont1_b = (uip_key[SCANCODE_B] ||
		    uip_key[SCANCODE_S]) ? 1 : 0;
  mem68k_cont1_c = (uip_key[SCANCODE_C] ||
		    uip_key[SCANCODE_D]) ? 1 : 0;
  mem68k_cont1_left = uip_key[SCANCODE_CURSORBLOCKLEFT] ? 1 : 0;
  mem68k_cont1_up = uip_key[SCANCODE_CURSORBLOCKUP] ? 1 : 0;
  mem68k_cont1_right = uip_key[SCANCODE_CURSORBLOCKRIGHT] ? 1 : 0;
  mem68k_cont1_down = uip_key[SCANCODE_CURSORBLOCKDOWN] ? 1 : 0;
  mem68k_cont1_start = uip_key[SCANCODE_ENTER] ? 1 : 0;
  return (uip_key[SCANCODE_ESCAPE] ? 1 : 0);
}

void uip_vsync(void)
{
  vga_waitretrace();
}

unsigned int uip_whichbank(void)
{
  /* returns 0 or 1 - the bank being VIEWED */
  return uip_displaybanknum;
}

uint8 uip_getchar(void)
{
  char c;

  keyboard_setdefaulteventhandler();
  keyboard_close();
  c = getchar();
  keyboard_init();
  memset(uip_key, 0, sizeof(uip_key));
  keyboard_seteventhandler(uip_keyboardhandler);
  return c;
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.