quake2forge/rhapsody/r_next.m

#import <AppKit/AppKit.h>
#include "../ref_soft/r_local.h"

/*
====================================================================

 OPENSTEP specific stuff

====================================================================
*/

@interface QuakeView : NSView
@end

NSWindow	*vid_window_i;
QuakeView	*vid_view_i;

unsigned	*buffernative;

//===========================================================


int Draw_SetResolution (void);

#define	TYPE_FULLSCREEN	0
#define	TYPE_WINDOWED	1
#define	TYPE_STRETCHED	2

#define	NUM_RESOLUTIONS		7
int	resolutions[NUM_RESOLUTIONS][2] = { 
	{320,200}, {320,240}, {400,300}, {512,384}, {640,480}, {800,600}, {1024,768} };

qboolean	available[NUM_RESOLUTIONS][3];
int			mode_res = 0, mode_type = TYPE_WINDOWED;

byte		gammatable[256];	// palette is sent through this
unsigned       	current_palette[256];
unsigned       	gamma_palette[256];

int			cursor_res, cursor_type;

cvar_t		*vid_x;
cvar_t		*vid_y;
cvar_t		*vid_mode;
cvar_t		*vid_stretched;
cvar_t		*vid_fullscreen;
cvar_t		*draw_gamma;

void Draw_BuildGammaTable (void);

/*
====================================================================

MENU INTERACTION

====================================================================
*/

void FindModes (void)
{
	if (mode_res < 0 || mode_res >= NUM_RESOLUTIONS)
		mode_res = 0;
	if (mode_type < 0 || mode_type > 3)
		mode_type = 1;

}

void RM_Print (int x, int y, char *s)
{
	while (*s)
	{
		Draw_Char (x, y, (*s)+128);
		s++;
		x += 8;
	}
}

/*
================
Draw_MenuDraw
================
*/
void Draw_MenuDraw (void)
{
	int		i, j;
	int		y;
	char	string[32];

	Draw_Pic ( 4, 4, "vidmodes");

	RM_Print (80, 32, "fullscreen windowed stretched");
	RM_Print (80, 40, "---------- -------- ---------");
	y = 50;

	// draw background behind selected mode
	Draw_Fill ( (mode_type+1)*80, y+(mode_res)*10, 40,10, 8);

	// draw available grid
	for (i=0 ; i<NUM_RESOLUTIONS ; i++, y+= 10)
	{
		sprintf (string, "%ix%i", resolutions[i][0], resolutions[i][1]);
		RM_Print (0, y, string);
		for (j=0 ; j<3 ; j++)
			if (available[i][j])
				RM_Print ( 80 + j*80, y, "*");
	}

	// draw the cursor
	Draw_Char (80 + cursor_type*80, 50 + cursor_res*10, 128 + 12+((int)(r_newrefdef.time*4)&1));
}


#define	K_TAB			9
#define	K_ENTER			13
#define	K_ESCAPE		27
#define	K_SPACE			32

// normal keys should be passed as lowercased ascii

#define	K_BACKSPACE		127
#define	K_UPARROW		128
#define	K_DOWNARROW		129
#define	K_LEFTARROW		130
#define	K_RIGHTARROW	131

/*
================
Draw_MenuKey
================
*/
void Draw_MenuKey (int key)
{
	switch (key)
	{
	case K_LEFTARROW:
		cursor_type--;
		if (cursor_type < 0)
			cursor_type = 2;
		break;

	case K_RIGHTARROW:
		cursor_type++;
		if (cursor_type > 2)
			cursor_type = 0;
		break;

	case K_UPARROW:
		cursor_res--;
		if (cursor_res < 0)
			cursor_res = NUM_RESOLUTIONS-1;
		break;

	case K_DOWNARROW:
		cursor_res++;
		if (cursor_res >= NUM_RESOLUTIONS)
			cursor_res = 0;
		break;

	case K_ENTER:
		ri.Cmd_ExecuteText (EXEC_NOW, va("vid_mode %i", cursor_res));
		switch (cursor_type)
                {
                    case TYPE_FULLSCREEN:
                        ri.Cmd_ExecuteText (EXEC_NOW, "vid_fullscreen 1");
                        ri.Cmd_ExecuteText (EXEC_NOW, "vid_stretched 0");
                        break;
                    case TYPE_WINDOWED:
                        ri.Cmd_ExecuteText (EXEC_NOW, "vid_fullscreen 0");
                        ri.Cmd_ExecuteText (EXEC_NOW, "vid_stretched 0");
                        break;
                    case TYPE_STRETCHED:
                        ri.Cmd_ExecuteText (EXEC_NOW, "vid_fullscreen 0");
                        ri.Cmd_ExecuteText (EXEC_NOW, "vid_stretched 1");
                        break;
		}
                    
		mode_res = cursor_res;
		mode_type = cursor_type;
		Draw_SetResolution ();
		break;

	default:
		break;
	}
}

