quake2forge/rhapsody/swimp_rhap.m

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

@interface QuakeView : NSView
@end

NSWindow	*vid_window_i;
QuakeView	*vid_view_i;
NSDirectScreen *vid_screen;
byte		*vid_buffer;		// real framebuffer
int			vid_rowbytes;		// framebuffer rowbytes

unsigned	*buffernative;		// 24 bit off-screen back buffer for window
unsigned	swimp_palette[256];

typedef enum {
    rhap_shutdown,
    rhap_windowed,
    rhap_fullscreen
} rhapMode_t;

rhapMode_t	rhap_mode;

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

FULLSCREEN

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

/*
** InitFullscreen
*/
rserr_t InitFullscreen (int width, int height)
{
    NSDictionary *mode, *bestMode;
    int			modeWidth, bestWidth;
    int			modeHeight, bestHeight;
	NSArray		*modes;
    int			i;
	NSString	*string;

    
    vid_screen = [[NSDirectScreen alloc] initWithScreen:[NSScreen mainScreen]];

    // search for an apropriate mode
    modes = [vid_screen availableDisplayModes];
    bestMode = NULL;
    bestWidth = 99999;
    bestHeight = 99999;
   	for (i=0 ; i<[modes count] ; i++) {
        mode = [modes objectAtIndex: i];
        string = [mode objectForKey: @"NSDirectScreenPixelEncoding"];
        if ( ![string isEqualToString: @"PPPPPPPP"] )
            continue;	// only look at paletted modes
        modeWidth = [[mode objectForKey: @"NSDirectScreenWidth"] intValue];
        modeHeight = [[mode objectForKey: @"NSDirectScreenHeight"] intValue];
        if (modeWidth < width || modeHeight < height)
            continue;
        if (modeWidth < bestWidth) {
            bestWidth = modeWidth;
            bestHeight = modeHeight;
            bestMode = mode;
        }
    } 

    // if there wasn't any paletted mode of that res or greater, fail
    if (!bestMode)
        return rserr_invalid_fullscreen;

	ri.Con_Printf (PRINT_ALL, "SheildDisplay\n");
    [vid_screen shieldDisplay];

    // hide the cursor in all fullscreen modes
    [NSCursor hide];
    
    vid_window_i = [vid_screen shieldingWindow];

    ri.Con_Printf (PRINT_ALL, "switchToDisplayMode\n");
    [vid_screen switchToDisplayMode:bestMode];
//    [vid_screen fadeDisplayOutToColor:[NSColor blackColor]];
//    [vid_screen fadeDisplayInFromColor:[NSColor blackColor]];

	vid_buffer = [vid_screen data];
	vid_rowbytes = [vid_screen bytesPerRow];

    return rserr_ok;
}

void ShutdownFullscreen (void)
{
	[vid_screen dealloc];
	[NSCursor unhide];
}

void SetPaletteFullscreen (const unsigned char *palette) {
#if 0
    byte	*p;
    int		i;
	NSDirectPalette		*pal;

    pal = [NSDirectPalette init];
    for (i=0 ; i<256 ; i++)
        [pal setRed: palette[0]*(1.0/255)
              green:  palette[1]*(1.0/255)
               blue:  palette[2]*(1.0/255)
            atIndex: i];
	[vid_screen setPalette: pal];
    [pal release];
#endif
}



void BlitFullscreen (void)
{
	int		i, j;
	int		w;
	int		*dest, *source;

	w = vid.width>>2;

    source = (int *)vid.buffer;		// off-screen buffer
    dest = (int *)vid_buffer;		// directly on screen
    for (j=0 ; j<vid.height ; j++
         , source += (vid.rowbytes>>2), dest += (vid_rowbytes>>2)  ) {
        for (i=0 ; i<w ; i++ ) {
            dest[i] = source[i];            
        }
 	}
}

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

WINDOWED

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

/*
** InitWindowed
*/
rserr_t InitWindowed (int width, int height)
{
    rserr_t retval = rserr_ok;
    NSRect	content;
    cvar_t	*vid_xpos;
    cvar_t	*vid_ypos;

    //
    // open a window
    //
    vid_xpos = ri.Cvar_Get ("vid_xpos", "0", 0);
    vid_ypos = ri.Cvar_Get ("vid_ypos", "0", 0);

    content = NSMakeRect (vid_xpos->value,vid_ypos->value, width, height);
    vid_window_i = [[NSWindow alloc]
                initWithContentRect:	content
                            styleMask:	NSTitledWindowMask
                            backing:	NSBackingStoreRetained
                            defer:	NO
    ];

//    [vid_window_i addToEventMask: NS_FLAGSCHANGEDMASK];
    [vid_window_i setTitle: @"Quake2"];

    buffernative = malloc(width * height * 4);

    return retval;
}

void ShutdownWindowed (void)
{
    if (vid_window_i)
    {
        [vid_window_i release];
        vid_window_i = NULL;
    }
    if (buffernative)
    {
        free (buffernative);
        buffernative = NULL;
    }
}

void SetPaletteWindowed (const unsigned char *palette) {
    byte	*p;
    int		i;

    p = (byte *)swimp_palette;
    for (i=0 ; i<256 ; i++, p+=4, palette+=4)
    {
        p[0] = palette[0];
       	p[1] = palette[1];
        p[2] = palette[2];
        p[3] = 0xff;
    }
}


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

    if (!vid_view_i)
        return;

    // translate to 24 bit color
    c = vid.width*vid.height;
    for (i=0 ; i<c ; i++)
        buffernative[i] = swimp_palette[vid.buffer[i]];

     bps = 8;
     spp = 3;
     bpp = 32;
     bpr = vid.width * 4;
     planes[0] = (unsigned char *)buffernative;

    bounds = [vid_view_i bounds];

    [vid_view_i lockFocus];

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

    [vid_view_i unlockFocus];
	PSWait ();
}


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

