I DID IT PLANAR BUFFERING IS RENDERED! IT JUST NEEDS POLISHING~

diff --git a/16.exe b/16.exe
index 0eac45e61c4a36bc7b226cb28986f13aecac2e38..b2de2cf4325eda78d29398f5dc56612c027091d9 100755 (executable)
Binary files a/16.exe and b/16.exe differ

diff --git a/bakapi.exe b/bakapi.exe
index 4bc4733b6f409cae830d737d81ab5e0e5a55e4db..191066e2da7a316a3a7a0f299023f4faf4a98957 100755 (executable)
Binary files a/bakapi.exe and b/bakapi.exe differ

diff --git a/exmmtest.exe b/exmmtest.exe
index 0645e31eac07673a2e1a217a0f5a44796d5af713..573d7487b06d0a00ea7f7e6ce4b153344d80b4b1 100755 (executable)
Binary files a/exmmtest.exe and b/exmmtest.exe differ

diff --git a/fontgfx.exe b/fontgfx.exe
index 13953f93820f7dc6ebb18159c088750cc0145408..da3d1446916809d77883b7682682716cf6c801f5 100755 (executable)
Binary files a/fontgfx.exe and b/fontgfx.exe differ

diff --git a/maptest.exe b/maptest.exe
index 0ebfa9faacf17a5f314de580c3083474c9eabe3b..9e8a2c6407ddb55b403d810855a8ed0348207d2b 100755 (executable)
Binary files a/maptest.exe and b/maptest.exe differ

diff --git a/palettec.exe b/palettec.exe
index 38431222bcc0af01084f9a93ed0ff497181803f2..00180097ff301b4e1fb545817302ec98aef64105 100755 (executable)
Binary files a/palettec.exe and b/palettec.exe differ

diff --git a/palettel.exe b/palettel.exe
index de042c2fdea470f825c2f58cc8deb7fddc2f4796..7ef37e50870c7748f2b3156a64979da5d01d8521 100755 (executable)
Binary files a/palettel.exe and b/palettel.exe differ

diff --git a/pcxtest.exe b/pcxtest.exe
index a5070a2f792e7aee31ef6381a24c270714aa1a77..4ff8f919aaf60555ce669362b76384ba51bbc2fa 100755 (executable)
Binary files a/pcxtest.exe and b/pcxtest.exe differ

diff --git a/pcxtest2.exe b/pcxtest2.exe
index 0e215b4cbe06e6bd1619b309c0699096058edde1..454e4515133b766bfde0a5b31297de6f5904ef92 100755 (executable)
Binary files a/pcxtest2.exe and b/pcxtest2.exe differ

diff --git a/planrpcx.exe b/planrpcx.exe
index 390b37837e72c288c6354e6eff8e20c7e9eb066f..429816d95093ad2f54981111e5dc923fcc96da3a 100755 (executable)
Binary files a/planrpcx.exe and b/planrpcx.exe differ

diff --git a/scroll.exe b/scroll.exe
index c93f9c1873c17edce379bed8e040ac5a18e88b0f..c495ac894aec013e3a4ad1caf1620d35a296065a 100755 (executable)
Binary files a/scroll.exe and b/scroll.exe differ

diff --git a/src/lib/mapread.c b/src/lib/mapread.c
index 7fc94d189f567051bc0d58ca7b7cfffaf1d90463..205bf39a6ca32163ce9c483d6e58d9038973fa8f 100755 (executable)
--- a/src/lib/mapread.c
+++ b/src/lib/mapread.c
@@ -74,7 +74,7 @@ word dump(const char *js, jsmntok_t *t, size_t count, word indent, char *js_sv,
                        //map->tiles->data = malloc(sizeof(bitmap_t));
                        //fix this to be far~
                        bp = bitmapLoadPcx("data/ed.pcx");
-                       map->tiles->data = &bp;
+                       map->tiles->btdata = &bp;
                        //map->tiles->data->data = malloc((16/**2*/)*16);
                        //map->tiles->data->width = (16/**2*/);
                        //map->tiles->data->height= 16;

diff --git a/src/lib/mapread.h b/src/lib/mapread.h
index 7b22348b69606999c12c503fcf9483a5ba7259f9..b8062211d456350c31c64400fc4060d158d90e58 100755 (executable)
--- a/src/lib/mapread.h
+++ b/src/lib/mapread.h
@@ -16,7 +16,8 @@
 //#define DEBUG_JS\r
 \r
 typedef struct {\r
-       bitmap_t *data;\r
+       bitmap_t huge *btdata;\r
+//     planar_buf_t huge *data;\r
        word tileHeight;\r
        word tileWidth;\r
        unsigned int rows;\r

diff --git a/src/lib/modex16.c b/src/lib/modex16.c
index 19ab89c711592f593524195ef7957539fe1c3d0d..8a0015bd5e2b06f9a1d7ec22551bf4d4e658ed8a 100755 (executable)
--- a/src/lib/modex16.c
+++ b/src/lib/modex16.c
@@ -499,6 +499,7 @@ oldDrawBmp(byte far* page, int x, int y, bitmap_t *bmp, byte sprite)
        }\r
 }\r
 \r
+//* normal versions *//\r
 void\r
 modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {\r
     /* draw the region (the entire freakin bitmap) */\r
@@ -508,19 +509,18 @@ modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {
 void\r
 modexDrawBmpRegion(page_t *page, int x, int y,\r
                   int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
-    word poffset = (word) page->data  + y*(page->width/4) + x/4;\r
-    byte far *data = bmp->data;//+bmp->offset;\r
-    word bmpOffset = (word) data + ry * bmp->width + rx;\r
-    word width = rw;\r
-    word height = rh;\r
-    byte plane = 1 << ((byte) x & 0x03);\r
-    word scanCount = width/4 + (width%4 ? 1 :0);\r
-    word nextPageRow = page->width/4 - scanCount;\r
-    word nextBmpRow = (word) bmp->width - width;\r
-    word rowCounter;\r
-    byte planeCounter = 4;\r
-\r
-       //code is a bit slow here\r
+       word poffset = (word) page->data  + y*(page->width/4) + x/4;\r
+       byte *data = bmp->data;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw;\r
+       word height = rh;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
     __asm {\r
                MOV AX, SCREEN_SEG      ; go to the VGA memory\r
                MOV ES, AX\r
@@ -555,7 +555,6 @@ modexDrawBmpRegion(page_t *page, int x, int y,
                DEC rowCounter\r
                JNZ ROW_LOOP        ; do all the rows\r
                ;-- end plane painting\r
-\r
                MOV AL, plane      ; advance to the next plane\r
                SHL AL, 1              ;\r
                AND AL, 0x0f        ; mask the plane properly\r
@@ -577,17 +576,163 @@ modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp) {
 void\r
 modexDrawSpriteRegion(page_t *page, int x, int y,\r
                      int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
-    word poffset = (word)page->data + y*(page->width/4) + x/4;\r
-    byte *data = bmp->data;//+bmp->offset;\r
-    word bmpOffset = (word) data + ry * bmp->width + rx;\r
-    word width = rw;\r
-    word height = rh;\r
-    byte plane = 1 << ((byte) x & 0x03);\r
-    word scanCount = width/4 + (width%4 ? 1 :0);\r
-    word nextPageRow = page->width/4 - scanCount;\r
-    word nextBmpRow = (word) bmp->width - width;\r
-    word rowCounter;\r
-    byte planeCounter = 4;\r
+       word poffset = (word)page->data + y*(page->width/4) + x/4;\r
+       byte *data = bmp->data;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw;\r
+       word height = rh;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
+    __asm {\r
+               MOV AX, SCREEN_SEG      ; go to the VGA memory\r
+               MOV ES, AX\r
+\r
+               MOV DX, SC_INDEX        ; point at the map mask register\r
+               MOV AL, MAP_MASK        ;\r
+               OUT DX, AL            ;\r
+\r
+       PLANE_LOOP:\r
+               MOV DX, SC_DATA  ; select the current plane\r
+               MOV AL, plane      ;\r
+               OUT DX, AL            ;\r
+\r
+               ;-- begin plane painting\r
+               MOV AX, height    ; start the row counter\r
+               MOV rowCounter, AX      ;\r
+               MOV DI, poffset  ; go to the first pixel\r
+               MOV SI, bmpOffset       ; go to the bmp pixel\r
+       ROW_LOOP:\r
+               MOV CX, width      ; count the columns\r
+       SCAN_LOOP:\r
+               LODSB\r
+               DEC SI\r
+               CMP AL, 0\r
+               JNE DRAW_PIXEL    ; draw non-zero pixels\r
+\r
+               INC DI            ; skip the transparent pixel\r
+               ADD SI, 1\r
+               JMP NEXT_PIXEL\r
+       DRAW_PIXEL:\r
+               MOVSB              ; copy the pixel\r
+       NEXT_PIXEL:\r
+               SUB CX, 3              ; we skip the next 3\r
+               ADD SI, 3              ; skip the bmp pixels\r
+               LOOP SCAN_LOOP    ; finish the scan\r
+\r
+               MOV AX, nextPageRow\r
+               ADD DI, AX            ; go to the next row on screen\r
+               MOV AX, nextBmpRow\r
+               ADD SI, AX            ; go to the next row on bmp\r
+\r
+               DEC rowCounter\r
+               JNZ ROW_LOOP        ; do all the rows\r
+               ;-- end plane painting\r
+\r
+               MOV AL, plane      ; advance to the next plane\r
+               SHL AL, 1              ;\r
+               AND AL, 0x0f        ; mask the plane properly\r
+               MOV plane, AL      ; store the plane\r
+\r
+               INC bmpOffset      ; start bmp at the right spot\r
+\r
+               DEC planeCounter\r
+               JNZ PLANE_LOOP    ; do all 4 planes\r
+    }\r
+}\r
+\r
+//* planar buffer versions *//\r
+void\r
+modexDrawBmpPBuf(page_t *page, int x, int y, planar_buf_t *bmp) {\r
+    /* draw the region (the entire freakin bitmap) */\r
+    modexDrawBmpPBufRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
+}\r
+\r
+void\r
+modexDrawBmpPBufRegion(page_t *page, int x, int y,\r
+                  int rx, int ry, int rw, int rh, planar_buf_t *bmp) {\r
+       word poffset = (word) page->data  + y*(page->width/4) + x/4;\r
+       byte huge *data = *bmp->plane;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw/4;\r
+       word height = rh/4;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
+    __asm {\r
+               MOV AX, SCREEN_SEG      ; go to the VGA memory\r
+               MOV ES, AX\r
+\r
+               MOV DX, SC_INDEX        ; point at the map mask register\r
+               MOV AL, MAP_MASK        ;\r
+               OUT DX, AL            ;\r
+\r
+       PLANE_LOOP:\r
+               MOV DX, SC_DATA  ; select the current plane\r
+               MOV AL, plane      ;\r
+               OUT DX, AL            ;\r
+\r
+               ;-- begin plane painting\r
+               MOV AX, height    ; start the row counter\r
+               MOV rowCounter, AX      ;\r
+               MOV DI, poffset  ; go to the first pixel\r
+               MOV SI, bmpOffset       ; go to the bmp pixel\r
+       ROW_LOOP:\r
+               MOV CX, width      ; count the columns\r
+       SCAN_LOOP:\r
+               MOVSB              ; copy the pixel\r
+               SUB CX, 3              ; we skip the next 3\r
+               ADD SI, 3              ; skip the bmp pixels\r
+               LOOP SCAN_LOOP    ; finish the scan\r
+\r
+               MOV AX, nextPageRow\r
+               ADD DI, AX            ; go to the next row on screen\r
+               MOV AX, nextBmpRow\r
+               ADD SI, AX            ; go to the next row on bmp\r
+\r
+               DEC rowCounter\r
+               JNZ ROW_LOOP        ; do all the rows\r
+               ;-- end plane painting\r
+               MOV AL, plane      ; advance to the next plane\r
+               SHL AL, 1              ;\r
+               AND AL, 0x0f        ; mask the plane properly\r
+               MOV plane, AL      ; store the plane\r
+\r
+               INC bmpOffset      ; start bmp at the right spot\r
+\r
+               DEC planeCounter\r
+               JNZ PLANE_LOOP    ; do all 4 planes\r
+    }\r
+}\r
+\r
+void\r
+modexDrawSpritePBuf(page_t *page, int x, int y, planar_buf_t *bmp) {\r
+    /* draw the whole sprite */\r
+    modexDrawSpritePBufRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
+}\r
+\r
+void\r
+modexDrawSpritePBufRegion(page_t *page, int x, int y,\r
+                     int rx, int ry, int rw, int rh, planar_buf_t *bmp) {\r
+       word poffset = (word)page->data + y*(page->width/4) + x/4;\r
+       byte huge *data = *bmp->plane;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw/4;\r
+       word height = rh/4;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
 \r
     __asm {\r
                MOV AX, SCREEN_SEG      ; go to the VGA memory\r

diff --git a/src/lib/modex16.h b/src/lib/modex16.h
index 9c9ea4bb6a4c00f54215d5e6077a13f9db456331..7eb605407ced0c7c702d5506fcf0398beb00bbc1 100755 (executable)
--- a/src/lib/modex16.h
+++ b/src/lib/modex16.h
@@ -77,6 +77,10 @@ void modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp);
 void modexDrawBmpRegion(page_t *page, int x, int y, int rx, int ry, int rw, int rh, bitmap_t *bmp);
 void modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp);
 void modexDrawSpriteRegion(page_t *page, int x, int y, int rx, int ry, int rw, int rh, bitmap_t *bmp);
+void modexDrawBmpPBuf(page_t *page, int x, int y, planar_buf_t *bmp); /*pbuf version*/
+void modexDrawBmpPBufRegion(page_t *page, int x, int y, int rx, int ry, int rw, int rh, planar_buf_t *bmp);
+void modexDrawSpritePBuf(page_t *page, int x, int y, planar_buf_t *bmp);
+void modexDrawSpritePBufRegion(page_t *page, int x, int y, int rx, int ry, int rw, int rh, planar_buf_t *bmp);
 void modexCopyPageRegion(page_t *dest, page_t *src, word sx, word sy, word dx, word dy, word width, word height);
 
 /* Palette fade and flash effects */

diff --git a/src/lib/modex16/rn.c b/src/lib/modex16/rn.c
new file mode 100755 (executable)
index 0000000..61bc1a5
--- /dev/null
+++ b/src/lib/modex16/rn.c
@@ -0,0 +1,144 @@
+void\r
+modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {\r
+    /* draw the region (the entire freakin bitmap) */\r
+    modexDrawBmpRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
+}\r
+\r
+void\r
+modexDrawBmpRegion(page_t *page, int x, int y,\r
+                  int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
+       word poffset = (word) page->data  + y*(page->width/4) + x/4;\r
+       byte *data = bmp->data;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw;\r
+       word height = rh;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
+    __asm {\r
+               MOV AX, SCREEN_SEG      ; go to the VGA memory\r
+               MOV ES, AX\r
+\r
+               MOV DX, SC_INDEX        ; point at the map mask register\r
+               MOV AL, MAP_MASK        ;\r
+               OUT DX, AL            ;\r
+\r
+       PLANE_LOOP:\r
+               MOV DX, SC_DATA  ; select the current plane\r
+               MOV AL, plane      ;\r
+               OUT DX, AL            ;\r
+\r
+               ;-- begin plane painting\r
+               MOV AX, height    ; start the row counter\r
+               MOV rowCounter, AX      ;\r
+               MOV DI, poffset  ; go to the first pixel\r
+               MOV SI, bmpOffset       ; go to the bmp pixel\r
+       ROW_LOOP:\r
+               MOV CX, width      ; count the columns\r
+       SCAN_LOOP:\r
+               MOVSB              ; copy the pixel\r
+               SUB CX, 3              ; we skip the next 3\r
+               ADD SI, 3              ; skip the bmp pixels\r
+               LOOP SCAN_LOOP    ; finish the scan\r
+\r
+               MOV AX, nextPageRow\r
+               ADD DI, AX            ; go to the next row on screen\r
+               MOV AX, nextBmpRow\r
+               ADD SI, AX            ; go to the next row on bmp\r
+\r
+               DEC rowCounter\r
+               JNZ ROW_LOOP        ; do all the rows\r
+               ;-- end plane painting\r
+               MOV AL, plane      ; advance to the next plane\r
+               SHL AL, 1              ;\r
+               AND AL, 0x0f        ; mask the plane properly\r
+               MOV plane, AL      ; store the plane\r
+\r
+               INC bmpOffset      ; start bmp at the right spot\r
+\r
+               DEC planeCounter\r
+               JNZ PLANE_LOOP    ; do all 4 planes\r
+    }\r
+}\r
+\r
+void\r
+modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp) {\r
+    /* draw the whole sprite */\r
+    modexDrawSpriteRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
+}\r
+\r
+void\r
+modexDrawSpriteRegion(page_t *page, int x, int y,\r
+                     int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
+       word poffset = (word)page->data + y*(page->width/4) + x/4;\r
+       byte *data = bmp->data;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw;\r
+       word height = rh;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
+    __asm {\r
+               MOV AX, SCREEN_SEG      ; go to the VGA memory\r
+               MOV ES, AX\r
+\r
+               MOV DX, SC_INDEX        ; point at the map mask register\r
+               MOV AL, MAP_MASK        ;\r
+               OUT DX, AL            ;\r
+\r
+       PLANE_LOOP:\r
+               MOV DX, SC_DATA  ; select the current plane\r
+               MOV AL, plane      ;\r
+               OUT DX, AL            ;\r
+\r
+               ;-- begin plane painting\r
+               MOV AX, height    ; start the row counter\r
+               MOV rowCounter, AX      ;\r
+               MOV DI, poffset  ; go to the first pixel\r
+               MOV SI, bmpOffset       ; go to the bmp pixel\r
+       ROW_LOOP:\r
+               MOV CX, width      ; count the columns\r
+       SCAN_LOOP:\r
+               LODSB\r
+               DEC SI\r
+               CMP AL, 0\r
+               JNE DRAW_PIXEL    ; draw non-zero pixels\r
+\r
+               INC DI            ; skip the transparent pixel\r
+               ADD SI, 1\r
+               JMP NEXT_PIXEL\r
+       DRAW_PIXEL:\r
+               MOVSB              ; copy the pixel\r
+       NEXT_PIXEL:\r
+               SUB CX, 3              ; we skip the next 3\r
+               ADD SI, 3              ; skip the bmp pixels\r
+               LOOP SCAN_LOOP    ; finish the scan\r
+\r
+               MOV AX, nextPageRow\r
+               ADD DI, AX            ; go to the next row on screen\r
+               MOV AX, nextBmpRow\r
+               ADD SI, AX            ; go to the next row on bmp\r
+\r
+               DEC rowCounter\r
+               JNZ ROW_LOOP        ; do all the rows\r
+               ;-- end plane painting\r
+\r
+               MOV AL, plane      ; advance to the next plane\r
+               SHL AL, 1              ;\r
+               AND AL, 0x0f        ; mask the plane properly\r
+               MOV plane, AL      ; store the plane\r
+\r
+               INC bmpOffset      ; start bmp at the right spot\r
+\r
+               DEC planeCounter\r
+               JNZ PLANE_LOOP    ; do all 4 planes\r
+    }\r
+}\r

diff --git a/src/lib/modex16/rp.c b/src/lib/modex16/rp.c
new file mode 100755 (executable)
index 0000000..f99cb76
--- /dev/null
+++ b/src/lib/modex16/rp.c
@@ -0,0 +1,144 @@
+void\r
+modexDrawBmpPBuf(page_t *page, int x, int y, planar_buf_t *bmp) {\r
+    /* draw the region (the entire freakin bitmap) */\r
+    modexDrawBmpPBufRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
+}\r
+\r
+void\r
+modexDrawBmpPBufRegion(page_t *page, int x, int y,\r
+                  int rx, int ry, int rw, int rh, planar_buf_t *bmp) {\r
+       word poffset = (word) page->data  + y*(page->width/4) + x/4;\r
+       byte huge *data = *bmp->plane;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw/4;\r
+       word height = rh/4;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
+    __asm {\r
+               MOV AX, SCREEN_SEG      ; go to the VGA memory\r
+               MOV ES, AX\r
+\r
+               MOV DX, SC_INDEX        ; point at the map mask register\r
+               MOV AL, MAP_MASK        ;\r
+               OUT DX, AL            ;\r
+\r
+       PLANE_LOOP:\r
+               MOV DX, SC_DATA  ; select the current plane\r
+               MOV AL, plane      ;\r
+               OUT DX, AL            ;\r
+\r
+               ;-- begin plane painting\r
+               MOV AX, height    ; start the row counter\r
+               MOV rowCounter, AX      ;\r
+               MOV DI, poffset  ; go to the first pixel\r
+               MOV SI, bmpOffset       ; go to the bmp pixel\r
+       ROW_LOOP:\r
+               MOV CX, width      ; count the columns\r
+       SCAN_LOOP:\r
+               MOVSB              ; copy the pixel\r
+               SUB CX, 3              ; we skip the next 3\r
+               ADD SI, 3              ; skip the bmp pixels\r
+               LOOP SCAN_LOOP    ; finish the scan\r
+\r
+               MOV AX, nextPageRow\r
+               ADD DI, AX            ; go to the next row on screen\r
+               MOV AX, nextBmpRow\r
+               ADD SI, AX            ; go to the next row on bmp\r
+\r
+               DEC rowCounter\r
+               JNZ ROW_LOOP        ; do all the rows\r
+               ;-- end plane painting\r
+               MOV AL, plane      ; advance to the next plane\r
+               SHL AL, 1              ;\r
+               AND AL, 0x0f        ; mask the plane properly\r
+               MOV plane, AL      ; store the plane\r
+\r
+               INC bmpOffset      ; start bmp at the right spot\r
+\r
+               DEC planeCounter\r
+               JNZ PLANE_LOOP    ; do all 4 planes\r
+    }\r
+}\r
+\r
+void\r
+modexDrawSpritePBuf(page_t *page, int x, int y, planar_buf_t *bmp) {\r
+    /* draw the whole sprite */\r
+    modexDrawSpritePBufRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
+}\r
+\r
+void\r
+modexDrawSpritePBufRegion(page_t *page, int x, int y,\r
+                     int rx, int ry, int rw, int rh, planar_buf_t *bmp) {\r
+       word poffset = (word)page->data + y*(page->width/4) + x/4;\r
+       byte huge *data = *bmp->plane;//+bmp->offset;\r
+       word bmpOffset = (word) data + ry * bmp->width + rx;\r
+       word width = rw/4;\r
+       word height = rh/4;\r
+       byte plane = 1 << ((byte) x & 0x03);\r
+       word scanCount = width/4 + (width%4 ? 1 :0);\r
+       word nextPageRow = page->width/4 - scanCount;\r
+       word nextBmpRow = (word) bmp->width - width;\r
+       word rowCounter;\r
+       byte planeCounter = 4;\r
+\r
+    __asm {\r
+               MOV AX, SCREEN_SEG      ; go to the VGA memory\r
+               MOV ES, AX\r
+\r
+               MOV DX, SC_INDEX        ; point at the map mask register\r
+               MOV AL, MAP_MASK        ;\r
+               OUT DX, AL            ;\r
+\r
+       PLANE_LOOP:\r
+               MOV DX, SC_DATA  ; select the current plane\r
+               MOV AL, plane      ;\r
+               OUT DX, AL            ;\r
+\r
+               ;-- begin plane painting\r
+               MOV AX, height    ; start the row counter\r
+               MOV rowCounter, AX      ;\r
+               MOV DI, poffset  ; go to the first pixel\r
+               MOV SI, bmpOffset       ; go to the bmp pixel\r
+       ROW_LOOP:\r
+               MOV CX, width      ; count the columns\r
+       SCAN_LOOP:\r
+               LODSB\r
+               DEC SI\r
+               CMP AL, 0\r
+               JNE DRAW_PIXEL    ; draw non-zero pixels\r
+\r
+               INC DI            ; skip the transparent pixel\r
+               ADD SI, 1\r
+               JMP NEXT_PIXEL\r
+       DRAW_PIXEL:\r
+               MOVSB              ; copy the pixel\r
+       NEXT_PIXEL:\r
+               SUB CX, 3              ; we skip the next 3\r
+               ADD SI, 3              ; skip the bmp pixels\r
+               LOOP SCAN_LOOP    ; finish the scan\r
+\r
+               MOV AX, nextPageRow\r
+               ADD DI, AX            ; go to the next row on screen\r
+               MOV AX, nextBmpRow\r
+               ADD SI, AX            ; go to the next row on bmp\r
+\r
+               DEC rowCounter\r
+               JNZ ROW_LOOP        ; do all the rows\r
+               ;-- end plane painting\r
+\r
+               MOV AL, plane      ; advance to the next plane\r
+               SHL AL, 1              ;\r
+               AND AL, 0x0f        ; mask the plane properly\r
+               MOV plane, AL      ; store the plane\r
+\r
+               INC bmpOffset      ; start bmp at the right spot\r
+\r
+               DEC planeCounter\r
+               JNZ PLANE_LOOP    ; do all 4 planes\r
+    }\r
+}\r

diff --git a/src/lib/scroll16.c b/src/lib/scroll16.c
index ccc347a5b1162a11831ff7da64b8ba8695d8104b..39b9394d8df6a42c58239aaf680169ee7f7eb8a0 100755 (executable)
--- a/src/lib/scroll16.c
+++ b/src/lib/scroll16.c
@@ -60,11 +60,7 @@ void walk(map_view_t *pip, player_t *player, word pn)
                        {
                                modexCopyPageRegion(pip[1].page, pip[0].page, player[pn].x-4, player[pn].y-TILEWH, player[pn].x-4, player[pn].y-TILEWH, 24, 32);
 #ifdef SPRITE
-#ifdef BMPTYPE
-                               modexDrawPBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 24, 32, &player[pn].data, 1);
-#else
-                               modexDrawSpriteRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 24, 32, &player[pn].data);
-#endif
+                               modexDrawSpritePBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 24, 32, &player[pn].data);
 #else
                                modexClearRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 14);
 #endif
@@ -105,11 +101,7 @@ void walk(map_view_t *pip, player_t *player, word pn)
                        {
                                modexCopyPageRegion(pip[1].page, pip[0].page, player[pn].x-4, player[pn].y-TILEWH, player[pn].x-4, player[pn].y-TILEWH, 24, 32);
 #ifdef SPRITE
-#ifdef BMPTYPE
-                               modexDrawPBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 96, 24, 32, &player[pn].data, 1);
-#else
-                               modexDrawSpriteRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 96, 24, 32, &player[pn].data);
-#endif
+                               modexDrawSpritePBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 96, 24, 32, &player[pn].data);
 #else
                                modexClearRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 10);
 #endif
