Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-23 12:08:56 +00:00
Code Issues Packages Projects Releases Wiki Activity
ee8250371f
Descent3/win32/winmono.cpp

683 lines
12 KiB
C++
Raw Blame History

#ifndef RELEASE
#include "Debug.h"
#include "pstring.h"
#include "networking.h"
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winioctl.h>
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <io.h>
#include <fcntl.h>
#include <sys\stat.h>
extern bool Debug_NT;
extern bool Debug_print_block = false;
///////////////////////////////////////////////////////////////////////////////
// NT MONO DRIVER SPECS
//
// Define the various device type values. Note that values used by Microsoft
// Corporation are in the range 0-32767, and 32768-65535 are reserved for use
// by customers.
//
#define FILE_DEVICE_MONO 0x00008100
//
// Macro definition for defining IOCTL and FSCTL function control codes. Note
// that function codes 0-2047 are reserved for Microsoft Corporation, and
// 2048-4095 are reserved for customers.
//
#define MONO_IOCTL_INDEX 0x810
//
// The MONO device driver IOCTLs
//
#define IOCTL_MONO_PRINT CTL_CODE(FILE_DEVICE_MONO, \
MONO_IOCTL_INDEX, \
METHOD_BUFFERED, \
FILE_ANY_ACCESS)
#define IOCTL_MONO_CLEAR_SCREEN CTL_CODE(FILE_DEVICE_MONO, \
MONO_IOCTL_INDEX + 1, \
METHOD_BUFFERED, \
FILE_ANY_ACCESS)
// ---------------------------------------------------------------------------
// console debugging functions
#define MAX_NUM_WINDOWS 4
#define MAX_NUM_VWINDOWS 8
typedef struct mono_element {
unsigned char character;
unsigned char attribute;
} mono_element;
typedef struct {
short first_row;
short height;
short first_col;
short width;
short cursor_row;
short cursor_col;
short open;
struct mono_element save_buf[25][80];
struct mono_element text[25][80];
} WINDOW;
static bool Mono_initialized = 0;
static mono_element (*Mono_screen)[25][80];
static char Dbgstr_format[512];
static WINDOW Window[MAX_NUM_WINDOWS];
static ubyte Mono_virtual_window_list[MAX_NUM_VWINDOWS];
#ifndef RELEASE
#define MAX_MONO_LENGTH 2048
#else
#define MAX_MONO_LENGTH 256
#endif
static char Mono_buffer[MAX_MONO_LENGTH];
static HANDLE hNTMonoDriver = NULL;
static int Debug_logfile = -1;
#define ROW Window[n].first_row
#define HEIGHT Window[n].height
#define COL Window[n].first_col
#define WIDTH Window[n].width
#define CROW Window[n].cursor_row
#define CCOL Window[n].cursor_col
#define OPEN Window[n].open
#define CHAR(r,c) (*Mono_screen)[ROW+(r)][COL+(c)].character
#define ATTR(r,c) (*Mono_screen)[ROW+(r)][COL+(c)].attribute
#define XCHAR(r,c) Window[n].text[ROW+(r)][COL+(c)].character
#define XATTR(r,c) Window[n].text[ROW+(r)][COL+(c)].attribute
void con_scroll( int n );
void con_drawbox( int n );
void con_clear( int n);
void con_setcursor(int r, int c);
void con_mputc(int n, char ch);
#define MAX_TCPLOG_LEN 2000
SOCKET tcp_log_sock;
SOCKADDR_IN tcp_log_addr;
char tcp_log_buffer[MAX_TCPLOG_LEN];
void nw_InitTCPLogging(char *ip,unsigned short port)
{
unsigned long argp = 1;
int addrlen = sizeof(SOCKADDR_IN);
tcp_log_sock = socket(AF_INET,SOCK_STREAM,0);
if(INVALID_SOCKET == tcp_log_sock)
{
return;
}
memset( &tcp_log_addr, 0, sizeof(SOCKADDR_IN) );
tcp_log_addr.sin_family = AF_INET;
tcp_log_addr.sin_addr.s_addr = INADDR_ANY;
tcp_log_addr.sin_port = 0;
if (SOCKET_ERROR==bind(tcp_log_sock, (SOCKADDR*)&tcp_log_addr, sizeof (sockaddr)))
{
return;
}
ioctlsocket(tcp_log_sock,FIONBIO,&argp);
tcp_log_addr.sin_addr.s_addr = inet_addr(ip);
tcp_log_addr.sin_port = htons(port);
connect(tcp_log_sock,(SOCKADDR *)&tcp_log_addr,addrlen);
}
void nw_TCPPrintf(int n, char * format, ... )
{
va_list args;
if(tcp_log_sock==INVALID_SOCKET)
return;
// filter out messages for other windows
if (n !=0)
return;
va_start(args, format );
Pvsprintf(tcp_log_buffer,MAX_TCPLOG_LEN,format,args);
fd_set read_fds;
timeval tv = {0,0};
FD_ZERO(&read_fds);
FD_SET( tcp_log_sock, &read_fds );
if(select(0,NULL,&read_fds,0,&tv))
{
send(tcp_log_sock,tcp_log_buffer,strlen(tcp_log_buffer),0);
}
else
{
//Int3();
}
}
void Debug_ConsoleExit()
{
if (hNTMonoDriver) CloseHandle(hNTMonoDriver);
}
bool Debug_ConsoleInit()
{
int n=0;
if (Mono_initialized)
return 1;
//Only use monochrome if D3_MONO environment var is set
atexit(Debug_ConsoleExit);
if (Debug_NT == true) {
hNTMonoDriver = CreateFile("\\\\.\\MONO",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hNTMonoDriver != (HANDLE)(-1))
Mono_initialized = 1;
else
Mono_initialized = 0;
}
else {
_outp( 0x3b4, 0x0f );
_outp( 0x3b4+1, 0x55 );
if ( _inp( 0x3b4+1 ) != 0x55 ) {
if (getenv("D3_MONO"))
Mono_initialized = 1;
else
Mono_initialized = 0;
}
else {
_outp( 0x3b4+1, 0 );
Mono_initialized = 1;
}
Mono_screen = (mono_element (*)[25][80])0xB0000;
}
if (Mono_initialized)
OPEN=1;
else
OPEN=0;
ROW=2;
COL=0;
WIDTH=80;
HEIGHT=24;
CCOL=0;
CROW=0;
con_clear(0);
for (n=1; n<MAX_NUM_WINDOWS; n++ )
{
OPEN = 0;
ROW = 2;
COL = 1;
WIDTH=78;
HEIGHT=23;
CROW=0;
CCOL=0;
}
// map 0 always to itself.
Mono_virtual_window_list[0] = 0;
for (n = 1; n < MAX_NUM_VWINDOWS; n++)
{
Mono_virtual_window_list[n] = -1;
}
return 1;
}
void Debug_ConsoleRedirectMessages(int virtual_window, int physical_window)
{
int i,n;
if (virtual_window < 1 || virtual_window >= MAX_NUM_VWINDOWS) {
return;
}
if (physical_window < 1 || physical_window >= MAX_NUM_WINDOWS) {
return;
}
n = physical_window;
if (!OPEN) return;
// clear out any bindings and map virtual window to physical window.
for (i = 0; i < MAX_NUM_VWINDOWS; i++)
{
if (Mono_virtual_window_list[i] == physical_window) {
Mono_virtual_window_list[i] = -1;
}
}
Mono_virtual_window_list[virtual_window] = physical_window;
con_clear(physical_window);
}
void Debug_LogClose();
bool Debug_Logfile(const char *filename)
{
if (Debug_logfile == -1) {
Debug_logfile = _open(filename, _O_CREAT | _O_WRONLY | _O_TEXT, _S_IREAD | _S_IWRITE);
if (Debug_logfile == -1) {
Debug_MessageBox(OSMBOX_OK, "Debug", "FYI Logfile couldn't be created.");
return false;
}
atexit(Debug_LogClose);
}
Debug_LogWrite("BEGINNING LOG\n\n");
return true;
}
void Debug_LogWrite(const char *str)
{
if (Debug_logfile > -1)
_write(Debug_logfile, str, strlen(str));
}
void Debug_LogClose()
{
if (Debug_logfile > -1) {
Debug_LogWrite("\nEND LOG");
_close(Debug_logfile);
Debug_logfile = -1;
}
}
void Debug_ConsoleOpen(int n, int row, int col, int width, int height, char * title )
{
if (!Mono_initialized) return; //error! no mono card
if (n >= MAX_NUM_WINDOWS) return;
if (OPEN) Debug_ConsoleClose(n);
OPEN = 1;
ROW = row;
COL = col;
WIDTH = width;
HEIGHT = height;
Mono_virtual_window_list[n] = n;
if (Debug_NT) {
}
else {
for (row=-1; row<HEIGHT+1; row++ )
for (col=-1; col<WIDTH+1; col++ )
{
CHAR(row,col) = 32;
ATTR(row,col) = 7;
XCHAR(row,col) = 32;
XATTR(row,col) = 7;
}
con_drawbox(n);
CROW=-1; CCOL=0;
Debug_ConsolePrintf( n, title );
CROW=0; CCOL=0;
con_setcursor( ROW+CROW, COL+CCOL );
}
}
void Debug_ConsoleClose(int n)
{
int row, col;
if (!OPEN) return;
if (n >= MAX_NUM_WINDOWS) return;
if (Debug_NT) {
}
else {
for (row=-1; row<HEIGHT+1; row++ )
for (col=-1; col<WIDTH+1; col++ )
{
CHAR(row,col) = 32;
ATTR(row,col) = 7;
}
}
OPEN = 0;
CCOL = 0;
CROW = 0;
con_setcursor(0,0);
Mono_virtual_window_list[n] = -1;
}
void Debug_ConsolePrintf( int n, char * format, ... )
{
static bool newline=false;
char *ptr=Mono_buffer;
va_list args;
if (n >= MAX_NUM_VWINDOWS) return;
if (n > 0) {
n = Mono_virtual_window_list[n];
}
// filter out messages
if (n > MAX_NUM_WINDOWS || n < 0)
return;
//if (!OPEN) return;
va_start(args, format );
Pvsprintf(ptr,MAX_MONO_LENGTH,format,args);
if (strlen (ptr)>=MAX_MONO_LENGTH)
{
return;
}
if(OPEN)
{
if (Debug_NT) {
DWORD cbReturned;
DeviceIoControl (hNTMonoDriver,
(DWORD) IOCTL_MONO_PRINT,
ptr,
strlen(ptr)+1,
NULL,
0,
&cbReturned,
0
);
}
else {
while( *ptr )
con_mputc( n, *ptr++ );
}
}
Debug_LogWrite(Mono_buffer);
if (n == 0)
{
OutputDebugString (Mono_buffer);
nw_TCPPrintf(n,Mono_buffer);
}
}
void Debug_ConsolePrintf( int n, int row, int col, char * format, ... )
{
char *ptr=Mono_buffer;
int r,c;
va_list args;
if (Debug_NT) return;
if (n >= MAX_NUM_VWINDOWS) return;
if (n > 0) {
n = Mono_virtual_window_list[n];
}
if (n > MAX_NUM_WINDOWS || n < 0)
return;
va_start(args, format );
Pvsprintf(ptr,MAX_MONO_LENGTH,format,args);
// if (n==MAX_NUM_WINDOWS)
// OutputDebugString (Mono_buffer);
if (!OPEN) return;
r = CROW; c = CCOL;
CROW = row;
CCOL = col;
while( *ptr )
con_mputc( n, *ptr++ );
CROW = r;
CCOL = c;
if (n == 0) OutputDebugString (Mono_buffer);
}
void con_mputc( int n, char c )
{
if (!OPEN) return;
if (Debug_NT) {
return;
}
switch (c)
{
case 8:
if (CCOL > 0) CCOL--;
break;
case 9:
CHAR( CROW, CCOL ) = ' ';
ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
XCHAR( CROW, CCOL ) = ' ';
CCOL++;
while (CCOL % 4) {
CHAR( CROW, CCOL ) = ' ';
ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
XCHAR( CROW, CCOL ) = ' ';
CCOL++;
}
break;
case 10:
case 13:
CCOL = 0;
CROW++;
break;
default:
CHAR( CROW, CCOL ) = c;
ATTR( CROW, CCOL ) = XATTR( CROW, CCOL );
XCHAR( CROW, CCOL ) = c;
CCOL++;
}
if ( CCOL >= WIDTH ) {
CCOL = 0;
CROW++;
}
if ( CROW >= HEIGHT ) {
CROW--;
con_scroll(n);
}
con_setcursor( ROW+CROW, COL+CCOL );
}
void copy_row(int nwords,short *src, short *dest1, short *dest2 )
{
__asm {
mov ecx,nwords
mov esi,src
mov ebx,dest1
mov edx,dest2
shr ecx, 1
jnc even_num
mov ax, [esi]
add esi, 2
mov [ebx], ax
add ebx, 2
mov [edx], ax
add edx, 2
even_num: cmp ecx, 0
je done
rowloop: mov eax, [esi]
add esi, 4
mov [edx], eax
add edx, 4
mov [ebx], eax
add ebx, 4
loop rowloop
done:
}
}
void con_scroll( int n )
{
register int row, col;
if (!OPEN) return;
if (Debug_NT) return;
col = 0;
for ( row = 0; row < (HEIGHT-1); row++ )
copy_row( WIDTH, (short *)&XCHAR(row+1,col), (short *)&CHAR(row,col), (short *)&XCHAR(row,col) );
// for ( col = 0; col < WIDTH; col++ )
// {
// CHAR( row, col ) = XCHAR( row+1, col );
// ATTR( row, col ) = XATTR( row+1, col );
// XCHAR( row, col ) = XCHAR( row+1, col );
// XATTR( row, col ) = XATTR( row+1, col );
// }
for ( col = 0; col < WIDTH; col++ )
{
CHAR( HEIGHT-1, col ) = ' ';
ATTR( HEIGHT-1, col ) = XATTR( HEIGHT-1, col );
XCHAR( HEIGHT-1, col ) = ' ';
}
}
void con_setcursor(int row, int col)
{
int pos = row*80+col;
if (Debug_NT) {
return;
}
_outp( 0x3b4, 15 );
_outp( 0x3b5, pos & 0xFF );
_outp( 0x3b4, 14 );
_outp( 0x3b5, (pos >> 8) & 0xff );
}
void con_drawbox(int n)
{
short row, col;
if (!OPEN) return;
if (Debug_NT) {
return;
}
for (row=0; row <HEIGHT; row++ )
{
CHAR( row, -1 ) = 179;
CHAR( row, WIDTH ) = 179;
XCHAR( row, -1 ) = 179;
XCHAR( row, WIDTH ) = 179;
}
for (col=0; col < WIDTH; col++ )
{
CHAR( -1, col ) = 196;
CHAR( HEIGHT, col ) = 196;
XCHAR( -1, col ) = 196;
XCHAR( HEIGHT, col ) = 196;
}
CHAR( -1,-1 ) = 218;
CHAR( -1, WIDTH ) = 191;
CHAR( HEIGHT, -1 ) = 192;
CHAR( HEIGHT, WIDTH ) = 217;
XCHAR( -1,-1 ) = 218;
XCHAR( -1, WIDTH ) = 191;
XCHAR( HEIGHT, -1 ) = 192;
XCHAR( HEIGHT, WIDTH ) = 217;
}
void con_clear( int n )
{
short row, col;
if (!OPEN) return;
if (Debug_NT) {
DWORD cbReturned;
DeviceIoControl (hNTMonoDriver,
(DWORD) IOCTL_MONO_CLEAR_SCREEN,
NULL,
0,
NULL,
0,
&cbReturned,
0);
return;
}
for (row=0; row<HEIGHT; row++ )
for (col=0; col<WIDTH; col++ ) {
CHAR(row,col) = 32;
ATTR(row,col) = 7;
XCHAR(row,col) = 32;
XATTR(row,col) = 7;
}
CCOL = 0;
CROW = 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink