+++ /dev/null
-////////////////////////////////////////\r
-// Graph.h\r
-// Coded by Denn Man\r
-//\r
-// Licensed under the Academic Free License version 1.2\r
-//\r
-// *Special thanks to Micheal Abrash\r
-// and his columns in Dr. Dobbs Journal\r
-// (Jul91 and Aug91) documenting\r
-// ModeX\r
-//\r
-// For use with Turbo-C\r
-// Uses as much assembly as possible\r
-// in order to optimize drawing speed\r
-// Self-sufficient: Nothing else needed\r
-////////////////////////////////////////\r
-\r
-#include <alloc.h>\r
-#include <dos.h>\r
-#include <math.h>\r
-#include <stdio.h>\r
-\r
-\r
-// Start of video memory (SEGMENT)\r
-#define MCGA_MEM 0xA000\r
-// Video Digital-Analog-Converter Port\r
-#define VIDEO_DAC 0x03C8\r
-// Video DAC Read Port\r
-#define DAC_READ 0x03C7\r
-// Video Data Port\r
-#define VIDEO_DATA 0x03C9\r
-// VGA Sequence Controller\r
-#define SC_INDEX 0x03C4\r
-// CRT Control Register\r
-#define CRTC_INDEX 0x03D4\r
-// Miscellaneous Output Register\r
-#define MISC_OUTPUT 0x03C2\r
-// VGA Map Mask Register\r
-#define MAP_MASK 0x02\r
-// Screen Width\r
-#define SCR_WIDTH 80\r
-// VGA Graphics Controller Register\r
-#define GC_INDEX 0x03CE\r
-// VGA Read Map Register\r
-#define READ_MAP 0x04\r
-// PI\r
-#define PI 3.14159265358\r
-\r
-// Datatypes\r
-typedef unsigned char byte;\r
-typedef unsigned int word;\r
-typedef unsigned long dword;\r
-\r
-typedef struct tagTILE {\r
- word height;\r
- word width;\r
- byte *data;\r
-} TILE;\r
-\r
-// FOR BITMAP FILES!!!\r
-typedef struct tagBITMAPFILEHEADER {\r
- word bfType;\r
- dword bfSize;\r
- word bfReserved1;\r
- word bfReserved2;\r
- dword bfOffBits;\r
-} BITMAPFILEHEADER;\r
-\r
-typedef struct tagBITMAPINFOHEADER {\r
- dword biSize;\r
- dword biWidth;\r
- dword biHeight;\r
- word biPlanes;\r
- word biBitCount;\r
- dword biCompression;\r
- dword biSizeImage;\r
- dword biXPelsPerMeter;\r
- dword biYPelsPerMeter;\r
- dword biClrUsed;\r
- dword biClrImportant;\r
-} BITMAPINFOHEADER;\r
-\r
-typedef struct tagRGBQUAD {\r
- byte rgbBlue;\r
- byte rgbGreen;\r
- byte rgbRed;\r
- byte rgbReserved;\r
-} RGBQUAD;\r
-\r
-typedef struct tagBITMAPINFO {\r
- BITMAPINFOHEADER bmiHeader;\r
- RGBQUAD bmiColors[256];\r
-} BITMAPINFO;\r
-\r
-typedef struct tagBITMAP {\r
- BITMAPFILEHEADER bmFileHeader;\r
- BITMAPINFO bmInfo;\r
- byte *bmData;\r
-} BITMAP;\r
-// DONE WITH BITMAP FILE INFO\r
-\r
-// Monitor settings for ModeX\r
-struct tagCRTParms {\r
- word V_Total; // Vertical Total\r
- word OverFlow; // Overflow\r
- word CellHeight; // Cell Height\r
- word V_Sync_Start; // Vertical Sync Start\r
- word V_Sync_End; // Vertical Sync End\r
- word V_Disp; // Vertical Displayed\r
- word D_Off; // Turn off dword mode\r
- word V_Blank_Start; // Vertical Blank Start\r
- word V_Blank_End; // Vertical Blank End\r
- word B_On; // Turn byte mode on\r
-} CRTParms;\r
-\r
-byte VIDEO_MODE; // The current video mode\r
-word MAX_X; // Last available X\r
-word MAX_Y; // Last available Y\r
-word SCREEN_WIDTH;\r
-word SCREEN_HEIGHT;\r
-byte MAX_COLORS; // Last available color\r
-byte FG_COLOR; // For text and mono stuff\r
-byte BG_COLOR;\r
-word CUR_X; // Current X\r
-word CUR_Y; // Current Y\r
-word visibleStart;// Start offset in video memory of screen\r
-word activeStart; // Start offset in video memory to write to\r
-\r
-// For rectangle filling (ModeX)\r
-byte LeftClipPlaneMask[] = { 0x0F, 0x0E, 0x0C, 0x08 };\r
-byte RightClipPlaneMask[] = { 0x0F, 0x01, 0x03, 0x07 };\r
-\r
-// In case things go awry\r
-char msg_error[81];\r
-\r
-void exit_error(void)\r
-{\r
- printf("%s\a\n", msg_error);\r
-}\r
-\r
-////////////////////////////////////////\r
-// init_modeX\r
-//\r
-// -Initialized modeX 320x240x256 graphics\r
-// -Clears video memory\r
-// -Sets page 1 active at offset 0\r
-////////////////////////////////////////\r
-void init_modeX(void)\r
-{\r
- // Fill the CRT Parameters\r
- CRTParms.V_Total = 0x0D06;\r
- CRTParms.OverFlow = 0x3E07;\r
- CRTParms.CellHeight = 0x4109;\r
- CRTParms.V_Sync_Start = 0xEA10;\r
- CRTParms.V_Sync_End = 0xAC11;\r
- CRTParms.V_Disp = 0xDF12;\r
- CRTParms.D_Off = 0x0014;\r
- CRTParms.V_Blank_Start = 0xE715;\r
- CRTParms.V_Blank_End = 0x0616;\r
- CRTParms.B_On = 0xE317;\r
-\r
- asm {\r
- mov ax, 0x0013 // Start in mode 13h\r
- int 0x10 // Call interrupt\r
-\r
- mov dx, SC_INDEX // Disable Chain-4 Memory model\r
- mov ax, 0x0604\r
- out dx, ax\r
- mov ax, 0x0100 // Synchronous reset while switching clocks\r
- out dx, ax\r
-\r
- mov dx, MISC_OUTPUT // Select 28MHz dot clock, 60 Hz scan rate\r
- mov al, 0xE3\r
- out dx, al\r
-\r
- mov dx, SC_INDEX // Restart Sequencer\r
- mov ax, 0x0300\r
- out dx, ax\r
-\r
- mov dx, CRTC_INDEX // Reprogram the CRT Controller\r
- mov al, 0x11 // Select Write-Protect bit\r
- out dx, al\r
- inc dx // CRT-Data register into DX now\r
- in al, dx // Get current VSync End Register setting\r
- and al, 0x7F // Remove write-protect on various registers\r
- out dx, al\r
- dec dx // CRT-Controller\r
- cld // Clear the direction\r
- mov si, OFFSET CRTParms // Load settings\r
- mov cx, 20 // 20 Entries\r
- }\r
- SetCRTParmsLoop:asm {\r
- lodsw // Load the addr:data pair\r
- out dx, ax // Send them out\r
- loop SetCRTParmsLoop // Do it for each one\r
-\r
- mov dx, SC_INDEX // Enable write to all bitplanes\r
- mov ax, 0x0F02\r
- out dx, ax\r
- mov ax, MCGA_MEM // Load video memory\r
- mov es, ax\r
- mov di, 0 // Start at the top\r
- mov ax, 0 // Store 0's\r
- mov cx, 0x8000 // Do it 8000h times\r
- rep stosw // Store them\r
- }\r
-\r
- // Fill globals\r
- VIDEO_MODE = 0xFF;\r
- MAX_X = 319;\r
- MAX_Y = 239;\r
- SCREEN_WIDTH = 320;\r
- SCREEN_HEIGHT = 240;\r
- MAX_COLORS = 255;\r
- FG_COLOR = 15;\r
- BG_COLOR = 0;\r
- CUR_X = 0;\r
- CUR_Y = 0;\r
-\r
- activeStart = 0; // Write to Page 0\r
- visibleStart = 0; // Read from Page 0\r
-}\r
-\r
-////////////////////////////////////////\r
-// close_graph\r
-//\r
-// -Shuts down graphics, sets text mode,\r
-// and fills appropriate variables\r
-// -Frees memory taken by video buffers\r
-////////////////////////////////////////\r
-void close_graph(void)\r
-{\r
- asm {\r
- mov ax, 0x0003\r
- int 0x10\r
- }\r
-\r
- VIDEO_MODE = 0x03;\r
- MAX_X = 80;\r
- MAX_Y = 25;\r
- SCREEN_WIDTH = 80;\r
- SCREEN_HEIGHT = 25;\r
- MAX_COLORS = 15;\r
- FG_COLOR = 7;\r
- BG_COLOR = 0;\r
- CUR_X = 1;\r
- CUR_Y = 1;\r
-}\r
-\r
-void cleargraph(void)\r
-{\r
- asm {\r
- pusha\r
- push es\r
- push di\r
-\r
- mov ax, MCGA_MEM\r
- mov es, ax\r
- mov di, 0\r
-\r
- mov dx, SC_INDEX // Enable write to all bitplanes\r
- mov ax, 0x0F02\r
- out dx, ax\r
-\r
- mov cx, 0x8000\r
- mov ax, 0x0000\r
- rep stosw\r
-\r
- pop di\r
- pop es\r
- popa\r
- }\r
-}\r
-\r
-////////////////////////////////////////\r
-// setActiveStart\r
-//\r
-// -Sets the starting memory address\r
-// at which graphics are written to\r
-////////////////////////////////////////\r
-void setActiveStart(word PageBase)\r
-{\r
- activeStart = PageBase;\r
-}\r
-\r
-////////////////////////////////////////\r
-// setVisibleStart\r
-//\r
-// -Sets the starting memory address\r
-// at which graphics are displayed from\r
-////////////////////////////////////////\r
-void setVisibleStart(word PageBase)\r
-{\r
- visibleStart = PageBase;\r
-\r
- asm {\r
- pusha // Dont touch!\r
-\r
- mov bx, PageBase // Load the offset into BX\r
- mov dx, CRTC_INDEX // Load the CRT Index Port into DX\r
- mov al, 0x0C // Function 0Ch, High Byte of addres\r
- mov ah, bh // Load the high byte\r
- out dx, ax // Send it\r
- inc al // Function 0Dh, Low Byte of address\r
- mov ah, bl // Load the low byte\r
- out dx, ax // Send it\r
-\r
- popa // We were never here\r
- }\r
-}\r
-\r
-////////////////////////////////////////\r
-// setActivePage\r
-//\r
-// -Sets page in which graphics are\r
-// written\r
-////////////////////////////////////////\r
-void setActivePage(byte Page)\r
-{\r
- // Page = (Page Offset * Width of Screen (Bytes) * Screen Height (Rows))\r
- setActiveStart(Page * SCR_WIDTH * SCREEN_HEIGHT);\r
-}\r
-\r
-////////////////////////////////////////\r
-// setVisiblePage\r
-//\r
-// -Sets page from which graphics are\r
-// drawn\r
-////////////////////////////////////////\r
-void setVisiblePage(byte Page)\r
-{\r
- // Page = (Page Offset * Width of Screen (Bytes) * Screen Height (Rows))\r
- setVisibleStart(Page * SCR_WIDTH * SCREEN_HEIGHT);\r
-}\r
-\r
-void vScroll(int rows)\r
-{\r
- // Scrolling = current start + (rows * bytes in a row)\r
- setVisibleStart(visibleStart + (rows * SCR_WIDTH));\r
-}\r
-\r
-void read_palette(byte *pal)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < 256; i++)\r
- {\r
- asm cli\r
- outportb(DAC_READ, i);\r
- pal[(i * 3) + 0] = inportb(VIDEO_DATA);\r
- pal[(i * 3) + 1] = inportb(VIDEO_DATA);\r
- pal[(i * 3) + 2] = inportb(VIDEO_DATA);\r
- asm sti\r
- }\r
-}\r
-\r
-void load_palette(byte *pal)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < 256; i++)\r
- {\r
- asm cli\r
- outportb(VIDEO_DAC, i);\r
- outportb(VIDEO_DATA, pal[(i * 3) + 0]);\r
- outportb(VIDEO_DATA, pal[(i * 3) + 1]);\r
- outportb(VIDEO_DATA, pal[(i * 3) + 2]);\r
- asm sti\r
- }\r
-}\r
-\r
-////////////////////////////////////////\r
-// setpalette\r
-//\r
-// -Self explanatory, sets the color\r
-// of a given index in 256 MCGA mode\r
-////////////////////////////////////////\r
-void setpalette(byte index, byte red, byte green, byte blue)\r
-{\r
- outportb(VIDEO_DAC, index);\r
- outportb(VIDEO_DATA, red);\r
- outportb(VIDEO_DATA, green);\r
- outportb(VIDEO_DATA, blue);\r
-}\r
-\r
-////////////////////////////////////////\r
-// putpixel\r
-//\r
-// -Puts a pixel (in modeX) at (X, Y)\r
-// in active page\r
-////////////////////////////////////////\r
-void putpixel(word x, word y, byte Color)\r
-{\r
- asm {\r
- pusha\r
- push es\r
- push di\r
-\r
- mov ax, SCR_WIDTH // Load screen width, in bytes\r
- mul y // Multiply it by Y to get row\r
- mov di, x // Load X into BX\r
- shr di, 2 // Divide X by 4 to get plane\r
- add di, ax // Add to col offset, row offset\r
- add di, activeStart // Add the page offset\r
- mov ax, MCGA_MEM // Load video memory into AX\r
- mov es, ax // Then ES\r
-\r
- mov cx, x // Get X pos\r
- and cl, 0x03 // Get X plane\r
- mov ax, 0x0100 + MAP_MASK // Load Map-Mask register\r
- shl ah, cl // Write to only the desired plane\r
- mov dx, SC_INDEX // Tell the Map-Mask to do the same\r
- out dx, ax // Do it\r
-\r
- mov al, Color // Load the color\r
- stosb // Store it\r
-\r
- pop di\r
- pop es\r
- popa\r
- }\r
-}\r
-\r
-////////////////////////////////////////\r
-// getpixel\r
-//\r
-// -Returns color of pixel (in ModeX)\r
-// at (x, y)\r
-////////////////////////////////////////\r
-byte getpixel(word x, word y)\r
-{\r
- byte returnvalue; // To hold color\r
-\r
- asm {\r
- pusha // Dont touch anything\r
- push es\r
- push di\r
- mov ax, SCR_WIDTH // Move screen width (in bytes) into AX\r
- mul y // Multiply by y to get row\r
- mov bx, x // Move x into BX\r
- shr bx, 2 // Divide by 4 to get plane\r
- add bx, ax // Add the two offsets together\r
- add bx, activeStart // Add the PageBase\r
- mov ax, MCGA_MEM // Video Memory into AX\r
- mov es, ax // Now into ES\r
-\r
- mov ah, byte ptr x // X into AH\r
- and ah, 0x03 // Get Plane\r
- mov al, READ_MAP // Tell the Video Card\r
- mov dx, GC_INDEX\r
- out dx, ax // Do it\r
-\r
- mov al, es:[bx] // Get the color\r
- sub ah, ah // Clear AH\r
- mov returnvalue, al // Store the color into returnvalue\r
- pop di\r
- pop es\r
- popa // Put everything back\r
- }\r
-\r
- return returnvalue; // Return color\r
-}\r
-\r
-////////////////////////////////////////\r
-// vline\r
-//\r
-// -Draws a vertical line from (x,y1)-(x,y2)\r
-// of color in activePage\r
-////////////////////////////////////////\r
-void vline(word y1, word y2, word x, byte color)\r
-{\r
- asm {\r
- pusha // Dont touch anything here\r
- push es\r
- push di\r
- push si // For lowY\r
-\r
- mov si, y1 // Move y1 into SI\r
- mov bx, y2 // y2 into BX\r
- cmp si, bx // Compare the two\r
- jle vline_ordered // IF y1 <= y2, skip the next lines\r
-\r
- xchg si, bx // ELSE switch them\r
- }\r
- vline_ordered:asm {\r
- mov ax, MCGA_MEM // Load the video memory into AX\r
- mov es, ax // then into ES\r
- mov ax, SCR_WIDTH // Load screen width (bytes) into AX\r
- mul si // and Multiply by the y1 value\r
- mov di, ax // Move it into DI\r
- mov ax, x // x into AX\r
- shr ax, 2 // Divided by 4\r
- add di, ax // and added to get first point offset\r
-\r
- mov dx, SC_INDEX // Point to Sequence Controller\r
- mov al, MAP_MASK // Select Map Mask Register (0x02)\r
- out dx, al // Do it\r
- inc dx // Next Register (SC Data)\r
- mov cl, byte ptr x // x into CL\r
- and cl, 0x03 // x & 0011b to get plane\r
- mov al, 0x01 // Only one plane, so load 0001b\r
- shl ax, cl // Shift it left by the plane number\r
- out dx, al // Send it\r
-\r
- mov cx, bx // Load highY into CX\r
- sub cx, si // Subtract lowY to get ydelta\r
- inc cx // Add one\r
-\r
- mov al, color // Load the color into AL\r
- }\r
- vline_row_top:asm {\r
- stosb // Store the color\r
- add di, SCR_WIDTH // Add a row\r
- dec di // Subtract one, because STO incs DI\r
- loop vline_row_top // Loop until done\r
-\r
- pop si\r
- pop di\r
- pop es\r
- popa // Put everything back\r
- }\r
-}\r
-\r
-////////////////////////////////////////\r
-// hline\r
-//\r
-// -Draws a horizontal line from\r
-// (x1, y)-(x2, y) of color in activePage\r
-// -Faster than a speeding bullet! (Draws\r
-// four pixels at a time by turning on\r
-// all bitplanes for read at once.\r
-// -This function is ALL MINE!!! Not one\r
-// bit of a copy. :)\r
-////////////////////////////////////////\r
-void hline(word x1, word x2, word y, byte color)\r
-{\r
- asm {\r
- pusha // Dont touch anything\r
- push es\r
- push di\r
- push si // For lowX\r
-\r
- mov ax, MCGA_MEM // Load the graphics memory\r
- mov es, ax\r
-\r
- mov ax, SCR_WIDTH // Screen width (bytes) into AX\r
- mul y // Multiply by y to get row offset\r
- mov di, ax // Move row offset into DI\r
-\r
- mov si, x1 // This was a pain to order the variables\r
- mov cx, x2 // Load x1 into SI, x2 into CX\r
- cmp si, cx // Compare them\r
- jle hline_ordered // If x1 is <= x2, skip the next stuff\r
-\r
- xchg si, cx // ELSE switch them\r
- }\r
- hline_ordered:asm {\r
- mov ax, si // lowX into AX\r
- shr ax, 2 // Divided by 4\r
- add di, ax // Add the lowX offset to DI\r
-\r
- mov ax, si // lowX back into AX\r
- and ax, 0x0003 // lowX AND 0011b to get left bit planes\r
- }\r
- _BH = LeftClipPlaneMask[_AX]; // Load the left mask into BH\r
- asm {\r
- mov dx, SC_INDEX // Sequence Controller into DX\r
- mov al, MAP_MASK // Map Mask (Function 0Ch) into AL\r
- out dx, al // Send it\r
- inc dx // SC Data Register\r
- mov al, bh // Load the mask into AL\r
- out dx, al // Send it\r
-\r
- mov al, color // Load color into AL\r
- stosb // Store the first byte of line\r
-\r
- mov dx, SC_INDEX // Loading a mask again\r
- mov al, MAP_MASK // ...\r
- out dx, al // ...\r
- inc dx // ... as before\r
- mov al, 0x0F // Turn all bits on, we want MAX SPEED!\r
- out dx, al // Send it\r
-\r
- push cx // Store the highX\r
- sub cx, si // Subtract the lowX from highX\r
- shr cx, 2 // Divide it by 4\r
- dec cx // Minus the last byte\r
-\r
- mov al, color // Load the color into AL\r
- rep stosb // Repeat the storing of color\r
-\r
- pop cx // Get out highX back\r
- inc cl // Increment, BUG FIX : Not sure why\r
- and cl, 0x03 // AND 0011b to get bit planes\r
- }\r
- _BL = RightClipPlaneMask[_CL];// Load the right mask into BL\r
- asm {\r
- mov dx, SC_INDEX // Again, we send the mask to the\r
- mov al, MAP_MASK // VGA card\r
- out dx, al // ...\r
- inc dx // ...\r
- mov al, bl // ...\r
- out dx, al // ... We have seen this already...\r
-\r
- mov al, color // Load the color into AL\r
- stosb // Store the last byte\r
-\r
- pop si\r
- pop di\r
- pop es\r
- popa // Put everything back, we're done!\r
- }\r
-}\r
-\r
-////////////////////////////////////////\r
-// line\r
-//\r
-// -Draws a line from (x1, y1)-(x2, y2)\r
-// of color in the active page\r
-// -Uses Bresenhem's Line routine\r
-////////////////////////////////////////\r
-void line(word x1, word y1, word x2, word y2, byte color)\r
-{\r
- int dx, dy;\r
- int xinc, yinc;\r
- int P_right;\r
- int P_right_up;\r
- int P;\r
-\r
- if (x1 == x2)\r
- vline(y1, y2, x1, color);\r
-// if (y1 == y2)\r
-// hline(x1, x1, y1, 0, color);\r
-\r
- dx = abs(x2 - x1);\r
- dy = abs(y2 - y1);\r
-\r
- xinc = (x1 > x2) ? -1 : 1;\r
- yinc = (y1 > y2) ? -1 : 1;\r
-\r
- if (dx > dy)\r
- {\r
- P_right = (2 * dy);\r
- P_right_up = P_right - (2 * dx);\r
- P = P_right - dx;\r
-\r
- for (; dx >= 0; dx--)\r
- {\r
- putpixel(x1, y1, color);\r
- if (P > 0)\r
- {\r
- x1 += xinc;\r
- y1 += yinc;\r
- P += P_right_up;\r
- }\r
- else\r
- {\r
- x1 += xinc;\r
- P += P_right;\r
- }\r
- }\r
- }\r
- else\r
- {\r
- P_right = (2 * dx);\r
- P_right_up = P_right - (2 * dy);\r
- P = P_right - dy;\r
-\r
- for (; dy >= 0; dy--)\r
- {\r
- putpixel(x1, y1, color);\r
- if (P > 0)\r
- {\r
- x1 += xinc;\r
- y1 += yinc;\r
- P += P_right_up;\r
- }\r
- else\r
- {\r
- y1 += yinc;\r
- P += P_right;\r
- }\r
- }\r
- }\r
-}\r
-\r
-void rect(word x1, word y1, word x2, word y2, byte color)\r
-{\r
- // Just draw the four lines, x is longer because hline is a\r
- // faster routine than vline.\r
- hline(x1, x2, y1, color);\r
- hline(x1, x2, y2, color);\r
- vline(y1 + 1, y2 - 1, x1, color);\r
- vline(y1 + 1, y2 - 1, x2, color);\r
-}\r
-\r
-////////////////////////////////////////\r
-// fillrect\r
-//\r
-// -Fills a rectangle (in ModeX) of color\r
-// from (x1, y1) to (x2, y2)\r
-//\r
-// *Adopted from Dr. Dobbs Journal Sep 91\r
-////////////////////////////////////////\r
-void fillrect(word x1, word y1, word x2, word y2, byte color)\r
-{\r
- asm {\r
- pusha // Dont touch anything\r
- push ds\r
- push si\r
- push es\r
- push di\r
- push bp\r
-\r
- cld // Clear direction flag (left to right)\r
- mov ax, SCR_WIDTH // Screen Width (bytes) into AX\r
- mul y1 // Times y1 value\r
- mov di, x1 // x1 into DI\r
- shr di, 2 // Divided by four to get plane\r
- add di, ax // Add the y offset\r
- add di, activeStart // Add the PageBase\r
- mov ax, MCGA_MEM // Now set up the video memory\r
- mov es, ax // into ES\r
- mov dx, SC_INDEX // Point to Sequence Controller\r
- mov al, MAP_MASK // Select Map Mask Register (0x02)\r
- out dx, al // Do it\r
- inc dx // Next Register (SC Data)\r
- mov si, x1 // x1 into SI\r
- and si, 0x0003 // x1 & 0011b to get plane\r
- }\r
- _BH = LeftClipPlaneMask[_SI]; // Select appropriate mask\r
- asm {\r
- mov si, x2 // Do the same for x2\r
- and si, 0x0003 // x2 & 0011b\r
- }\r
- _BL = RightClipPlaneMask[_SI]; // Mask select\r
- asm {\r
- mov cx, x2 // x2 into CX\r
- mov si, x1 // x1 into SI\r
- cmp cx, si // Compare them\r
- jle FillDone // IF CX <= SI jump to FillDone\r
- dec cx // Decrement CX\r
- and si, 0xFFFC // x1 & 1111111111111100\r
- sub cx, si // Subtract x1 from x2\r
- shr cx, 2 // Divide CX by 4\r
- jnz MasksSet // Jump if not zero to MasksSet\r
- and bh, bl // BH = BH and BL\r
- }\r
- MasksSet:asm {\r
- mov si, y2 // y2 into SI\r
- sub si, y1 // Subtract y1\r
- jle FillDone // IF SI <= 0 jump to FillDone\r
- mov ah, byte ptr color // Load color\r
- mov bp, SCR_WIDTH // Load screen width (bytes)\r
- sub bp, cx // Subtract xdelta from width\r
- dec bp // Minus 1\r
- }\r
- FillRowsLoop:asm {\r
- push cx // Dont hurt CX\r
- mov al, bh // Left Clip Mask into AL\r
- out dx, al // Send it out\r
- mov al, ah // Color to AL\r
- stosb // Send it out\r
- dec cx // Minus left edge byte\r
- js FillLoopBottom // Jump if SIGNAL flag NOT set\r
- jz DoRightEdge // If that's it, do the right.\r
- mov al, 0x0F // Turn all bit planes on\r
- out dx, al // Do it\r
- mov al, ah // Load color into AL\r
- rep stosb // Store it over and over\r
- }\r
- DoRightEdge:asm {\r
- mov al, bl // Right Clip Mask into AL\r
- out dx, al // Do it\r
- mov al, ah // Load color into AL\r
- stosb // Store it\r
- }\r
- FillLoopBottom:asm {\r
- add di, bp // Next scan line\r
- pop cx // What row?\r
- dec si // One less row\r
- jnz FillRowsLoop // If not zero, go again\r
- }\r
- FillDone:asm {\r
- pop bp\r
- pop di\r
- pop es\r
- pop si\r
- pop ds\r
- popa // All done, put everything back\r
- }\r
-}\r
-\r
-void circle(word x, word y, word radius, byte color)\r
-{\r
- float angle;\r
- float ainc = 1;\r
- word xc, yc;\r
-\r
- if (radius > 119) // IF the radius is greater than 119, make the\r
- ainc = 0.25; // increment smaller\r
- if (radius > 61) // IF it's bigger than 61\r
- ainc = 0.5; // do the same\r
-\r
-\r
- // Only calculate 1/8th of the circle\r
- // Four quadrants = (x, y), (-x, y), (-x, -y), (x, -y)\r
- // Eight octants are made by switching x's and y's.\r
- // Draw eight pixels per iteration and make the circle\r
- // eight times faster than conventional routines.\r
- for (angle = 0; angle <= 45; angle += ainc)\r
- {\r
- xc = (word)floor(cos((angle * PI) / 180) * radius);\r
- yc = (word)floor(sin((angle * PI) / 180) * radius);\r
-\r
- putpixel(x + xc, y + yc, color);\r
- putpixel(x + xc, y - yc, color);\r
- putpixel(x - xc, y + yc, color);\r
- putpixel(x - xc, y - yc, color);\r
-\r
- putpixel(x + yc, y + xc, color);\r
- putpixel(x + yc, y - xc, color);\r
- putpixel(x - yc, y + xc, color);\r
- putpixel(x - yc, y - xc, color);\r
- }\r
-}\r
-\r
-void load_BMP_palette(BITMAP *s)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < 256; i++)\r
- setpalette(i, (byte)floor((s->bmInfo.bmiColors[i].rgbRed / 63) * 255),\r
- (byte)floor((s->bmInfo.bmiColors[i].rgbGreen / 63) * 255),\r
- (byte)floor((s->bmInfo.bmiColors[i].rgbBlue / 63) * 255));\r
-}\r
-\r
-////////////////////////////////////////\r
-// load_BMP\r
-//\r
-// -Opens a bitmap (Non-Compressed) and\r
-// stores the data into a given BITMAP\r
-// variable\r
-// -Allocate memory BEFORE calling this\r
-// function for the BITMAP structure\r
-// -Must be 256 Color, Columns divisible\r
-// by four\r
-////////////////////////////////////////\r
-void load_BMP(char *filename, TILE *target)\r
-{\r
- FILE *inBMP; // Create file handle\r
- BITMAP *tempBMP;\r
- int color;\r
-\r
- if ((inBMP = fopen(filename, "r+b")) == NULL)// Open it\r
- {\r
- sprintf(msg_error, "Cannot open %s", filename);\r
- atexit(exit_error); // IF error, exit and\r
- exit(1); // tell user.\r
- }\r
-\r
- tempBMP = (BITMAP *)malloc(sizeof(BITMAP) - 1);\r
-\r
- fseek(inBMP, 0, 0); // Goto the beginning\r
- fread(tempBMP, sizeof(BITMAP) - 1, 1, inBMP); // And load it all into\r
- // the given variable\r
-\r
- fseek(inBMP, 54, 0); // Goto color offset\r
- for (color = 0; color < 256; color++) // and read 'em in.\r
- {\r
- tempBMP->bmInfo.bmiColors[color].rgbBlue = fgetc(inBMP);\r
- tempBMP->bmInfo.bmiColors[color].rgbGreen = fgetc(inBMP);\r
- tempBMP->bmInfo.bmiColors[color].rgbRed = fgetc(inBMP);\r
- tempBMP->bmInfo.bmiColors[color].rgbReserved = fgetc(inBMP);\r
- }\r
-\r
- load_BMP_palette(tempBMP);\r
-\r
- // Allocate space for the data to hold the pixels\r
- // Goto the pixel offset in the file\r
- // Read in the pixels\r
- target->data = (byte *)calloc((tempBMP->bmFileHeader.bfSize - tempBMP->bmFileHeader.bfOffBits), 1);\r
- target->height = tempBMP->bmInfo.bmiHeader.biHeight;\r
- target->width = tempBMP->bmInfo.bmiHeader.biWidth;\r
- fseek(inBMP, tempBMP->bmFileHeader.bfOffBits, 0);\r
- fread(target->data, target->height * target->width, 1, inBMP);\r
-\r
- free(tempBMP);\r
- fclose(inBMP); // Dont forget to close\r
-}\r
-\r
-void show_BMP(TILE *source, word x, word y)\r
-{\r
- word row, col, offset = 0;\r
-\r
- for (row = source->height; row > 0; row--)\r
- {\r
- for (col = 0; col < source->height; col++)\r
- {\r
- if (source->data[offset] != 255)\r
- putpixel(x + col, y + row, source->data[offset]);\r
- offset++;\r
- }\r
- }\r
-}\r
-\r
-void show_tile(TILE *tile, word x, word y)\r
-{\r
- word cx, cy;\r
-\r
- for (cy = 1; cy <= tile->height; cy++)\r
- for (cx = 0; cx < tile->width; cx++)\r
- if (tile->data[cx + (cy * tile->width)] != 255)\r
- putpixel(x + cx, y + cy, tile->data[cx + (cy * tile->width)]);\r
-}\r
-\r
-void make_tile(TILE *target, TILE *source)\r
-{\r
- int row, col, offset = 0;\r
-\r
- target->data = (byte *)malloc(source->height * source->width + source->width);\r
-\r
- target->height = source->height;\r
- target->width = source->width;\r
-\r
- for (row = source->height * source->width; row >= 0; row -= source->width)\r
- {\r
- for (col = 0; col < source->width; col++)\r
- {\r
- target->data[offset] = source->data[col + row];\r
- offset++;\r
- }\r
- }\r
-}\r
-\r
-void get_tile(word x1, word y1, word x2, word y2, TILE *target)\r
-{\r
- int cx, cy, offset = 0;\r
-\r
- target->height = abs(y2 - y1);\r
- target->width = abs(x2 - x1);\r
-\r
- target->data = (byte *)malloc(target->height * target->width + target->width);\r
-\r
- for (cy = 0; cy <= target->height; cy++)\r
- for (cx = 0; cx < target->width; cx++)\r
- {\r
- target->data[offset] = getpixel(x1 + cx, y1 + cy);\r
- offset++;\r
- }\r
-}\r
projects / 16.git / blobdiff