]> 4ch.mooo.com Git - 16.git/blob - src/lib/modex16.c
trying to fix~ palette updater bug! wwww
[16.git] / src / lib / modex16.c
1 #include <dos.h>
2 #include <string.h>
3 #include <mem.h>
4 #include <conio.h>
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include "src\lib\modex16.h"
8
9
10 byte far* VGA=(byte far*) 0xA0000000;   /* this points to video memory. */
11
12 static void fadePalette(sbyte fade, sbyte start, word iter, byte *palette);
13 static byte tmppal[PAL_SIZE];
14
15 static void
16 vgaSetMode(byte mode)
17 {
18   union REGS regs;
19
20   regs.h.ah = SET_MODE;
21   regs.h.al = mode;
22   int86(VIDEO_INT, &regs, &regs);
23 }
24
25
26 /* -========================= Entry  Points ==========================- */
27 void
28 modexEnter() {
29     word i;
30     dword far*ptr=(dword far*)VGA;      /* used for faster screen clearing */
31     word CRTParms[] = {
32         0x0d06,         /* vertical total */
33         0x3e07,         /* overflow (bit 8 of vertical counts) */
34         0x4109,         /* cell height (2 to double-scan */
35         0xea10,         /* v sync start */
36         0xac11,         /* v sync end and protect cr0-cr7 */
37         0xdf12,         /* vertical displayed */
38         0x0014,         /* turn off dword mode */
39         0xe715,         /* v blank start */
40         0x0616,         /* v blank end */
41         0xe317          /* turn on byte mode */
42     };
43     int CRTParmCount = sizeof(CRTParms) / sizeof(CRTParms[0]);
44
45     /* TODO save current video mode and palette */
46     vgaSetMode(VGA_256_COLOR_MODE);
47
48     /* disable chain4 mode */
49     outpw(SC_INDEX, 0x0604);
50
51     /* synchronous reset while setting Misc Output */
52     outpw(SC_INDEX, 0x0100);
53
54     /* select 25 MHz dot clock & 60 Hz scanning rate */
55     outp(MISC_OUTPUT, 0xe3);
56
57     /* undo reset (restart sequencer) */
58     outpw(SC_INDEX, 0x0300);
59
60     /* reprogram the CRT controller */
61     outp(CRTC_INDEX, 0x11); /* VSync End reg contains register write prot */
62     outp(CRTC_DATA, 0x7f);  /* get current write protect on varios regs */
63
64     /* send the CRTParms */
65     for(i=0; i<CRTParmCount; i++) {
66         outpw(CRTC_INDEX, CRTParms[i]);
67     }
68
69     /* clear video memory */
70     outpw(SC_INDEX, 0x0f02);
71     for(i=0; i<0x8000; i++) {
72         ptr[i] = 0x0000;
73     }
74 }
75
76
77 void
78 modexLeave() {
79     /* TODO restore original mode and palette */
80     vgaSetMode(TEXT_MODE);
81 }
82
83
84 page_t
85 modexDefaultPage() {
86     page_t page;
87
88     /* default page values */
89     page.data = VGA;
90     page.dx = 0;
91     page.dy = 0;
92     page.width = SCREEN_WIDTH;
93     page.height = SCREEN_HEIGHT;
94
95     return page;
96 }
97
98 /* returns the next page in contiguous memory
99  * the next page will be the same size as p, by default
100  */
101 page_t
102 modexNextPage(page_t *p) {
103     page_t result;
104
105     result.data = p->data + (p->width/4)*p->height;  /* compute the offset */
106     result.dx = 0;
107     result.dy = 0;
108     result.width = p->width;
109     result.height = p->height;
110
111     return result;
112 }
113
114
115 void
116 modexShowPage(page_t *page) {
117     word high_address;
118     word low_address;
119     word offset;
120     byte crtcOffset;
121
122     /* calculate offset */
123     offset = (word) page->data;
124     offset += page->dy * (page->width >> 2 );
125     offset += page->dx >> 2;
126
127     /* calculate crtcOffset according to virtual width */
128     crtcOffset = page->width >> 3;
129
130     high_address = HIGH_ADDRESS | (offset & 0xff00);
131     low_address  = LOW_ADDRESS  | (offset << 8);
132
133     /* wait for appropriate timing and then program CRTC */
134     while ((inp(INPUT_STATUS_1) & DISPLAY_ENABLE));
135     outpw(CRTC_INDEX, high_address);
136     outpw(CRTC_INDEX, low_address);
137     outp(CRTC_INDEX, 0x13);
138     outp(CRTC_DATA, crtcOffset);
139
140     /*  wait for one retrace */
141     while (!(inp(INPUT_STATUS_1) & VRETRACE)); 
142
143     /* do PEL panning here */
144     outp(AC_INDEX, 0x33);
145     outp(AC_INDEX, (page->dx & 0x03) << 1);
146 }
147
148
149 void
150 modexPanPage(page_t *page, int dx, int dy) {
151     page->dx = dx;
152     page->dy = dy;
153 }
154
155
156 void
157 modexSelectPlane(byte plane) {
158     outp(SC_INDEX, MAP_MASK);          /* select plane */
159     outp(SC_DATA,  plane);
160 }
161
162
163 void
164 modexClearRegion(page_t *page, int x, int y, int w, int h, byte  color) {
165     word pageOff = (word) page->data;
166     word xoff=x/4;       /* xoffset that begins each row */
167     word scanCount=w/4;  /* number of iterations per row (excluding right clip)*/
168     word poffset = pageOff + y*(page->width/4) + xoff; /* starting offset */
169     word nextRow = page->width/4-scanCount-1;  /* loc of next row */
170     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */
171     byte rclip[] = {0x00, 0x01, 0x03, 0x07};
172     byte left = lclip[x&0x03];
173     byte right = rclip[(x+w)&0x03];
174
175     /* handle the case which requires an extra group */
176     if((x & 0x03) && !((x+w) & 0x03)) {
177       right=0x0f;
178     }
179
180     __asm {
181                 MOV AX, SCREEN_SEG      ; go to the VGA memory
182                 MOV ES, AX
183                 MOV DI, poffset         ; go to the first pixel
184                 MOV DX, SC_INDEX        ; point to the map mask
185                 MOV AL, MAP_MASK
186                 OUT DX, AL
187                 INC DX
188                 MOV AL, color           ; get ready to write colors
189         SCAN_START:
190                 MOV CX, scanCount       ; count the line
191                 MOV BL, AL              ; remember color
192                 MOV AL, left            ; do the left clip
193                 OUT DX, AL              ; set the left clip
194                 MOV AL, BL              ; restore color
195                 STOSB                   ; write the color
196                 DEC CX
197                 JZ SCAN_DONE            ; handle 1 group stuff
198
199                 ;-- write the main body of the scanline
200                 MOV BL, AL              ; remember color
201                 MOV AL, 0x0f            ; write to all pixels
202                 OUT DX, AL
203                 MOV AL, BL              ; restore color
204                 REP STOSB               ; write the color
205         SCAN_DONE:
206                 MOV BL, AL              ; remeber color
207                 MOV AL, right
208                 OUT DX, AL              ; do the right clip
209                 MOV AL, BL              ; restore color
210                 STOSB                   ; write pixel
211                 ADD DI, nextRow         ; go to the next row
212                 DEC h
213                 JNZ SCAN_START
214     }
215 }
216
217
218 void
219 modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {
220     /* draw the region (the entire freakin bitmap) */
221     modexDrawBmpRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);
222 }
223
224
225 void
226 modexDrawBmpRegion(page_t *page, int x, int y,
227                    int rx, int ry, int rw, int rh, bitmap_t *bmp) {
228     word poffset = (word) page->data  + y*(page->width/4) + x/4;
229     byte *data = bmp->data;//+bmp->offset;
230     word bmpOffset = (word) data + ry * bmp->width + rx;
231     word width = rw;
232     word height = rh;
233     byte plane = 1 << ((byte) x & 0x03);
234     word scanCount = width/4 + (width%4 ? 1 :0);
235     word nextPageRow = page->width/4 - scanCount;
236     word nextBmpRow = (word) bmp->width - width;
237     word rowCounter;
238     byte planeCounter = 4;
239
240         //code is a bit slow here
241     __asm {
242                 MOV AX, SCREEN_SEG      ; go to the VGA memory
243                 MOV ES, AX
244
245                 MOV DX, SC_INDEX        ; point at the map mask register
246                 MOV AL, MAP_MASK        ;
247                 OUT DX, AL              ;
248
249         PLANE_LOOP:
250                 MOV DX, SC_DATA         ; select the current plane
251                 MOV AL, plane           ;
252                 OUT DX, AL              ;
253
254                 ;-- begin plane painting
255                 MOV AX, height          ; start the row counter
256                 MOV rowCounter, AX      ; 
257                 MOV DI, poffset         ; go to the first pixel
258                 MOV SI, bmpOffset       ; go to the bmp pixel
259         ROW_LOOP:
260                 MOV CX, width           ; count the columns
261         SCAN_LOOP:
262                 MOVSB                   ; copy the pixel
263                 SUB CX, 3               ; we skip the next 3
264                 ADD SI, 3               ; skip the bmp pixels
265                 LOOP SCAN_LOOP          ; finish the scan
266
267                 MOV AX, nextPageRow
268                 ADD DI, AX              ; go to the next row on screen
269                 MOV AX, nextBmpRow
270                 ADD SI, AX              ; go to the next row on bmp
271
272                 DEC rowCounter
273                 JNZ ROW_LOOP            ; do all the rows
274                 ;-- end plane painting
275
276                 MOV AL, plane           ; advance to the next plane
277                 SHL AL, 1               ;
278                 AND AL, 0x0f            ; mask the plane properly
279                 MOV plane, AL           ; store the plane
280
281                 INC bmpOffset           ; start bmp at the right spot
282
283                 DEC planeCounter
284                 JNZ PLANE_LOOP          ; do all 4 planes
285     }
286 }
287
288
289 void
290 modexDrawPlanarBuf(page_t *page, int x, int y, planar_buf_t *bmp) {
291     /* TODO - adapt from test code */
292         int plane;
293         for(plane=0; plane < 4; plane++)
294         {
295                 //fack
296         }
297 }
298
299
300 void
301 modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp) {
302     /* draw the whole sprite */
303     modexDrawSpriteRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);
304 }
305
306 void
307 modexDrawSpriteRegion(page_t *page, int x, int y,
308                       int rx, int ry, int rw, int rh, bitmap_t *bmp) {
309     word poffset = (word)page->data + y*(page->width/4) + x/4;
310     byte *data = bmp->data;//+bmp->offset;
311     word bmpOffset = (word) data + ry * bmp->width + rx;
312     word width = rw;
313     word height = rh;
314     byte plane = 1 << ((byte) x & 0x03);
315     word scanCount = width/4 + (width%4 ? 1 :0);
316     word nextPageRow = page->width/4 - scanCount;
317     word nextBmpRow = (word) bmp->width - width;
318     word rowCounter;
319     byte planeCounter = 4;
320
321     __asm {
322                 MOV AX, SCREEN_SEG      ; go to the VGA memory
323                 MOV ES, AX
324
325                 MOV DX, SC_INDEX        ; point at the map mask register
326                 MOV AL, MAP_MASK        ;
327                 OUT DX, AL              ;
328
329         PLANE_LOOP:
330                 MOV DX, SC_DATA         ; select the current plane
331                 MOV AL, plane           ;
332                 OUT DX, AL              ;
333
334                 ;-- begin plane painting
335                 MOV AX, height          ; start the row counter
336                 MOV rowCounter, AX      ; 
337                 MOV DI, poffset         ; go to the first pixel
338                 MOV SI, bmpOffset       ; go to the bmp pixel
339         ROW_LOOP:
340                 MOV CX, width           ; count the columns
341         SCAN_LOOP:
342                 LODSB
343                 DEC SI
344                 CMP AL, 0
345                 JNE DRAW_PIXEL          ; draw non-zero pixels
346
347                 INC DI                  ; skip the transparent pixel
348                 ADD SI, 1
349                 JMP NEXT_PIXEL
350         DRAW_PIXEL:
351                 MOVSB                   ; copy the pixel
352         NEXT_PIXEL:
353                 SUB CX, 3               ; we skip the next 3
354                 ADD SI, 3               ; skip the bmp pixels
355                 LOOP SCAN_LOOP          ; finish the scan
356
357                 MOV AX, nextPageRow
358                 ADD DI, AX              ; go to the next row on screen
359                 MOV AX, nextBmpRow
360                 ADD SI, AX              ; go to the next row on bmp
361
362                 DEC rowCounter
363                 JNZ ROW_LOOP            ; do all the rows
364                 ;-- end plane painting
365
366                 MOV AL, plane           ; advance to the next plane
367                 SHL AL, 1               ;
368                 AND AL, 0x0f            ; mask the plane properly
369                 MOV plane, AL           ; store the plane
370
371                 INC bmpOffset           ; start bmp at the right spot
372
373                 DEC planeCounter
374                 JNZ PLANE_LOOP          ; do all 4 planes
375     }
376 }
377
378
379 /* copy a region of video memory from one page to another.
380  * It assumes that the left edge of the tile is the same on both
381  * regions and the memory areas do not overlap.
382  */
383 void
384 modexCopyPageRegion(page_t *dest, page_t *src,
385                     word sx, word sy,
386                     word dx, word dy,
387                     word width, word height)
388 {
389     word doffset = (word)dest->data + dy*(dest->width/4) + dx/4;
390     word soffset = (word)src->data + sy*(src->width/4) + sx/4;
391     word scans   = width/4;
392     word nextSrcRow = src->width/4 - scans - 1;
393     word nextDestRow = dest->width/4 - scans - 1;
394     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */
395     byte rclip[] = {0x0f, 0x01, 0x03, 0x07};
396     byte left = lclip[sx&0x03];
397     byte right = rclip[(sx+width)&0x03];
398
399     __asm {
400                 MOV AX, SCREEN_SEG      ; work in the vga space
401                 MOV ES, AX              ;
402                 MOV DI, doffset         ;
403                 MOV SI, soffset         ;
404
405                 MOV DX, GC_INDEX        ; turn off cpu bits
406                 MOV AX, 0008h           ;
407                 OUT DX, AX
408
409                 MOV AX, SC_INDEX        ; point to the mask register
410                 MOV DX, AX              ;
411                 MOV AL, MAP_MASK        ;
412                 OUT DX, AL              ;
413                 INC DX                  ;
414
415         ROW_START:
416                 PUSH DS
417                 MOV AX, ES
418                 MOV DS, AX
419                 MOV CX, scans           ; the number of latches
420
421                 MOV AL, left            ; do the left column
422                 OUT DX, AL              ;
423                 MOVSB                   ;
424                 DEC CX                  ;
425
426                 MOV AL, 0fh             ; do the inner columns
427                 OUT DX, AL
428                 REP MOVSB               ; copy the pixels
429
430                 MOV AL, right           ; do the right column
431                 OUT DX, AL
432                 MOVSB
433                 POP DS
434
435                 MOV AX, SI              ; go the start of the next row
436                 ADD AX, nextSrcRow      ;
437                 MOV SI, AX              ;
438                 MOV AX, DI              ;
439                 ADD AX, nextDestRow     ;
440                 MOV DI, AX              ;
441
442                 DEC height              ; do the rest of the actions
443                 JNZ ROW_START           ;
444
445                 MOV DX, GC_INDEX+1      ; go back to CPU data
446                 MOV AL, 0ffh            ; none from latches
447                 OUT DX, AL              ;
448     }
449 }
450
451
452 /* fade and flash */
453 void
454 modexFadeOn(word fade, byte *palette) {
455     fadePalette(-fade, 64, 64/fade+1, palette);
456 }
457
458
459 void
460 modexFadeOff(word fade, byte *palette) {
461     fadePalette(fade, 0, 64/fade+1, palette);
462 }
463
464
465 void
466 modexFlashOn(word fade, byte *palette) {
467     fadePalette(fade, -64, 64/fade+1, palette);
468 }
469
470
471 void
472 modexFlashOff(word fade, byte *palette) {
473     fadePalette(-fade, 0, 64/fade+1, palette);
474 }
475
476
477 static void
478 fadePalette(sbyte fade, sbyte start, word iter, byte *palette) {
479     word i;
480     byte dim = start;
481
482     /* handle the case where we just update */
483     if(iter == 0) {
484         modexPalUpdate2(palette);
485         return;
486     }
487
488     while(iter > 0) {  /* FadeLoop */
489         for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */
490             tmppal[i] = palette[i] - dim;
491             if(tmppal[i] > 127) {
492                 tmppal[i] = 0;
493             } else if(tmppal[i] > 63) {
494                 tmppal[i] = 63;
495             }
496         }
497         modexPalUpdate2(tmppal);
498         iter--;
499         dim += fade;
500     }
501 }
502
503
504 /* save and load */
505 void
506 modexPalSave(byte *palette) {
507     int  i;
508
509     outp(PAL_READ_REG, 0);      /* start at palette entry 0 */
510     for(i=0; i<PAL_SIZE; i++) {
511         palette[i] = inp(PAL_DATA_REG); /* read the palette data */
512     }
513 }
514
515
516 byte *
517 modexNewPal() {
518     byte *ptr;
519     ptr = malloc(PAL_SIZE);
520
521     /* handle errors */
522     if(!ptr) {
523         printf("Could not allocate palette.\n");
524         exit(-1);
525     }
526
527     return ptr;
528 }
529
530
531 void
532 modexLoadPalFile(byte *filename, byte **palette) {
533     FILE *file;
534     byte *ptr;
535
536     /* free the palette if it exists */
537     if(*palette) {
538         free(*palette);
539     }
540
541     /* allocate the new palette */
542     *palette = modexNewPal();
543
544     /* open the file */
545     file = fopen(filename, "rb");
546     if(!file) {
547         printf("Could not open palette file: %s\n", filename);
548         exit(-2);
549     }
550
551     /* read the file */
552     ptr = *palette;
553     while(!feof(file)) {
554         *ptr++ = fgetc(file);
555     }
556
557     fclose(file);
558 }
559
560
561 void
562 modexSavePalFile(char *filename, byte *pal) {
563     unsigned int i;
564     FILE *file;
565
566     /* open the file for writing */
567     file = fopen(filename, "wb");
568     if(!file) {
569         printf("Could not open %s for writing\n", filename);
570         exit(-2);
571     }
572
573     /* write the data to the file */
574     fwrite(pal, 1, PAL_SIZE, file);
575     fclose(file);
576 }
577
578
579 /* blanking */
580 void
581 modexPalBlack() {
582     fadePalette(-1, 64, 1, tmppal);
583 }
584
585
586 void
587 modexPalWhite() {
588     fadePalette(-1, -64, 1, tmppal);
589 }
590
591
592 /* utility */
593 void
594 modexPalUpdate(bitmap_t *bmp, word *i, word qp, word aqpp)
595 {
596 //----  static word count=0;
597         byte *p = bmp->palette;
598         word w=0;
599         word q=0;
600         word qq=0;
601         word ii;
602         static word a[256] = { 0 };
603         word z=0, aq=0, aa=0, pp=0;
604         sword aqpw;
605
606         //printf("1     (*i)=%02d\n", (*i)/3);
607         modexWaitBorder();
608         if((*i)==0) outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
609         else if(qp==0)
610         {
611                 q=(*i);
612         }
613         else
614         {
615                 q=(*i);
616                 qq=(*i)/3;
617 //              printf("q: %02d\n", (q));
618 //              printf("qq: %02d\n", (qq));
619                 //printf("      (*i)-q=%02d\n", (*i)-q);
620 //              printf("================\n");
621                 outp(PAL_WRITE_REG, qq);  /* start at the beginning of palette */
622         }
623         if((*i)<PAL_SIZE/2 && w==0)
624         {
625                 for(; (*i)<PAL_SIZE/2; (*i)++)
626                 {
627                         //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]))
628 //____                  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
629                         if(((((*i)-q)%3==0) || ((qp>0)&&((*i)-(bmp->offset*3))%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]))
630                         {
631                                 if(qp>0)
632                                 {
633                                         (*i)-=(aqpp*3);
634                                         aqpw=aqpp-1;
635                                         outp(PAL_WRITE_REG, qq+(((*i)+(aqpw*3)-(bmp->offset*3))/3));
636                                         for(ii=aqpp; ii>0; ii--)
637                                         {
638                                                 outp(PAL_DATA_REG, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3))-(bmp->offset*3))]);
639                                                 outp(PAL_DATA_REG, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3)+1)-(bmp->offset*3))]);
640                                                 outp(PAL_DATA_REG, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3)+2)-(bmp->offset*3))]);
641 //                                              printf("position        =       %d\n", qq+(((*i)+(aqpw*3)-(bmp->offset*3))/3));
642 /*if(qp>0){ //printf("[%d]", p[((*i)-q)]);      printf("[%d]", p[((*i)-q)+1]);  printf("[%d]", p[((*i)-q)+2]);  printf("[%d]", p[((*i)-q)+3]);                  printf("[%d]", p[((*i)-q)+4]);                  printf("[%d]", p[((*i)-q)+5]);                  printf("        %d [%d]\n", (*i), p[((*i)-q)]); }
643 printf("[%d]", p[((((*i)+((aqpp-ii)*3)))-(bmp->offset*3))]);
644 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+1)-(bmp->offset*3))]);
645 printf("[%d] | ", p[((((*i)+((aqpp-ii)*3))+2)-(bmp->offset*3))]);
646 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+3)-(bmp->offset*3))]);
647 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+4)-(bmp->offset*3))]);
648 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+5)-(bmp->offset*3))]);
649 printf("        %d [%d]\n",((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3))-(bmp->offset*3))/3, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3))-(bmp->offset*3))]); }*/
650                                                 //printf("%d\n", ((*i)+((ii)*3))/3);
651                                                 //printf("ii=%d\n", ii);
652                                                 //printf("aqpp=%d\n", aqpp);
653                                                 //printf("                      %d\n", ((*i)+((aqpp-ii)*3))/3);
654                                         }
655                                         //printf("      %d\n",((((*i)+((aqpp-ii)*3)))-(bmp->offset*3)));
656                                         //printf("      %d\n",((((*i)+((aqpp-ii)*3))+1)-(bmp->offset*3)));
657                                         //printf("      %d\n",((((*i)+((aqpp-ii)*3))+2)-(bmp->offset*3)));
658                                         //printf("(*i)=%d\n", (*i));
659                                 }
660                                 //if(q>0) printf("%d\n", (*i)/3);
661                                 //printf("[%d]", p[((*i)-q)]);  printf("[%d]", p[((*i)-q)+1]);  printf("[%d]", p[((*i)-q)+2]);  printf("[%d]", p[((*i)-q)+3]);                  printf("[%d]", p[((*i)-q)+4]);                  printf("[%d]", p[((*i)-q)+5]);                  printf("        %d [%d]\n", (*i), p[((*i)-q)]);
662                                 w++;
663                                 break;
664                         }
665                         else
666                         {
667                                 if(bmp->offset==0 && (*i)<3 && q==0) outp(PAL_DATA_REG, 0);
668                                 else
669                                 if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
670                                 else outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3))]);
671                         }
672                 }
673         }
674         modexWaitBorder();          /* waits one retrace -- less flicker */
675         if((*i)>=PAL_SIZE/2 && w==0)
676         {
677                 for(; (*i)<PAL_SIZE; (*i)++)
678                 {
679 //____                  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
680                         if(((((*i)-q)%3==0) || ((qp>0)&&((*i)-(bmp->offset*3))%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]))
681                         {
682                                 if(qp>0)
683                                 {
684                                         (*i)-=(aqpp*3);
685                                         aqpw=aqpp-1;
686                                         outp(PAL_WRITE_REG, qq+(((*i)+(aqpw*3)-(bmp->offset*3))/3));
687                                         for(ii=aqpp; ii>0; ii--)
688                                         {
689                                                 outp(PAL_DATA_REG, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3))-(bmp->offset*3))]);
690                                                 outp(PAL_DATA_REG, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3)+1)-(bmp->offset*3))]);
691                                                 outp(PAL_DATA_REG, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3)+2)-(bmp->offset*3))]);
692 //                                              printf("position        =       %d\n", qq+(((*i)+(aqpw*3)-(bmp->offset*3))/3));
693 /*if(qp>0){ //printf("[%d]", p[((*i)-q)]);      printf("[%d]", p[((*i)-q)+1]);  printf("[%d]", p[((*i)-q)+2]);  printf("[%d]", p[((*i)-q)+3]);                  printf("[%d]", p[((*i)-q)+4]);                  printf("[%d]", p[((*i)-q)+5]);                  printf("        %d [%d]\n", (*i), p[((*i)-q)]); }
694 printf("[%d]", p[((((*i)+((aqpp-ii)*3)))-(bmp->offset*3))]);
695 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+1)-(bmp->offset*3))]);
696 printf("[%d] | ", p[((((*i)+((aqpp-ii)*3))+2)-(bmp->offset*3))]);
697 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+3)-(bmp->offset*3))]);
698 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+4)-(bmp->offset*3))]);
699 printf("[%d]", p[((((*i)+((aqpp-ii)*3))+5)-(bmp->offset*3))]);
700 printf("        %d [%d]\n",((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3))-(bmp->offset*3))/3, p[((((*i)+((aqpp-ii)*3))+((aqpp+ii)*3))-(bmp->offset*3))]); }*/
701                                                 //printf("%d\n", ((*i)+((ii)*3))/3);
702                                                 //printf("ii=%d\n", ii);
703                                                 //printf("aqpp=%d\n", aqpp);
704                                                 //printf("                      %d\n", ((*i)+((aqpp-ii)*3))/3);
705                                         }
706                                         //printf("      %d\n",((((*i)+((aqpp-ii)*3)))-(bmp->offset*3)));
707                                         //printf("      %d\n",((((*i)+((aqpp-ii)*3))+1)-(bmp->offset*3)));
708                                         //printf("      %d\n",((((*i)+((aqpp-ii)*3))+2)-(bmp->offset*3)));
709                                         //printf("(*i)=%d\n", (*i));
710                                 }
711                                 //if(q>0) printf("%d\n", (*i)/3);
712                                 //printf("[%d]", p[((*i)-q)]);  printf("[%d]", p[((*i)-q)+1]);  printf("[%d]", p[((*i)-q)+2]);  printf("[%d]", p[((*i)-q)+3]);                  printf("[%d]", p[((*i)-q)+4]);                  printf("[%d]", p[((*i)-q)+5]);                  printf("        %d [%d]\n", (*i), p[((*i)-q)]);
713                                 w++;
714                                 break;
715                         }
716                         else
717                         {
718                                 if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);
719                                 else outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3))]);
720                         }
721                 }
722         }
723
724 //      if(q>0) 
725         printf("2       (*i)=%02d\n", (*i)/3);
726
727         //palette checker~
728         if(q>0 && qp==0)
729         {
730                 long lq;
731                 long bufSize = (bmp->width * bmp->height);
732                 pp = q;
733                 //printf("1(*i)=%02d\n", (*i)/3);
734                 //printf("1z=%02d\n", z/3);
735                 chkcolor(bmp, &q, &a, &aa, &z, i);
736                 //printf("2(*i)=%02d\n", (*i)/3);
737                 //printf("2z=%02d\n", z/3);
738
739                 /*printf("z=%d\n", z/3);
740                 printf("q+z=%d\n", (q+z)/3);
741                 printf("z-ppee=%d\n", (z-ppee)/3);*/
742                 //printf("      q=%d\n", q/3);
743                 //printf("aa=%d\n", aa);
744
745                 aq=0;//ppee=q;
746 aqpee:
747                 while(aq<=aa)
748                 {
749                         //printf("a[%02d]=(%d)", aq, a[aq]);
750                         if(a[aq]==0) aq++;
751                         else{ aqpp++; break; }
752                 }
753
754                 //printf("(*i)  =%02d\n", (*i)/3);
755                 //printf("z     =%02d\n", z/3);
756                 printf("aq=%02d\n", aq);
757                 //printf("aqpp=%02d\n", aqpp);
758
759         for(lq=0; lq<bufSize; lq++)
760         {
761                 if(bmp->data[lq]+bmp->offset==aq)
762                 {
763                         //printf("\n%02d\n", bmp->data[lq]);
764                         //printf("\n%02d\n", bmp->offset);
765                         //printf("\naq= %02d\n", aq);
766                         //printf("a[aq]=        %02d\n", a[aq]);
767                         //bmp->data[lq]=((bmp->data[lq]+bmp->offset)-a[aq]);
768                         bmp->data[lq]=a[aq];
769                         printf("_%d ", bmp->data[lq]);
770                         if(lq > 0 && lq%bmp->width==0) printf("\n");
771                 }
772                 else if(bmp->data[lq]+bmp->offset < ((*i)/3)-aqpp)
773                 {
774                         if(bmp->data[lq]+bmp->offset >= aq)
775                         {
776                                 bmp->data[lq]=(bmp->data[lq]+bmp->offset)-aqpp-((z-(*i))/3);
777                                 //printf("_%d \n", bmp->data[lq]);
778                         }
779                         else bmp->data[lq]+=(bmp->offset);
780                 }
781
782                 //printf("%02d ", bmp->data[lq]);
783                 //if(lq > 0 && lq%bmp->width==0) printf("\n");
784         }
785
786         /*while(pp<=(aq*3))
787         {
788                 if(((pp/3)==aq || spee>0))
789                 {
790                         printf("spee=%d\n", spee);
791                         printf("                pp=%02d ", pp/3);
792                         printf("old     bmp: [%d]", bmp->palette[(pp-ppee)]);
793                         printf("[%d]", bmp->palette[(pp-ppee)+1]);
794                         printf("[%d]\n", bmp->palette[(pp-ppee)+2]);
795                         //if(spee==0) printf("\npp=%02d\n\n", pp/3);
796                         //if(bmp->cleaned==0)
797                         //{
798                                 bmp->palette[(pp-ppee)]=                bmp->palette[(pp-ppee)+3];
799                                 bmp->palette[(pp-ppee)+1]=      bmp->palette[(pp-ppee)+4];
800                                 bmp->palette[(pp-ppee)+2]=      bmp->palette[(pp-ppee)+5];
801                         //}
802                         if(spee==0) spee++;
803                 }
804                 printf("                pp=%02d ", pp/3);
805                 printf("        bmp: [%d]", bmp->palette[(pp-ppee)]);
806                 printf("[%d]", bmp->palette[(pp-ppee)+1]);
807                 printf("[%d]\n", bmp->palette[(pp-ppee)+2]);
808                 pp+=3;
809                 //if(pp==(aq*3)) bmp->cleaned++;
810         }*/
811
812 //printf("              aq=%02d\n", aq);
813 //printf("              aa=%02d\n", aa);/
814
815         //update the palette~
816         //printf("      aqpp=           %d\n", aqpp);
817         //printf("1     pp=     %d\n", pp/3);
818         modexPalUpdate(bmp, &pp, 1, aqpp);
819         (*i)=pp;
820         //printf("      (*i)=%d\n", (*i)/3);
821         //printf("2     pp=%02d\n", pp/3);
822
823         //printf(".\n");
824         //printf("      aqpp=           %d\n", aqpp);
825         /*printf("aq=   %02d\n", aq);
826         printf("aa=     %02d\n", aa);
827         printf("                ppee=   %02d\n", ppee);*/
828
829         if(aq<aa){ /*printf("~~~~\n"); */pp=q; aq++; goto aqpee; }
830         /*printf("ppee=%d\n", ppee);
831         printf("pp=%d\n", pp);
832         printf("q=%d\n", q);
833         printf("(*i)=%d\n", (*i));*/
834         /*if(q>0)
835         {
836                 //printf("z=%d\n", z/3);
837                 //printf("(*i)=%d\n", (*i)/3);
838                 //(*i)+=3;
839 //----          printf("count=%d\n", count);
840         }*/
841         }
842 }
843
844 void
845 modexPalUpdate2(byte *p)
846 {
847         int i;
848         modexWaitBorder();
849         outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
850         for(i=0; i<PAL_SIZE/2; i++)
851         {
852                 outp(PAL_DATA_REG, p[i]);
853         }
854         modexWaitBorder();          /* waits one retrace -- less flicker */
855         for(; i<PAL_SIZE; i++)
856         {
857                 outp(PAL_DATA_REG, p[(i)]);
858         }
859 }
860
861 void
862 modexPalUpdate3(byte *p)
863 {
864         int i;
865         modexWaitBorder();
866         outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
867         for(i=0; i<PAL_SIZE/2; i++)
868         {
869                 outp(PAL_DATA_REG, rand());
870         }
871         modexWaitBorder();          /* waits one retrace -- less flicker */
872         for(; i<PAL_SIZE; i++)
873         {
874                 outp(PAL_DATA_REG, rand());
875         }
876 }
877
878 //color checker~
879 //i want to make another vesion that checks the palette when the palette is being appened~
880 void chkcolor(bitmap_t *bmp, word *q, word *a, word *aa, word *z, word *i)
881 {
882                 byte *pal;
883                 word zz=0;
884                 pal = modexNewPal();
885                 modexPalSave(pal);
886                 //printf("q: %02d\n", (*q));
887
888                 //check palette for dups
889                 for(; (*z)<PAL_SIZE; (*z)+=3)
890                 {
891 //                      printf("\n              z: %d\n", (*z));
892 //                      printf("                q: %d\n", (*q));
893 //                      printf("                z+q: %d\n\n", ((*z)+(*q)));
894                         if((*z)%3==0)
895                         {
896 //----                          if(pal[(*z)]==pal[(*z)+3] && pal[(*z)+1]==pal[(*z)+4] && pal[(*z)+2]==pal[(*z)+5])
897                                 if((*z)==(*i))
898                                 {
899 //                                      printf("\n%d    [%02d][%02d][%02d]\n", (*z), pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
900 //                                      printf("%d      [%02d][%02d][%02d]\n\n", (*z)+3, pal[(*z)+3], pal[(*z)+4], pal[(*z)+5]);
901 //0000                                  (*z)-=3;
902                                         break;
903                                 }
904                                 else for(zz=0; zz<(*q); zz+=3)
905                                 {
906                                         //zq=(zz+(q-3));
907                                         //printf("zz: %02d\n", zz/3);
908                                         if(zz%3==0)
909                                         {
910                                                 if(pal[((*z)+(*q))]==pal[((*z)+(*q))+3] && pal[((*z)+(*q))+1]==pal[((*z)+(*q))+4] && pal[((*z)+(*q))+2]==pal[((*z)+(*q))+5])
911                                                 {
912 //                                                      (*z)-=3;
913 //                                                      (*i)-=3;
914 //                                                      printf("\nzq1:%d[%02d][%02d][%02d]\n", (zz+q), pal[(zz+q)], pal[(zz+q)+1], pal[(zz+q)+2]);
915 //                                                      printf("zq2:%d[%02d][%02d][%02d]\n\n", (zz+q)+3, pal[(zz+q)+3], pal[(zz+q)+4], pal[(zz+q)+5]);
916 //0000                                                  printf("wwww\n");
917                                                         break;
918                                                 }
919                                                 else if(pal[zz]==pal[((*z)+(*q))] && pal[zz+1]==pal[((*z)+(*q))+1] && pal[zz+2]==pal[((*z)+(*q))+2])
920                                                 {
921 //                                                      printf("\n\nwwwwwwwwwwwwwwww\n");
922 //                                                      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]);
923 //                                                      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]);
924 //                                                      //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]);
925 //                                                      printf("        z : %d  [%02d][%02d][%02d] offset value~\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
926                                                         a[((*z)+(*q))/3]=zz/3;
927                                                         (*aa)=((*z)+(*q))/3;
928                                                         //(*i)--;
929 //                                                      printf("\n              aa: %d\n\n", (*aa));
930 //                                                      printf("        a[%02d]=(%02d) offset array i think the palette should be updated again~\n", ((*z)+(*q))/3, a[((*z)+(*q))/3]);
931 //                                                      printf("wwwwwwwwwwwwwwww\n\n");
932                                                 }
933                                                 /*else
934                                                 {
935                                                         printf("================\n");
936                                                         printf("zq: %d  [%02d][%02d][%02d]\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);
937                                                         printf("zz: %d  [%02d][%02d][%02d]\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
938                                                         printf("z : %d  [%02d][%02d][%02d]\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);
939                                                         printf("================\n");
940                                                 }*/
941                                                 //printf("[%d]", (zz+q));
942                                         }
943                                 }
944                                 //printf("\nz:  %d\n", z);
945                                 //printf("q:    %d\n", q);
946                                 //printf("zz:   %d\n", zz);
947                         }
948                 }
949                 //printf("              aa: %d\n", (*aa));
950                 printf("                                (*z): %d\n", (*z)/3);
951                 printf("                                (*i): %d\n", (*i)/3);
952                 free(pal);
953 }
954
955 void
956 modexWaitBorder() {
957     while(inp(INPUT_STATUS_1)  & 8)  {
958         /* spin */
959     }
960
961     while(!(inp(INPUT_STATUS_1)  & 8))  {
962         /* spin */
963     }
964 }