@@ -150,11 +142,7 @@ void walk(map_view_t *pip, player_t *player, word pn)
                        {
                                modexCopyPageRegion(pip[1].page, pip[0].page, player[pn].x-4, player[pn].y-TILEWH, player[pn].x-4, player[pn].y-TILEWH, 24, 32);
 #ifdef SPRITE
-#ifdef BMPTYPE
-                               modexDrawPBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 64, 24, 32, &player[pn].data, 1);
-#else
-                               modexDrawSpriteRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 64, 24, 32, &player[pn].data);
-#endif
+                               modexDrawSpritePBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 64, 24, 32, &player[pn].data);
 #else
                                modexClearRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 9);
 #endif
@@ -195,11 +183,7 @@ void walk(map_view_t *pip, player_t *player, word pn)
                        {
                                modexCopyPageRegion(pip[1].page, pip[0].page, player[pn].x-4, player[pn].y-TILEWH, player[pn].x-4, player[pn].y-TILEWH, 24, 32);
 #ifdef SPRITE
-#ifdef BMPTYPE
-                               modexDrawPBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 0, 24, 32, &player[pn].data, 1);
-#else
-                               modexDrawSpriteRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 0, 24, 32, &player[pn].data);
-#endif
+                               modexDrawSpritePBufRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 0, 24, 32, &player[pn].data);
 #else
                                modexClearRegion(pip[1].page, player[pn].x-4, player[pn].y-TILEWH, 24, 32, 12);
 #endif
