np2/lio/gput1.c - diff

Return to gput1.c CVS log

Up to [RetroPC.NET] / np2 / lio

Diff for /np2/lio/gput1.c between versions 1.6 and 1.16

version 1.6, 2004/02/20 16:20:41	version 1.16, 2005/02/07 14:46:12
Line 8	Line 8


typedef struct {	typedef struct {
BYTE x1[2];	UINT8 x1[2];
BYTE y1[2];	UINT8 y1[2];
BYTE x2[2];	UINT8 x2[2];
BYTE y2[2];	UINT8 y2[2];
BYTE off[2];	UINT8 off[2];
BYTE seg[2];	UINT8 seg[2];
BYTE leng[2];	UINT8 leng[2];
} GGET;	} GGET;

typedef struct {	typedef struct {
BYTE x[2];	UINT8 x[2];
BYTE y[2];	UINT8 y[2];
BYTE off[2];	UINT8 off[2];
BYTE seg[2];	UINT8 seg[2];
BYTE leng[2];	UINT8 leng[2];
BYTE mode;	UINT8 mode;
BYTE colorsw;	UINT8 colorsw;
BYTE fg;	UINT8 fg;
BYTE bg;	UINT8 bg;
} GPUT1;	} GPUT1;

typedef struct {	typedef struct {
BYTE x[2];	UINT8 x[2];
BYTE y[2];	UINT8 y[2];
BYTE chr[2];	UINT8 chr[2];
BYTE mode;	UINT8 mode;
BYTE colorsw;	UINT8 colorsw;
BYTE fg;	UINT8 fg;
BYTE bg;	UINT8 bg;
} GPUT2;	} GPUT2;

