np2/lio/lio.c - diff

Return to lio.c CVS log

Up to [RetroPC.NET] / np2 / lio

Diff for /np2/lio/lio.c between versions 1.8 and 1.14

version 1.8, 2004/02/21 00:25:33	version 1.14, 2004/02/22 00:05:56
Line 9	Line 9
#include "lio.h"	#include "lio.h"


static _LIOWORK liowork;


void lio_initialize(void) {	void lio_initialize(void) {

UINT i;	UINT i;
Line 28 void lio_initialize(void) {	Line 25 void lio_initialize(void) {

void bios_lio(REG8 cmd) {	void bios_lio(REG8 cmd) {

LIOWORK lio;	_GLIO lio;
UINT8 ret;	UINT8 ret;

// TRACEOUT(("lio command %.2x", cmd));	// TRACEOUT(("lio command %.2x", cmd));
	i286_memstr_read(CPU_DS, 0x0620, &lio.work, sizeof(lio.work));
lio = &liowork;	lio.palmode = i286_membyte_read(CPU_DS, 0x0a08);
lio->wait = 500;	lio.wait = 0;
switch(cmd) {	switch(cmd) {
case 0x00: // a0: GINIT	case 0x00: // a0: GINIT
ret = lio_ginit(lio);	ret = lio_ginit(&lio);
break;	break;

case 0x01: // a1: GSCREEN	case 0x01: // a1: GSCREEN
ret = lio_gscreen(lio);	ret = lio_gscreen(&lio);
break;	break;

case 0x02: // a2: GVIEW	case 0x02: // a2: GVIEW
ret = lio_gview(lio);	ret = lio_gview(&lio);
break;	break;

case 0x03: // a3: GCOLOR1	case 0x03: // a3: GCOLOR1
ret = lio_gcolor1(lio);	ret = lio_gcolor1(&lio);
break;	break;

case 0x04: // a4: GCOLOR2	case 0x04: // a4: GCOLOR2
ret = lio_gcolor2(lio);	ret = lio_gcolor2(&lio);
break;	break;

case 0x05: // a5: GCLS	case 0x05: // a5: GCLS
ret = lio_gcls(lio);	ret = lio_gcls(&lio);
break;	break;

case 0x06: // a6: GPSET	case 0x06: // a6: GPSET
ret = lio_gpset(lio);	ret = lio_gpset(&lio);
break;	break;

case 0x07: // a7: GLINE	case 0x07: // a7: GLINE
ret = lio_gline(lio);	ret = lio_gline(&lio);
break;	break;

// case 0x08: // a8: GCIRCLE	// case 0x08: // a8: GCIRCLE
Line 78 void bios_lio(REG8 cmd) {	Line 75 void bios_lio(REG8 cmd) {
// break;	// break;

case 0x0b: // ab: GGET	case 0x0b: // ab: GGET
ret = lio_gget(lio);	ret = lio_gget(&lio);
break;	break;

case 0x0c: // ac: GPUT1	case 0x0c: // ac: GPUT1
ret = lio_gput1(lio);	ret = lio_gput1(&lio);
break;	break;

case 0x0d: // ad: GPUT2	case 0x0d: // ad: GPUT2
ret = lio_gput2(lio);	ret = lio_gput2(&lio);
break;	break;

// case 0x0e: // ae: GROLL	// case 0x0e: // ae: GROLL
// break;	// break;

case 0x0f: // af: GPOINT2	case 0x0f: // af: GPOINT2
ret = lio_gpoint2(lio);	ret = lio_gpoint2(&lio);
break;	break;

// case 0x10: // ce: GCOPY	// case 0x10: // ce: GCOPY
Line 104 void bios_lio(REG8 cmd) {	Line 101 void bios_lio(REG8 cmd) {
break;	break;
}	}
CPU_AH = ret;	CPU_AH = ret;
gdcsub_setslavewait(lio->wait);	if (lio.wait) {
	gdcsub_setslavewait(lio.wait);
	}
}	}


Line 112 void bios_lio(REG8 cmd) {	Line 111 void bios_lio(REG8 cmd) {

const UINT32 lioplaneadrs[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};	const UINT32 lioplaneadrs[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};

void lio_updatedraw(LIOWORK lio) {	void lio_updatedraw(GLIO lio) {

	UINT8 flag;
	UINT8 colorbit;
	SINT16 maxline;
	SINT16 tmp;

	flag = 0;
	colorbit = 3;
	maxline = 399;
	if (lio->palmode == 2) {
	flag \|= LIODRAW_4BPP;
	colorbit = 4;
	}
	switch(lio->work.scrnmode) {
	case 0:
	if (lio->work.pos & 1) {
	flag \|= LIODRAW_UPPER;
	}
	maxline = 199;
	break;

	case 1:
	flag \|= lio->work.pos % colorbit;
	flag \|= LIODRAW_MONO;
	if (lio->work.pos >= colorbit) {
	flag \|= LIODRAW_UPPER;
	}
	maxline = 199;
	break;

	case 2:
	flag \|= lio->work.pos % colorbit;
	flag \|= LIODRAW_MONO;
	break;
	}
	lio->draw.flag = flag;
	lio->draw.palmax = 1 << colorbit;

lio->draw.x1 = max(lio->gview.x1, 0);	tmp = (SINT16)LOADINTELWORD(lio->work.viewx1);
lio->draw.y1 = max(lio->gview.y1, 0);	lio->draw.x1 = max(tmp, 0);
lio->draw.x2 = min(lio->gview.x2, 639);	tmp = (SINT16)LOADINTELWORD(lio->work.viewy1);
lio->draw.y2 = min(lio->gview.x2, (lio->scrn.lines - 1));	lio->draw.y1 = max(tmp, 0);
	tmp = (SINT16)LOADINTELWORD(lio->work.viewx2);
	lio->draw.x2 = min(tmp, 639);
	tmp = (SINT16)LOADINTELWORD(lio->work.viewy2);
	lio->draw.y2 = min(tmp, maxline);
if (!gdcs.access) {	if (!gdcs.access) {
lio->draw.base = 0;	lio->draw.base = 0;
lio->draw.bank = 0;	lio->draw.bank = 0;
Line 133 void lio_updatedraw(LIOWORK lio) {	Line 173 void lio_updatedraw(LIOWORK lio) {

// ----	// ----

static const BYTE bit_l[8] = {0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};	static void pixed8(const _GLIO *lio, UINT addr, REG8 bit, REG8 pal) {
static const BYTE bit_r[8] = {0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe};

static void pixed8(const _LIOWORK *lio, UINT32 vadrs, BYTE bit, REG8 pal) {	BYTE *ptr;

if (lio->scrn.plane & 0x80) {	addr = LOW15(addr);
	vramupdate[addr] \|= lio->draw.sbit;
	ptr = mem + lio->draw.base + addr;
	if (!(lio->draw.flag & LIODRAW_MONO)) {
if (pal & 1) {	if (pal & 1) {
mem[vadrs + VRAM_B] \|= bit;	ptr[VRAM_B] \|= bit;
}	}
else {	else {
mem[vadrs + VRAM_B] &= ~bit;	ptr[VRAM_B] &= ~bit;
}	}
if (pal & 2) {	if (pal & 2) {
mem[vadrs + VRAM_R] \|= bit;	ptr[VRAM_R] \|= bit;
}	}
else {	else {
mem[vadrs + VRAM_R] &= ~bit;	ptr[VRAM_R] &= ~bit;
}	}
if (pal & 4) {	if (pal & 4) {
mem[vadrs + VRAM_G] \|= bit;	ptr[VRAM_G] \|= bit;
}	}
else {	else {
mem[vadrs + VRAM_G] &= ~bit;	ptr[VRAM_G] &= ~bit;
}	}
if (lio->gcolor1.palmode == 2) {	if (lio->draw.flag & LIODRAW_4BPP) {
if (pal & 8) {	if (pal & 8) {
mem[vadrs + VRAM_E] \|= bit;	ptr[VRAM_E] \|= bit;
}	}
else {	else {
mem[vadrs + VRAM_E] &= ~bit;	ptr[VRAM_E] &= ~bit;
}	}
}	}
}	}
else {	else {
vadrs += lioplaneadrs[lio->scrn.plane & 3];	ptr += lioplaneadrs[lio->draw.flag & LIODRAW_PMASK];
if (pal) {	if (pal) {
mem[vadrs] \|= bit;	*ptr \|= bit;
}	}
else {	else {
mem[vadrs] &= ~bit;	*ptr &= ~bit;
}	}
}	}
}	}

void lio_pset(const _LIOWORK *lio, SINT16 x, SINT16 y, REG8 pal) {	void lio_pset(const _GLIO *lio, SINT16 x, SINT16 y, REG8 pal) {

UINT32 adrs;	UINT addr;
BYTE bit;	BYTE bit;

if ((lio->draw.x1 > x) \|\| (lio->draw.x2 < x) \|\|	if ((lio->draw.x1 > x) \|\| (lio->draw.x2 < x) \|\|
(lio->draw.y1 > y) \|\| (lio->draw.y2 < y)) {	(lio->draw.y1 > y) \|\| (lio->draw.y2 < y)) {
return;	return;
}	}
adrs = (y * 80) + (x >> 3);	addr = (y * 80) + (x >> 3);
bit = 0x80 >> (x & 7);	bit = 0x80 >> (x & 7);
if (lio->scrn.top) {	if (lio->draw.flag & LIODRAW_UPPER) {
adrs += 16000;	addr += 16000;
}	}
vramupdate[adrs] \|= lio->draw.sbit;
gdcs.grphdisp \|= lio->draw.sbit;	gdcs.grphdisp \|= lio->draw.sbit;
adrs += lio->draw.base;	pixed8(lio, addr, bit, pal);
pixed8(lio, adrs, bit, pal);
}	}

void lio_line(const _LIOWORK *lio, SINT16 x1, SINT16 x2, SINT16 y, REG8 pal) {	#if 0
	void lio_line(const _GLIO *lio, SINT16 x1, SINT16 x2, SINT16 y, REG8 pal) {

UINT adrs;	UINT addr;
UINT32 vadrs;	BYTE bit, dbit;
BYTE bit, dbit, sbit;
SINT16 width;	SINT16 width;

if ((lio->draw.y1 > y) \|\| (lio->draw.y2 < y)) {	if ((lio->draw.y1 > y) \|\| (lio->draw.y2 < y)) {
Line 217 void lio_line(const _LIOWORK *lio, SINT1	Line 257 void lio_line(const _LIOWORK *lio, SINT1
if (width <= 0) {	if (width <= 0) {
return;	return;
}	}
adrs = (y * 80) + (x1 >> 3);	addr = (y * 80) + (x1 >> 3);
bit = 0x80 >> (x1 & 7);	bit = 0x80 >> (x1 & 7);
if (lio->scrn.top) {	if (lio->draw.flag & LIODRAW_UPPER) {
adrs += 16000;	addr += 16000;
}
if (!lio->scrn.bank) {
vadrs = adrs;
sbit = 1;
gdcs.grphdisp \|= 1;
}	}
else {	gdcs.grphdisp \|= lio->draw.sbit;
vadrs = adrs + VRAM_STEP;
sbit = 2;
gdcs.grphdisp \|= 2;
}

dbit = 0;	dbit = 0;
while(bit && width--) {	while((bit) && (width)) {
dbit \|= bit;	dbit \|= bit;
bit >>= 1;	bit >>= 1;
	width--;
}	}
pixed8(lio, vadrs++, dbit, pal);	pixed8(lio, addr, dbit, pal);
vramupdate[adrs++] \|= sbit;	addr++;
while(width >= 8) {	while(width >= 8) {
width -= 8;	width -= 8;
pixed8(lio, vadrs++, 0xff, pal);	pixed8(lio, addr, 0xff, pal);
vramupdate[adrs++] \|= sbit;	addr++;
}	}
dbit = 0;	dbit = 0;
bit = 0x80;	bit = 0x80;
while(bit && width--) {	while((bit) && (width)) {
dbit \|= bit;	dbit \|= bit;
bit >>= 1;	bit >>= 1;
	width--;
}	}
if (dbit) {	if (dbit) {
pixed8(lio, vadrs, dbit, pal);	pixed8(lio, addr, dbit, pal);
vramupdate[adrs] \|= sbit;
}	}
}	}
	#endif


	#if 0
void lio_look(UINT vect) {	void lio_look(UINT vect) {

BYTE work[16];	BYTE work[16];
Line 281 void lio_look(UINT vect) {	Line 314 void lio_look(UINT vect) {
work[6], work[7], work[8], work[9]));	work[6], work[7], work[8], work[9]));
}	}
}	}
	#endif

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.8
changed lines
	Added in v.1.14