1 /* Project 16 Source Code~
\r
2 * Copyright (C) 2012-2015 sparky4 & pngwen & andrius4669
\r
4 * This file is part of Project 16.
\r
6 * Project 16 is free software; you can redistribute it and/or modify
\r
7 * it under the terms of the GNU General Public License as published by
\r
8 * the Free Software Foundation; either version 3 of the License, or
\r
9 * (at your option) any later version.
\r
11 * Project 16 is distributed in the hope that it will be useful,
\r
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
14 * GNU General Public License for more details.
\r
16 * You should have received a copy of the GNU General Public License
\r
17 * along with this program. If not, see <http://www.gnu.org/licenses/>, or
\r
18 * write to the Free Software Foundation, Inc., 51 Franklin Street,
\r
19 * Fifth Floor, Boston, MA 02110-1301 USA.
\r
26 #include "src/lib/modex16.h"
\r
28 byte far* VGA=(byte far*) 0xA0000000; /* this points to video memory. */
\r
30 static void fadePalette(sbyte fade, sbyte start, word iter, byte *palette);
\r
31 static byte tmppal[PAL_SIZE];
\r
33 /////////////////////////////////////////////////////////////////////////////
\r
35 // setvideo() - This function Manages the video modes //
\r
37 /////////////////////////////////////////////////////////////////////////////
\r
38 void VGAmodeX(sword vq, global_game_variables_t *gv)
\r
44 case 0: // deinit the video
\r
45 // change to the video mode we were in before we switched to mode 13h
\r
48 in.h.al = gv->video.old_mode;
\r
49 int86(0x10, &in, &out);
\r
51 default: // init the video
\r
52 // get old video mode
\r
54 //int86(0x10, &in, &out);
\r
55 gv->video.old_mode = vgaGetMode();//out.h.al;
\r
63 vgaSetMode(byte mode)
\r
67 regs.h.ah = SET_MODE;
\r
69 int86(VIDEO_INT, ®s, ®s);
\r
72 //---------------------------------------------------
\r
74 // Use the bios to get the current video mode
\r
83 int86(VIDEO_INT, &rg, &rg);
\r
88 /* -========================= Entry Points ==========================- */
\r
90 modexEnter(sword vq, global_game_variables_t *gv)
\r
93 dword far*ptr=(dword far*)VGA; /* used for faster screen clearing */
\r
95 /* common mode X initiation stuff~ */
\r
96 modexsetBaseXMode(gv->video.page);
\r
101 CRTParmCount = sizeof(ModeX_320x240regs) / sizeof(ModeX_320x240regs[0]);
\r
102 /* width and height */
\r
103 gv->video.page[0].sw=320;
\r
104 gv->video.page[0].sh=240;
\r
106 /* send the CRTParms */
\r
107 for(i=0; i<CRTParmCount; i++) {
\r
108 outpw(CRTC_INDEX, ModeX_320x240regs[i]);
\r
111 /* clear video memory */
\r
112 outpw(SC_INDEX, 0x0f02);
\r
113 for(i=0; i<0x8000; i++) {
\r
118 CRTParmCount = sizeof(ModeX_160x120regs) / sizeof(ModeX_160x120regs[0]);
\r
119 /* width and height */
\r
120 gv->video.page[0].sw=120;
\r
121 gv->video.page[0].sh=160;
\r
123 /* send the CRTParms */
\r
124 for(i=0; i<CRTParmCount; i++) {
\r
125 outpw(CRTC_INDEX, ModeX_160x120regs[i]);
\r
128 /* clear video memory */
\r
129 outpw(SC_INDEX, 0x0f02);
\r
130 for(i=0; i<0x8000; i++) {
\r
135 CRTParmCount = sizeof(ModeX_320x200regs) / sizeof(ModeX_320x200regs[0]);
\r
136 /* width and height */
\r
137 gv->video.page[0].sw=320;
\r
138 gv->video.page[0].sh=200;
\r
140 /* send the CRTParms */
\r
141 for(i=0; i<CRTParmCount; i++) {
\r
142 outpw(CRTC_INDEX, ModeX_320x200regs[i]);
\r
145 /* clear video memory */
\r
146 outpw(SC_INDEX, 0x0f02);
\r
147 for(i=0; i<0x8000; i++) {
\r
152 CRTParmCount = sizeof(ModeX_192x144regs) / sizeof(ModeX_192x144regs[0]);
\r
153 /* width and height */
\r
154 gv->video.page[0].sw=192;
\r
155 gv->video.page[0].sh=144;
\r
157 /* send the CRTParms */
\r
158 for(i=0; i<CRTParmCount; i++) {
\r
159 outpw(CRTC_INDEX, ModeX_192x144regs[i]);
\r
162 /* clear video memory */
\r
163 outpw(SC_INDEX, 0x0f02);
\r
164 for(i=0; i<0x8000; i++) {
\r
169 CRTParmCount = sizeof(ModeX_256x192regs) / sizeof(ModeX_256x192regs[0]);
\r
170 /* width and height */
\r
171 gv->video.page[0].sw=256;
\r
172 gv->video.page[0].sh=192;
\r
174 /* send the CRTParms */
\r
175 for(i=0; i<CRTParmCount; i++) {
\r
176 outpw(CRTC_INDEX, ModeX_256x192regs[i]);
\r
179 /* clear video memory */
\r
180 outpw(SC_INDEX, 0x0f02);
\r
181 for(i=0; i<0x8000; i++) {
\r
186 gv->video.page[0].tilesw = gv->video.page[0].sw/TILEWH;
\r
187 gv->video.page[0].tilesh = gv->video.page[0].sh/TILEWH;
\r
188 //TODO MAKE FLEXIBLE~
\r
189 gv->video.page[0].tilemidposscreenx = gv->video.page[0].tilesw;
\r
190 gv->video.page[0].tilemidposscreeny = (gv->video.page[0].tilesh/2)+1;
\r
191 #define PAGE_SIZE (word)(gv->video.page[0].sw/4 * gv->video.page[0].sh)
\r
196 /* TODO restore original mode and palette */
\r
197 vgaSetMode(TEXT_MODE);
\r
200 // setBaseXMode() does the initialization to make the VGA ready to
\r
201 // accept any combination of configuration register settings. This
\r
202 // involves enabling writes to index 0 to 7 of the CRT controller (port
\r
203 // 0x3D4), by clearing the most significant bit (bit 7) of index 0x11.
\r
205 modexsetBaseXMode(page_t *page)
\r
208 /* TODO save current video mode and palette */
\r
209 vgaSetMode(VGA_256_COLOR_MODE);
\r
211 /* disable chain4 mode */
\r
212 outpw(SC_INDEX, 0x0604);
\r
214 /* synchronous reset while setting Misc Output */
\r
215 outpw(SC_INDEX, 0x0100);
\r
217 /* select 25 MHz dot clock & 60 Hz scanning rate */
\r
218 outp(MISC_OUTPUT, 0xe3);
\r
220 /* undo reset (restart sequencer) */
\r
221 outpw(SC_INDEX, 0x0300);
\r
223 /* reprogram the CRT controller */
\r
224 outp(CRTC_INDEX, 0x11); /* VSync End reg contains register write prot */
\r
225 // temp = inp(CRTC_DATA) & 0x7F;
\r
226 // outp(CRTC_INDEX, 0x11);
\r
227 outp(CRTC_DATA, 0x7f); /* get current write protect on varios regs */
\r
228 // outp(CRTC_DATA, temp); /* get current write protect on varios regs */
\r
232 modexDefaultPage(page_t *p)
\r
236 /* default page values */
\r
242 page.width = p->sw;
\r
243 page.height = p->sh;
\r
244 page.tw = page.sw/TILEWH;
\r
245 page.th = page.sh/TILEWH;
\r
246 page.tilemidposscreenx = page.tw/2;
\r
247 page.tilemidposscreeny = (page.th/2)+1;
\r
248 page.tilesw=p->tilesw;
\r
249 page.tilesh=p->tilesh;
\r
250 //pageSize = p->sw*p->sh;
\r
256 /* returns the next page in contiguous memory
\r
257 * the next page will be the same size as p, by default
\r
260 modexNextPage(page_t *p) {
\r
263 result.data = p->data + (p->width/4)*p->height;
\r
266 result.width = p->width;
\r
267 result.height = p->height;
\r
268 result.tw = p->width/TILEWH;
\r
269 result.th = p->height/TILEWH;
\r
270 result.id = p->id+1;
\r
273 // return modexNextPageFlexibleSize(&p, p->width, p->height);
\r
276 //next page with defined dimentions~
\r
278 modexNextPageFlexibleSize(page_t *p, word x, word y)
\r
282 result.data = p->data + (p->width/4)*p->height; /* compute the offset */
\r
287 result.tw = p->width/TILEWH;
\r
288 result.th = p->height/TILEWH;
\r
289 result.id = p->id+1;
\r
296 modexShowPage(page_t *page) {
\r
302 /* calculate offset */
\r
303 offset = (word) page->data;
\r
304 offset += page->dy * (page->width >> 2 );
\r
305 offset += page->dx >> 2;
\r
307 /* calculate crtcOffset according to virtual width */
\r
308 crtcOffset = page->width >> 3;
\r
310 high_address = HIGH_ADDRESS | (offset & 0xff00);
\r
311 low_address = LOW_ADDRESS | (offset << 8);
\r
313 /* wait for appropriate timing and then program CRTC */
\r
314 while ((inp(INPUT_STATUS_1) & DISPLAY_ENABLE));
\r
315 outpw(CRTC_INDEX, high_address);
\r
316 outpw(CRTC_INDEX, low_address);
\r
317 outp(CRTC_INDEX, 0x13);
\r
318 outp(CRTC_DATA, crtcOffset);
\r
320 /* wait for one retrace */
\r
321 while (!(inp(INPUT_STATUS_1) & VRETRACE));
\r
323 /* do PEL panning here */
\r
324 outp(AC_INDEX, 0x33);
\r
325 outp(AC_INDEX, (page->dx & 0x03) << 1);
\r
330 modexPanPage(page_t *page, int dx, int dy) {
\r
337 modexSelectPlane(byte plane) {
\r
338 outp(SC_INDEX, MAP_MASK); /* select plane */
\r
339 outp(SC_DATA, plane);
\r
344 modexClearRegion(page_t *page, int x, int y, int w, int h, byte color) {
\r
345 word pageOff = (word) page->data;
\r
346 word xoff=x/4; /* xoffset that begins each row */
\r
347 word scanCount=w/4; /* number of iterations per row (excluding right clip)*/
\r
348 word poffset = pageOff + y*(page->width/4) + xoff; /* starting offset */
\r
349 word nextRow = page->width/4-scanCount-1; /* loc of next row */
\r
350 byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08}; /* clips for rectangles not on 4s */
\r
351 byte rclip[] = {0x00, 0x01, 0x03, 0x07};
\r
352 byte left = lclip[x&0x03];
\r
353 byte right = rclip[(x+w)&0x03];
\r
355 /* handle the case which requires an extra group */
\r
356 if((x & 0x03) && !((x+w) & 0x03)) {
\r
361 MOV AX, SCREEN_SEG ; go to the VGA memory
\r
363 MOV DI, poffset ; go to the first pixel
\r
364 MOV DX, SC_INDEX ; point to the map mask
\r
368 MOV AL, color ; get ready to write colors
\r
370 MOV CX, scanCount ; count the line
\r
371 MOV BL, AL ; remember color
\r
372 MOV AL, left ; do the left clip
\r
373 OUT DX, AL ; set the left clip
\r
374 MOV AL, BL ; restore color
\r
375 STOSB ; write the color
\r
377 JZ SCAN_DONE ; handle 1 group stuff
\r
379 ;-- write the main body of the scanline
\r
380 MOV BL, AL ; remember color
\r
381 MOV AL, 0x0f ; write to all pixels
\r
383 MOV AL, BL ; restore color
\r
384 REP STOSB ; write the color
\r
386 MOV BL, AL ; remeber color
\r
388 OUT DX, AL ; do the right clip
\r
389 MOV AL, BL ; restore color
\r
390 STOSB ; write pixel
\r
391 ADD DI, nextRow ; go to the next row
\r
397 /* moved to src/lib/modex16/16render.c */
\r
399 /* copy a region of video memory from one page to another.
\r
400 * It assumes that the left edge of the tile is the same on both
\r
401 * regions and the memory areas do not overlap.
\r
404 modexCopyPageRegion(page_t *dest, page_t *src,
\r
407 word width, word height)
\r
409 word doffset = (word)dest->data + dy*(dest->width/4) + dx/4;
\r
410 word soffset = (word)src->data + sy*(src->width/4) + sx/4;
\r
411 word scans = width/4;
\r
412 word nextSrcRow = src->width/4 - scans - 1;
\r
413 word nextDestRow = dest->width/4 - scans - 1;
\r
414 byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08}; /* clips for rectangles not on 4s */
\r
415 byte rclip[] = {0x0f, 0x01, 0x03, 0x07};
\r
416 byte left = lclip[sx&0x03];
\r
417 byte right = rclip[(sx+width)&0x03];
\r
420 MOV AX, SCREEN_SEG ; work in the vga space
\r
425 MOV DX, GC_INDEX ; turn off cpu bits
\r
429 MOV AX, SC_INDEX ; point to the mask register
\r
439 MOV CX, scans ; the number of latches
\r
441 MOV AL, left ; do the left column
\r
446 MOV AL, 0fh ; do the inner columns
\r
448 REP MOVSB ; copy the pixels
\r
450 MOV AL, right ; do the right column
\r
455 MOV AX, SI ; go the start of the next row
\r
456 ADD AX, nextSrcRow ;
\r
459 ADD AX, nextDestRow ;
\r
462 DEC height ; do the rest of the actions
\r
465 MOV DX, GC_INDEX+1 ; go back to CPU data
\r
466 MOV AL, 0ffh ; none from latches
\r
472 /* fade and flash */
\r
474 modexFadeOn(word fade, byte *palette) {
\r
475 fadePalette(-fade, 64, 64/fade+1, palette);
\r
480 modexFadeOff(word fade, byte *palette) {
\r
481 fadePalette(fade, 0, 64/fade+1, palette);
\r
486 modexFlashOn(word fade, byte *palette) {
\r
487 fadePalette(fade, -64, 64/fade+1, palette);
\r
492 modexFlashOff(word fade, byte *palette) {
\r
493 fadePalette(-fade, 0, 64/fade+1, palette);
\r
498 fadePalette(sbyte fade, sbyte start, word iter, byte *palette) {
\r
502 /* handle the case where we just update */
\r
504 modexPalUpdate1(palette);
\r
508 while(iter > 0) { /* FadeLoop */
\r
509 for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */
\r
510 tmppal[i] = palette[i] - dim;
\r
511 if(tmppal[i] > 127) {
\r
513 } else if(tmppal[i] > 63) {
\r
517 modexPalUpdate1(tmppal);
\r
524 /* save and load */
\r
526 modexPalSave(byte *palette) {
\r
529 outp(PAL_READ_REG, 0); /* start at palette entry 0 */
\r
530 for(i=0; i<PAL_SIZE; i++) {
\r
531 palette[i] = inp(PAL_DATA_REG); /* read the palette data */
\r
539 ptr = malloc(PAL_SIZE);
\r
541 /* handle errors */
\r
543 printf("Could not allocate palette.\n");
\r
552 modexLoadPalFile(byte *filename, byte **palette) {
\r
556 /* free the palette if it exists */
\r
561 /* allocate the new palette */
\r
562 *palette = modexNewPal();
\r
564 /* open the file */
\r
565 file = fopen(filename, "rb");
\r
567 printf("Could not open palette file: %s\n", filename);
\r
571 /* read the file */
\r
573 while(!feof(file)) {
\r
574 *ptr++ = fgetc(file);
\r
582 modexSavePalFile(char *filename, byte *pal) {
\r
586 /* open the file for writing */
\r
587 file = fopen(filename, "wb");
\r
589 printf("Could not open %s for writing\n", filename);
\r
593 /* write the data to the file */
\r
594 fwrite(pal, 1, PAL_SIZE, file);
\r
602 fadePalette(-1, 64, 1, tmppal);
\r
608 fadePalette(-1, -64, 1, tmppal);
\r
614 modexPalUpdate(bitmap_t *bmp, word *i, word qp, word aqoffset)
\r
616 byte *p = bmp->palette;
\r
620 static word a[PAL_SIZE]; //palette array of change values!
\r
621 word z=0, aq=0, aa=0, pp=0;
\r
626 memset(a, -1, sizeof(a));
\r
627 outp(PAL_WRITE_REG, 0); /* start at the beginning of palette */
\r
637 // printf("q: %02d\n", (q));
\r
638 // printf("qq: %02d\n", (qq));
\r
639 //printf(" (*i)-q=%02d\n", (*i)-q);
\r
640 outp(PAL_WRITE_REG, qq); /* start at the beginning of palette */
\r
642 if((*i)<PAL_SIZE/2 && w==0)
\r
644 for(; (*i)<PAL_SIZE/2; (*i)++)
\r
646 //if(i%3==0 && (p[i+5]==p[i+4] && p[i+4]==p[i+3] && p[i+3]==p[i+2] && p[i+2]==p[i+1] && p[i+1]==p[i] && p[i+5]==p[i]))
\r
647 //____ if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else
\r
648 if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))
\r
653 else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))
\r
655 //printf("qp=%d\n", qp);
\r
656 //printf(" (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);
\r
657 printf(" %d's color=%d\n", (*i), (a[qp])-(bmp->offset*3)+qp);
\r
658 //outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!
\r
659 if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }
\r
663 if(bmp->offset==0 && (*i)<3 && q==0) outp(PAL_DATA_REG, 0);
\r
665 if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
\r
666 else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);
\r
667 printf("p[]=%d qp=%d p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }
\r
670 //if(qp>0) printf("qp=%d\n", qp);
\r
671 //if(qp>0) printf(" (*i)=%d\n", (*i)/3);
\r
673 modexWaitBorder(); /* waits one retrace -- less flicker */
\r
674 if((*i)>=PAL_SIZE/2 && w==0)
\r
676 for(; (*i)<PAL_SIZE; (*i)++)
\r
678 //____ if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else
\r
679 if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))
\r
684 else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))
\r
686 //printf("qp=%d\n", qp);
\r
687 //printf(" (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);
\r
688 printf(" %d's color=%d\n", (*i), (a[qp]-(bmp->offset*3)+qp));
\r
689 //outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!
\r
690 if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }
\r
694 if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
\r
695 else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);
\r
696 printf("p[]=%d qp=%d p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }
\r
699 //printf(" (*i)=%d\n", (*i)/3);
\r
702 printf("\nqqqqqqqq\n\n");
\r
708 long bufSize = (bmp->width * bmp->height);
\r
710 //printf("1(*i)=%02d\n", (*i)/3);
\r
711 //printf("1z=%02d\n", z/3);
\r
712 chkcolor(bmp, &q, &a, &aa, &z, i);
\r
713 //printf("2(*i)=%02d\n", (*i)/3);
\r
714 //printf("2z=%02d\n", z/3);
\r
719 // printf("a[%02d]=(%d)\n", aq, a[aq]);
\r
720 if(a[aq]==-1) aq++;
\r
721 else { aqoffset++; break; }
\r
723 //update the image data here!
\r
724 for(lq=0; lq<bufSize; lq++)
\r
728 use a[qp] instead of bmp->offset for this spot!
\r
733 Facking bloody point the values of the changed palette to correct values.... major confusion! wwww
\r
736 //(offset/bmp->offset)*bmp->offset
\r
739 //printf("%02d ",bmp->data[lq]+bmp->offset);
\r
740 //if(lq > 0 && lq%bmp->width==0) printf("\n");
\r
741 //printf("%02d_", bmp->data[lq]+bmp->offset);
\r
742 /*if(bmp->data[lq]+bmp->offset==aq)
\r
744 //printf("%02d", bmp->data[lq]);
\r
745 //printf("\n%02d\n", bmp->offset);
\r
746 printf("aq=%02d ", aq);
\r
747 printf("a[aq]=%02d ", a[aq]);
\r
748 printf("a[aq]+aqpp=%02d ", a[aq]+aqpp);
\r
749 printf("a[aq]-aqpp=%02d\n", a[aq]-aqpp);
\r
750 //bmp->data[lq]=((bmp->data[lq]+bmp->offset)-a[aq]);
\r
751 //++++ bmp->data[lq]=a[aq]-aqpp;
\r
752 // printf("_%d ", bmp->data[lq]);
\r
753 //if(lq > 0 && lq%bmp->width==0) printf("\n");
\r
755 else if(bmp->data[lq]+bmp->offset < ((*i)/3)-aqpp)
\r
757 if(bmp->data[lq]+bmp->offset >= aq)
\r
759 bmp->data[lq]=(bmp->data[lq]+bmp->offset)-aqpp;//-((z-(*i))/3);
\r
760 //printf("_%d ", bmp->data[lq]+bmp->offset)-aqpp-((z-(*i))/3);
\r
762 else bmp->data[lq]+=(bmp->offset-aqpp);
\r
765 //printf("%02d`", bmp->data[lq]);
\r
766 //if(lq > 0 && lq%bmp->width==0) printf("\n");
\r
769 //printf(" aq=%02d\n", aq);
\r
770 //printf(" aa=%02d\n", aa);
\r
772 //update the palette~
\r
773 modexPalUpdate(bmp, &pp, aq, aqoffset);
\r
776 if(aq<aa){ pp=q; aq++; goto aqpee; }
\r
781 modexPalUpdate1(byte *p)
\r
785 outp(PAL_WRITE_REG, 0); /* start at the beginning of palette */
\r
786 for(i=0; i<PAL_SIZE/2; i++)
\r
788 outp(PAL_DATA_REG, p[i]);
\r
790 modexWaitBorder(); /* waits one retrace -- less flicker */
\r
791 for(; i<PAL_SIZE; i++)
\r
793 outp(PAL_DATA_REG, p[(i)]);
\r
798 modexPalUpdate0(byte *p)
\r
802 outp(PAL_WRITE_REG, 0); /* start at the beginning of palette */
\r
803 for(i=0; i<PAL_SIZE/2; i++)
\r
805 outp(PAL_DATA_REG, rand());
\r
807 modexWaitBorder(); /* waits one retrace -- less flicker */
\r
808 for(; i<PAL_SIZE; i++)
\r
810 outp(PAL_DATA_REG, rand());
\r
815 modexPalOverscan(byte *p, word col)
\r
818 outp(PAL_WRITE_REG, 0); /* start at the beginning of palette */
\r
819 outp(PAL_DATA_REG, col);
\r
823 //i want to make another vesion that checks the palette when the palette is being appened~
\r
824 void chkcolor(bitmap_t *bmp, word *q, word *a, word *aa, word *z, word *i/*, word *offset*/)
\r
828 pal = modexNewPal();
\r
830 //printf("q: %02d\n", (*q));
\r
831 printf("chkcolor start~\n");
\r
832 printf("1 (*z): %d\n", (*z)/3);
\r
833 printf("1 (*i): %d\n", (*i)/3);
\r
834 // printf("1 offset of color in palette (*q): %d\n", (*q)/3);
\r
835 printf("wwwwwwwwwwwwwwww\n");
\r
836 //check palette for dups
\r
837 for(; (*z)<PAL_SIZE; (*z)+=3)
\r
839 //printf("\n z: %d\n", (*z));
\r
840 //printf(" q: %d\n", (*q));
\r
841 //printf(" z+q: %d\n\n", ((*z)+(*q)));
\r
844 //---- if(pal[(*z)]==pal[(*z)+3] && pal[(*z)+1]==pal[(*z)+4] && pal[(*z)+2]==pal[(*z)+5])
\r
847 // printf("\n%d [%02d][%02d][%02d]\n", (*z), pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
\r
848 // printf("%d [%02d][%02d][%02d]\n\n", (*z)+3, pal[(*z)+3], pal[(*z)+4], pal[(*z)+5]);
\r
852 else for(zz=0; zz<(*q); zz+=3)
\r
854 //printf("zz: %02d\n", zz/3);
\r
857 if(pal[((*z)+(*q))]==pal[((*z)+(*q))+3] && pal[((*z)+(*q))+1]==pal[((*z)+(*q))+4] && pal[((*z)+(*q))+2]==pal[((*z)+(*q))+5]) //break if duplicate colors found in palette because it have reached the end of the current data of the palette
\r
861 // printf("\nzq1:%d[%02d][%02d][%02d]\n", (zz+q), pal[(zz+q)], pal[(zz+q)+1], pal[(zz+q)+2]);
\r
862 // printf("zq2:%d[%02d][%02d][%02d]\n\n", (zz+q)+3, pal[(zz+q)+3], pal[(zz+q)+4], pal[(zz+q)+5]);
\r
865 else if(pal[zz]==pal[((*z)+(*q))] && pal[zz+1]==pal[((*z)+(*q))+1] && pal[zz+2]==pal[((*z)+(*q))+2])
\r
867 // printf("\n\nwwwwwwwwwwwwwwww\n");
\r
868 // printf(" zq: %d [%02d][%02d][%02d] value that is needing to be changed~\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
\r
869 // printf(" zz: %d [%02d][%02d][%02d] value that the previous value is going to change to~\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
\r
870 // //printf(" zv: %d [%02d][%02d][%02d] wwww\n", (zz-z+q)/3, pal[(zz-z+q)], pal[(zz-z+q)+1], pal[(zz-z+q)+2]);
\r
871 // printf(" z : %d [%02d][%02d][%02d] offset value~\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
\r
876 planned features that i plan to implement~
\r
877 image that has values on the pallete list!
\r
879 no... wait.... no wwww
\r
881 //for(zzii=0; zzii<3; zzii++)
\r
883 //printf("z+q: %d\n\n", ((*z)+(*q)));
\r
884 a[(((*z)+(*q)))]=zz;
\r
886 (*aa)=(((*z)+(*q)));
\r
887 printf("!! a[%02d]: %d\n", (((*z)+(*q))/3), zz/3);
\r
888 // printf("\n aa: %d\n\n", (*aa));
\r
889 // printf(" a[%02d]=(%02d) offset array i think the palette should be updated again~\n", ((*z)+(*q))/3, a[((*z)+(*q))/3]);
\r
890 // printf("wwwwwwwwwwwwwwww\n\n");
\r
894 printf("================\n");
\r
895 printf("zq: %d [%02d][%02d][%02d]\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
\r
896 printf("zz: %d [%02d][%02d][%02d]\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
\r
897 printf("z : %d [%02d][%02d][%02d]\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
\r
898 printf("================\n");
\r
900 //printf("[%d]", (zz+q));
\r
904 printf("wwwwwwwwwwwwwwww\n");
\r
905 printf("2 (*z): %d\n", (*z)/3);
\r
906 printf("2 (*i): %d\n", (*i)/3);
\r
907 // printf("2 offset of color in palette (*q): %d\n", (*q)/3);
\r
908 printf("chkcolor end~\n");
\r
912 void modexputPixel(page_t *page, int x, int y, byte color)
\r
914 word pageOff = (word) page->data;
\r
915 /* Each address accesses four neighboring pixels, so set
\r
916 Write Plane Enable according to which pixel we want
\r
917 to modify. The plane is determined by the two least
\r
918 significant bits of the x-coordinate: */
\r
919 modexSelectPlane(PLANE(x));
\r
920 //outp(SC_INDEX, 0x02);
\r
921 //outp(SC_DATA, 0x01 << (x & 3));
\r
923 /* The offset of the pixel into the video segment is
\r
924 offset = (width * y + x) / 4, and write the given
\r
925 color to the plane we selected above. Heed the active
\r
926 page start selection. */
\r
927 VGA[(unsigned)((page->width/4) * y) + (x / 4) + pageOff] = color;
\r
931 byte modexgetPixel(page_t *page, int x, int y)
\r
933 word pageOff = (word) page->data;
\r
934 /* Select the plane from which we must read the pixel color: */
\r
935 outpw(GC_INDEX, 0x04);
\r
936 outpw(GC_INDEX+1, x & 3);
\r
938 return VGA[(unsigned)((page->width/4) * y) + (x / 4) + pageOff];
\r
942 void modexhlin(page_t *page, word xl, word xh, word y, word color)
\r
947 for(x=0;x<xh*4;x+=4)
\r
949 if(x+4>=page[0].sw-1){ x=0; yy+=4; }
\r
950 modexClearRegion(page, x+xl, y+yy, 4, 4, color);
\r
952 //modexputPixel(page, x+xl, y, color);
\r
955 void modexprint(page_t *page, word x, word y, word t, word col, word bgcol, const byte *str, boolean q)
\r
958 word addr = (word) romFontsData.l;
\r
963 w=romFonts[t].charSize;
\r
964 romFontsData.chw=0;
\r
966 for(; *str != '\0'; str++)
\r
969 if((c=='\n'/* || c=="\
\r
970 "*/) || romFontsData.chw
\r
973 romFontsData.chw=0;
\r
974 y+=romFonts[t].charSize;
\r
977 //load the letter 'A'
\r
983 MOV AL, c ; the letter
\r
986 ADD SI, AX ;the address of charcter
\r
994 //TODO: OPTIMIZE THIS!!!!
\r
995 modexDrawCharPBuf(page, x, y, t, col, bgcol, q);
\r
1001 void modexprintbig(page_t *page, word x, word y, word t, word col, word bgcol, const byte *str)
\r
1003 word i, s, o, w, j, xp;
\r
1005 word addr = (word) l;
\r
1029 s=romFonts[t].seg;
\r
1030 o=romFonts[t].off;
\r
1032 for(; *str != '\0'; str++)
\r
1035 if((c=='\n'/* || c=="\
\r
1036 "*/)/* || chw>=page->width*/)
\r
1042 //load the letter 'A'
\r
1048 MOV AL, c ; the letter
\r
1051 ADD SI, AX ;the address of charcter
\r
1060 for(i=0; i<w; i++)
\r
1066 //modexputPixel(page, x+xp+chw, y+i, l[i] & j ? col:bgcol);
\r
1067 modexClearRegion(page, (x+xp+chw)*8, (y+i)*8, 8, 8, l[i] & j ? col:bgcol);
\r
1076 /* palette dump on display! */
\r
1077 void pdump(page_t *pee)
\r
1079 int mult=(QUADWH);
\r
1080 int palq=(mult)*TILEWH;
\r
1083 for(paly=0; paly<palq; paly+=mult){
\r
1084 for(palx=0; palx<palq; palx+=mult){
\r
1085 modexClearRegion(pee, palx+TILEWH, paly+TILEWH, mult, mult, palcol);
\r
1091 /////////////////////////////////////////////////////////////////////////////
\r
1093 // cls() - This clears the screen to the specified color, on the VGA or on //
\r
1094 // the Virtual screen. //
\r
1096 /////////////////////////////////////////////////////////////////////////////
\r
1097 void cls(page_t *page, byte color, byte *Where)
\r
1099 //modexClearRegion(page, 0, 0, page->width, page->height, color);
\r
1100 /* set map mask to all 4 planes */
\r
1101 outpw(SC_INDEX, 0xff02);
\r
1102 //_fmemset(VGA, color, 16000);
\r
1103 _fmemset(Where, color, page->width*(page->height)/4);
\r
1107 modexWaitBorder() {
\r
1108 while(inp(INPUT_STATUS_1) & 8) {
\r
1112 while(!(inp(INPUT_STATUS_1) & 8)) {
\r