]> 4ch.mooo.com Git - 16.git/blob - src/lib/modex16.c
Having issues with updating palette~ ><
[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)
595 {
596         byte *p = bmp->palette;
597         word w=0;
598         word q=0;
599
600         if(qp>0) printf("(*i)=%02d\n", (*i)/3);
601
602         modexWaitBorder();
603         if((*i)==0) outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
604         else if(qp==0) q=(*i);// else outp(PAL_WRITE_REG, (*i));
605         if((*i)<PAL_SIZE/2 && w==0)
606         {
607                 for(; (*i)<PAL_SIZE/2; (*i)++)
608                 {
609                         //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]))
610 //____                  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
611                         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]))
612                         {
613 //                              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)]);
614                                 w++;
615                                 break;
616                         }
617                         else
618                         {
619                                 outp(PAL_DATA_REG, p[(*i)-q]);
620                         }
621                 }
622         }
623         modexWaitBorder();          /* waits one retrace -- less flicker */
624         if((*i)>=PAL_SIZE/2 && w==0)
625         {
626                 for(; (*i)<PAL_SIZE; (*i)++)
627                 {
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 && (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 //                              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)]);
632                                 w++;
633                                 break;
634                         }
635                         else
636                         {
637                                 outp(PAL_DATA_REG, p[(*i)-q]);
638                         }
639                 }
640         }
641
642
643         //palette checker~
644         if(q>0 && qp==0)
645         {
646                 static word a[256] = { 0 };
647                 long lq;
648                 long bufSize = (bmp->width * bmp->height);
649                 byte *pal;
650                 word z, zz=0,aq=0,aa=0,pp=0,aqpp=0,spee=0,ppp=0;
651                 pal = modexNewPal();
652                 modexPalSave(pal);
653                 //q-=3;
654                 printf("q: %02d\n", (q/3));
655                 //check palette for dups
656                 for(z=0; z<PAL_SIZE; z+=3)
657                 {
658                         if(z%3==0)
659                         {
660                                 if(pal[z]==pal[z+3] && pal[z+1]==pal[z+4] && pal[z+2]==pal[z+5])
661                                 {
662 //                                      printf("\n%d    [%02d][%02d][%02d]\n", z, pal[z], pal[z+1], pal[z+2]);
663 //                                      printf("%d      [%02d][%02d][%02d]\n\n", z+3, pal[z+3], pal[z+4], pal[z+5]);
664                                         break;
665                                 }
666                                 else for(zz=0; zz<q; zz+=3)
667                                 {
668                                         //zq=(zz+(q-3));
669                                         //printf("zz: %02d\n", zz/3);
670                                         if(zz%3==0)
671                                         {
672                                                 if(pal[(z+q)]==pal[(z+q)+3] && pal[(z+q)+1]==pal[(z+q)+4] && pal[(z+q)+2]==pal[(z+q)+5])
673                                                 {
674 //                                                      printf("\nzq1:%d[%02d][%02d][%02d]\n", (zz+q), pal[(zz+q)], pal[(zz+q)+1], pal[(zz+q)+2]);
675 //                                                      printf("zq2:%d[%02d][%02d][%02d]\n\n", (zz+q)+3, pal[(zz+q)+3], pal[(zz+q)+4], pal[(zz+q)+5]);
676                                                         break;
677                                                 }
678                                                 else if(pal[zz]==pal[(z+q)] && pal[zz+1]==pal[(z+q)+1] && pal[zz+2]==pal[(z+q)+2])
679                                                 {
680 //                                                      printf("\n\nwwwwwwwwwwwwwwww\n");
681 //                                                      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]);
682 //                                                      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]);
683 //                                                      //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]);
684 //                                                      printf("        z : %d  [%02d][%02d][%02d] offset value~\n", z/3, pal[z], pal[z+1], pal[z+2]);
685                                                         a[(z+q)/3]=zz/3;
686                                                         aa=(z+q)/3;
687 //                                                      printf("        a[%02d]=(%02d) offset array i think the palette should be updated again~\n", (z+q)/3, a[(z+q)/3]);
688 //                                                      printf("wwwwwwwwwwwwwwww\n\n");
689                                                 }
690                                                 /*else
691                                                 {
692                                                         printf("================\n");
693                                                         printf("zq: %d  [%02d][%02d][%02d]\n", (z+q)/3, pal[(z+q)], pal[(z+q)+1], pal[(z+q)+2]);
694                                                         printf("zz: %d  [%02d][%02d][%02d]\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);
695                                                         printf("z : %d  [%02d][%02d][%02d]\n", z/3, pal[z], pal[z+1], pal[z+2]);
696                                                         printf("================\n");
697                                                 }*/
698                                                 //printf("[%d]", (zz+q));
699                                         }
700                                 }
701                                 //printf("\nz:  %d\n", z);
702                                 //printf("q:    %d\n", q);
703                                 //printf("zz:   %d\n", zz);
704                         }
705                 }
706
707 //              printf("z=%d\n", z/3);
708 //              printf("q+z=%d\n", (q+z)/3);
709 //              printf("z-q=%d\n", (z-q)/3);
710 //              printf("%d\n", (z-(z-q))/3);
711 //              printf("q=%d\n", q/3);
712 //              printf("aa=%d\n", aa);
713
714                 aq=0; pp = q; ppp=q;//(aq)*3;
715 aqpee:
716                 while(aq<aa)
717                 {
718                         //printf("a[%02d]=(%d)", aq, a[aq]);
719                         if(a[aq]==0) aq++;
720                         else break;
721                 }
722
723 //              spee=0;
724
725                 aqpp=(aq*3);
726                 //aqpp=q*2;
727
728 //                      printf("\naq=%02d\n", aq);
729 //                      printf("spee=%02d\n\n", spee);
730                         //printf("aqpp=%02d\n\n", aqpp/3);
731
732         for(lq=0; lq<bufSize; lq++)
733         {
734                 if(bmp->data[lq]+bmp->offset==aq)
735                 {
736                         //printf("%02d", bmp->data[lq]);
737                         //printf("\n%02d\n", bmp->offset);
738                         //printf("%02d\n", a[aq]);
739                         bmp->data[lq]=((bmp->data[lq]+bmp->offset)-a[aq]);
740                 }
741                 else if(bmp->data[lq]+bmp->offset < z/3){ bmp->data[lq]+=bmp->offset; }
742                 //printf("%02d ", bmp->data[lq]);
743                 //if(lq > 0 && lq%bmp->width==0) printf("\n");
744         }
745
746 //      if(spee==0)
747 //      {
748         while(pp<=aqpp)
749         {
750                 //if(pp<(z-1))
751                 /*printf("pp=%02d       ", pp/3);
752                 printf("bmp: [%d]", bmp->palette[pp-q]);
753                 printf("[%d]", bmp->palette[(pp-q)+1]);
754                 printf("[%d]\n", bmp->palette[(pp-q)+2]);*/
755                 if(((pp/3)==aq || spee>0))
756                 {
757                         printf("spee=%d\n", spee);
758                         printf("                pp=%02d ", pp/3);
759                         printf("old     bmp: [%d]", bmp->palette[(pp-ppp)]);
760                         printf("[%d]", bmp->palette[(pp-ppp)+1]);
761                         printf("[%d]\n", bmp->palette[(pp-ppp)+2]);
762                         //if(spee==0) printf("\npp=%02d\n\n", pp/3);
763                         bmp->palette[(pp-ppp)]=         bmp->palette[(pp-ppp)+3];
764                         bmp->palette[(pp-ppp)+1]=       bmp->palette[(pp-ppp)+4];
765                         bmp->palette[(pp-ppp)+2]=       bmp->palette[(pp-ppp)+5];
766                         if(spee==0) spee++;
767                 }
768 /*              bmp->palette[pp]=               bmp->palette[pp+3];
769                 bmp->palette[pp+1]=     bmp->palette[pp+4];
770                 bmp->palette[pp+2]=     bmp->palette[pp+5];*/
771                 printf("                pp=%02d ", pp/3);
772                 printf("        bmp: [%d]", bmp->palette[(pp-ppp)]);
773                 printf("[%d]", bmp->palette[(pp-ppp)+1]);
774                 printf("[%d]\n", bmp->palette[(pp-ppp)+2]);
775 /*              printf("bmp: [%d]", bmp->palette[pp]);
776                 printf("[%d]", bmp->palette[pp+1]);
777                 printf("[%d]\n", bmp->palette[pp+2]);*/
778                 //aqpp=(pp-q);
779                 //else if(pp==(z-1)) bmp->palette[pp]=0;
780                 pp+=3;
781         }
782 //      spee++;
783         printf("aqpp=   %02d\n", aqpp/3);
784         //printf("&aqpp=        %02d\n", &aqpp);
785         //printf("q=    %02d\n", q/3);
786         //printf("z=    %02d\n", z/3);
787         //printf("&q=   %02d\n", &q);
788         //modexPalUpdate(bmp, &q, 1);
789         //modexPalUpdate(bmp, &, 1);
790 //      if(pp<=aqpp) 
791         //modexPalUpdate(bmp, &ppp, 1);
792         modexPalUpdate(bmp, 0, 1);
793 //      }
794
795 //      modexPalUpdate(bmp, 0, 1);
796
797         if(aq<aa){ printf("~~~~\n"); ppp=q; /*spee=0;*/ aq++; goto aqpee; }
798
799         }
800 }
801
802 void
803 modexPalUpdate2(byte *p)
804 {
805         int i;
806         modexWaitBorder();
807         outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */
808         for(i=0; i<PAL_SIZE/2; i++)
809         {
810                 outp(PAL_DATA_REG, p[i]);
811         }
812         modexWaitBorder();          /* waits one retrace -- less flicker */
813         for(; i<PAL_SIZE; i++)
814         {
815                 outp(PAL_DATA_REG, p[(i)]);
816         }
817 }
818
819 void
820 modexWaitBorder() {
821     while(inp(INPUT_STATUS_1)  & 8)  {
822         /* spin */
823     }
824
825     while(!(inp(INPUT_STATUS_1)  & 8))  {
826         /* spin */
827     }
828 }