//===========================================================


/*
================
Draw_SetResolution

The vid structure will be filled in on return
Also allocates the z buffer and surface cache
================
*/
int Draw_SetResolution (void)
{
    NSRect	content;
    
	if (vid_mode->value < 0)
		ri.Cmd_ExecuteText (EXEC_NOW, "vid_mode 0");
	if (vid_mode->value >= NUM_RESOLUTIONS)
		ri.Cmd_ExecuteText (EXEC_NOW, va("vid_mode %i", NUM_RESOLUTIONS-1));

	vid_mode->modified = false;
        vid_fullscreen->modified = false;
        vid_stretched->modified = false;

        // free nativebuffer
        if (buffernative)
        {
            free (buffernative);
            buffernative = NULL;
        }
        
	// free z buffer
	if (d_pzbuffer)
	{
		free (d_pzbuffer);
		d_pzbuffer = NULL;
	}
	// free surface cache
	if (sc_base)
	{
		D_FlushCaches ();
		free (sc_base);
		sc_base = NULL;
	}

        vid.width = resolutions[(int)(vid_mode->value)][0];
	vid.height = resolutions[(int)(vid_mode->value)][1];

	vid.win_width = vid.width;
	vid.win_height = vid.height;
	if (vid_stretched->value)
	{
		vid.win_width <<= 1;
		vid.win_height <<= 1;
	}

	vid.aspect = 1;
	vid.buffer = malloc (vid.width*vid.height);
	vid.rowbytes = vid.width;
        d_pzbuffer = malloc(vid.width*vid.height*2);
        buffernative = malloc(vid.width*vid.height*4);

	D_InitCaches ();

	Sys_SetPalette ((byte *)d_8to24table);

        if (vid_view_i)
            [vid_view_i unlockFocus];
        if (vid_window_i)
            [vid_window_i close];
//
// open a window
//
        content = NSMakeRect (vid_x->value,vid_y->value,vid.win_width, vid.win_height);
   vid_window_i = [[NSWindow alloc]
                       initWithContentRect:	content
                                 styleMask:	NSTitledWindowMask
                                   backing:	NSBackingStoreRetained
                            	defer:	NO
       ];

   [vid_window_i setDelegate: vid_window_i];
   [vid_window_i display];
   [NSApp activateIgnoringOtherApps: YES];
   [vid_window_i makeKeyAndOrderFront: nil];

//   NSPing ();

   content.origin.x = content.origin.y = 0;
   vid_view_i = [[QuakeView alloc] initWithFrame: content];
   [vid_window_i setContentView: vid_view_i];
   [vid_window_i makeFirstResponder: vid_view_i];
   [vid_window_i setDelegate: vid_view_i];

//   [vid_window_i addToEventMask: NS_FLAGSCHANGEDMASK];
   [vid_window_i setTitle: @"Bitmap Quake Console"];
 	[vid_window_i makeKeyAndOrderFront: nil];
        
   // leave focus locked forever
   [vid_view_i lockFocus];
   
	ri.VID_SetSize (vid.width, vid.height);

	return 0;
}

/*
@@@@@@@@@@@@@@@@@@@@@
Draw_Init

@@@@@@@@@@@@@@@@@@@@@
*/
int Draw_Init (void *window)
{
    [NSApplication sharedApplication];
	[NSApp finishLaunching];
  
	ri.Con_Printf (PRINT_ALL, "refresh version: "REF_VERSION"\n");

	vid_x = ri.Cvar_Get ("vid_x", "0", CVAR_ARCHIVE);
	vid_y = ri.Cvar_Get ("vid_y", "0", CVAR_ARCHIVE);
	vid_mode = ri.Cvar_Get ("vid_mode", "0", CVAR_ARCHIVE);
        vid_fullscreen = ri.Cvar_Get ("vid_fullscreen", "0", CVAR_ARCHIVE);
        vid_stretched = ri.Cvar_Get ("vid_stretched", "0", CVAR_ARCHIVE);
	draw_gamma = ri.Cvar_Get ("gamma", "1", CVAR_ARCHIVE);

        Draw_GetPalette ();

	Draw_BuildGammaTable ();

	// get the lighting colormap
	ri.FS_LoadFile ("gfx/colormap.lmp", (void **)&vid.colormap);
	if (!vid.colormap)
	{
		ri.Con_Printf (PRINT_ALL, "ERROR: Couldn't load gfx/colormap.lmp");
		return -1;
	}

	Draw_SetResolution ();

	R_Init ();

	return 0;
}


