r_next.m

Quake 2 Source code for students by Theerthan You can also download from idsoftwares.com

		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