/*
** RW_IMP.C
**
** This file contains ALL Win32 specific stuff having to do with the
** software refresh.  When a port is being made the following functions
** must be implemented by the port:
**
** SWimp_EndFrame
** SWimp_Init
** SWimp_SetPalette
** SWimp_Shutdown
*/


/*
** SWimp_Init
**
** This routine is responsible for initializing the implementation
** specific stuff in a software rendering subsystem.
*/
int SWimp_Init( void *hInstance, void *wndProc )
{
    if (!NSApp)
    {
        [NSApplication sharedApplication];
        [NSApp finishLaunching];
    }

    return true;
}


/*
** SWimp_SetMode
*/
rserr_t SWimp_SetMode( int *pwidth, int *pheight, int mode, qboolean fullscreen)
{
    const char 	*win_fs[] = { "W", "FS" };
    NSRect		content;
	rserr_t		ret;
    
    // free resources in use
    SWimp_Shutdown ();

    ri.Con_Printf (PRINT_ALL, "setting mode %d:", mode );

    if ( !ri.Vid_GetModeInfo( pwidth, pheight, mode ) )
    {
        ri.Con_Printf( PRINT_ALL, " invalid mode\n" );
        return rserr_invalid_mode;
    }

    ri.Con_Printf( PRINT_ALL, " %d %d %s\n", *pwidth, *pheight, win_fs[fullscreen] );

    vid.buffer = malloc(*pwidth * *pheight);
	vid.rowbytes = *pwidth;

    if (fullscreen) {
        rhap_mode = rhap_fullscreen;
        ret = InitFullscreen (*pwidth, *pheight);        
    } else {
        rhap_mode = rhap_windowed;
        ret = InitWindowed (*pwidth, *pheight);
    }

    if (ret != rserr_ok) {
        SWimp_Shutdown ();
        return ret;       
    }
    
    /*
     ** the view is identical in windowed and fullscreen modes
     */
    content.origin.x = content.origin.y = 0;
    content.size.width = *pwidth;
    content.size.height = *pheight;
    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];

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

	return ret;
}

/*
** SWimp_Shutdown
**
** System specific graphics subsystem shutdown routine
*/
void SWimp_Shutdown( void )
{
    if (rhap_mode == rhap_windowed)
        ShutdownWindowed ();
    else if (rhap_mode == rhap_fullscreen)
        ShutdownFullscreen ();

    rhap_mode = rhap_shutdown;

    if (vid.buffer)
    {
        free (vid.buffer);
        vid.buffer = NULL;
    }
}


/*
** SWimp_SetPalette
**
** System specific palette setting routine.  A NULL palette means
** to use the existing palette.  The palette is expected to be in
** a padded 4-byte xRGB format.
*/
void SWimp_SetPalette( const unsigned char *palette )
{
    if (rhap_mode == rhap_windowed)
        SetPaletteWindowed (palette);
    else if (rhap_mode == rhap_fullscreen)
        SetPaletteFullscreen (palette);
}


/*
** SWimp_EndFrame
**
** This does an implementation specific copy from the backbuffer to the
** front buffer.  In the Win32 case it uses BitBlt or BltFast depending
** on whether we're using DIB sections/GDI or DDRAW.
*/
void SWimp_EndFrame (void)
{
    if (rhap_mode == rhap_windowed)
        BlitWindowed ();
    else if (rhap_mode == rhap_fullscreen)
        BlitFullscreen ();
}


/*
** SWimp_AppActivate
*/
void SWimp_AppActivate( qboolean active )
{
}


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

 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_xpos %i", (int)r.origin.x+1));
    ri.Cmd_ExecuteText (EXEC_NOW, va("vid_ypos %i", (int)r.origin.y+1));
}

- (void)becomeKeyWindow
{
    IN_ActivateMouse ();
}

- (void)resignKeyWindow
{
    IN_DeactivateMouse ();
}


typedef struct
{
    int		source, dest;
} keymap_t;

keymap_t keymaps[] =
{
    {0xf703, K_RIGHTARROW},
	{0xf702, K_LEFTARROW},
	{0xf700, K_UPARROW},
	{0xf701, K_DOWNARROW},

	{0xf704, K_F1},
	{0xf705, K_F2},
	{0xf706, K_F3},
	{0xf707, K_F4},
	{0xf708, K_F5},
	{0xf709, K_F6},
	{0xf70a, K_F7},
	{0xf70b, K_F8},
	{0xf70c, K_F9},
	{0xf70d, K_F10},
	{0xf70e, K_F11},
	{0xf70f, 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, 0);
}
- (void)mouseUp:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE1, false, 0);
}
- (void)rightMouseDown:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE2, true, 0);
}
- (void)rightMouseUp:(NSEvent *)theEvent
{
    Key_Event (K_MOUSE2, false, 0);
}


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

//    PSobscurecursor ();

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

    if (ch >= 'A' && ch <= 'Z')
        ch += 'a' - 'A';
    if (ch>=256)
        return;

    Key_Event (ch, true, 0);
}

- (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, 0);
                else
                    Key_Event (km->dest, false, 0);
            }

    }

        oldflags = newflags;
}


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

    ch = [[theEvent charactersIgnoringModifiers] characterAtIndex:0];

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

    if (ch >= 'A' && ch <= 'Z')
        ch += 'a' - 'A';
    if (ch>=256)
        return;
    Key_Event (ch, false, 0);
}

@end