/*
@@@@@@@@@@@@@@@@@@@@@
Draw_Shutdown

@@@@@@@@@@@@@@@@@@@@@
*/
void Draw_Shutdown (void)
{
   R_Shutdown ();
}


/*
@@@@@@@@@@@@@@@@@@@@@
Draw_BuildGammaTable

@@@@@@@@@@@@@@@@@@@@@
*/
void Draw_BuildGammaTable (void)
{
	int		i, inf;
	float	g;

	draw_gamma->modified = false;
	g = draw_gamma->value;

	if (g == 1.0)
	{
		for (i=0 ; i<256 ; i++)
			gammatable[i] = i;
		return;
	}
	
	for (i=0 ; i<256 ; i++)
	{
		inf = 255 * pow ( (i+0.5)/255.5 , g ) + 0.5;
		if (inf < 0)
			inf = 0;
		if (inf > 255)
			inf = 255;
		gammatable[i] = inf;
	}
}


/*
@@@@@@@@@@@@@@@@@@@@@
Draw_BeginFram

@@@@@@@@@@@@@@@@@@@@@
*/
void Draw_BeginFrame (void)
{
	if (vid_mode->modified || vid_fullscreen->modified
     	|| vid_stretched->modified)
		Draw_SetResolution ();

	if (draw_gamma->modified)
	{
		Draw_BuildGammaTable ();
		Sys_SetPalette ((byte *)current_palette);
	}

//	MGL_beginDirectAccess();
//	vid.buffer = mgldc->surface;
//	vid.rowbytes = mgldc->mi.bytesPerLine;
}


/*
@@@@@@@@@@@@@@@@@@@@@
Draw_EndFrame

@@@@@@@@@@@@@@@@@@@@@
*/
void Draw_EndFrame (void)
{
	int		i, c;
	int		bps, spp, bpp, bpr;
        unsigned char	*planes[5];
        NSRect			bounds;

	// translate to 24 bit color
        c = vid.width*vid.height;
	for (i=0 ; i<c ; i++)
		buffernative[i] = gamma_palette[vid.buffer[i]];
        
     bps = 8;
     spp = 3;
     bpp = 32;
     bpr = vid.width * 4;
     planes[0] = (unsigned char *)buffernative;

    bounds = [vid_view_i bounds];

    NSDrawBitmap(
                bounds,
                vid.width,
                vid.height,
                bps,
                spp,
                bpp,
                bpr,
                NO,
                NO,
                 @"NSDeviceRGBColorSpace",
                planes
                );
}


//===============================================================================

#define	HUNK_MAGIC	0xffaffaff
typedef struct
{
    int		magic;
    int		length;
    int		pad[6];
} hunkheader_t;

hunkheader_t	*membase;
int		maxsize;
int		cursize;

void *Hunk_Begin (void)
{
    kern_return_t	r;

// reserve a huge chunk of memory, but don't commit any yet
    maxsize = 16*1024*1024;
    cursize = 0;
    membase = NULL;
    r = vm_allocate(task_self(), (vm_address_t *)&membase, maxsize, 1);
    if (!membase || r != KERN_SUCCESS)
            ri.Sys_Error (ERR_FATAL,"vm_allocate failed");
    membase->magic = HUNK_MAGIC;
    membase->length = maxsize;
    cursize = 32;
    return (void *)((byte *)membase + cursize);
}

void *Hunk_Alloc (int size)
{
	// round to cacheline
	size = (size+31)&~31;
	
	cursize += size;

        if (cursize > maxsize)
            ri.Sys_Error (ERR_DROP, "Hunk_Alloc overflow");

        memset ((byte *)membase+cursize-size,0,size);

        return (void *)((byte *)membase+cursize-size);
}

int Hunk_End (void)
{
    kern_return_t	r;
    
    // round to pagesize
    cursize = (cursize+vm_page_size)&~(vm_page_size-1);
    membase->length = cursize;
    r = vm_deallocate(task_self(),
                  (vm_address_t)((byte *)membase + cursize),
                  maxsize - cursize);
    if ( r != KERN_SUCCESS )
        ri.Sys_Error (ERR_DROP, "vm_deallocate failed");
    return cursize;
}

void Hunk_Free (void *base)
{
    hunkheader_t	*h;
    kern_return_t	r;
    
    h = ((hunkheader_t *)base) - 1;
    if (h->magic != HUNK_MAGIC)
        ri.Sys_Error (ERR_FATAL, "Hunk_Free: bad magic");

    r = vm_deallocate(task_self(), (vm_address_t)h, h->length);
    if ( r != KERN_SUCCESS )
        ri.Sys_Error (ERR_DROP, "vm_deallocate failed");
}