@@ -494,8 +478,8 @@ mapDrawTile(tiles_t *t, word i, page_t *page, word x, word y)
        }
        else
        {
-               rx = (((i-1) % ((t->data->width)/t->tileWidth)) * t->tileWidth);
-               ry = (((i-1) / ((t->data->height)/t->tileHeight)) * t->tileHeight);
+               rx = (((i-1) % ((t->btdata->width)/t->tileWidth)) * t->tileWidth);
+               ry = (((i-1) / ((t->btdata->height)/t->tileHeight)) * t->tileHeight);
 ////0000printf("i=%d\n", i);
                switch(t->debug_text)
                {
@@ -504,12 +488,8 @@ mapDrawTile(tiles_t *t, word i, page_t *page, word x, word y)
                                modexClearRegion(page, x, y, t->tileWidth, t->tileHeight, ((t->debug_data[i])+1)*2);
                                //cannot print number value du to it being slow as bakapee
 #else
-#ifdef BMPTYPE
-                               modexClearRegion(page, x, y, t->tileWidth, t->tileHeight, ((t->debug_data[i])+1)*2);
-                               //modexDrawPBufRegion(page, x, y, rx, ry, t->tileWidth, t->tileHeight, (t->data), 0);
-#else
-                               modexDrawBmpRegion(page, x, y, rx, ry, t->tileWidth, t->tileHeight, (t->data));
-#endif
+                               //0000modexDrawBmpPBufRegion(page, x, y, rx, ry, t->tileWidth, t->tileHeight, (t->data));
+                               modexDrawBmpRegion(page, x, y, rx, ry, t->tileWidth, t->tileHeight, (t->btdata));
 #endif
                        break;
                        case 1:
@@ -681,17 +661,10 @@ void near animatePlayer(map_view_t *pip, player_t *player, word playnum, sword s
        }
 
 #ifdef SPRITE
-#ifdef BMPTYPE
-#define FRAME1 modexDrawPBufRegion(pip[1].page, x, y, 48, dire, 24, 32, &player[playnum].data, 1);
-#define FRAME2 modexDrawPBufRegion(pip[1].page, x, y, 24, dire, 24, 32, &player[playnum].data, 1);
-#define FRAME3 modexDrawPBufRegion(pip[1].page, x, y, 0, dire, 24, 32, &player[playnum].data, 1);
-#define FRAME4 modexDrawPBufRegion(pip[1].page, x, y, 24, dire, 24, 32, &player[playnum].data, 1);
-#else
-#define FRAME1 modexDrawSpriteRegion(pip[1].page, x, y, 48, dire, 24, 32, &player[playnum].data);
-#define FRAME2 modexDrawSpriteRegion(pip[1].page, x, y, 24, dire, 24, 32, &player[playnum].data);
-#define FRAME3 modexDrawSpriteRegion(pip[1].page, x, y, 0, dire, 24, 32, &player[playnum].data);
-#define FRAME4 modexDrawSpriteRegion(pip[1].page, x, y, 24, dire, 24, 32, &player[playnum].data);
-#endif
+#define FRAME1 modexDrawSpritePBufRegion(pip[1].page, x, y, 48, dire, 24, 32, &player[playnum].data);
+#define FRAME2 modexDrawSpritePBufRegion(pip[1].page, x, y, 24, dire, 24, 32, &player[playnum].data);
+#define FRAME3 modexDrawSpritePBufRegion(pip[1].page, x, y, 0, dire, 24, 32, &player[playnum].data);
+#define FRAME4 modexDrawSpritePBufRegion(pip[1].page, x, y, 24, dire, 24, 32, &player[playnum].data);
 #else
 #define FRAME1 modexClearRegion(pip[1].page, x, y, 24, 32, 2+dire);
 #define FRAME2 modexClearRegion(pip[1].page, x, y, 24, 32, 1+dire);

diff --git a/src/lib/scroll16.h b/src/lib/scroll16.h
index b74570f09d05588ba16d6cc3fe0d32f4e54e2a39..300a05141085b08fa7a50365740519e60c4360ad 100755 (executable)
--- a/src/lib/scroll16.h
+++ b/src/lib/scroll16.h
@@ -33,8 +33,7 @@
 #include "src/lib/timer.h"
 #include "src/lib/wcpu/wcpu.h"
 
-#define SPRITE
-#define BMPTYPE
+//#define SPRITE
 
 typedef struct {
        map_t *map;

diff --git a/src/planrpcx.c b/src/planrpcx.c
index 9594015241f99524de9abd83515f269b34537234..9de942b3f64504fa3116ccaed15b3d6c778629df 100755 (executable)
--- a/src/planrpcx.c
+++ b/src/planrpcx.c
@@ -36,7 +36,7 @@ void main(int argc, char *argv[])
        int i;\r
        word start;\r
        int plane;\r
-       float t1, t2;\r
+       float t1, t2, tpee;\r
        int x,y;\r
        word px,py;\r
        sword baka;\r
@@ -77,7 +77,7 @@ baka = 1;
        start = *clockw;\r
 //             oldDrawBmp(VGA, 20, 20, &bmp, 0);\r
        for(i=0; i<100 ;i++) {\r
-               modexDrawBmp(&gvar.video.page[0], 32, 32, &bmp);\r
+               modexDrawBmpPBuf(&gvar.video.page[0], 32, 32, p);\r
        }\r
        t1 = (*clockw-start) /18.2;\r
 //     start = *clockw;\r
@@ -88,8 +88,9 @@ baka = 1;
                modexDrawPBuf(&gvar.video.page[0], 0, 0, p, 0);\r
        }\r
        t2 = (*clockw-start) /18.2;\r
+       /*getch();\r
        modexPalUpdate1(ptmpbt.palette);\r
-       modexDrawPBufRegion(&gvar.video.page[0], 160, 140, 48, 32, 24, 32, ptmp, 1);\r
+       modexDrawBmpPBufRegion(&gvar.video.page[0], 64, 64, 48, 32, 24, 32, ptmp);*/\r
        while(!kbhit())\r
        {\r
        }\r
@@ -141,8 +142,9 @@ baka = 1;
        fprintf(stderr,"%dx%d\n", gvar.video.page[0].sw-(p->width), gvar.video.page[0].sh-(p->height));\r
        planar_buf_free(p);\r
        free(bakapeee);\r
-       fprintf(stderr, "modexDrawBmp:  %f\n", t1);\r
-       fprintf(stderr, "DrawPBuf:      %f\n", t2);\r
+       fprintf(stderr, "modexDrawBmpPBuf:      %f\n", t1);\r
+       fprintf(stderr, "modexDrawPBuf: %f\n", t2);\r
+       fprintf(stderr, "speed difference       %f\n", t2/t1);\r
        fprintf(stderr, "gvar.video.page[0].width: %u\n", gvar.video.page[0].width);\r
        fprintf(stderr, "gvar.video.page[0].height: %u\n", gvar.video.page[0].height);\r
        return;\r

diff --git a/src/scroll.c b/src/scroll.c
index c5280652903e8d07cfb70168fa7b320e49373337..96f0660c6f11eb53a593253e5831b7423c6d7d03 100755 (executable)
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -87,7 +87,7 @@ void main(int argc, char *argv[])
        /* draw the tiles */
 #ifdef MODEX
        ptr = map.data;
-       mappalptr = map.tiles->data->palette;
+       //mappalptr = map.tiles->bt_data->palette;
 
        /* data */
        p = bitmapLoadPcx("data/ptmp.pcx"); // load sprite
@@ -186,14 +186,10 @@ void main(int argc, char *argv[])
        npc0.d=0;
        modexDrawSpriteRegion(spri->page, npc0.x-4, npc0.y-TILEWH, 24, 64, 24, 32, &npctmp);*/
        modexCopyPageRegion(mv[1].page, mv[0].page, 0, 0, 0, 0, mv[0].page->width, mv[0].page->height);
-#ifdef SPRITE
-#ifdef BMPTYPE
-       //oldDrawBmp(VGA, player[0].x-4, player[0].y-TILEWH, &player[0].data, 1);
-#else
-       modexDrawSpriteRegion(spri->page, player[0].x-4, player[0].y-TILEWH, 24, 64, 24, 32, &player[0].data);
-#endif
-#else
+#ifndef        SPRITE
        modexClearRegion(mv[1].page, player[0].x-4, player[0].y-TILEWH, 24, 32, 15);
+#else
+       modexDrawSpritePBufRegion(spri->page, player[0].x-4, player[0].y-TILEWH, 24, 64, 24, 32, &player[0].data);
 #endif
 
        modexShowPage(spri->page);

diff --git a/test.exe b/test.exe
index 0ad7e77cabd96a4037cee20be77d385d24745b3d..f9b03820b8617768b708181ec168d26e66a306e5 100755 (executable)
Binary files a/test.exe and b/test.exe differ

diff --git a/test2.exe b/test2.exe
index 3b0ebe5d79f31baf9bd33ff6b2b480da5a04a411..50abe51ac2c9d6a39ffba18ab254ebbe9e61c43a 100755 (executable)
Binary files a/test2.exe and b/test2.exe differ