--- /dev/null
+/* Catacomb 3-D Source Code\r
+ * Copyright (C) 1993-2014 Flat Rock Software\r
+ *\r
+ * This program is free software; you can redistribute it and/or modify\r
+ * it under the terms of the GNU General Public License as published by\r
+ * the Free Software Foundation; either version 2 of the License, or\r
+ * (at your option) any later version.\r
+ *\r
+ * This program is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ * GNU General Public License for more details.\r
+ *\r
+ * You should have received a copy of the GNU General Public License along\r
+ * with this program; if not, write to the Free Software Foundation, Inc.,\r
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\r
+ */\r
+\r
+// C3_SCALE.C\r
+\r
+#include "C3_DEF.H"\r
+#pragma hdrstop\r
+\r
+//const unsigned viewheight = 144;\r
+const unsigned screenbwide = 40;\r
+const byte BACKGROUNDPIX = 5;\r
+\r
+unsigned shapesize[MAXSCALE+1];\r
+t_compscale _seg *scaledirectory[MAXSCALE+1];\r
+t_compshape _seg *shapedirectory[NUMSCALEPICS];\r
+memptr walldirectory[NUMSCALEWALLS];\r
+\r
+/*\r
+===========================\r
+=\r
+= DeplanePic\r
+=\r
+= Takes a raw bit map of width bytes by height and creates a scaleable shape\r
+=\r
+= Returns the length of the shape in bytes\r
+=\r
+= Fills in spotvis (a convenient 64*64 array) with the color values\r
+=\r
+===========================\r
+*/\r
+\r
+void DeplanePic (int picnum)\r
+{\r
+ byte far *plane0,far *plane1,far *plane2,far *plane3;\r
+ byte by0,by1,by2,by3;\r
+ unsigned x,y,b,color,shift,width,height;\r
+ byte *dest;\r
+\r
+//\r
+// convert ega pixels to byte color values in a temp buffer\r
+//\r
+ width = pictable[picnum-STARTPICS].width;\r
+ height = pictable[picnum-STARTPICS].height;\r
+\r
+ if (width>64 || height!=64)\r
+ Quit ("DePlanePic: Bad size shape");\r
+\r
+ memset (spotvis,BACKGROUNDPIX,sizeof(spotvis));\r
+\r
+ plane0 = (byte _seg *)grsegs[picnum];\r
+ plane1 = plane0 + width*height;\r
+ plane2 = plane1 + width*height;\r
+ plane3 = plane2 + width*height;\r
+\r
+ for (y=0;y<height;y++)\r
+ {\r
+ dest = &spotvis[y][0];\r
+ for (x=0;x<width;x++)\r
+ {\r
+ by0 = *plane0++;\r
+ by1 = *plane1++;\r
+ by2 = *plane2++;\r
+ by3 = *plane3++;\r
+\r
+ for (b=0;b<8;b++)\r
+ {\r
+ shift=8-b;\r
+\r
+ color = 0;\r
+ asm mov cl,[BYTE PTR shift]\r
+ asm mov al,[BYTE PTR by3]\r
+ asm rcr al,cl;\r
+ asm rcl [BYTE PTR color],1;\r
+\r
+ asm mov cl,[BYTE PTR shift]\r
+ asm mov al,[BYTE PTR by2]\r
+ asm rcr al,cl;\r
+ asm rcl [BYTE PTR color],1;\r
+\r
+ asm mov cl,[BYTE PTR shift]\r
+ asm mov al,[BYTE PTR by1]\r
+ asm rcr al,cl;\r
+ asm rcl [BYTE PTR color],1;\r
+\r
+ asm mov cl,[BYTE PTR shift]\r
+ asm mov al,[BYTE PTR by0]\r
+ asm rcr al,cl;\r
+ asm rcl [BYTE PTR color],1;\r
+\r
+ *dest++ = color;\r
+ } // B\r
+ } // X\r
+ } // Y\r
+}\r
+\r
+\r
+\r
+\r
+/*\r
+========================\r
+=\r
+= BuildCompScale\r
+=\r
+= Builds a compiled scaler object that will scale a 64 tall object to\r
+= the given height (centered vertically on the screen)\r
+=\r
+= height should be even\r
+=\r
+= Call with\r
+= ---------\r
+= DS:SI Source for scale\r
+= ES:DI Dest for scale\r
+=\r
+= Calling the compiled scaler only destroys AL\r
+=\r
+========================\r
+*/\r
+\r
+unsigned BuildCompScale (int height, memptr *finalspot)\r
+{\r
+ t_compscale _seg *work;\r
+ byte far *code;\r
+\r
+ int i;\r
+ long fix,step;\r
+ unsigned src,totalscaled,totalsize;\r
+ int startpix,endpix,toppix;\r
+\r
+\r
+ MM_GetPtr (&(memptr)work,20000);\r
+\r
+ step = ((long)height<<16) / 64;\r
+ code = &work->code[0];\r
+ toppix = (viewheight-height)/2;\r
+ fix = 0;\r
+\r
+ for (src=0;src<=64;src++)\r
+ {\r
+ startpix = fix>>16;\r
+ fix += step;\r
+ endpix = fix>>16;\r
+\r
+ work->start[src] = startpix;\r
+ if (endpix>startpix)\r
+ work->width[src] = endpix-startpix;\r
+ else\r
+ work->width[src] = 0;\r
+\r
+//\r
+// mark the start of the code\r
+//\r
+ work->codeofs[src] = FP_OFF(code);\r
+\r
+//\r
+// compile some code if the source pixel generates any screen pixels\r
+//\r
+ startpix+=toppix;\r
+ endpix+=toppix;\r
+\r
+ if (startpix == endpix || endpix < 0 || startpix >= VIEWHEIGHT || src == 64)\r
+ continue;\r
+\r
+ //\r
+ // mov al,[si+src]\r
+ //\r
+ *code++ = 0x8a;\r
+ *code++ = 0x44;\r
+ *code++ = src;\r
+\r
+ for (;startpix<endpix;startpix++)\r
+ {\r
+ if (startpix >= VIEWHEIGHT)\r
+ break; // off the bottom of the view area\r
+ if (startpix < 0)\r
+ continue; // not into the view area\r
+\r
+ //\r
+ // and [es:di+heightofs],al\r
+ //\r
+ *code++ = 0x26;\r
+ *code++ = 0x20;\r
+ *code++ = 0x85;\r
+ *((unsigned far *)code)++ = startpix*screenbwide;\r
+ }\r
+\r
+ }\r
+\r
+//\r
+// retf\r
+//\r
+ *code++ = 0xcb;\r
+\r
+ totalsize = FP_OFF(code);\r
+ MM_GetPtr (finalspot,totalsize);\r
+ _fmemcpy ((byte _seg *)(*finalspot),(byte _seg *)work,totalsize);\r
+ MM_FreePtr (&(memptr)work);\r
+\r
+ return totalsize;\r
+}\r
+\r
+\r
+\r
+\r
+/*\r
+========================\r
+=\r
+= BuildCompShape\r
+=\r
+= typedef struct\r
+= {\r
+= unsigned width;\r
+= unsigned codeofs[64];\r
+= } t_compshape;\r
+=\r
+= Width is the number of compiled line draws in the shape. The shape\r
+= drawing code will assume that the midpoint of the shape is in the\r
+= middle of the width.\r
+=\r
+= The non background pixel data will start at codeofs[width], so codeofs\r
+= greater than width will be invalid.\r
+=\r
+= Each code offset will draw one vertical line of the shape, consisting\r
+= of 0 or more segments of scaled pixels.\r
+=\r
+= The scaled shapes use ss:0-4 as a scratch variable for the far call to\r
+= the compiled scaler, so zero it back out after the shape is scaled, or\r
+= a "null pointer assignment" will result upon termination.\r
+=\r
+= Setup for a call to a compiled shape\r
+= -----------------------------------\r
+= ax toast\r
+= bx toast\r
+= cx toast\r
+= dx segment of compiled shape\r
+= si toast\r
+= di byte at top of view area to draw the line in\r
+= bp 0\r
+= ss:2 and ds the segment of the compiled scaler to use\r
+= es screenseg\r
+=\r
+= Upon return, ds IS NOT SET to the data segment. Do:\r
+= mov ax,ss\r
+= mov ds,ax\r
+=\r
+=\r
+= GC_BITMASK set to the pixels to be drawn in the row of bytes under DI\r
+= GC_MODE read mode 1, write mode 2\r
+= GC_COLORDONTCARE set to 0, so all reads from video memory return 0xff\r
+=\r
+=\r
+= Code generated for each segment\r
+= -------------------------------\r
+= mov bx,[(segend+1)*2]\r
+= mov cx,[bx]\r
+= mov [BYTE PTR bx],0xc8 // far return\r
+= mov ax,[segstart*2]\r
+= mov [ss:0],ax // entry point into the compiled scaler\r
+= mov ds,dx // (mov ds,cs) the data is after the compiled code\r
+= mov si,ofs data\r
+= call [bp] // scale some pixels\r
+= mov ds,[bp+2]\r
+= mov [bx],cx // un patch return\r
+=\r
+= Code generated after all segments on a line\r
+= -------------------------------------------\r
+= retf\r
+=\r
+========================\r
+*/\r
+\r
+unsigned BuildCompShape (t_compshape _seg **finalspot)\r
+{\r
+ t_compshape _seg *work;\r
+ byte far *code;\r
+ int firstline,lastline,x,y;\r
+ unsigned firstpix,lastpix,width;\r
+ unsigned totalsize,pixelofs;\r
+ unsigned buff;\r
+\r
+\r
+// MM_GetPtr (&(memptr)work,20000);\r
+ EGAWRITEMODE(0);\r
+ EGAREADMAP(0); // use ega screen memory for temp buffer\r
+ EGAMAPMASK(1);\r
+ buff = screenloc[1];\r
+ work = (t_compshape _seg *)(0xa000+(buff+15)/16);\r
+\r
+//\r
+// find the width of the shape\r
+//\r
+ firstline = -1;\r
+ x=0;\r
+ do\r
+ {\r
+ for (y=0;y<64;y++)\r
+ if (spotvis[y][x] != BACKGROUNDPIX)\r
+ {\r
+ firstline = x;\r
+ break;\r
+ }\r
+ if (++x == 64)\r
+ Quit ("BuildCompShape: No shape data!");\r
+ } while (firstline == -1);\r
+\r
+ lastline = -1;\r
+ x=63;\r
+ do\r
+ {\r
+ for (y=0;y<64;y++)\r
+ if (spotvis[y][x] != BACKGROUNDPIX)\r
+ {\r
+ lastline = x;\r
+ break;\r
+ }\r
+ x--;\r
+ } while (lastline == -1);\r
+\r
+ width = lastline-firstline+1;\r
+\r
+ work->width = width;\r
+ code = (byte far *)&work->codeofs[width];\r
+\r
+//\r
+// copy all non background pixels to the work space\r
+//\r
+ pixelofs = FP_OFF(code);\r
+\r
+ for (x=firstline;x<=lastline;x++)\r
+ for (y=0;y<64;y++)\r
+ if (spotvis[y][x] != BACKGROUNDPIX)\r
+ *code++ = spotvis[y][x];\r
+\r
+//\r
+// start compiling the vertical lines\r
+//\r
+ for (x=firstline;x<=lastline;x++)\r
+ {\r
+ work->codeofs[x-firstline] = FP_OFF(code);\r
+\r
+ y=0;\r
+ do\r
+ {\r
+ //\r
+ // scan past black background pixels\r
+ //\r
+ while (spotvis[y][x] == BACKGROUNDPIX && y<64)\r
+ y++;\r
+\r
+ if (y>63) // no more segments\r
+ break;\r
+\r
+ firstpix = y+1; // +1 because width is before codeofs\r
+\r
+ //\r
+ // scan past scalable pixels\r
+ //\r
+ while (spotvis[y][x] != BACKGROUNDPIX && y<64)\r
+ y++;\r
+\r
+ if (y>63)\r
+ lastpix = 65;\r
+ else\r
+ lastpix = y+1; // actually one pixel past the last displayed\r
+\r
+ //\r
+ // compile the scale call\r
+ //\r
+ *code++ = 0x8b; // mov bx,[lastpix*2]\r
+ *code++ = 0x1e;\r
+ *((unsigned far *)code)++ = lastpix*2;\r
+\r
+ *code++ = 0x8b; // mov cx,[bx]\r
+ *code++ = 0x0f;\r
+\r
+ *code++ = 0xc6; // move [BYTE bx],0xcb\r
+ *code++ = 0x07;\r
+ *code++ = 0xcb;\r
+\r
+ *code++ = 0xa1; // mov ax,[firstpix*2] /*************\r
+ *((unsigned far *)code)++ = firstpix*2;\r
+\r
+ *code++ = 0x36; // mov [ss:0],ax\r
+ *code++ = 0xa3;\r
+ *code++ = 0x00;\r
+ *code++ = 0x00;\r
+\r
+ *code++ = 0x8e; // mov ds,dx (mov ds,cs)\r
+ *code++ = 0xda;\r
+\r
+ *code++ = 0xbe; // mov si,OFFSET pixelofs-firstpixel\r
+ *((unsigned far *)code)++ = pixelofs-firstpix;\r
+\r
+ *code++ = 0xff; // call [DWORD bp]\r
+ *code++ = 0x5e;\r
+ *code++ = 0x00;\r
+\r
+ *code++ = 0x8e; // mov ds,[bp+2]\r
+ *code++ = 0x5e;\r
+ *code++ = 0x02;\r
+\r
+ *code++ = 0x89; // mov [bx],cx\r
+ *code++ = 0x0f;\r
+\r
+ pixelofs += (lastpix-firstpix);\r
+ } while (y<63);\r
+\r
+ //\r
+ // retf\r
+ //\r
+ *code++ = 0xcb;\r
+ }\r
+\r
+\r
+//\r
+// copy the final shape to a properly sized buffer\r
+//\r
+ totalsize = FP_OFF(code);\r
+ MM_GetPtr ((memptr *)finalspot,totalsize);\r
+ _fmemcpy ((byte _seg *)(*finalspot),(byte _seg *)work,totalsize);\r
+// MM_FreePtr (&(memptr)work);\r
+\r
+ return totalsize;\r
+}\r
+\r
+\r
+\r
+/*\r
+=======================\r
+=\r
+= ScaleShape\r
+=\r
+= Draws a compiled shape at [scale] pixels high\r
+=\r
+= Setup for call\r
+= --------------\r
+= GC_MODE read mode 1, write mode 2\r
+= GC_COLORDONTCARE set to 0, so all reads from video memory return 0xff\r
+= GC_INDEX pointing at GC_BITMASK\r
+=\r
+=======================\r
+*/\r
+\r
+static long longtemp;\r
+\r
+void ScaleShape (int xcenter, t_compshape _seg *compshape, unsigned scale)\r
+{\r
+ t_compscale _seg *comptable;\r
+ unsigned width,scalewidth;\r
+ int x,pixel,lastpixel,pixwidth,min;\r
+ unsigned far *codehandle, far *widthptr;\r
+ unsigned badcodeptr;\r
+ int rightclip;\r
+\r
+ if (!compshape)\r
+ Quit ("ScaleShape: NULL compshape ptr!");\r
+\r
+ scale = (scale+1)/2;\r
+ if (!scale)\r
+ return; // too far away\r
+ if (scale>MAXSCALE)\r
+ scale = MAXSCALE;\r
+ comptable = scaledirectory[scale];\r
+\r
+ width = compshape->width;\r
+ scalewidth = comptable->start[width];\r
+\r
+ pixel = xcenter - scalewidth/2;\r
+ lastpixel = pixel+scalewidth-1;\r
+ if (pixel >= VIEWWIDTH || lastpixel < 0)\r
+ return; // totally off screen\r
+\r
+//\r
+// scan backwards from the right edge until pixels are visable\r
+// rightclip is the first NON VISABLE pixel\r
+//\r
+ if (lastpixel>=VIEWWIDTH-1)\r
+ rightclip = VIEWWIDTH-1;\r
+ else\r
+ rightclip = lastpixel;\r
+\r
+ if (zbuffer[rightclip]>scale)\r
+ {\r
+ if (pixel>0)\r
+ min = pixel;\r
+ else\r
+ min = 0;\r
+ do\r
+ {\r
+ if (--rightclip < min)\r
+ return; // totally covered or before 0\r
+ if (zbuffer[rightclip]<=scale)\r
+ break;\r
+ } while (1);\r
+ }\r
+ rightclip++;\r
+\r
+//\r
+// scan from the left until it is on screen, leaving\r
+// [pixel],[pixwidth],[codehandle],and [widthptr] set correctly\r
+//\r
+ *(((unsigned *)&longtemp)+1) = (unsigned)compshape; // seg of shape\r
+ codehandle = &compshape->codeofs[0];\r
+ badcodeptr = compshape->codeofs[width];\r
+ widthptr = &comptable->width[0];\r
+ asm mov ax,[comptable]\r
+ asm mov WORD PTR [2],ax // ds:0-4 is used as a far call pointer\r
+ // by the compiled shapes\r
+ pixwidth = *widthptr; // scaled width of this pixel\r
+ while (!pixwidth)\r
+ {\r
+ pixwidth = *++widthptr; // find the first visable pixel\r
+ codehandle++;\r
+ }\r
+\r
+ if (pixel<0)\r
+ {\r
+ do\r
+ {\r
+ if (pixel+pixwidth>0)\r
+ {\r
+ pixwidth += pixel;\r
+ pixel = 0;\r
+ break;\r
+ }\r
+ do\r
+ {\r
+ pixwidth = *++widthptr;\r
+ codehandle++;\r
+ } while (!pixwidth);\r
+ pixel+=pixwidth;\r
+ } while (1);\r
+ }\r
+\r
+//\r
+// scan until it is visable, leaving\r
+// [pixel],[pixwidth],[codehandle],and [widthptr] set correctly\r
+//\r
+ do\r
+ {\r
+ if (zbuffer[pixel] <= scale)\r
+ break; // start drawing here\r
+ pixel++;\r
+ if (!--pixwidth)\r
+ {\r
+ do\r
+ {\r
+ pixwidth = *++widthptr;\r
+ codehandle++;\r
+ } while (!pixwidth);\r
+ }\r
+ } while (1);\r
+\r
+ if (pixel+pixwidth>rightclip)\r
+ pixwidth = rightclip-pixel;\r
+//\r
+// draw lines\r
+//\r
+ do // while (1)\r
+ {\r
+ //\r
+ // scale a vertical segment [pixwidth] pixels wide at [pixel]\r
+ //\r
+ (unsigned)longtemp = *codehandle; // offset of compiled code\r
+ if ((unsigned)longtemp == badcodeptr)\r
+ Quit ("ScaleShape: codehandle past end!");\r
+\r
+ asm mov bx,[pixel]\r
+ asm mov di,bx\r
+ asm shr di,1\r
+ asm shr di,1\r
+ asm shr di,1 // X in bytes\r
+ asm add di,[bufferofs]\r
+ asm and bx,7\r
+ asm shl bx,1\r
+ asm shl bx,1\r
+ asm shl bx,1\r
+ asm add bx,[pixwidth] // bx = pixel*8+pixwidth-1\r
+ asm dec bx\r
+ asm push bx\r
+ asm mov al,BYTE PTR [bitmasks1+bx]\r
+ asm mov dx,GC_INDEX+1\r
+ asm out dx,al // set bit mask register\r
+\r
+ asm mov es,[screenseg]\r
+ asm push si\r
+ asm push di\r
+ asm push bp\r
+ asm xor bp,bp\r
+ asm mov dx,[WORD PTR longtemp+2]\r
+ asm mov ds,[2]\r
+ asm call ss:[DWORD PTR longtemp] // scale the line of pixels\r
+ asm mov ax,ss\r
+ asm mov ds,ax\r
+ asm pop bp\r
+ asm pop di\r
+ asm pop si\r
+\r
+ asm pop bx\r
+ asm mov al,BYTE PTR [bitmasks2+bx]\r
+ asm or al,al\r
+ asm jz nosecond\r
+\r
+ //\r
+ // draw a second byte for vertical strips that cross two bytes\r
+ //\r
+ asm inc di\r
+ asm mov dx,GC_INDEX+1\r
+ asm out dx,al // set bit mask register\r
+ asm push si\r
+ asm push di\r
+ asm push bp\r
+ asm xor bp,bp\r
+ asm mov dx,[WORD PTR longtemp+2]\r
+ asm mov ds,[2]\r
+ asm call ss:[DWORD PTR longtemp] // scale the line of pixels\r
+ asm mov ax,ss\r
+ asm mov ds,ax\r
+ asm pop bp\r
+ asm pop di\r
+ asm pop si\r
+\r
+\r
+ //\r
+ // advance to the next drawn line\r
+ //\r
+nosecond:;\r
+ if ( (pixel+=pixwidth) == rightclip )\r
+ {\r
+ asm mov WORD PTR [0],0\r
+ asm mov WORD PTR [2],0\r
+ return; // all done!\r
+ }\r
+\r
+ do\r
+ {\r
+ pixwidth = *++widthptr;\r
+ codehandle++;\r
+ } while (!pixwidth);\r
+\r
+ if (pixel+pixwidth > rightclip)\r
+ pixwidth = rightclip-pixel;\r
+\r
+ } while (1);\r
+\r
+}\r
+\r
+//\r
+// bit mask tables for drawing scaled strips up to eight pixels wide\r
+//\r
+\r
+byte bitmasks1[8][8] = {\r
+{0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff},\r
+{0x40,0x60,0x70,0x78,0x7c,0x7e,0x7f,0x7f},\r
+{0x20,0x30,0x38,0x3c,0x3e,0x3f,0x3f,0x3f},\r
+{0x10,0x18,0x1c,0x1e,0x1f,0x1f,0x1f,0x1f},\r
+{0x8,0xc,0xe,0xf,0xf,0xf,0xf,0xf},\r
+{0x4,0x6,0x7,0x7,0x7,0x7,0x7,0x7},\r
+{0x2,0x3,0x3,0x3,0x3,0x3,0x3,0x3},\r
+{0x1,0x1,0x1,0x1,0x1,0x1,0x1,0x1} };\r
+\r
+byte bitmasks2[8][8] = {\r
+{0,0,0,0,0,0,0,0},\r
+{0,0,0,0,0,0,0,0x80},\r
+{0,0,0,0,0,0,0x80,0xc0},\r
+{0,0,0,0,0,0x80,0xc0,0xe0},\r
+{0,0,0,0,0x80,0xc0,0xe0,0xf0},\r
+{0,0,0,0x80,0xc0,0xe0,0xf0,0xf8},\r
+{0,0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc},\r
+{0,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe} };\r
+\r
+\r
+\r
+\r
+\r
+\r
projects / 16.git / blobdiff