/*
================
Sys_MakeCodeWriteable
================
*/
void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
{
}


/*
================
Sys_SetPalette
================
*/
void Sys_SetPalette (byte *palette)
{
	byte	*p;
	int		i;

        memcpy (current_palette, palette, sizeof(current_palette));
        p = (byte *)gamma_palette;
	// gamma correct and byte swap
	for (i=0 ; i<256 ; i++, p+=4, palette+=4)
	{
		p[0] = gammatable[palette[0]];
		p[1] = gammatable[palette[1]];
		p[2] = gammatable[palette[2]];
                p[3] = 0xff;
	}

}


/*
 ==========================================================================

 NEXTSTEP VIEW CLASS

 ==========================================================================
 */
#include "../client/keys.h"

void IN_ActivateMouse (void);
void IN_DeactivateMouse (void);

@implementation QuakeView

-(BOOL) acceptsFirstResponder
{
    return YES;
}

- (void)windowDidMove: (NSNotification *)note
{
    NSRect	r;

    r = [vid_window_i frame];
    ri.Cmd_ExecuteText (EXEC_NOW, va("vid_x %i", (int)r.origin.x+1));
    ri.Cmd_ExecuteText (EXEC_NOW, va("vid_y %i", (int)r.origin.y+1));    
}

- (void)becomeKeyWindow
{
    IN_ActivateMouse ();
}

- (void)resignKeyWindow
{
    IN_DeactivateMouse ();
}


typedef struct
{
    int		source, dest;
} keymap_t;

keymap_t keymaps[] =
{
    {103, K_RIGHTARROW},
    {102, K_LEFTARROW},
    {100, K_UPARROW},
    {101, K_DOWNARROW},

    {59, K_F1},
    {60, K_F2},
    {61, K_F3},
    {62, K_F4},
    {63, K_F5},
    {64, K_F6},
    {65, K_F7},
    {66, K_F8},
    {67, K_F9},
    {68, K_F10},
    {87, K_F11},
    {88, K_F12},

    {-1,-1}
};

keymap_t flagmaps[] =
{
    {NSShiftKeyMask, K_SHIFT},
    {NSControlKeyMask, K_CTRL},
    {NSAlternateKeyMask, K_ALT},
    {NSCommandKeyMask, K_ALT},

    {-1,-1}
};

- (void)mouseDown:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE1, true);
}
- (void)mouseUp:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE1, false);
}
- (void)rightMouseDown:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE2, true);
}
- (void)rightMouseUp:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE2, false);
}


/*
 ===================
 keyboard methods
 ===================
 */
- (void)keyDown:(NSEvent *)theEvent
{
    int	ch;
    keymap_t	*km;

//    PSobscurecursor ();

// check for non-ascii first
    ch = [theEvent keyCode];
    for (km=keymaps;km->source!=-1;km++)
        if (ch == km->source)
        {
            Key_Event (km->dest, true);
            return;
        }

            ch = [[theEvent charactersIgnoringModifiers] characterAtIndex:0];
    if (ch >= 'A' && ch <= 'Z')
        ch += 'a' - 'A';
    if (ch>=256)
        return;

    Key_Event (ch, true);
}

- (void)flagsChanged:(NSEvent *)theEvent
{
    static int	oldflags;
    int		newflags;
    int		delta;
    keymap_t	*km;
    int		i;

//    PSobscurecursor ();
    newflags = [theEvent modifierFlags];
    delta = newflags ^ oldflags;
    for (i=0 ; i<32 ; i++)
    {
        if ( !(delta & (1<<i)))
            continue;
        // changed
        for (km=flagmaps;km->source!=-1;km++)
            if ( (1<<i) == km->source)
            {
                if (newflags & (1<<i))
                    Key_Event (km->dest, true);
                else
                    Key_Event (km->dest, false);
            }

    }

        oldflags = newflags;
}


- (void)keyUp:(NSEvent *)theEvent
{
    int	ch;
    keymap_t	*km;

 // check for non-ascii first
    ch = [theEvent keyCode];
    for (km=keymaps;km->source!=-1;km++)
        if (ch == km->source)
        {
            Key_Event (km->dest, false);
            return;
        }

            ch = [[theEvent charactersIgnoringModifiers] characterAtIndex:0];
    if (ch >= 'A' && ch <= 'Z')
        ch += 'a' - 'A';
    if (ch>=256)
        return;
    Key_Event (ch, false);
}

@end