static void R_InitFragmentShader( const char *filename, GLhandleARB *fragmentShader, GLhandleARB *program, GLhandleARB vertexShader, const char *fallbackShader ) {
int len;
int slen;
void *shaderSource;
char *text;
qboolean fallback = qfalse;
if ( !glsl ) {
return;
}
Com_VPrintf( "^5%s ->\n", filename );
*fragmentShader = qglCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
len = ri.FS_ReadFile( filename, &shaderSource );
if ( len <= 0 ) {
len = strlen(fallbackShader);
if ( len ) {
Com_VPrintf( "^1using fallback shader\n" );
//ri.FS_FreeFile(shaderSource);
//shaderSource = (void *)fallbackShader;
fallback = qtrue;
} else {
Com_VPrintf( "^1couldn't find file\n" );
R_DeleteGlslShadersAndPrograms();
glsl = qfalse;
return;
}
}
slen = strlen(ShaderExtensions);
text = (char *)malloc(len + slen + 3);
if (!text) {
Com_VPrintf( "R_InitFragmentShader() couldn't allocate memory for GLSL shader file\n" );
if ( !fallbackShader ) ri.FS_FreeFile(shaderSource);
qglDeleteObjectARB(*fragmentShader);
return;
}
Com_sprintf( text, len + slen + 3, "%s\n%s\n", ShaderExtensions, fallback ? fallbackShader : (char *)shaderSource );
qglShaderSourceARB(*fragmentShader, 1, (const char **)&text, NULL);
qglCompileShaderARB(*fragmentShader);
printGlslLog(*fragmentShader);
if ( !fallbackShader ) ri.FS_FreeFile(shaderSource);
free(text);
*program = qglCreateProgramObjectARB();
qglAttachObjectARB(*program, vertexShader);
qglAttachObjectARB(*program, *fragmentShader);
qglLinkProgramARB(*program);
printGlslLog(*program);
//Com_VPrintf("\n");
}
/*
===============
RE_Shutdown
===============
*/
void RE_Shutdown( qboolean destroyWindow ) {
//ri.Printf( PRINT_ALL, "RE_Shutdown( %i )\n", destroyWindow );
Com_VPrintf( "RE_Shutdown( %i )\n", destroyWindow );
ri.Cmd_RemoveCommand( "modelList" );
ri.Cmd_RemoveCommand( "screenShotJPEG" );
ri.Cmd_RemoveCommand( "screenShot" );
ri.Cmd_RemoveCommand( "imageList" );
ri.Cmd_RemoveCommand( "shaderList" );
ri.Cmd_RemoveCommand( "skinList" );
ri.Cmd_RemoveCommand( "gfxInfo" );
ri.Cmd_RemoveCommand( "minimize" );
ri.Cmd_RemoveCommand( "modeList" );
if ( tr.registered ) {
R_SyncRenderThread();
R_ShutdownCommandBuffers();
#ifdef USE_RENDERER_GLSLFBO
R_DeleteGlslShadersAndPrograms();
R_DeleteFramebufferObject();
#endif //USE_RENDERER_GLSLFBO
R_DeleteTextures();
}
R_DoneFreeType();
// shut down platform specific OpenGL stuff
if ( destroyWindow ) {
GLimp_Shutdown();
}
tr.registered = qfalse;
}
/*
* A Com_Printf that only shows up if the "developer" cvar is set
*/
void
Com_DPrintf(char *fmt, ...)
{
va_list argptr;
va_start(argptr, fmt);
Com_VPrintf(PRINT_DEVELOPER, fmt, argptr);
va_end(argptr);
}
/*
* Both client and server can use this, and it will output
* to the apropriate place.
*/
void
Com_Printf(char *fmt, ...)
{
va_list argptr;
va_start(argptr, fmt);
Com_VPrintf(PRINT_ALL, fmt, argptr);
va_end(argptr);
}
static void printGlslLog( GLhandleARB obj ) {
int infoLogLength = 0;
char infoLog[1024];
int len;
qglGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infoLogLength);
if (infoLogLength > 0) {
qglGetInfoLogARB(obj, 1024, &len, infoLog);
Com_VPrintf( "%s\n", infoLog );
}
}
static void NET_GetLocalAddress( void ) {
char hostname[256];
struct addrinfo hint;
struct addrinfo *res = NULL;
numIP = 0;
if(gethostname( hostname, 256 ) == SOCKET_ERROR)
return;
Com_VPrintf( "Hostname: %s\n", hostname ); //Com_VPrintf
memset(&hint, 0, sizeof(hint));
hint.ai_family = AF_UNSPEC;
hint.ai_socktype = SOCK_DGRAM;
if(!getaddrinfo(hostname, NULL, &hint, &res))
{
struct sockaddr_in mask4;
struct sockaddr_in6 mask6;
struct addrinfo *search;
/* On operating systems where it's more difficult to find out the configured interfaces, we'll just assume a
* netmask with all bits set. */
memset(&mask4, 0, sizeof(mask4));
memset(&mask6, 0, sizeof(mask6));
mask4.sin_family = AF_INET;
memset(&mask4.sin_addr.s_addr, 0xFF, sizeof(mask4.sin_addr.s_addr));
mask6.sin6_family = AF_INET6;
memset(&mask6.sin6_addr, 0xFF, sizeof(mask6.sin6_addr));
// add all IPs from returned list.
for(search = res; search; search = search->ai_next)
{
if(search->ai_family == AF_INET)
NET_AddLocalAddress("", search->ai_addr, (struct sockaddr *) &mask4);
else if(search->ai_family == AF_INET6)
NET_AddLocalAddress("", search->ai_addr, (struct sockaddr *) &mask6);
}
if ( com_verbose->integer )
Sys_ShowIP();
}
if(res)
freeaddrinfo(res);
}
/*
====================
NET_Init
====================
*/
void NET_Init( void ) {
#ifdef _WIN32
int r;
r = WSAStartup( MAKEWORD( 1, 1 ), &winsockdata );
if( r ) {
Com_Printf( "WARNING: Winsock initialization failed, returned %d\n", r );
return;
}
winsockInitialized = qtrue;
Com_VPrintf( "Winsock Initialized\n" ); //Com_VPrintf
#endif
NET_Config( qtrue );
Cmd_AddCommand ("net_restart", NET_Restart_f);
}
/*
==================
BotImport_Print
==================
*/
static __attribute__ ((format (printf, 2, 3))) void QDECL BotImport_Print(int type, char *fmt, ...)
{
char str[2048];
va_list ap;
va_start(ap, fmt);
Q_vsnprintf(str, sizeof(str), fmt, ap);
va_end(ap);
switch(type) {
case PRT_MESSAGE: {
Com_Printf("%s", str);
break;
}
case PRT_WARNING: {
Com_Printf(S_COLOR_YELLOW "Warning: %s", str);
break;
}
case PRT_ERROR: {
Com_Printf(S_COLOR_RED "Error: %s", str);
break;
}
case PRT_FATAL: {
Com_Printf(S_COLOR_RED "Fatal: %s", str);
break;
}
case PRT_EXIT: {
Com_Error(ERR_DROP, S_COLOR_RED "Exit: %s", str);
break;
}
case PRT_VERBOSE: {
Com_VPrintf("%s", str);
break;
}
default: {
Com_Printf("unknown print type\n");
break;
}
}
}
/*
=================
S_Init
=================
*/
void S_Init( void )
{
cvar_t *cv;
qboolean started = qfalse;
Com_VPrintf( "------ Initializing Sound ------\n" ); //Com_VPrintf
s_volume = Cvar_Get( "s_volume", "0.8", CVAR_ARCHIVE );
s_musicVolume = Cvar_Get( "s_musicvolume", "0.25", CVAR_ARCHIVE );
s_muted = Cvar_Get("s_muted", "0", CVAR_ROM);
s_doppler = Cvar_Get( "s_doppler", "1", CVAR_ARCHIVE );
s_backend = Cvar_Get( "s_backend", "", CVAR_ROM );
s_muteWhenMinimized = Cvar_Get( "s_muteWhenMinimized", "0", CVAR_ARCHIVE );
s_muteWhenUnfocused = Cvar_Get( "s_muteWhenUnfocused", "0", CVAR_ARCHIVE );
//muff
s_ambientLoopVolume = Cvar_Get( "s_ambientLoopVolume", "0.75", CVAR_ARCHIVE );
Cvar_CheckRange( s_ambientLoopVolume, 0, 1, qfalse );
s_ambientVolume = Cvar_Get( "s_ambientVolume", "0.75", CVAR_ARCHIVE );
Cvar_CheckRange( s_ambientVolume, 0, 1, qfalse );
s_announcerVolume = Cvar_Get( "s_announcerVolume", "0.75", CVAR_ARCHIVE );
Cvar_CheckRange( s_announcerVolume, 0, 1, qfalse );
s_menuMusicVolume = Cvar_Get( "s_menuMusicVolume", "0.25", CVAR_ARCHIVE );
Cvar_CheckRange( s_menuMusicVolume, 0, 1, qfalse );
//-muff
cv = Cvar_Get( "s_initsound", "1", 0 );
if( !cv->integer ) {
Com_Printf( "Sound disabled.\n" );
} else {
S_CodecInit( );
Cmd_AddCommand( "play", S_Play_f );
Cmd_AddCommand( "music", S_Music_f );
Cmd_AddCommand( "stopmusic", S_StopMusic_f );
Cmd_AddCommand( "s_list", S_SoundList );
Cmd_AddCommand( "s_stop", S_StopAllSounds );
Cmd_AddCommand( "s_info", S_SoundInfo );
cv = Cvar_Get( "s_useOpenAL", "0", CVAR_ARCHIVE );
if( cv->integer ) {
//OpenAL
started = S_AL_Init( &si );
Cvar_Set( "s_backend", "OpenAL" );
}
if( !started ) {
started = S_Base_Init( &si );
Cvar_Set( "s_backend", "base" );
}
if( started ) {
if( !S_ValidSoundInterface( &si ) ) {
Com_Error( ERR_FATAL, "Sound interface invalid" );
}
if ( com_verbose->integer )
S_SoundInfo();
Com_VPrintf( "Sound initialization successful.\n" ); //Com_VPrintf
} else {
Com_Printf( "Sound initialization failed.\n" );
}
}
Com_VPrintf( "-------------------------------\n"); //Com_VPrintf
}
/*
================
SV_SpawnServer
Change the server to a new map, taking all connected
clients along with it.
This is NOT called for map_restart
================
*/
void SV_SpawnServer( char *server, qboolean killBots ) {
int i;
int checksum;
qboolean isBot;
char systemInfo[16384];
const char *p;
// shut down the existing game if it is running
SV_ShutdownGameProgs();
Com_VPrintf( "------ Server Initialization ------\n" );
Com_VPrintf( "Server: %s\n", server );
// load map configurations
SV_MapConfig( server );
// if not running a dedicated server CL_MapLoading will connect the client to the server
// also print some status stuff
CL_MapLoading();
// make sure all the client stuff is unloaded
CL_ShutdownAll(qfalse);
// clear the whole hunk because we're (re)loading the server
Hunk_Clear();
// clear collision map data
CM_ClearMap();
// init client structures and svs.numSnapshotEntities
if ( !Cvar_VariableValue("sv_running") ) {
SV_Startup();
} else {
// check for maxclients change
if ( sv_maxclients->modified ) {
SV_ChangeMaxClients();
}
}
// clear pak references
FS_ClearPakReferences(0);
// allocate the snapshot entities on the hunk
svs.snapshotEntities = Hunk_Alloc( sizeof(entityState_t)*svs.numSnapshotEntities, h_high );
svs.nextSnapshotEntities = 0;
// toggle the server bit so clients can detect that a
// server has changed
svs.snapFlagServerBit ^= SNAPFLAG_SERVERCOUNT;
// set nextmap to the same map, but it may be overriden
// by the game startup or another console command
Cvar_Set( "nextmap", "map_restart 0");
// Cvar_Set( "nextmap", va("map %s", server) );
for (i=0 ; i<sv_maxclients->integer ; i++) {
// save when the server started for each client already connected
if (svs.clients[i].state >= CS_CONNECTED) {
svs.clients[i].oldServerTime = sv.time;
}
}
// wipe the entire per-level structure
SV_ClearServer();
for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
sv.configstrings[i] = CopyString("");
}
// make sure we are not paused
Cvar_Set("cl_paused", "0");
// get a new checksum feed and restart the file system
sv.checksumFeed = ( ((int) rand() << 16) ^ rand() ) ^ Com_Milliseconds();
FS_Restart( sv.checksumFeed );
CM_LoadMap( va("maps/%s.bsp", server), qfalse, &checksum );
// set serverinfo visible name
Cvar_Set( "mapname", server );
Cvar_Set( "sv_mapChecksum", va("%i",checksum) );
// serverid should be different each time
sv.serverId = com_frameTime;
sv.restartedServerId = sv.serverId; // I suppose the init here is just to be safe
sv.checksumFeedServerId = sv.serverId;
Cvar_Set( "sv_serverid", va("%i", sv.serverId ) );
// clear physics interaction links
SV_ClearWorld ();
// media configstring setting should be done during
// the loading stage, so connected clients don't have
// to load during actual gameplay
sv.state = SS_LOADING;
// load and spawn all other entities
SV_InitGameProgs();
// don't allow a map_restart if game is modified
sv_gametype->modified = qfalse;
// run a few frames to allow everything to settle
for (i = 0;i < 3; i++)
{
VM_Call (gvm, GAME_RUN_FRAME, sv.time);
SV_BotFrame (sv.time);
sv.time += 100;
svs.time += 100;
}
// create a baseline for more efficient communications
SV_CreateBaseline ();
for (i=0 ; i<sv_maxclients->integer ; i++) {
// send the new gamestate to all connected clients
if (svs.clients[i].state >= CS_CONNECTED) {
char *denied;
if ( svs.clients[i].netchan.remoteAddress.type == NA_BOT ) {
if ( killBots ) {
SV_DropClient( &svs.clients[i], "" );
continue;
}
isBot = qtrue;
}
else {
isBot = qfalse;
}
// connect the client again
denied = VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) ); // firstTime = qfalse
if ( denied ) {
// this generally shouldn't happen, because the client
// was connected before the level change
SV_DropClient( &svs.clients[i], denied );
} else {
if( !isBot ) {
// when we get the next packet from a connected client,
// the new gamestate will be sent
svs.clients[i].state = CS_CONNECTED;
}
else {
client_t *client;
sharedEntity_t *ent;
client = &svs.clients[i];
client->state = CS_ACTIVE;
ent = SV_GentityNum( i );
ent->s.number = i;
client->gentity = ent;
client->deltaMessage = -1;
client->lastSnapshotTime = 0; // generate a snapshot immediately
VM_Call( gvm, GAME_CLIENT_BEGIN, i );
}
}
}
}
// run another frame to allow things to look at all the players
VM_Call (gvm, GAME_RUN_FRAME, sv.time);
SV_BotFrame (sv.time);
sv.time += 100;
svs.time += 100;
if ( sv_pure->integer ) {
// the server sends these to the clients so they will only
// load pk3s also loaded at the server
p = FS_LoadedPakChecksums();
Cvar_Set( "sv_paks", p );
if (strlen(p) == 0) {
Com_Printf( "WARNING: sv_pure set but no PK3 files loaded\n" );
}
p = FS_LoadedPakNames();
Cvar_Set( "sv_pakNames", p );
// if a dedicated pure server we need to touch the cgame because it could be in a
// seperate pk3 file and the client will need to load the latest cgame.qvm
if ( com_dedicated->integer ) {
SV_TouchCGame();
}
}
else {
Cvar_Set( "sv_paks", "" );
Cvar_Set( "sv_pakNames", "" );
}
// the server sends these to the clients so they can figure
// out which pk3s should be auto-downloaded
p = FS_ReferencedPakChecksums();
Cvar_Set( "sv_referencedPaks", p );
p = FS_ReferencedPakNames();
Cvar_Set( "sv_referencedPakNames", p );
// save systeminfo and serverinfo strings
Q_strncpyz( systemInfo, Cvar_InfoString_Big( CVAR_SYSTEMINFO ), sizeof( systemInfo ) );
cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
SV_SetConfigstring( CS_SYSTEMINFO, systemInfo );
SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
cvar_modifiedFlags &= ~CVAR_SERVERINFO;
// any media configstring setting now should issue a warning
// and any configstring changes should be reliably transmitted
// to all clients
sv.state = SS_GAME;
// send a heartbeat now so the master will get up to date info
SV_Heartbeat_f();
Hunk_SetMark();
#ifndef DEDICATED
if ( com_dedicated->integer ) {
// restart renderer in order to show console for dedicated servers
// launched through the regular binary
CL_StartHunkUsers( qtrue );
}
#endif
Com_VPrintf( "-------------------------------\n" );
}
void InitGlslShadersAndPrograms( void ) {
void *shaderSource;
GLenum target;
float bloomTextureScale;
int ret;
if ( !r_enablePostProcess->integer || !glsl ) {
return;
}
GL_SelectTexture(0);
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_ARB );
bloomTextureScale = r_BloomTextureScale->value;
if ( bloomTextureScale < 0.01 ) {
bloomTextureScale = 0.01;
} else if ( bloomTextureScale > 1 ) {
bloomTextureScale = 1;
}
target = GL_TEXTURE_RECTANGLE_ARB;
tr.bloomWidth = glConfig.vidWidth * bloomTextureScale;
tr.bloomHeight = glConfig.vidHeight * bloomTextureScale;
qglGenTextures(1, &tr.bloomTexture);
qglBindTexture(target, tr.bloomTexture);
qglTexImage2D(target, 0, GL_RGBA8, tr.bloomWidth, tr.bloomHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
qglTexParameteri(target, GL_TEXTURE_WRAP_S, r_glClampToEdge->integer ? GL_CLAMP_TO_EDGE : GL_CLAMP);
qglTexParameteri(target, GL_TEXTURE_WRAP_T, r_glClampToEdge->integer ? GL_CLAMP_TO_EDGE : GL_CLAMP);
qglTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
target = GL_TEXTURE_RECTANGLE_ARB;
qglGenTextures(1, &tr.backBufferTexture);
qglBindTexture(target, tr.backBufferTexture);
qglTexImage2D(target, 0, GL_RGB8, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
qglTexParameteri(target, GL_TEXTURE_WRAP_S, r_glClampToEdge->integer ? GL_CLAMP_TO_EDGE : GL_CLAMP);
qglTexParameteri(target, GL_TEXTURE_WRAP_T, r_glClampToEdge->integer ? GL_CLAMP_TO_EDGE : GL_CLAMP);
qglTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglEnable(GL_TEXTURE_2D);
GL_SelectTexture(0);
Com_VPrintf("^5scripts/posteffect.vs ->\n");
ret = ri.FS_ReadFile("scripts/posteffect.vs", &shaderSource);
if (ret > 0) {
tr.mainVs = qglCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
qglShaderSourceARB(tr.mainVs, 1, (const char **)&shaderSource, NULL);
qglCompileShaderARB(tr.mainVs);
printGlslLog(tr.mainVs);
ri.FS_FreeFile(shaderSource);
} else if ( strlen(fallbackShader_posteffect) ) {
Com_VPrintf("^1file not found, using fallback shader\n");
//ri.FS_FreeFile(shaderSource);
tr.mainVs = qglCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
qglShaderSourceARB(tr.mainVs, 1, &fallbackShader_posteffect, NULL);
qglCompileShaderARB(tr.mainVs);
printGlslLog(tr.mainVs);
} else {
Com_VPrintf("^1file not found\n");
glsl = qfalse;
R_DeleteGlslShadersAndPrograms();
}
R_InitFragmentShader( "scripts/colorcorrect.fs", &tr.colorCorrectFs, &tr.colorCorrectSp, tr.mainVs, fallbackShader_colorcorrect );
R_InitFragmentShader( "scripts/blurhoriz.fs", &tr.blurHorizFs, &tr.blurHorizSp, tr.mainVs, fallbackShader_blurhoriz );
R_InitFragmentShader( "scripts/blurvertical.fs", &tr.blurVerticalFs, &tr.blurVerticalSp, tr.mainVs, fallbackShader_blurvertical );
R_InitFragmentShader( "scripts/brightpass.fs", &tr.brightPassFs, &tr.brightPassSp, tr.mainVs, fallbackShader_brightpass );
R_InitFragmentShader( "scripts/combine.fs", &tr.combineFs, &tr.combineSp, tr.mainVs, fallbackShader_combine );
R_InitFragmentShader( "scripts/downsample1.fs", &tr.downSample1Fs, &tr.downSample1Sp, tr.mainVs, fallbackShader_downsample1 );
}
/*
====================
NET_IP6Socket
====================
*/
SOCKET NET_IP6Socket( char *net_interface, int port, struct sockaddr_in6 *bindto, int *err ) {
SOCKET newsocket;
struct sockaddr_in6 address;
ioctlarg_t _true = 1;
*err = 0;
if( net_interface )
{
// Print the name in brackets if there is a colon:
if(Q_CountChar(net_interface, ':'))
Com_VPrintf( "Opening IP6 socket: [%s]:%i\n", net_interface, port ); //Com_VPrintf
else
Com_VPrintf( "Opening IP6 socket: %s:%i\n", net_interface, port ); //Com_VPrintf
}
else
Com_VPrintf( "Opening IP6 socket: [::]:%i\n", port ); //Com_VPrintf
if( ( newsocket = socket( PF_INET6, SOCK_DGRAM, IPPROTO_UDP ) ) == INVALID_SOCKET ) {
*err = socketError;
Com_Printf( "WARNING: NET_IP6Socket: socket: %s\n", NET_ErrorString() );
return newsocket;
}
// make it non-blocking
if( ioctlsocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: NET_IP6Socket: ioctl FIONBIO: %s\n", NET_ErrorString() );
*err = socketError;
closesocket(newsocket);
return INVALID_SOCKET;
}
#ifdef IPV6_V6ONLY
{
int i = 1;
// ipv4 addresses should not be allowed to connect via this socket.
if(setsockopt(newsocket, IPPROTO_IPV6, IPV6_V6ONLY, (char *) &i, sizeof(i)) == SOCKET_ERROR)
{
// win32 systems don't seem to support this anyways.
Com_DPrintf("WARNING: NET_IP6Socket: setsockopt IPV6_V6ONLY: %s\n", NET_ErrorString());
}
}
#endif
if( !net_interface || !net_interface[0]) {
address.sin6_family = AF_INET6;
address.sin6_addr = in6addr_any;
}
else
{
if(!Sys_StringToSockaddr( net_interface, (struct sockaddr *)&address, sizeof(address), AF_INET6))
{
closesocket(newsocket);
return INVALID_SOCKET;
}
}
if( port == PORT_ANY ) {
address.sin6_port = 0;
}
else {
address.sin6_port = htons( (short)port );
}
if( bind( newsocket, (void *)&address, sizeof(address) ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: NET_IP6Socket: bind: %s\n", NET_ErrorString() );
*err = socketError;
closesocket( newsocket );
return INVALID_SOCKET;
}
if(bindto)
*bindto = address;
return newsocket;
}
/*
====================
NET_IPSocket
====================
*/
SOCKET NET_IPSocket( char *net_interface, int port, int *err ) {
SOCKET newsocket;
struct sockaddr_in address;
ioctlarg_t _true = 1;
int i = 1;
*err = 0;
if( net_interface ) {
Com_VPrintf( "Opening IP socket: %s:%i\n", net_interface, port );
}
else {
Com_VPrintf( "Opening IP socket: 0.0.0.0:%i\n", port );
}
if( ( newsocket = socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP ) ) == INVALID_SOCKET ) {
*err = socketError;
Com_Printf( "WARNING: NET_IPSocket: socket: %s\n", NET_ErrorString() );
return newsocket;
}
// make it non-blocking
if( ioctlsocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: NET_IPSocket: ioctl FIONBIO: %s\n", NET_ErrorString() );
*err = socketError;
closesocket(newsocket);
return INVALID_SOCKET;
}
// make it broadcast capable
if( setsockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *) &i, sizeof(i) ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: NET_IPSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString() );
}
if( !net_interface || !net_interface[0]) {
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
}
else
{
if(!Sys_StringToSockaddr( net_interface, (struct sockaddr *)&address, sizeof(address), AF_INET))
{
closesocket(newsocket);
return INVALID_SOCKET;
}
}
if( port == PORT_ANY ) {
address.sin_port = 0;
}
else {
address.sin_port = htons( (short)port );
}
if( bind( newsocket, (void *)&address, sizeof(address) ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: NET_IPSocket: bind: %s\n", NET_ErrorString() );
*err = socketError;
closesocket( newsocket );
return INVALID_SOCKET;
}
return newsocket;
}
/*
===============
R_Init
===============
*/
void R_Init( void ) {
int err;
int i;
byte *ptr;
//ri.Printf( PRINT_ALL, "----- R_Init -----\n" );
Com_VPrintf( "----- R_Init -----\n" );
// clear all our internal state
Com_Memset( &tr, 0, sizeof( tr ) );
Com_Memset( &backEnd, 0, sizeof( backEnd ) );
Com_Memset( &tess, 0, sizeof( tess ) );
if(sizeof(glconfig_t) != 11332)
ri.Error( ERR_FATAL, "Mod ABI incompatible: sizeof(glconfig_t) == %u != 11332", (unsigned int) sizeof(glconfig_t) );
// Swap_Init();
if ( (intptr_t)tess.xyz & 15 ) {
ri.Printf( PRINT_WARNING, "tess.xyz not 16 byte aligned\n" );
}
Com_Memset( tess.constantColor255, 255, sizeof( tess.constantColor255 ) );
//
// init function tables
//
for ( i = 0; i < FUNCTABLE_SIZE; i++ )
{
tr.sinTable[i] = sin( DEG2RAD( i * 360.0f / ( ( float ) ( FUNCTABLE_SIZE - 1 ) ) ) );
tr.squareTable[i] = ( i < FUNCTABLE_SIZE/2 ) ? 1.0f : -1.0f;
tr.sawToothTable[i] = (float)i / FUNCTABLE_SIZE;
tr.inverseSawToothTable[i] = 1.0f - tr.sawToothTable[i];
if ( i < FUNCTABLE_SIZE / 2 )
{
if ( i < FUNCTABLE_SIZE / 4 )
{
tr.triangleTable[i] = ( float ) i / ( FUNCTABLE_SIZE / 4 );
}
else
{
tr.triangleTable[i] = 1.0f - tr.triangleTable[i-FUNCTABLE_SIZE / 4];
}
}
else
{
tr.triangleTable[i] = -tr.triangleTable[i-FUNCTABLE_SIZE/2];
}
}
R_InitFogTable();
R_NoiseInit();
R_Register();
max_polys = r_maxpolys->integer;
if (max_polys < MAX_POLYS)
max_polys = MAX_POLYS;
max_polyverts = r_maxpolyverts->integer;
if (max_polyverts < MAX_POLYVERTS)
max_polyverts = MAX_POLYVERTS;
ptr = ri.Hunk_Alloc( sizeof( *backEndData[0] ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
backEndData[0] = (backEndData_t *) ptr;
backEndData[0]->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData[0] ));
backEndData[0]->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData[0] ) + sizeof(srfPoly_t) * max_polys);
if ( r_smp->integer ) {
ptr = ri.Hunk_Alloc( sizeof( *backEndData[1] ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
backEndData[1] = (backEndData_t *) ptr;
backEndData[1]->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData[1] ));
backEndData[1]->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData[1] ) + sizeof(srfPoly_t) * max_polys);
} else {
backEndData[1] = NULL;
}
R_ToggleSmpFrame();
InitOpenGL();
R_InitImages();
R_InitShaders();
R_InitSkins();
R_ModelInit();
R_InitFreeType();
err = qglGetError();
if ( err != GL_NO_ERROR )
ri.Printf (PRINT_ALL, "glGetError() = 0x%x\n", err);
// print info
if ( com_verbose->integer )
GfxInfo_f();
//ri.Printf( PRINT_ALL, "----- finished R_Init -----\n" );
Com_VPrintf( "----- finished R_Init -----\n" );
}
/*
=================
VM_LoadQVM
Load a .qvm file
=================
*/
vmHeader_t *VM_LoadQVM( vm_t *vm, qboolean alloc, qboolean unpure)
{
int dataLength;
int i;
char filename[MAX_QPATH];
union {
vmHeader_t *h;
void *v;
} header;
// load the image
Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", vm->name );
Com_VPrintf( "Loading vm file %s...\n", filename ); //Com_VPrintf
FS_ReadFileDir(filename, vm->searchPath, unpure, &header.v, qfalse);
if ( !header.h ) {
Com_Printf( "Failed.\n" );
VM_Free( vm );
Com_Printf( S_COLOR_YELLOW "Warning: Couldn't open VM file %s\n", filename );
return NULL;
}
// show where the qvm was loaded from
if ( com_verbose->integer )
FS_Which(filename, vm->searchPath);
if( LittleLong( header.h->vmMagic ) == VM_MAGIC_VER2 ) {
Com_VPrintf( "...which has vmMagic VM_MAGIC_VER2\n" ); //Com_VPrintf
// byte swap the header
for ( i = 0 ; i < sizeof( vmHeader_t ) / 4 ; i++ ) {
((int *)header.h)[i] = LittleLong( ((int *)header.h)[i] );
}
// validate
if ( header.h->jtrgLength < 0
|| header.h->bssLength < 0
|| header.h->dataLength < 0
|| header.h->litLength < 0
|| header.h->codeLength <= 0 )
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: %s has bad header\n", filename);
return NULL;
}
} else if( LittleLong( header.h->vmMagic ) == VM_MAGIC ) {
// byte swap the header
// sizeof( vmHeader_t ) - sizeof( int ) is the 1.32b vm header size
for ( i = 0 ; i < ( sizeof( vmHeader_t ) - sizeof( int ) ) / 4 ; i++ ) {
((int *)header.h)[i] = LittleLong( ((int *)header.h)[i] );
}
// validate
if ( header.h->bssLength < 0
|| header.h->dataLength < 0
|| header.h->litLength < 0
|| header.h->codeLength <= 0 )
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: %s has bad header\n", filename);
return NULL;
}
} else {
VM_Free( vm );
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: %s does not have a recognisable "
"magic number in its header\n", filename);
return NULL;
}
// round up to next power of 2 so all data operations can
// be mask protected
dataLength = header.h->dataLength + header.h->litLength +
header.h->bssLength;
for ( i = 0 ; dataLength > ( 1 << i ) ; i++ ) {
}
dataLength = 1 << i;
if(alloc)
{
// allocate zero filled space for initialized and uninitialized data
vm->dataBase = Hunk_Alloc(dataLength, h_high);
vm->dataMask = dataLength - 1;
}
else
{
// clear the data, but make sure we're not clearing more than allocated
if(vm->dataMask + 1 != dataLength)
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: Data region size of %s not matching after "
"VM_Restart()\n", filename);
return NULL;
}
Com_Memset(vm->dataBase, 0, dataLength);
}
// copy the intialized data
Com_Memcpy( vm->dataBase, (byte *)header.h + header.h->dataOffset,
header.h->dataLength + header.h->litLength );
// byte swap the longs
for ( i = 0 ; i < header.h->dataLength ; i += 4 ) {
*(int *)(vm->dataBase + i) = LittleLong( *(int *)(vm->dataBase + i ) );
}
if(header.h->vmMagic == VM_MAGIC_VER2)
{
int previousNumJumpTableTargets = vm->numJumpTableTargets;
header.h->jtrgLength &= ~0x03;
vm->numJumpTableTargets = header.h->jtrgLength >> 2;
Com_VPrintf("Loading %d jump table targets\n", vm->numJumpTableTargets);
if(alloc)
{
vm->jumpTableTargets = Hunk_Alloc(header.h->jtrgLength, h_high);
}
else
{
if(vm->numJumpTableTargets != previousNumJumpTableTargets)
{
VM_Free(vm);
FS_FreeFile(header.v);
Com_Printf(S_COLOR_YELLOW "Warning: Jump table size of %s not matching after "
"VM_Restart()\n", filename);
return NULL;
}
Com_Memset(vm->jumpTableTargets, 0, header.h->jtrgLength);
}
Com_Memcpy(vm->jumpTableTargets, (byte *) header.h + header.h->dataOffset +
header.h->dataLength + header.h->litLength, header.h->jtrgLength);
// byte swap the longs
for ( i = 0 ; i < header.h->jtrgLength ; i += 4 ) {
*(int *)(vm->jumpTableTargets + i) = LittleLong( *(int *)(vm->jumpTableTargets + i ) );
}
}