typedef struct {	typedef struct {
Line 53 typedef struct {	Line 53 typedef struct {
} LIOPUT;	} LIOPUT;

typedef struct {	typedef struct {
BYTE *baseptr;	UINT8 *baseptr;
	UINT addr;
	UINT sft;
	UINT width;
	UINT8 mask;
	} GETCNTX;

	typedef struct {
	UINT8 *baseptr;
UINT addr;	UINT addr;
UINT sft;	UINT sft;
UINT width;	UINT width;
Line 61 typedef struct {	Line 69 typedef struct {
UINT8 maskr;	UINT8 maskr;
UINT8 masklr;	UINT8 masklr;
UINT8 mask;	UINT8 mask;
BYTE pat[84];	UINT8 pat[84];
} PUTCNTX;	} PUTCNTX;

#if 0
static void getvram(const PUTCNTX *pt) {

BYTE *baseptr;	static void getvram(const GETCNTX gt, UINT8 dst) {

	UINT8 *baseptr;
UINT addr;	UINT addr;
BYTE *dst;
UINT width;	UINT width;
UINT dat;	UINT dat;
UINT sft;	UINT sft;

baseptr = pt->baseptr;	baseptr = gt->baseptr;
addr = pt->addr;	addr = gt->addr;
src = pt->pat;	width = gt->width;
width = pt->width;	sft = 8 - gt->sft;
sft = 8 - pt->sft;
dat = baseptr[LOW15(addr)];	dat = baseptr[LOW15(addr)];
addr++;	addr++;
while(width > 8) {	while(width > 8) {
Line 86 static void getvram(const PUTCNTX *pt) {	Line 92 static void getvram(const PUTCNTX *pt) {
dat = (dat << 8) + baseptr[LOW15(addr)];	dat = (dat << 8) + baseptr[LOW15(addr)];
addr++;	addr++;
*dst = (UINT8)(dat >> sft);	*dst = (UINT8)(dat >> sft);
dst++	dst++;
}	}
dat = (dat << 8) + baseptr[LOW15(addr)];	dat = (dat << 8) + baseptr[LOW15(addr)];
*dst = (UINT8)((dat >> sft) & pt->mask);	*dst = (UINT8)((dat >> sft) & gt->mask);
}	}
#endif

static void setdirty(UINT addr, UINT width, UINT height, REG8 bit) {	static void setdirty(UINT addr, UINT width, UINT height, REG8 bit) {

Line 111 static void setdirty(UINT addr, UINT wid	Line 116 static void setdirty(UINT addr, UINT wid

static void putor(const PUTCNTX *pt) {	static void putor(const PUTCNTX *pt) {

BYTE *baseptr;	UINT8 *baseptr;
UINT addr;	UINT addr;
const BYTE *src;	const UINT8 *src;
UINT width;	UINT width;
UINT dat;	UINT dat;

Line 145 const BYTE *src;	Line 150 const BYTE *src;

static void putorn(const PUTCNTX *pt) {	static void putorn(const PUTCNTX *pt) {

BYTE *baseptr;	UINT8 *baseptr;
UINT addr;	UINT addr;
const BYTE *src;	const UINT8 *src;
UINT width;	UINT width;
UINT dat;	UINT dat;

Line 179 const BYTE *src;	Line 184 const BYTE *src;

static void putand(const PUTCNTX *pt) {	static void putand(const PUTCNTX *pt) {

BYTE *baseptr;	UINT8 *baseptr;
UINT addr;	UINT addr;
const BYTE *src;	const UINT8 *src;
UINT width;	UINT width;
UINT dat;	UINT dat;

Line 213 const BYTE *src;	Line 218 const BYTE *src;

static void putandn(const PUTCNTX *pt) {	static void putandn(const PUTCNTX *pt) {

BYTE *baseptr;	UINT8 *baseptr;
UINT addr;	UINT addr;
const BYTE *src;	const UINT8 *src;
UINT width;	UINT width;
UINT dat;	UINT dat;

Line 247 const BYTE *src;	Line 252 const BYTE *src;

static void putxor(const PUTCNTX *pt) {	static void putxor(const PUTCNTX *pt) {

BYTE *baseptr;	UINT8 *baseptr;
UINT addr;	UINT addr;
const BYTE *src;	const UINT8 *src;
UINT width;	UINT width;
UINT dat;	UINT dat;

Line 281 const BYTE *src;	Line 286 const BYTE *src;

static void putxorn(const PUTCNTX *pt) {	static void putxorn(const PUTCNTX *pt) {

BYTE *baseptr;	UINT8 *baseptr;
UINT addr;	UINT addr;
const BYTE *src;	const UINT8 *src;
UINT width;	UINT width;
UINT dat;	UINT dat;

Line 316 const BYTE *src;	Line 321 const BYTE *src;

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

static REG8 putsub(LIOWORK lio, const LIOPUT *lput) {	static REG8 putsub(GLIO lio, const LIOPUT *lput) {

UINT addr;	UINT addr;
UINT8 sbit;
PUTCNTX pt;	PUTCNTX pt;
UINT datacnt;	UINT datacnt;
UINT off;	UINT off;
Line 328 static REG8 putsub(LIOWORK lio, const LI	Line 332 static REG8 putsub(LIOWORK lio, const LI
UINT pl;	UINT pl;
UINT writecnt;	UINT writecnt;

if ((lput->x < lio->range.x1) \|\|	if ((lput->x < lio->draw.x1) \|\|
(lput->y < lio->range.y1) \|\|	(lput->y < lio->draw.y1) \|\|
((lput->x + lput->width) > lio->range.x2) \|\|	((lput->x + lput->width - 1) > lio->draw.x2) \|\|
((lput->y + lput->height) > lio->range.y2)) {	((lput->y + lput->height - 1) > lio->draw.y2)) {
return(LIO_ILLEGALFUNC);	return(LIO_ILLEGALFUNC);
}	}
if ((lput->width <= 0) \|\| (lput->height <= 0)) {	if ((lput->width <= 0) \|\| (lput->height <= 0)) {
Line 339 static REG8 putsub(LIOWORK lio, const LI	Line 343 static REG8 putsub(LIOWORK lio, const LI
}	}

addr = (lput->x >> 3) + (lput->y * 80);	addr = (lput->x >> 3) + (lput->y * 80);
if (lio->scrn.top) {	if (lio->draw.flag & LIODRAW_UPPER) {
addr += 16000;	addr += 16000;
}	}
if (!lio->scrn.bank) {	setdirty(addr, (lput->x & 7) + lput->width, lput->height, lio->draw.sbit);
sbit = 1;
}
else {
addr += VRAM_STEP;
sbit = 2;
}
setdirty(addr, (lput->x & 7) + lput->width, lput->height, sbit);

	pt.addr = addr;
pt.sft = lput->x & 7;	pt.sft = lput->x & 7;
pt.width = lput->width;	pt.width = lput->width;
pt.maskl = (UINT8)(0xff >> pt.sft);	pt.maskl = (UINT8)(0xff >> pt.sft);
Line 360 static REG8 putsub(LIOWORK lio, const LI	Line 358 static REG8 putsub(LIOWORK lio, const LI
datacnt = (lput->width + 7) >> 3;	datacnt = (lput->width + 7) >> 3;
off = lput->off;	off = lput->off;

flag = (lio->gcolor1.palmode == 2)?0x0f:0x07;	flag = (lio->draw.flag & LIODRAW_4BPP)?0x0f:0x07;
flag \|= (lput->fg & 15) << 4;	flag \|= (lput->fg & 15) << 4;
flag \|= (lput->bg & 15) << 8;	flag \|= (lput->bg & 15) << 8;

TRACEOUT(("mode = %d [%.x]", lput->mode, flag));

// ��ɽ��	// ��ɽ��
writecnt = 0;	writecnt = 0;
for (pl=0; pl<4; pl++) {	height = lput->height;
if (flag & 1) {	do {
pt.baseptr = mem + lioplaneadrs[pl];	flag <<= 4;
pt.addr = addr;	for (pl=0; pl<4; pl++) {
height = lput->height;	flag >>= 1;
do {	if (flag & 8) {
i286_memstr_read(lput->seg, off, pt.pat, datacnt);	pt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
off += datacnt;	MEML_READSTR(lput->seg, off, pt.pat, datacnt);
	if (lput->sw) {
	off += datacnt;
	}
switch(lput->mode) {	switch(lput->mode) {
case 0: // PSET	case 0: // PSET
if (flag & (1 << 4)) {	if (flag & (8 << 4)) {
putor(&pt);	putor(&pt);
}	}
else {	else {
putandn(&pt);	putandn(&pt);
}	}
if (flag & (1 << 8)) {	if (flag & (8 << 8)) {
putorn(&pt);	putorn(&pt);
}	}
else {	else {
Line 394 static REG8 putsub(LIOWORK lio, const LI	Line 393 static REG8 putsub(LIOWORK lio, const LI
break;	break;

case 1: // NOT	case 1: // NOT
if (!(flag & (1 << 4))) {	if (!(flag & (8 << 4))) {
putor(&pt);	putor(&pt);
}	}
else {	else {
putandn(&pt);	putandn(&pt);
}	}
if (!(flag & (1 << 8))) {	if (!(flag & (8 << 8))) {
putorn(&pt);	putorn(&pt);
}	}
else {	else {
Line 410 static REG8 putsub(LIOWORK lio, const LI	Line 409 static REG8 putsub(LIOWORK lio, const LI
break;	break;

case 2: // OR	case 2: // OR
if (flag & (1 << 4)) {	if (flag & (8 << 4)) {
putor(&pt);	putor(&pt);
writecnt++;	writecnt++;
}	}
if (flag & (1 << 8)) {	if (flag & (8 << 8)) {
putorn(&pt);	putorn(&pt);
writecnt++;	writecnt++;
}	}
break;	break;

case 3: // AND	case 3: // AND
if (!(flag & (1 << 4))) {	if (!(flag & (8 << 4))) {
putandn(&pt);	putandn(&pt);
writecnt++;	writecnt++;
}	}
if (!(flag & (1 << 8))) {	if (!(flag & (8 << 8))) {
putand(&pt);	putand(&pt);
writecnt++;	writecnt++;
}	}
break;	break;

case 4: // XOR	case 4: // XOR
if (flag & (1 << 4)) {	if (flag & (8 << 4)) {
putxor(&pt);	putxor(&pt);
writecnt++;	writecnt++;
}	}
if (flag & (1 << 8)) {	if (flag & (8 << 8)) {
putxorn(&pt);	putxorn(&pt);
writecnt++;	writecnt++;
}	}
break;	break;
}	}
pt.addr += 80;
} while(--height);
if (!lput->sw) {
off = lput->off;
}	}
}	}
flag >>= 1;	pt.addr += 80;
}	if (!lput->sw) {
	off += datacnt;
	}
	} while(--height);
lio->wait += writecnt * datacnt * (10 + 10 + 10);	lio->wait += writecnt * datacnt * (10 + 10 + 10);
return(LIO_SUCCESS);	return(LIO_SUCCESS);
}	}
Line 457 static REG8 putsub(LIOWORK lio, const LI	Line 455 static REG8 putsub(LIOWORK lio, const LI

// ---- GGET	// ---- GGET

REG8 lio_gget(LIOWORK lio) {	REG8 lio_gget(GLIO lio) {

GGET dat;	GGET dat;
	SINT32 x;
	SINT32 y;
	int x2;
	int y2;
	UINT off;
	UINT seg;
	UINT32 leng;
	UINT32 size;
	UINT datacnt;
	UINT mask;
	GETCNTX gt;
	UINT8 pat[84];
	UINT pl;

lio_updaterange(lio);	lio_updatedraw(lio);
i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));	MEML_READSTR(CPU_DS, CPU_BX, &dat, sizeof(dat));
	x = (SINT16)LOADINTELWORD(dat.x1);
	y = (SINT16)LOADINTELWORD(dat.y1);
	x2 = (SINT16)LOADINTELWORD(dat.x2);
	y2 = (SINT16)LOADINTELWORD(dat.y2);
	if ((x < lio->draw.x1) \|\| (y < lio->draw.y1) \|\|
	(x2 > lio->draw.x2) \|\| (y2 > lio->draw.y2)) {
	return(LIO_ILLEGALFUNC);
	}
	x2 = x2 - x + 1;
	y2 = y2 - y + 1;
	if ((x2 <= 0) \|\| (y2 <= 0)) {
	return(LIO_ILLEGALFUNC);
	}
	off = LOADINTELWORD(dat.off);
	seg = (SINT16)LOADINTELWORD(dat.seg);

return(0);	datacnt = (x2 + 7) >> 3;
	size = datacnt * y2;
	leng = LOADINTELWORD(dat.leng);
	if (!(lio->draw.flag & LIODRAW_MONO)) {
	if (lio->draw.flag & LIODRAW_4BPP) {
	size *= 4;
	mask = 0x0f;
	}
	else {
	size *= 3;
	mask = 0x07;
	}
	}
	else {
	mask = 1 << (lio->draw.flag & LIODRAW_PMASK);
	}
	if (leng < (size + 4)) {
	return(LIO_ILLEGALFUNC);
	}
	MEML_WRITE16(seg, off, (REG16)x2);
	MEML_WRITE16(seg, off+2, (REG16)y2);
	off += 4;
	gt.addr = (x >> 3) + (y * 80);
	if (lio->draw.flag & LIODRAW_UPPER) {
	gt.addr += 16000;
	}
	gt.sft = x & 7;
	gt.width = x2;
	gt.mask = (UINT8)((~0x7f) >> ((x2 - 1) & 7));
	do {
	mask <<= 4;
	for (pl=0; pl<4; pl++) {
	mask >>= 1;
	if (mask & 8) {
	gt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
	getvram(&gt, pat);
	MEML_WRITESTR(seg, off, pat, datacnt);
	off += datacnt;
	}
	}
	gt.addr += 80;
	} while(--y2);
	lio->wait = size * 12;
	return(LIO_SUCCESS);
}	}


// ---- GPUT1	// ---- GPUT1

REG8 lio_gput1(LIOWORK lio) {	REG8 lio_gput1(GLIO lio) {

GPUT1 dat;	GPUT1 dat;
LIOPUT lput;	LIOPUT lput;
UINT leng;	UINT leng;
UINT size;	UINT size;

lio_updaterange(lio);	lio_updatedraw(lio);
i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));	MEML_READSTR(CPU_DS, CPU_BX, &dat, sizeof(dat));
lput.x = (SINT16)LOADINTELWORD(dat.x);	lput.x = (SINT16)LOADINTELWORD(dat.x);
lput.y = (SINT16)LOADINTELWORD(dat.y);	lput.y = (SINT16)LOADINTELWORD(dat.y);
lput.off = (UINT16)(LOADINTELWORD(dat.off) + 4);	lput.off = (UINT16)(LOADINTELWORD(dat.off) + 4);
lput.seg = LOADINTELWORD(dat.seg);	lput.seg = LOADINTELWORD(dat.seg);
lput.mode = dat.mode;	lput.mode = dat.mode;
leng = LOADINTELWORD(dat.leng);	leng = LOADINTELWORD(dat.leng);
lput.width = i286_memword_read(lput.seg, lput.off - 4);	lput.width = MEML_READ16(lput.seg, lput.off - 4);
lput.height = i286_memword_read(lput.seg, lput.off - 2);	lput.height = MEML_READ16(lput.seg, lput.off - 2);
size = ((lput.width + 7) >> 3) * lput.height;	size = ((lput.width + 7) >> 3) * lput.height;
if (leng < (size + 4)) {	if (leng < (size + 4)) {
return(LIO_ILLEGALFUNC);	return(LIO_ILLEGALFUNC);
Line 498 REG8 lio_gput1(LIOWORK lio) {	Line 567 REG8 lio_gput1(LIOWORK lio) {
lput.bg = dat.bg;	lput.bg = dat.bg;
}	}
else {	else {
lput.fg = lio->gcolor1.fgcolor;	lput.fg = lio->work.fgcolor;
lput.bg = lio->gcolor1.bgcolor;	lput.bg = lio->work.bgcolor;
}	}
}	}
else {	else {
Line 511 REG8 lio_gput1(LIOWORK lio) {	Line 580 REG8 lio_gput1(LIOWORK lio) {
else {	else {
lput.sw = 1;	lput.sw = 1;
lput.fg = 0x0f;	lput.fg = 0x0f;
lput.bg = 0x0f;	lput.bg = 0;
}	}
}	}
return(putsub(lio, &lput));	return(putsub(lio, &lput));
Line 520 REG8 lio_gput1(LIOWORK lio) {	Line 589 REG8 lio_gput1(LIOWORK lio) {

// ---- GPUT2	// ---- GPUT2

REG8 lio_gput2(LIOWORK lio) {	REG8 lio_gput2(GLIO lio) {

GPUT2 dat;	GPUT2 dat;
LIOPUT lput;	LIOPUT lput;
UINT16 jis;	UINT16 jis;
	int pat;
REG16 size;	REG16 size;

lio_updaterange(lio);	lio_updatedraw(lio);
i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));	MEML_READSTR(CPU_DS, CPU_BX, &dat, sizeof(dat));
lput.x = (SINT16)LOADINTELWORD(dat.x);	lput.x = (SINT16)LOADINTELWORD(dat.x);
lput.y = (SINT16)LOADINTELWORD(dat.y);	lput.y = (SINT16)LOADINTELWORD(dat.y);
	lput.off = 0x104e;
	lput.seg = CPU_DS;
jis = LOADINTELWORD(dat.chr);	jis = LOADINTELWORD(dat.chr);
if (jis & 0xff00) {	pat = 0;
lput.off = 0x104e;	if (jis < 0x200) {
lput.seg = CPU_DS;	if (jis < 0x80) {
if (jis < 0x200) { // 1/4ANK	if (jis == 0x7c) {
	pat = 1;
	}
	else if (jis == 0x7e) {
	pat = 2;
	}
	else {
	jis += 0x2900;
	}
	}
	else if (jis < 0x100) {
	if ((jis - 0x20) & 0x40) {
	pat = (jis & 0x3f) + 3;
	}
	else {
	jis += 0x2980;
	}
	}
	else {
jis &= 0xff;	jis &= 0xff;
}	}
	}
	if (!pat) {
size = bios0x18_14(lput.seg, 0x104c, jis);	size = bios0x18_14(lput.seg, 0x104c, jis);
lput.width = (size & 0xff00) >> (8 - 3);
lput.height = (size & 0xff) << 3;
}	}
else {	else {
return(0);	MEML_WRITESTR(lput.seg, lput.off, mem + (LIO_SEGMENT << 4) +
	LIO_FONT + ((pat - 1) << 4), 0x10);
	size = 0x0102;
}	}
	lput.width = (size & 0xff00) >> (8 - 3);
	lput.height = (size & 0xff) << 3;
lput.mode = dat.mode;	lput.mode = dat.mode;
lput.sw = 0;	lput.sw = 0;
if (dat.colorsw) {	if (dat.colorsw) {
Line 552 REG8 lio_gput2(LIOWORK lio) {	Line 646 REG8 lio_gput2(LIOWORK lio) {
lput.bg = dat.bg;	lput.bg = dat.bg;
}	}
else {	else {
lput.fg = lio->gcolor1.fgcolor;	lput.fg = lio->work.fgcolor;
lput.bg = lio->gcolor1.bgcolor;	lput.bg = lio->work.bgcolor;
}	}
return(putsub(lio, &lput));	return(putsub(lio, &lput));
}	}

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

Removed from v.1.6
changed lines
	Added in v.1.16