beaae8ac45
* Adds support for Visual Studio 2012 and 2013 * VR Mode: . Switches from headtrack.dll to sourcevr.dll . Improved readability of the UI in VR . Removed the IPD calibration tool. TF2 will now obey the Oculus configuration file. Use the Oculus calibration tool in your SDK or install and run "OpenVR" under Tools in Steam to calibrate your IPD. . Added dropdown to enable VR mode in the Video options. Removed the -vr command line option. . Added the ability to switch in and out of VR mode without quitting the game . By default VR mode will run full screen. To switch back to a borderless window set the vr_force_windowed convar. . Added support for VR mode on Linux * Many assorted bug fixes and other changes from Team Fortress in various shared files
113 lines
5.6 KiB
C++
113 lines
5.6 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
/******************************************************************/
|
|
/* qsort.c -- Non-Recursive ANSI Quicksort function */
|
|
/* */
|
|
/* Public domain by Raymond Gardner, Englewood CO February 1991 */
|
|
/* */
|
|
/* Usage: */
|
|
/* qsort(base, nbr_elements, width_bytes, compare_function); */
|
|
/* void *base; */
|
|
/* size_t nbr_elements, width_bytes; */
|
|
/* int (*compare_function)(const void *, const void *); */
|
|
/* */
|
|
/* Sorts an array starting at base, of length nbr_elements, each */
|
|
/* element of size width_bytes, ordered via compare_function, */
|
|
/* which is called as (*compare_function)(ptr_to_element1, */
|
|
/* ptr_to_element2) and returns < 0 if element1 < element2, */
|
|
/* 0 if element1 = element2, > 0 if element1 > element2. */
|
|
/* Most refinements are due to R. Sedgewick. See "Implementing */
|
|
/* Quicksort Programs", Comm. ACM, Oct. 1978, and Corrigendum, */
|
|
/* Comm. ACM, June 1979. */
|
|
/******************************************************************/
|
|
|
|
// modified to take (and use) a context object, ala Microsoft's qsort_s
|
|
// "extension" to the stdlib
|
|
|
|
#include <stddef.h> /* for size_t definition */
|
|
|
|
/*
|
|
** swap nbytes between a and b
|
|
*/
|
|
|
|
static void swap_bytes(char *a, char *b, size_t nbytes)
|
|
{
|
|
char tmp;
|
|
do {
|
|
tmp = *a; *a++ = *b; *b++ = tmp;
|
|
} while ( --nbytes );
|
|
}
|
|
|
|
#define SWAP(a, b) (swap_bytes((char *)(a), (char *)(b), size))
|
|
|
|
#define COMP(ctx, a, b) ((*comp)((void *)ctx, (void *)(a), (void *)(b)))
|
|
|
|
#define T 7 /* subfiles of T or fewer elements will */
|
|
/* be sorted by a simple insertion sort */
|
|
/* Note! T must be at least 3 */
|
|
|
|
extern "C" void qsort_s(void *basep, size_t nelems, size_t size,
|
|
int (*comp)(void *, const void *, const void *),
|
|
void *ctx)
|
|
{
|
|
char *stack[40], **sp; /* stack and stack pointer */
|
|
char *i, *j, *limit; /* scan and limit pointers */
|
|
size_t thresh; /* size of T elements in bytes */
|
|
char *base; /* base pointer as char * */
|
|
|
|
base = (char *)basep; /* set up char * base pointer */
|
|
thresh = T * size; /* init threshold */
|
|
sp = stack; /* init stack pointer */
|
|
limit = base + nelems * size;/* pointer past end of array */
|
|
for ( ;; ) { /* repeat until break... */
|
|
if ( limit - base > thresh ) { /* if more than T elements */
|
|
/* swap base with middle */
|
|
SWAP((((limit-base)/size)/2)*size+base, base);
|
|
i = base + size; /* i scans left to right */
|
|
j = limit - size; /* j scans right to left */
|
|
if ( COMP(ctx, i, j) > 0 ) /* Sedgewick's */
|
|
SWAP(i, j); /* three-element sort */
|
|
if ( COMP(ctx, base, j) > 0 )/* sets things up */
|
|
SWAP(base, j); /* so that */
|
|
if ( COMP(ctx, i, base) > 0 )/* *i <= *base <= *j */
|
|
SWAP(i, base); /* *base is pivot element */
|
|
for ( ;; ) { /* loop until break */
|
|
do /* move i right */
|
|
i += size; /* until *i >= pivot */
|
|
while ( COMP(ctx, i, base) < 0 );
|
|
do /* move j left */
|
|
j -= size; /* until *j <= pivot */
|
|
while ( COMP(ctx, j, base) > 0 );
|
|
if ( i > j ) /* if pointers crossed */
|
|
break; /* break loop */
|
|
SWAP(i, j); /* else swap elements, keep scanning*/
|
|
}
|
|
SWAP(base, j); /* move pivot into correct place */
|
|
if ( j - base > limit - i ) { /* if left subfile larger */
|
|
sp[0] = base; /* stack left subfile base */
|
|
sp[1] = j; /* and limit */
|
|
base = i; /* sort the right subfile */
|
|
} else { /* else right subfile larger*/
|
|
sp[0] = i; /* stack right subfile base */
|
|
sp[1] = limit; /* and limit */
|
|
limit = j; /* sort the left subfile */
|
|
}
|
|
sp += 2; /* increment stack pointer */
|
|
} else { /* else subfile is small, use insertion sort */
|
|
for ( j = base, i = j+size; i < limit; j = i, i += size )
|
|
for ( ; COMP(ctx, j, j+size) > 0; j -= size ) {
|
|
SWAP(j, j+size);
|
|
if ( j == base )
|
|
break;
|
|
}
|
|
if ( sp != stack ) { /* if any entries on stack */
|
|
sp -= 2; /* pop the base and limit */
|
|
base = sp[0];
|
|
limit = sp[1];
|
|
} else /* else stack empty, done */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|