ref: 005cceb68e49b40e29120a94e9e7138a54f5e65c
dir: /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