+++ /dev/null
-/*----------------------------------------------------------------------------\r
-blit() function for VBE 1.x banked framebuffer\r
-Chris Giese <geezer@execpc.com> http://my.execpc.com/~geezer/\r
-This code is public domain (no copyright).\r
-You can do whatever you want with it.\r
-\r
-Compile with any of the following DOS compilers:\r
-- Turbo C++ 1.0\r
-- Borland C++ 3.1\r
-- 16-bit Watcom C\r
-- DJGPP\r
-\r
-April 4, 2008\r
-- Initial release\r
-\r
-More notes:\r
-- The 'BPP' macro can be changed to 2, 3, or 4 to work with color\r
- depths 16, 24, and 32, respectively. BPP can also be a run-\r
- time variable; letting you use the same blit() function for\r
- various color depths.\r
-- Some video boards (Intel i810 integrated video) report compliance\r
- with VBE 2.x but _still_ do not support a linear framebuffer\r
-- Left as an exercise for the reader: it should be easy to convert\r
- blit_mem_to_fb() to blit_fb_to_mem()\r
-- Left as an exercise for the reader: it should be easy to convert\r
- blit_mem_to_fb() to blot_fb(); a function that draws a solid\r
- filled rectangle. (Hint: replace MEMCPY()s with MEMSET()s)\r
-- To handle arbitrary blitting in a system with a banked framebuffer,\r
- you need four functions: blit_mem_to_mem(), blit_mem_to_fb(),\r
- blit_fb_to_mem(), and blit_fb_to_fb()\r
-----------------------------------------------------------------------------*/\r
-#include <string.h> /* memset(), [_f]memcpy() */\r
-/* EOF, FILE, fopen(), fwrite(), fputc(), fclose(), remove(), printf() */\r
-#include <stdio.h>\r
-#include <conio.h> /* getch(), outp[ortb]() */\r
-/* union REGS, struct SREGS, int86(), int86x() */\r
-#include <dos.h> /* FP_SEG(), FP_OFF(), MK_FP() */\r
-#if 0\r
-/* C99 fixed-width types */\r
-#include <stdint.h>\r
-#else\r
-typedef unsigned char uint8_t;\r
-typedef unsigned short uint16_t;\r
-typedef unsigned long uint32_t;\r
-#endif\r
-\r
-#if defined(__TURBOC__)\r
-#if __TURBOC__==0x401\r
-#error Sorry, 'huge' is broken in Turbo C++ 3.0\r
-#endif\r
-\r
-/* This code exposes some bugs in Borland C++ 3.1, so... */\r
-#if __TURBOC__==0x410\r
-#pragma option -Od /* ...disable all optimizations */\r
-#endif\r
-\r
-#define HUGE huge\r
-#define MEMCPY(D,S,N) _fmemcpy(D,S,N)\r
-#define MEMSET(D,C,N) _fmemset(D,C,N)\r
-\r
-#elif defined(__WATCOMC__)&&!defined(__386__)\r
-#define outportb(P,V) outp(P,V)\r
-#define HUGE huge\r
-#define MEMCPY(D,S,N) _fmemcpy(D,S,N)\r
-#define MEMSET(D,C,N) _fmemset(D,C,N)\r
-\r
-#elif defined(__DJGPP__)\r
-/* __djgpp_conventional_base, __djgpp_nearptr_enable() */\r
-#include <sys/nearptr.h>\r
-#include <dpmi.h> /* __dpmi_regs, __dpmi_int(), __dpmi_allocate_dos_memory() */\r
-#include <crt0.h> /* _CRT0_FLAG_NEARPTR, _crt0_startup_flags */\r
-\r
-#define __386__ 1\r
-#define HUGE /* nothing */\r
-#define MEMCPY(D,S,N) memcpy(D,S,N)\r
-#define MEMSET(D,C,N) memset(D,C,N)\r
-\r
-#else\r
-#error Sorry, unsupported compiler\r
-#endif\r
-\r
-#define MIN(X,Y) (((X) < (Y)) ? (X) : (Y))\r
-\r
-/* structure used by INT 10h AX=4F01h */\r
-#pragma pack(1)\r
-typedef struct\r
-{\r
- uint16_t mode_attrib; /* b5=1 for non-VGA mode */\r
- uint8_t win_a_attrib;\r
- uint8_t win_b_attrib;\r
- uint16_t k_per_gran;\r
- uint16_t win_size;\r
- uint16_t win_a_seg;\r
- uint16_t win_b_seg;\r
- char reserved1[4];\r
-/* this is not always the expected value;\r
-rounded up to the next power of 2 for some video boards: */\r
- uint16_t bytes_per_row;\r
-/* OEM modes and VBE 1.2 only: */\r
- uint16_t wd;\r
- uint16_t ht;\r
- uint8_t char_wd;\r
- uint8_t char_ht;\r
- uint8_t planes;\r
- uint8_t depth;\r
- uint8_t banks;\r
- uint8_t memory_model;\r
- uint8_t k_per_bank;\r
- uint8_t num_pages; /* ? */\r
- char reserved2;\r
-/* VBE 1.2 only */\r
- uint8_t red_width;\r
- uint8_t red_shift;\r
- uint8_t green_width;\r
- uint8_t green_shift;\r
- uint8_t blue_width;\r
- uint8_t blue_shift;\r
- char reserved3[3];\r
- uint32_t lfb_adr;\r
- char reserved4[212];\r
-} vbe_mode_info_t;\r
-\r
-typedef struct\r
-{\r
- unsigned wd, ht;\r
- unsigned long bytes_per_row;\r
- unsigned char HUGE *raster;\r
-} img_t;\r
-\r
-typedef struct\r
-{\r
- int src_x, src_y, dst_x, dst_y;\r
- unsigned wd, ht;\r
-} clip_t;\r
-\r
-static img_t g_fb;\r
-static unsigned g_use_win_a, g_gran_per_64k;\r
-/*****************************************************************************\r
-no _fmemcpy() in Turbo C++ 1.0\r
-*****************************************************************************/\r
-#if defined(__TURBOC__)\r
-#if __TURBOC__<0x300\r
-void far * far _fmemcpy(void far *dst_ptr, const void far *src_ptr,\r
- unsigned n)\r
-{\r
- unsigned char huge *dst = dst_ptr;\r
- unsigned char huge *src = src_ptr;\r
-\r
- for(; n != 0; n--)\r
- {\r
- *dst = *src;\r
- dst++;\r
- src++;\r
- }\r
- return dst_ptr;\r
-}\r
-#endif\r
-#endif\r
-/*****************************************************************************\r
-*****************************************************************************/\r
-static void set_bank(unsigned b)\r
-{\r
- static unsigned curr_bank = -1u;\r
-/**/\r
- union REGS regs;\r
-\r
- if(b == curr_bank)\r
- return;\r
- curr_bank = b;\r
- regs.x.ax = 0x4F05;\r
-/* g_use_win_a and g_gran_per_64k were set by INT 10h AX=4F01h */\r
- regs.x.bx = g_use_win_a ? 0x0000 : 0x0001;\r
- regs.x.dx = b * g_gran_per_64k;\r
- int86(0x10, ®s, ®s);\r
-}\r
-/*****************************************************************************\r
-If using Borland C, compile this without optimizations.\r
-Even without optimizations, it probably won't work with Turbo C++ 3.0\r
-*****************************************************************************/\r
-#define BPP 1 /* bytes per pixel */\r
-static void blit_mem_to_fb(img_t *src_img, clip_t *clip)\r
-{\r
- unsigned bank, y, row_with_bank_switch, max_y;\r
- unsigned char HUGE *src;\r
- unsigned long off32;\r
- uint16_t off16, i;\r
-\r
- src = src_img->raster +\r
- src_img->bytes_per_row * clip->src_y + clip->src_x * BPP;\r
-/* calculate 32-bit offset into framebuffer corresponding to\r
-(clip->dst_x, clip->dst_y) */\r
- off32 = g_fb.bytes_per_row * clip->dst_y + clip->dst_x * BPP;\r
-/* use low 16 bits for offset into 64K bank; use top 16 bits for bank */\r
- off16 = (uint16_t)off32;\r
- off32 >>= 16;\r
- bank = (uint16_t)off32;\r
-/* set bank and increment bank number */\r
- set_bank(bank);\r
- bank++;\r
- for(y = clip->dst_y; ; )\r
- {\r
-/* in which row does the next bank-switch occur? */\r
- off32 = bank;\r
- off32 <<= 16;\r
- row_with_bank_switch = (unsigned)\r
- (off32 / g_fb.bytes_per_row);\r
-/* blit until we reach that row or until we reach (clip->dst_y + clip->ht) */\r
- max_y = MIN(clip->dst_y + clip->ht, row_with_bank_switch);\r
- for(; y < max_y; y++)\r
- {\r
- MEMCPY(g_fb.raster + off16, src, clip->wd * BPP);\r
- off16 += g_fb.bytes_per_row;\r
- src += src_img->bytes_per_row;\r
- }\r
-/* exit now if done */\r
- if(y >= clip->dst_y + clip->ht)\r
- break;\r
-/* else it's a row with bank switch. There are 3 possibilities:\r
-line of pixels in this row starts AFTER bank switch */\r
- if(off16 < g_fb.bytes_per_row) /* overflowed 64K (clever!) */\r
- {\r
- set_bank(bank);\r
- MEMCPY(g_fb.raster + off16, src, clip->wd * BPP);\r
- }\r
-/* line of pixels in this row ends BEFORE bank switch */\r
- else if(off16 + (unsigned long)clip->wd * BPP <= 0x10000L)\r
- {\r
- MEMCPY(g_fb.raster + off16, src, clip->wd * BPP);\r
- set_bank(bank);\r
- }\r
-/* line of pixels in this row STRADDLES bank switch */\r
- else\r
- {\r
- i = (uint16_t)(0x10000uL - off16);\r
- MEMCPY(g_fb.raster + off16, src + 0,\r
- i);\r
- set_bank(bank);\r
- MEMCPY(g_fb.raster + 0 , src + i,\r
- clip->wd * BPP - i);\r
- }\r
- off16 += g_fb.bytes_per_row;\r
- src += src_img->bytes_per_row;\r
- bank++;\r
- y++;\r
- }\r
-}\r
-/*****************************************************************************\r
-*****************************************************************************/\r
-int main(void)\r
-{\r
- static const unsigned vbe_mode_num = 0x101; /* 640x480x256 */\r
-/* 14x14 test bitmap */\r
- static unsigned char raster[] =\r
- "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x01\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x02\x02\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x03\x03\x03\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x04\x04\x04\x04\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x05\x05\x05\x05\x05\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x06\x06\x06\x06\x06\x06\x06\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x07\x07\x07\x07\x07\x07\x07\x07\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x08\x08\x08\x08\x08\x08\x08\x08\x08\x09\x0A\x0B\x0C\x0D"\r
- "\x09\x09\x09\x09\x09\x09\x09\x09\x09\x09\x0A\x0B\x0C\x0D"\r
- "\x0A\x0A\x0A\x0A\x0A\x0A\x0A\x0A\x0A\x0A\x0A\x0B\x0C\x0D"\r
- "\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0B\x0C\x0D"\r
- "\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0C\x0D"\r
- "\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D\x0D";\r
-/**/\r
- union REGS regs;\r
- unsigned i;\r
- clip_t clip;\r
- img_t img;\r
-\r
-#if !defined(__386__)\r
- static vbe_mode_info_t vbe_mode_info;\r
- struct SREGS sregs;\r
-\r
-/* get info for VBE mode */\r
- regs.x.ax = 0x4F01;\r
- regs.x.cx = vbe_mode_num;\r
- sregs.es = FP_SEG(&vbe_mode_info);\r
- regs.x.di = FP_OFF(&vbe_mode_info);\r
- int86x(0x10, ®s, ®s, &sregs);\r
- if(regs.x.ax != 0x004F)\r
- {\r
- printf("Error getting info for VBE mode 0x%X\n",\r
- vbe_mode_num);\r
- return 1;\r
- }\r
-/* init g_fb */\r
- g_fb.wd = vbe_mode_info.wd;\r
- g_fb.ht = vbe_mode_info.ht;\r
- g_fb.bytes_per_row = vbe_mode_info.bytes_per_row;\r
- g_gran_per_64k = 64 / vbe_mode_info.k_per_gran;\r
- if(vbe_mode_info.win_a_attrib == 7)\r
- {\r
- g_fb.raster = (unsigned char HUGE *)\r
- MK_FP(vbe_mode_info.win_a_seg, 0);\r
- g_use_win_a = 1;\r
- }\r
- else if(vbe_mode_info.win_b_attrib == 7)\r
- {\r
- g_fb.raster = (unsigned char HUGE *)\r
- MK_FP(vbe_mode_info.win_b_seg, 0);\r
- g_use_win_a = 0;\r
- }\r
- else\r
- {\r
- printf("Error locating banked framebuffer "\r
- "for VBE mode 0x%X\n", vbe_mode_num);\r
- return -1;\r
- }\r
-#else /* if defined(__DJGPP__) */\r
- vbe_mode_info_t *vbe_mode_info;\r
- int conv_mem_seg, conv_mem_sel;\r
- __dpmi_regs dregs;\r
-\r
-/* turn off data segment limit, for nearptr access */\r
- if(!(_crt0_startup_flags & _CRT0_FLAG_NEARPTR))\r
- {\r
- if(!__djgpp_nearptr_enable())\r
- {\r
- printf("Error: can't enable near pointer "\r
- "access to framebuffer (WinNT/2k/XP?)\n");\r
- return 1;\r
- }\r
- }\r
-/* allocate conventional memory for INT 10h AX=4F01h buffer */\r
- conv_mem_seg = __dpmi_allocate_dos_memory(256 / 16, &conv_mem_sel);\r
- if(conv_mem_seg == -1)\r
- {\r
- printf("Error: can't allocate conventional memory\n");\r
- return 1;\r
- }\r
- vbe_mode_info = (vbe_mode_info_t *)\r
- (conv_mem_seg * 16uL + __djgpp_conventional_base);\r
-printf("vbe_mode_info: sel=0x%X, real-mode seg=0x%X, linear=0x%lX, near=0x%p\n",\r
- conv_mem_sel, conv_mem_seg, conv_mem_seg * 16uL, vbe_mode_info);\r
-/* get info for VBE mode */\r
- dregs.x.ax = 0x4F01;\r
- dregs.x.cx = vbe_mode_num;\r
- dregs.x.es = conv_mem_seg;\r
- dregs.x.di = 0;\r
- __dpmi_int(0x10, &dregs);\r
- if(dregs.x.ax != 0x004F)\r
- {\r
- printf("Error getting info for VBE mode 0x%X\n",\r
- vbe_mode_num);\r
- return 1;\r
- }\r
-/* init g_fb */\r
- g_fb.wd = vbe_mode_info->wd;\r
- g_fb.ht = vbe_mode_info->ht;\r
- g_fb.bytes_per_row = vbe_mode_info->bytes_per_row;\r
- g_gran_per_64k = 64 / vbe_mode_info->k_per_gran;\r
- if(vbe_mode_info->win_a_attrib == 7)\r
- {\r
- g_fb.raster = (unsigned char HUGE *)\r
- (vbe_mode_info->win_a_seg * 16uL +\r
- __djgpp_conventional_base);\r
- g_use_win_a = 1;\r
- }\r
- else if(vbe_mode_info->win_b_attrib == 7)\r
- {\r
- g_fb.raster = (unsigned char HUGE *)\r
- (vbe_mode_info->win_b_seg * 16uL +\r
- __djgpp_conventional_base);\r
- g_use_win_a = 0;\r
- }\r
- else\r
- {\r
- printf("Error locating banked framebuffer "\r
- "for VBE mode 0x%X\n", vbe_mode_num);\r
- return -1;\r
- }\r
-#endif\r
-/* init img */\r
- img.wd = 14;\r
- img.ht = 14;\r
- img.bytes_per_row = img.wd;\r
- img.raster = raster;\r
-/* init clip_t */\r
- clip.wd = img.wd;\r
- clip.ht = img.ht;\r
- clip.src_x = 0;\r
- clip.src_y = 0;\r
-/* set graphics mode */\r
- regs.x.bx = vbe_mode_num;\r
- regs.x.ax = 0x4F02;\r
- int86(0x10, ®s, ®s);\r
-/* green palette */\r
-#define VGA_DAC_WRITE_INDEX 0x3C8\r
-#define VGA_DAC_DATA 0x3C9\r
- outportb(VGA_DAC_WRITE_INDEX, 0);\r
- for(i = 0; i < 16; i++)\r
- {\r
- outportb(VGA_DAC_DATA, /* red= */0 >> 2);\r
- outportb(VGA_DAC_DATA, /* green= */i * 3);\r
- outportb(VGA_DAC_DATA, /* blue= */0 >> 2);\r
- }\r
-/* test banked blit function */\r
- clip.dst_y = 0;\r
- for(; clip.dst_y + clip.ht < g_fb.ht; clip.dst_y += clip.ht)\r
- {\r
- clip.dst_x = 0;\r
- for(; clip.dst_x + clip.wd < g_fb.wd; clip.dst_x += clip.wd)\r
- blit_mem_to_fb(&img, &clip);\r
- }\r
- if(getch() == 0)\r
- (void)getch();\r
-/* set text mode */\r
- regs.x.ax = 0x0003;\r
- int86(0x10, ®s, ®s);\r
- return 0;\r
-}\r
c2e.convert_special: 0
e2c.convert_num: 0
-openfiles: /dos/z/16/16/dos_gfx.cpp:8340:8091:1:
-openfiles: /dos/z/16/16/dos_gfx.h:941:268:0:
+openfiles: /dos/z/16/16/dos_gfx.cpp:8341:8024:0:
+openfiles: /dos/z/16/16/dos_gfx.h:941:208:0:
openfiles: /dos/z/16/16/dos_kb.c:759:642:0:
openfiles: /dos/z/16/16/dos_kb.h:179:0:0:
openfiles: /dos/z/16/16/lib_com.cpp:164:0:0:
openfiles: /dos/z/16/16/lib_com.h:0:0:0:
openfiles: /dos/z/16/16/16.txt:0:0:0:
openfiles: /dos/z/16/16/project16.txt:1755:1676:0:
+openfiles: /dos/z/4x4_16/sauce/jstick.h:0:0:0:
+openfiles: /dos/z/4x4_16/sauce/keydrv.h:0:601:0:
+openfiles: /dos/z/4x4_16/sauce/sprite.h:590:35:0:
+openfiles: /dos/z/4x4_16/sauce/tile.h:327:173:0:
+openfiles: /dos/z/4x4_16/sauce/vgabuff.h:0:0:0:
+openfiles: /dos/z/4x4_16/sauce/vgautils.h:0:0:0:
+openfiles: /dos/z/4x4_16/sauce/keydrv.c:0:0:0:
+openfiles: /dos/z/4x4_16/sauce/sprite.c:0:0:0:
+openfiles: /dos/z/4x4_16/sauce/tile.c:304:55:1:
+openfiles: /dos/z/4x4_16/sauce/vgabuff.c:0:0:0:
+openfiles: /dos/z/4x4_16/sauce/vgautils.c:0:0:0:
snr_recursion_level: 0
convertcolumn_horizontally: 0
adv_open_matchname: 0
default_mime_type: text/plain
e2c.convert_xml: 1
c2e.convert_iso: 0
-opendir: file:///dos/z/4x4_16/tauron/C_SRC
+opendir: file:///dos/z/4x4_16/sauce
wrap_text_default: 0
bookmarks_filename_mode: 1
-ssearch_text: fmem
+ssearch_text: 386
snr_casesens: 0
view_blocks: 1
name: project 16
recent_files: file:///dos/z/4x4_16/tauron/C_SRC/MODES.CPP
recent_files: file:///dos/z/4x4_16/tauron/C_SRC/FONT1.H
recent_files: file:///dos/z/4x4_16/tauron/C_SRC/FONT2.H
+recent_files: file:///dos/z/4x4_16/tile.c
+recent_files: file:///dos/z/4x4_16/tile.h
+recent_files: file:///dos/z/4x4_16/sauce/jstick.h
+recent_files: file:///dos/z/4x4_16/sauce/keydrv.h
+recent_files: file:///dos/z/4x4_16/sauce/sprite.h
+recent_files: file:///dos/z/4x4_16/sauce/tile.h
+recent_files: file:///dos/z/4x4_16/sauce/vgautils.h
+recent_files: file:///dos/z/4x4_16/sauce/keydrv.c
+recent_files: file:///dos/z/4x4_16/sauce/vgabuff.h
+recent_files: file:///dos/z/4x4_16/sauce/sprite.c
+recent_files: file:///dos/z/4x4_16/sauce/tile.c
+recent_files: file:///dos/z/4x4_16/sauce/vgautils.c
+recent_files: file:///dos/z/4x4_16/sauce/vgabuff.c
snr_replacetype: 0
-savedir: file:///dos/z/16/16
+savedir: file:///dos/z/4x4_16/sauce
spell_check_default: 1
spell_insert_entities: 0
last_filefilter:
htmlbar_notebooktab: 0
view_blockstack: 1
snr_escape_chars: 0
-htmlbar_view: 1
+htmlbar_view: 0
spell_lang: en
ssearch_dotmatchall: 0
-searchlist: put
-searchlist: print
searchlist: d put
searchlist: print
searchlist: tile
searchlist:
searchlist: rect
searchlist: fmem
+searchlist: vga
+searchlist: 386
autocomplete: 1
outputb_show_all_output: 0
bookmarks_show_mode: 0
--- /dev/null
+#define JOYPORT 0x201
+#define J1B1 0x10
+#define J1B2 0x20
+#define J2B1 0x40
+#define J2B2 0x80
+#define J1 0x01
+#define J2 0x02
+#define J1X 0x01
+#define J1Y 0x02
+
+
+unsigned char joybutton(unsigned char button) {
+ outp(JOYPORT,0);
+ return ((unsigned char) (~inp(JOYPORT) &button));
+}//end joybutton
+
+int joy1b(int button);
+ #pragma aux joy1b = \
+ "mov dx, 0x201" \
+ "out dx, al" \
+ "in al, dx" \
+ "and ax, bx" \
+ "xor ax, bx" \
+ parm [bx] \
+ modify[dx ax] \
+ value[ax];
+
+extern unsigned int joystick( unsigned char _stick );
+ #pragma aux joystick = \
+ "cli" \
+ "mov ah,ch" \
+ "xor al,al" \
+ "xor cx,cx" \
+ "mov dx,0x201" \
+ "out dx,al" \
+ "charged:" \
+ "in al,dx" \
+ "test al,ah" \
+ "loopne charged" \
+ "xor ax,ax" \
+ "sub ax,cx" \
+ "sti" \
+ parm [ch] \
+ modify [ax];
+
+
--- /dev/null
+#include<conio.h>
+#include<dos.h>
+
+#include "keydrv.h"
+
+extern int pressed;
+extern char keymap[];
+
+static void (__interrupt __far * old9h ) () ; //holds dos key int
+
+
+
+void __interrupt __far Key_handler() {
+ int scan,cv;
+
+ irenable();
+ scan = inp(0x60); //read scan code
+ cv = inp(0x61);
+ outp( 0x61, cv | 0x80 );
+ outp( 0x61, cv );
+ outp(0x20, 0x20); //reset key int
+
+ if(scan > 127) { //on break set keymap 0, dec pressed
+ keymap[(scan & 127)] = 0;
+ pressed -= 1;
+ }
+ else if(keymap[scan] == 0) { //on make set keymap 1, inc pressed
+ pressed += 1; //if not already set
+ keymap[scan] = 1;
+ }
+
+}
+
+void hook_keys() {
+ int i;
+
+ for(i=0; i<128; i++) //set all keys to off
+ keymap[i] = 0;
+ pressed = 0; //set number keys pressed to 0
+
+ old9h = _dos_getvect ( 0x9 ); //save old key int
+ _dos_setvect ( 0x9 , Key_handler ); //set key int to new handler
+}
+
+void release_keys() {
+ _dos_setvect ( 0x9 , old9h ) ; // Return to DOS keyboard driver
+}
+
+void waitkey(int key) {
+ int temp = 0;
+ while(!temp)
+ if(keymap[key])
+ temp = 1;
+}
+
+void waitkeyup(int key) {
+ int temp = 0;
+ while(!temp)
+ if(!keymap[key])
+ temp = 1;
+}//end waitkeyup
+
+
+
--- /dev/null
+/**********************************************
+ to use keydrv must include global variables:
+ int pressed; //globals for key driver (# keys pressed)
+ char keymap[128]; //map of all keys and their state
+***********************************************/
+
+#ifndef keydrv_h
+#define keydrv_h
+
+
+void irdisable();
+#pragma aux irdisable = \
+ "cli";
+
+void irenable();
+#pragma aux irenable = \
+ "sti";
+
+void hook_keys(); //installs keydrv,saves dos driver,0's out globals
+void release_keys(); //reinstalls dos driver
+void waitkey(int key); //waits for a key to be pressed then returns
+void waitkeyup(int key); //waits for key specified by parameter
+ //to be released
+
+//scan code defines
+#define ESC 1
+#define KEY1 2
+#define KEY2 3
+#define KEY3 4
+#define KEY4 5
+#define KEY5 6
+#define KEY6 7
+#define KEY7 8
+#define KEY8 9
+#define KEY9 10
+#define KEY0 11
+#define KEYQ 16
+#define KEYA 30
+#define KEYJ 36
+#define KEYL 38
+#define LSHIFT 42
+#define KEYZ 44
+#define SPACE 57
+#define UP 72
+#define LEFT 75
+#define RIGHT 77
+#define DOWN 80
+
+#endif
+
+
--- /dev/null
+#include<malloc.h>
+#include<string.h>
+
+#include "sprite.h"
+
+extern unsigned char far* dbuffer;
+
+int sprcreate(sprite *spr, int width, int height, int frames, int trans) {
+ int i; //loop counter
+ int error = 0;
+
+ spr->x_dim = width;
+ spr->y_dim = height;
+ spr->numimages = frames;
+ spr->state = 0;
+ spr->transparent = trans;
+ for(i=0; i<frames; i++) {
+ spr->images[i] = (unsigned char far*)_fmalloc(width * height);
+ if(!spr->images[i])
+ error = 1;
+ }
+ spr->background = (unsigned char far*)_fmalloc(width * height);
+ if(!spr->background)
+ error = 1;
+
+ return error;
+}//end sprcreate
+
+void sprclose(sprite *spr) {
+ int i; // loop counter
+
+ for(i=0; i<spr->numimages; i++)
+ _ffree(spr->images[i]);
+ _ffree(spr->background);
+}//end sprclose
+
+void sprload (sprite * spr) {
+ unsigned char far* dest;
+ unsigned char far* source;
+ int x_loc = 0, y_loc = 0; //frame coordinates in dbuffer
+ int i,j; //loop counters
+
+ for(i=0; i < spr->numimages; i++) {
+ x_loc = i * (spr->x_dim + 1);
+ if (x_loc > (320 - spr->x_dim)) {
+ x_loc = 0;
+ y_loc += (spr->y_dim + 1);
+ }//endif
+ source = dbuffer + ((y_loc * 320) + x_loc);
+ dest = spr->images[i];
+ for(j=0; j < spr->y_dim; j++) {
+ _fmemcpy(dest,source,spr->x_dim);
+ source += 320;
+ dest += spr->x_dim;
+ }//end for
+ }//end outer for
+
+}//end sprload
+
+void sprinit(sprite *spr,int x,int y,int fimage) {
+ spr->state = 1;
+ spr->x_loc = x;
+ spr->y_loc = y;
+ spr->curimage = fimage;
+ sprback(spr);
+}//end sprinit
+
+void sprback(sprite * spr) {
+ int width = spr->x_dim;
+ int height = spr->y_dim;
+ int xloc = spr->x_loc;
+ int yloc = spr->y_loc;
+ unsigned char far* source = dbuffer;
+ unsigned char * dest = spr->background;
+ int i; //loop counter
+
+ source += ((yloc << 8) + (yloc << 6) + xloc);
+
+ for(i=0; i < height; i++) {
+ puturow(dest,source,width);
+ source += 320;
+ dest += width;
+ }//end for
+}//end sprback
+
+void sprwrite(sprite *spr) {
+ unsigned char far* dest = dbuffer;
+ unsigned char * source = spr->images[spr->curimage];
+ int height = spr->y_dim;
+ int width = spr->x_dim;
+ int i,x,y; //loop counters
+
+ dest += ((spr->y_loc << 8) + (spr->y_loc << 6) + spr->x_loc);
+
+ if(!(spr->transparent))
+ for(i=0; i < height; i++) {
+ _fmemcpy(dest,source,width);
+ dest += 320;
+ source += width;
+ }//end for
+ else {
+ for(y=0; y<height; y++) {
+ for(x=0; x<width; x++) {
+ if((*source != 0))
+ dest[x] = *source;
+ source++;
+ }//endfor
+ dest += 320;
+ }//endfor
+ }//end else
+}//end sprwrite
+
+void sprerase(sprite * spr) {
+ unsigned char far* dest = dbuffer;
+ unsigned char * source = spr->background;
+ int height = spr->y_dim;
+ int width = spr->x_dim;
+ int i; //loop counter
+
+ dest += ((spr->y_loc << 8) + (spr->y_loc << 6) + spr->x_loc);
+
+
+ for(i=0; i<height; i++) {
+ puturow(dest,source,width);
+ dest += 320;
+ source += width;
+ }//end for
+}//end sprerase
+
+void sprcopy(sprite *dest, sprite *source) {
+ int i; //loop counter
+
+ dest->x_dim = source->x_dim;
+ dest->y_dim = source->y_dim;
+ dest->state = source->state;
+ dest->numimages = source->numimages;
+ dest->curimage = source->curimage;
+ dest->transparent = source->transparent;
+ for(i=0; i<source->numimages; i++)
+ dest->images[i] = source->images[i];
+ dest->background = (unsigned char far*)_fmalloc(source->x_dim * source->y_dim);
+}//end copy
+
+/*
+
+sprcopy(sprite *dest, sprite *source) {
+ int i; //loop counter
+
+ dest->x_dim = source->x_dim;
+ dest->y_dim = source->y_dim;
+ dest->numimages = source->numimages;
+ dest->curimage = source->curimage;
+ dest->transparent = source->transparent;
+ for(i=0; i<numimages; i++)
+ dest->images[i] = source->images[i];
+ dest->background = (unsigned char far*)_fmalloc(width * height);
+}//end copy
+
+int collide(sprite * orig,sprite *check) {
+ if(orig->x_loc > check->x_loc) {
+ if((orig->x_loc - check->x_loc) >= check->x_dim)
+ return 0;
+ }
+ else if((check->x_loc - orig->x_loc) >= orig->x_dim)
+ return 0;
+ if(orig->y_loc > check->y_loc) {
+ if((orig->y_loc - check->y_loc) >= check->y_dim)
+ return 0;
+ }
+ else if((check->y_loc - orig->y_loc) >= orig->y_dim)
+ return 0;
+ return 1;
+}//end collide
+
+
+
+
+
+
+writesprclip(sprite * in,unsigned char far * dest) {
+ unsigned char far * source = in->images[in->curimage];
+
+ int sx,sy;
+ int width;
+ int bx = 0,by = 0, bwidth = 0,bheight = 0;
+ unsigned char pixel;
+
+ width = in->x_dim;
+ bwidth = width;
+ bheight = in->y_dim;
+ sx = in->x_loc;
+ sy = in->y_loc;
+
+ if(!(sx>319 || sy>199 || sx+width<1 || sy+bheight<1)) {
+ if(sx<0) {
+ bx = -sx;
+ sx = 0;
+ bwidth -= bx;
+ }
+ else if(sx+width >= 319) {
+ bx = 0;
+ bwidth = 319 -sx;
+ }
+
+ if(sy<0) {
+ by = -sy;
+ sy = 0;
+ bheight -= by;
+ }
+ else if(sy+bheight>199) {
+ by = 0;
+ bheight = 199 - sy;
+ }
+
+ dest = dest + (sy << 8) + (sy << 6) + sx;
+ in->preclip = (by * width) + bx;
+ source = source + in->preclip;
+
+ if(in->transparent) {
+ for(int y = 0; y < bheight; y++) {
+ for(int x = 0; x < bwidth; x++) {
+ if((pixel=source[x]))
+ dest[x] = pixel;
+ }//end for x
+ dest +=320;
+ source+=width;
+ }//end for y
+ }//end if
+ else {
+ for(int y =0; y < bheight; y++) {
+ _fmemcpy(dest,source,bwidth);
+ dest += 320;
+ source += width;
+ }//end for y
+ }//end else
+
+ in->x_clip = sx;
+ in->y_clip = sy;
+ in->x_dim_clip = bwidth;
+ in->y_dim_clip = bheight;
+ }
+
+}//end writesprclip
+
+*/
--- /dev/null
+#ifndef sprite_h
+#define sprite_h
+
+#define NUMFRAME 11 //max # of frames per sprite
+
+typedef struct sprite_typ
+ {
+ int x_loc;
+ int y_loc;
+ int x_dim;
+ int y_dim;
+ short numimages;
+ short curimage;
+ short state;
+ short transparent;
+ unsigned char far * images[NUMFRAME];
+ unsigned char far * background;
+ }sprite;
+
+int sprcreate(sprite *spr, int width, int height, int frames, int trans);
+void sprclose(sprite *spr);
+void sprload (sprite * spr);
+void sprinit(sprite *spr,int x,int y,int fimage);
+void sprback(sprite * spr);
+void sprwrite(sprite *spr);
+void sprwrite(sprite *spr);
+void sprerase(sprite *spr);
+void sprcopy(sprite *dest, sprite *source);
+
+void puturow(unsigned char far* dest, unsigned char far* source, int size);
+#pragma aux puturow = \
+ "mov bx, 0x3" \
+ "and bx, cx" \
+ "shr cx, 0x2" \
+ "rep movsd" \
+ "mov cx, bx" \
+ "rep movsb" \
+ parm [es di] [ds si] [cx] \
+ modify [bx];
+#endif
--- /dev/null
+#include "tile.h"
+#include <mem.h>
+#include <malloc.h>
+
+
+extern unsigned char far* dbuffer;
+
+//copy 16x16 tile to dest, loop unrolled 4 times
+void putile(unsigned char far* dest, unsigned char far* source);
+#pragma aux putile= \
+ "mov bx, 0" \
+ "marker:" \
+ "mov cx, 4" \
+ "rep movsb" \
+ "add di, 304" \
+ "mov cx, 4" \
+ "rep movsb" \
+ "add di, 304" \
+ "mov cx, 4" \
+ "rep movsb" \
+ "add di, 304" \
+ "mov cx, 4" \
+ "rep movsb" \
+ "add di, 304" \
+ "add bx, 1" \
+ "cmp bx, 4" \
+ "jnz marker" \
+ modify [cx bx] \
+ parm [es di] [ds si];
+
+int tilecreate(tile *ntile, int frames) {
+ int i; //loop counter
+ int error = 0;
+
+ ntile->numimages = frames;
+ ntile->state = 0;
+
+ for(i=0; i<frames; i++) {
+ ntile->images[i] = (unsigned char far*)_fmalloc(256);
+ if(!ntile->images[i])
+ error = 1;
+ }
+
+ return error;
+}//end tilecreate
+
+void tileclose(tile *dtile) {
+ int i; // loop counter
+
+ for(i=0; i<dtile->numimages; i++)
+ _ffree(dtile->images[i]);
+}//end sprclose
+
+void tileload (tile * in) {
+ unsigned char far* dest;
+ unsigned char far* source;
+ int x_loc = 0, y_loc = 0; //frame coordinates in dbuffer
+ int i,j; //loop counters
+
+ for(i=0; i < in->numimages; i++) {
+ x_loc = i * (17);
+ if (x_loc > (304)) {
+ x_loc = 0;
+ y_loc += (17);
+ }//endif
+ source = dbuffer + ((y_loc * 320) + x_loc);
+ dest = in->images[i];
+ for(j=0; j < 16; j++) {
+ _fmemcpy(dest,source,16);
+ source += 320;
+ dest += 16;
+ }//end for
+ }//end outer for
+
+}//end tileload
+
+writetile(tile *out, unsigned char far* dest) {
+ unsigned char far* source;
+
+ dest += ((out->y_loc << 8) + (out->y_loc << 6) + out->x_loc);
+ source = out->images[out->curimage];
+
+ putile(dest,source);
+ return 0;
+
+}//end writetile
+
+int writetile_xclip(tile *out, unsigned char far* dest) {
+ int dx; //clipped starting x location
+ int dwidth; //clipped width of sprite
+ int i;
+
+ unsigned char far * source = out->images[out->curimage];
+
+
+ if(out->x_loc < 0) {
+ if(out->x_loc > -16) {
+ dx = 0;
+ // preclip = - out->x_loc;
+ source -= out->x_loc;
+ dwidth = 16 + out->x_loc;
+ }
+ else
+ return 0; //tile not visible
+ }
+ else if(out->x_loc > 303) {
+ if(out->x_loc < 320) {
+ // preclip = 0;
+ dx = out->x_loc;
+ dwidth = 320 - dx;
+ }
+ else
+ return 0; //tile not visible
+ }
+ else {
+ // preclip = 0;
+ dwidth = 16;
+ dx = out->x_loc;
+ }
+
+
+ dest= dest + (out->y_loc << 8) + (out->y_loc << 6) + dx; //find first pixel in dest
+
+ for(i = 0; i < 16; i++) {
+ _fmemcpy(dest,source,dwidth);
+ source += 16;
+ dest += 320;
+ }
+
+ // x_clip = dx;
+ // x_dim_clip = dwidth;
+
+ return 1;
+}//writetile_xclip
+
+/* not sure if this is working
+***********************************************************
+sprite::writetile_prexclip(unsigned char far* dest) {
+ int dwidth = x_dim_clip;
+ unsigned char far * source = images[curimage];
+ int i;
+
+ dest= dest + (y_loc << 8) + (y_loc << 6) + x_clip; //find first pixel in dest
+ source += preclip; //set source at first visible pixel
+
+ for(i = 0; i < 16; i++) {
+ _fmemcpy(dest,source,dwidth);
+ source += 16;
+ dest += 320;
+ }
+}
+***************************************************************/
--- /dev/null
+#ifndef tile_h
+#define tile_h
+
+
+#define NUMTIMAGE 10 // size of tile image array
+
+// all tiles are 16x16 images with no background scanning
+typedef struct tile_typ
+ {
+ int x_loc;
+ int y_loc;
+ short numimages;
+ short curimage;
+ short state;
+ unsigned char far * images[NUMTIMAGE];
+ }tile;
+
+//FUNCTIONS
+
+// allocate memory for a tile with images[frames]
+// sets tile.state = 0; returns 1 if memory not allocated
+int tilecreate(tile *ntile, int frames);
+
+//frees image memory used by tile
+void tileclose(tile *dtile);
+
+// reads all tile images from double buffer
+// images must be in double buffer b4 called
+void tileload (tile * in);
+
+// writes tile to screen(dest points to upper left corner)
+// at location (tile.x_loc,tile.y_loc)
+writetile(tile *out, unsigned char far* dest);
+
+// writes tile to screen(dest) clipping the left or right
+// edge if necessary, returns 0 if tile completely off screen
+int writetile_xclip(tile *out, unsigned char far* dest);
+
+#endif
--- /dev/null
+#include<malloc.h>
+
+#include "vgautils.h"
+#include "vgabuff.h"
+
+extern unsigned char far * dbuffer;
+static FILE * fptr; //used to hold location in graphics file
+
+int vbinit(int height) {
+ height = height * 320;
+ dbuffer = (unsigned char far*)_fmalloc(height);
+ if(dbuffer)
+ return 1;
+ else
+ return 0;
+}//initbuff
+
+vbclose() {_ffree(dbuffer);}
+
+int getpcximage(char fname[], int plt)
+{
+ int z,t; //loop counters
+ FILE * fptr;
+ rgbcolor_ptr tcolor;
+ unsigned int index = 0;
+ char temp;
+ int run;
+
+ if ((fptr = fopen(fname,"rb")) == 0) {
+ return 0;
+ }//end if file not found
+
+ if(!dbuffer) //if buff memory not allocated ret 0
+ return 0;
+
+ for(z=0; z<128; z++)
+ (char)getc(fptr);
+ while(index < 64000) {
+ temp = (char)getc(fptr);
+ if(temp>=192) {
+ run = temp - 192;
+ temp = (char)getc(fptr);
+ while ((run-- > 0) && (index < 64000))
+ dbuffer[index++] = temp;
+ }//endif
+ else
+ dbuffer[index++] = temp;
+ }//end while
+
+ if(plt) {
+ fseek(fptr,-768L,SEEK_END);
+ for(t=0; t<256; t++) {
+ tcolor->red = (unsigned char)(getc(fptr) >> 2);
+ tcolor->green = (unsigned char)(getc(fptr) >> 2);
+ tcolor->blue = (unsigned char)(getc(fptr) >> 2);
+ write_rgbcolor_reg(t,tcolor);
+ }//end for
+ }//end if
+
+ fclose(fptr);
+
+ return 1;
+}//end getpcximage
+
+int pcxopen(char fname[])
+{
+ int z; //loop counter
+
+ if ((fptr = fopen(fname,"rb")) == 0) {
+ return 0;
+ }//end if file not found
+
+ if(!dbuffer) //if buff memory not allocated ret 0
+ return 0;
+ //read past header
+ for(z=0; z<128; z++)
+ (char)getc(fptr);
+
+ pcxfadvance();
+
+ return 1;
+}//end pcxopen
+
+
+void pcxfadvance()
+{
+ unsigned int index = 0;
+ char temp;
+ int run;
+
+ while(index < 64000) {
+ temp = (char)getc(fptr);
+ if(temp>=192) {
+ run = temp - 192;
+ temp = (char)getc(fptr);
+ while ((run-- > 0) && (index < 64000))
+ dbuffer[index++] = temp;
+ }//endif
+ else
+ dbuffer[index++] = temp;
+ }//end while
+
+}//end pcxfadvance
+
+void pcxclose()
+{
+ int t; //loop counters
+ rgbcolor_ptr tcolor;
+
+ fseek(fptr,-768L,SEEK_END);
+ for(t=0; t<256; t++) {
+ tcolor->red = (unsigned char)(getc(fptr) >> 2);
+ tcolor->green = (unsigned char)(getc(fptr) >> 2);
+ tcolor->blue = (unsigned char)(getc(fptr) >> 2);
+ write_rgbcolor_reg(t,tcolor);
+ }//end for
+
+ fclose(fptr);
+
+}//end pcxclose
--- /dev/null
+#ifndef vgabuff_h
+#define vgabuff_h
+
+//allocates 320 * height bytes for buff
+int vbinit(int height);
+
+//frees space held by buff
+vbclose();
+
+/********** dbtovga *****************************
+* function to copy from memory to vga
+* dest = location in vga to start copying to
+* size = source size / 4 (size mod 4 must = 0)
+************************************************/
+void dbtovga(unsigned char far* dest, unsigned char far* source, int size);
+#pragma aux dbtovga= \
+ "rep movsd" \
+ parm [es di] [ds si] [cx];
+
+/************* getpcximage ***********************************
+* function reads a 320x200x256 pcx file and outputs to screen
+* if plt = 0 then the palette is not read
+* returns 0 if file unopened or screen not allocated
+*************************************************************/
+int getpcximage(char fname[], int plt);
+
+/***************************************************************
+* new pcx functions for single graphics file created 10/12/97
+* still use whole 320x200 for each sprite/tile - change soon!
+* note: no error checking, yet
+* functions should be moved to own file
+***************************************************************/
+
+//opens pcx file and reads first 320x200 image, no palette
+//returns 0 if file not found, 1 otherwise
+int pcxopen(char fname[]);
+
+//reads next 320x200 image in file opened by pcxopen
+void pcxfadvance();
+
+//reads the pallette into the vga registers and closes the file
+void pcxclose();
+
+
+#endif
--- /dev/null
+#include "vgautils.h"
+
+void setvgamode(int mode)
+{
+ union REGS inregs,outregs;
+
+ inregs.h.ah = 0; //set video mode subfunction
+ inregs.h.al = (unsigned char)mode; //video mode to change to
+ int86(0x10, &inregs, &outregs);
+}//end set_graphics_mode
+
+void write_rgbcolor_reg(int index, rgbcolor_ptr color)
+{
+ outp(COLOR_REGISTER_WR, index); //set register
+ outp(COLOR_DATA,color->red);
+ outp(COLOR_DATA,color->green);
+ outp(COLOR_DATA,color->blue);
+}//end write_rgbcolor_reg
+
+rgbcolor_ptr read_rgbcolor_reg(int index, rgbcolor_ptr color)
+{
+ outp(COLOR_REGISTER_RD, index);
+ color->red = (unsigned char)inp(COLOR_DATA);
+ color->green = (unsigned char)inp(COLOR_DATA);
+ color->blue = (unsigned char)inp(COLOR_DATA);
+ return color;
+}//emd read_rgbcolor_reg
+
+void read_palette(int start_reg,int end_reg,rgb_palette_ptr pal)
+{
+ int index;
+ rgbcolor color;
+
+ for(index = start_reg; index<=end_reg; index++)
+ {
+ read_rgbcolor_reg(index,(rgbcolor_ptr)&color);
+
+ pal->colors[index].red = color.red;
+ pal->colors[index].green = color.green;
+ pal->colors[index].blue = color.blue;
+ }//end for
+
+ pal->start_reg = start_reg;
+ pal->end_reg = end_reg;
+}//end read_palette
+
+void write_palette(int start_reg,int end_reg, rgb_palette_ptr pal)
+{
+ int index;
+
+ for(index=start_reg; index <= end_reg; index++)
+ write_rgbcolor_reg(index,&(pal->colors[index]));
+}//end write_palette
+
+void putchr(char out, int color, unsigned char far* dest) {
+ unsigned char far* chrs = (unsigned char far*)ROMCHRS;
+ int i,j; //loop counters
+ int mask; //bitmask to extract bits from character set
+
+ chrs += (out << 3); //set romptr to char * 8 bytes per char
+
+ for(i=0; i<8; i++) {
+ mask = 128;
+ for(j=0; j<8; j++) {
+ if(*chrs & mask)
+ dest[j] = color;
+ mask = mask >> 1;
+ }
+ chrs++;
+ dest += 320;
+ }
+}//end putchr
+
--- /dev/null
+#ifndef vgautils_h
+#define vgautils_h
+
+#define MODE13 0x13
+#define TEXT 0x03
+#define SCREEN_WIDTH 320
+#define SCREEN_HEIGHT 200
+
+#define COLOR_MASK 0x3c6
+#define COLOR_REGISTER_RD 0x3c7
+#define COLOR_REGISTER_WR 0x3c8
+#define COLOR_DATA 0x3c9
+#define VGACARD 0xA0000000
+#define ROMCHRS 0xF000FA6E
+
+#include<conio.h>
+#include<stdlib.h>
+#include<stdio.h>
+#include<dos.h>
+#include<math.h>
+
+typedef struct rgbcolor_typ
+ {
+ unsigned char red;
+ unsigned char green;
+ unsigned char blue;
+ }rgbcolor, *rgbcolor_ptr;
+
+typedef struct rgb_palette_typ
+ {
+ int start_reg; //starting register to save
+ int end_reg; // last register to save
+ rgbcolor colors[256]; // palette storage
+ }rgb_palette, *rgb_palette_ptr;
+
+void setvgamode(int mode);
+void write_rgbcolor_reg(int index, rgbcolor_ptr color);
+rgbcolor_ptr read_rgbcolor_reg(int index, rgbcolor_ptr color);
+void read_palette(int start_reg,int end_reg,rgb_palette_ptr pal);
+void write_palette(int start_reg,int end_reg, rgb_palette_ptr pal);
+void putchr(char out, int color, unsigned char far* dest);
+
+/***** syncvr() ***********************************
+* inline funtction that waits for verticle retrace
+***************************************************/
+#define syncvr() while(inp(0x3da) & 0x08);while(!(inp(0x3da) & 0x08));
+
+#endif
projects / 16.git / commitdiff