ubergames/lilium-voyager
0
0
Fork 0
mirror of https://github.com/UberGames/lilium-voyager.git synced 2024-11-10 14:41:42 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'HEAD' of https://github.com/ioquake/ioq3.git into suntest

Browse source
This commit is contained in:
SmileTheory 2013-01-30 17:28:34 -08:00
commit cda1c46e3a
48 changed files with 458 additions and 1055 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

@ -1,2 +1,4 @@
build
Makefile.local
*.swp
*tags

90
Makefile
View file

@ -32,9 +32,6 @@ endif
ifndef BUILD_CLIENT
BUILD_CLIENT =
endif
ifndef BUILD_CLIENT_SMP
BUILD_CLIENT_SMP =
endif
ifndef BUILD_SERVER
BUILD_SERVER =
endif
@ -54,10 +51,6 @@ ifndef BUILD_RENDERER_REND2
BUILD_RENDERER_REND2=
endif
ifneq ($(PLATFORM),darwin)
BUILD_CLIENT_SMP = 0
endif
#############################################################################
#
# If you require a different configuration from the defaults below, create a
@ -586,8 +579,6 @@ ifeq ($(PLATFORM),mingw32)
SDLDLL=SDL.dll
endif
BUILD_CLIENT_SMP = 0
else # ifeq mingw32
#############################################################################
@ -861,26 +852,14 @@ endif
ifneq ($(BUILD_CLIENT),0)
ifneq ($(USE_RENDERER_DLOPEN),0)
TARGETS += $(B)/$(CLIENTBIN)$(FULLBINEXT) $(B)/renderer_opengl1_$(SHLIBNAME)
ifneq ($(BUILD_CLIENT_SMP),0)
TARGETS += $(B)/renderer_opengl1_smp_$(SHLIBNAME)
endif
ifneq ($(BUILD_RENDERER_REND2), 0)
TARGETS += $(B)/renderer_rend2_$(SHLIBNAME)
ifneq ($(BUILD_CLIENT_SMP),0)
TARGETS += $(B)/renderer_rend2_smp_$(SHLIBNAME)
endif
endif
else
TARGETS += $(B)/$(CLIENTBIN)$(FULLBINEXT)
ifneq ($(BUILD_RENDERER_REND2), 0)
TARGETS += $(B)/$(CLIENTBIN)_rend2$(FULLBINEXT)
endif
ifneq ($(BUILD_CLIENT_SMP),0)
TARGETS += $(B)/$(CLIENTBIN)-smp$(FULLBINEXT)
ifneq ($(BUILD_RENDERER_REND2), 0)
TARGETS += $(B)/$(CLIENTBIN)_rend2-smp$(FULLBINEXT)
endif
endif
endif
endif
@ -1030,11 +1009,6 @@ $(Q)cat $< | sed 's/^/\"/;s/$$/\\n\"/' >> $@
$(Q)echo ";" >> $@
endef
define DO_SMP_CC
$(echo_cmd) "SMP_CC $<"
$(Q)$(CC) $(SHLIBCFLAGS) $(CFLAGS) $(CLIENT_CFLAGS) $(OPTIMIZE) -DSMP -o $@ -c $<
endef
define DO_BOT_CC
$(echo_cmd) "BOT_CC $<"
$(Q)$(CC) $(NOTSHLIBCFLAGS) $(CFLAGS) $(BOTCFLAGS) $(OPTIMIZE) -DBOTLIB -o $@ -c $<
@ -1194,7 +1168,6 @@ makedirs:
@if [ ! -d $(B)/renderer ];then $(MKDIR) $(B)/renderer;fi
@if [ ! -d $(B)/rend2 ];then $(MKDIR) $(B)/rend2;fi
@if [ ! -d $(B)/rend2/glsl ];then $(MKDIR) $(B)/rend2/glsl;fi
@if [ ! -d $(B)/renderersmp ];then $(MKDIR) $(B)/renderersmp;fi
@if [ ! -d $(B)/ded ];then $(MKDIR) $(B)/ded;fi
@if [ ! -d $(B)/$(BASEGAME) ];then $(MKDIR) $(B)/$(BASEGAME);fi
@if [ ! -d $(B)/$(BASEGAME)/cgame ];then $(MKDIR) $(B)/$(BASEGAME)/cgame;fi
@ -1536,7 +1509,8 @@ Q3R2OBJ = \
$(B)/rend2/tr_vbo.o \
$(B)/rend2/tr_world.o \
\
$(B)/renderer/sdl_gamma.o
$(B)/renderer/sdl_gamma.o \
$(B)/renderer/sdl_glimp.o
Q3R2STRINGOBJ = \
$(B)/rend2/glsl/bokeh_fp.o \
@ -1599,14 +1573,9 @@ Q3ROBJ = \
$(B)/renderer/tr_surface.o \
$(B)/renderer/tr_world.o \
\
$(B)/renderer/sdl_gamma.o
Q3RPOBJ_UP = \
$(B)/renderer/sdl_gamma.o \
$(B)/renderer/sdl_glimp.o
Q3RPOBJ_SMP = \
$(B)/renderersmp/sdl_glimp.o
ifneq ($(USE_RENDERER_DLOPEN), 0)
Q3ROBJ += \
$(B)/renderer/q_shared.o \
@ -1833,50 +1802,27 @@ $(B)/$(CLIENTBIN)$(FULLBINEXT): $(Q3OBJ) $(LIBSDLMAIN)
-o $@ $(Q3OBJ) \
$(LIBSDLMAIN) $(CLIENT_LIBS) $(LIBS)
$(B)/renderer_opengl1_$(SHLIBNAME): $(Q3ROBJ) $(Q3RPOBJ_UP) $(JPGOBJ)
$(B)/renderer_opengl1_$(SHLIBNAME): $(Q3ROBJ) $(JPGOBJ)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3ROBJ) $(Q3RPOBJ_UP) $(JPGOBJ) \
$(Q)$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3ROBJ) $(JPGOBJ) \
$(THREAD_LIBS) $(LIBSDLMAIN) $(RENDERER_LIBS) $(LIBS)
$(B)/renderer_opengl1_smp_$(SHLIBNAME): $(Q3ROBJ) $(Q3RPOBJ_SMP) $(JPGOBJ)
$(B)/renderer_rend2_$(SHLIBNAME): $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(JPGOBJ)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3ROBJ) $(Q3RPOBJ_SMP) $(JPGOBJ) \
$(Q)$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(JPGOBJ) \
$(THREAD_LIBS) $(LIBSDLMAIN) $(RENDERER_LIBS) $(LIBS)
$(B)/renderer_rend2_$(SHLIBNAME): $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_UP) $(JPGOBJ)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_UP) $(JPGOBJ) \
$(THREAD_LIBS) $(LIBSDLMAIN) $(RENDERER_LIBS) $(LIBS)
$(B)/renderer_rend2_smp_$(SHLIBNAME): $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_SMP) $(JPGOBJ)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_SMP) $(JPGOBJ) \
$(THREAD_LIBS) $(LIBSDLMAIN) $(RENDERER_LIBS) $(LIBS)
else
$(B)/$(CLIENTBIN)$(FULLBINEXT): $(Q3OBJ) $(Q3ROBJ) $(Q3RPOBJ_UP) $(JPGOBJ) $(LIBSDLMAIN)
$(B)/$(CLIENTBIN)$(FULLBINEXT): $(Q3OBJ) $(Q3ROBJ) $(JPGOBJ) $(LIBSDLMAIN)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CLIENT_CFLAGS) $(CFLAGS) $(CLIENT_LDFLAGS) $(LDFLAGS) \
-o $@ $(Q3OBJ) $(Q3ROBJ) $(Q3RPOBJ_UP) $(JPGOBJ) \
-o $@ $(Q3OBJ) $(Q3ROBJ) $(JPGOBJ) \
$(LIBSDLMAIN) $(CLIENT_LIBS) $(RENDERER_LIBS) $(LIBS)
$(B)/$(CLIENTBIN)-smp$(FULLBINEXT): $(Q3OBJ) $(Q3ROBJ) $(Q3RPOBJ_SMP) $(JPGOBJ) $(LIBSDLMAIN)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CLIENT_CFLAGS) $(CFLAGS) $(CLIENT_LDFLAGS) $(LDFLAGS) $(THREAD_LDFLAGS) \
-o $@ $(Q3OBJ) $(Q3ROBJ) $(Q3RPOBJ_SMP) $(JPGOBJ) \
$(THREAD_LIBS) $(LIBSDLMAIN) $(CLIENT_LIBS) $(RENDERER_LIBS) $(LIBS)
$(B)/$(CLIENTBIN)_rend2$(FULLBINEXT): $(Q3OBJ) $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_UP) $(JPGOBJ) $(LIBSDLMAIN)
$(B)/$(CLIENTBIN)_rend2$(FULLBINEXT): $(Q3OBJ) $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(JPGOBJ) $(LIBSDLMAIN)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CLIENT_CFLAGS) $(CFLAGS) $(CLIENT_LDFLAGS) $(LDFLAGS) \
-o $@ $(Q3OBJ) $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_UP) $(JPGOBJ) \
-o $@ $(Q3OBJ) $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(JPGOBJ) \
$(LIBSDLMAIN) $(CLIENT_LIBS) $(RENDERER_LIBS) $(LIBS)
$(B)/$(CLIENTBIN)_rend2-smp$(FULLBINEXT): $(Q3OBJ) $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_SMP) $(JPGOBJ) $(LIBSDLMAIN)
$(echo_cmd) "LD $@"
$(Q)$(CC) $(CLIENT_CFLAGS) $(CFLAGS) $(CLIENT_LDFLAGS) $(LDFLAGS) $(THREAD_LDFLAGS) \
-o $@ $(Q3OBJ) $(Q3R2OBJ) $(Q3R2STRINGOBJ) $(Q3RPOBJ_SMP) $(JPGOBJ) \
$(THREAD_LIBS) $(LIBSDLMAIN) $(CLIENT_LIBS) $(RENDERER_LIBS) $(LIBS)
endif
ifneq ($(strip $(LIBSDLMAIN)),)
@ -2390,9 +2336,6 @@ $(B)/client/%.o: $(ZDIR)/%.c
$(B)/client/%.o: $(SDLDIR)/%.c
$(DO_CC)
$(B)/renderersmp/%.o: $(SDLDIR)/%.c
$(DO_SMP_CC)
$(B)/client/%.o: $(SYSDIR)/%.c
$(DO_CC)
@ -2548,7 +2491,7 @@ $(B)/$(MISSIONPACK)/qcommon/%.asm: $(CMDIR)/%.c $(Q3LCC)
# MISC
#############################################################################
OBJ = $(Q3OBJ) $(Q3ROBJ) $(Q3R2OBJ) $(Q3RPOBJ_UP) $(Q3RPOBJ_SMP) $(Q3DOBJ) $(JPGOBJ) \
OBJ = $(Q3OBJ) $(Q3ROBJ) $(Q3R2OBJ) $(Q3DOBJ) $(JPGOBJ) \
$(MPGOBJ) $(Q3GOBJ) $(Q3CGOBJ) $(MPCGOBJ) $(Q3UIOBJ) $(MPUIOBJ) \
$(MPGVMOBJ) $(Q3GVMOBJ) $(Q3CGVMOBJ) $(MPCGVMOBJ) $(Q3UIVMOBJ) $(MPUIVMOBJ)
TOOLSOBJ = $(LBURGOBJ) $(Q3CPPOBJ) $(Q3RCCOBJ) $(Q3LCCOBJ) $(Q3ASMOBJ)
@ -2576,15 +2519,6 @@ ifneq ($(BUILD_CLIENT),0)
endif
endif
# Don't copy the SMP until it's working together with SDL.
ifneq ($(BUILD_CLIENT_SMP),0)
ifneq ($(USE_RENDERER_DLOPEN),0)
$(INSTALL) $(STRIP_FLAG) -m 0755 $(BR)/renderer_opengl1_smp_$(SHLIBNAME) $(COPYBINDIR)/renderer_opengl1_smp_$(SHLIBNAME)
else
$(INSTALL) $(STRIP_FLAG) -m 0755 $(BR)/$(CLIENTBIN)-smp$(FULLBINEXT) $(COPYBINDIR)/$(CLIENTBIN)-smp$(FULLBINEXT)
endif
endif
ifneq ($(BUILD_SERVER),0)
@if [ -f $(BR)/$(SERVERBIN)$(FULLBINEXT) ]; then \
$(INSTALL) $(STRIP_FLAG) -m 0755 $(BR)/$(SERVERBIN)$(FULLBINEXT) $(COPYBINDIR)/$(SERVERBIN)$(FULLBINEXT); \

3
README
View file

@ -82,7 +82,6 @@ Makefile.local:
DEFAULT_BASEDIR - extra path to search for baseq3 and such
BUILD_SERVER - build the 'ioq3ded' server binary
BUILD_CLIENT - build the 'ioquake3' client binary
BUILD_CLIENT_SMP - build the 'ioquake3-smp' client binary
BUILD_BASEGAME - build the 'baseq3' binaries
BUILD_MISSIONPACK - build the 'missionpack' binaries
BUILD_GAME_SO - build the game shared libraries
@ -281,6 +280,8 @@ New commands
stopvideo - stop video capture
stopmusic - stop background music
minimize - Minimize the game and show desktop
togglemenu - causes escape key event for opening/closing menu, or
going to a previous menu. works in binds, even in UI
print - print out the contents of a cvar
unset - unset a user created cvar

4
code/asm/snapvector.c
View file

@ -55,8 +55,8 @@ void qsnapvectorsse(vec3_t vec)
#define QROUNDX87(src) \
"flds " src "\n" \
"fistps " src "\n" \
"filds " src "\n" \
"fistpl " src "\n" \
"fildl " src "\n" \
"fstps " src "\n"
void qsnapvectorx87(vec3_t vec)

5
code/client/cl_cin.c
View file

@ -1158,7 +1158,6 @@ redump:
if (cinTable[currentHandle].numQuads == -1) {
readQuadInfo( framedata );
setupQuad( 0, 0 );
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = CL_ScaledMilliseconds()*com_timescale->value;
}
if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0;
@ -1226,7 +1225,6 @@ redump:
static void RoQ_init( void )
{
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = CL_ScaledMilliseconds()*com_timescale->value;
cinTable[currentHandle].RoQPlayed = 24;
@ -1358,12 +1356,10 @@ e_status CIN_RunCinematic (int handle)
return cinTable[currentHandle].status;
}
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
thisTime = CL_ScaledMilliseconds()*com_timescale->value;
if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime))>100) {
cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime;
}
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
cinTable[currentHandle].tfps = ((((CL_ScaledMilliseconds()*com_timescale->value) - cinTable[currentHandle].startTime)*3)/100);
start = cinTable[currentHandle].startTime;
@ -1372,7 +1368,6 @@ e_status CIN_RunCinematic (int handle)
{
RoQInterrupt();
if (start != cinTable[currentHandle].startTime) {
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
cinTable[currentHandle].tfps = ((((CL_ScaledMilliseconds()*com_timescale->value)
- cinTable[currentHandle].startTime)*3)/100);
start = cinTable[currentHandle].startTime;

12
code/client/cl_console.c
View file

@ -81,6 +81,16 @@ void Con_ToggleConsole_f (void) {
Key_SetCatcher( Key_GetCatcher( ) ^ KEYCATCH_CONSOLE );
}
/*
===================
Con_ToggleMenu_f
===================
*/
void Con_ToggleMenu_f( void ) {
CL_KeyEvent( K_ESCAPE, qtrue, Sys_Milliseconds() );
CL_KeyEvent( K_ESCAPE, qfalse, Sys_Milliseconds() );
}
/*
================
Con_MessageMode_f
@ -332,6 +342,7 @@ void Con_Init (void) {
CL_LoadConsoleHistory( );
Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
Cmd_AddCommand ("togglemenu", Con_ToggleMenu_f);
Cmd_AddCommand ("messagemode", Con_MessageMode_f);
Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
Cmd_AddCommand ("messagemode3", Con_MessageMode3_f);
@ -349,6 +360,7 @@ Con_Shutdown
void Con_Shutdown(void)
{
Cmd_RemoveCommand("toggleconsole");
Cmd_RemoveCommand("togglemenu");
Cmd_RemoveCommand("messagemode");
Cmd_RemoveCommand("messagemode2");
Cmd_RemoveCommand("messagemode3");

37
code/client/cl_keys.c
View file

@ -1120,6 +1120,25 @@ void CL_InitKeyCommands( void ) {
Cmd_AddCommand ("bindlist",Key_Bindlist_f);
}
/*
===================
CL_BindUICommand
Returns qtrue if bind command should be executed while user interface is shown
===================
*/
static qboolean CL_BindUICommand( const char *cmd ) {
if ( Key_GetCatcher( ) & KEYCATCH_CONSOLE )
return qfalse;
if ( !Q_stricmp( cmd, "toggleconsole" ) )
return qtrue;
if ( !Q_stricmp( cmd, "togglemenu" ) )
return qtrue;
return qfalse;
}
/*
===================
CL_ParseBinding
@ -1130,11 +1149,20 @@ Execute the commands in the bind string
void CL_ParseBinding( int key, qboolean down, unsigned time )
{
char buf[ MAX_STRING_CHARS ], *p = buf, *end;
qboolean allCommands, allowUpCmds;
if( clc.state == CA_DISCONNECTED && Key_GetCatcher( ) == 0 )
return;
if( !keys[key].binding || !keys[key].binding[0] )
return;
Q_strncpyz( buf, keys[key].binding, sizeof( buf ) );
// run all bind commands if console, ui, etc aren't reading keys
allCommands = ( Key_GetCatcher( ) == 0 );
// allow button up commands if in game even if key catcher is set
allowUpCmds = ( clc.state != CA_DISCONNECTED );
while( 1 )
{
while( isspace( *p ) )
@ -1147,17 +1175,21 @@ void CL_ParseBinding( int key, qboolean down, unsigned time )
// button commands add keynum and time as parameters
// so that multiple sources can be discriminated and
// subframe corrected
if ( allCommands || ( allowUpCmds && !down ) ) {
char cmd[1024];
Com_sprintf( cmd, sizeof( cmd ), "%c%s %d %d\n",
( down ) ? '+' : '-', p + 1, key, time );
Cbuf_AddText( cmd );
}
}
else if( down )
{
// normal commands only execute on key press
if ( allCommands || CL_BindUICommand( p ) ) {
Cbuf_AddText( p );
Cbuf_AddText( "\n" );
}
}
if( !end )
break;
p = end + 1;
@ -1250,10 +1282,10 @@ void CL_KeyDownEvent( int key, unsigned time )
Message_Key( key );
} else if ( clc.state == CA_DISCONNECTED ) {
Console_Key( key );
} else {
}
// send the bound action
CL_ParseBinding( key, qtrue, time );
}
return;
}
@ -1285,7 +1317,6 @@ void CL_KeyUpEvent( int key, unsigned time )
// console mode and menu mode, to keep the character from continuing
// an action started before a mode switch.
//
if( clc.state != CA_DISCONNECTED )
CL_ParseBinding( key, qfalse, time );
if ( Key_GetCatcher( ) & KEYCATCH_UI && uivm ) {

2
code/client/cl_ui.c
View file

@ -750,7 +750,7 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0;
case UI_CVAR_CREATE:
Cvar_Get( VMA(1), VMA(2), args[3] );
Cvar_Register( NULL, VMA(1), VMA(2), args[3] );
return 0;
case UI_CVAR_INFOSTRINGBUFFER:

4
code/game/bg_misc.c
View file

@ -1229,7 +1229,7 @@ void BG_EvaluateTrajectory( const trajectory_t *tr, int atTime, vec3_t result )
result[2] -= 0.5 * DEFAULT_GRAVITY * deltaTime * deltaTime; // FIXME: local gravity...
break;
default:
Com_Error( ERR_DROP, "BG_EvaluateTrajectory: unknown trType: %i", tr->trTime );
Com_Error( ERR_DROP, "BG_EvaluateTrajectory: unknown trType: %i", tr->trType );
break;
}
}
@ -1272,7 +1272,7 @@ void BG_EvaluateTrajectoryDelta( const trajectory_t *tr, int atTime, vec3_t resu
result[2] -= DEFAULT_GRAVITY * deltaTime; // FIXME: local gravity...
break;
default:
Com_Error( ERR_DROP, "BG_EvaluateTrajectoryDelta: unknown trType: %i", tr->trTime );
Com_Error( ERR_DROP, "BG_EvaluateTrajectoryDelta: unknown trType: %i", tr->trType );
break;
}
}

27
code/q3_ui/ui_controls2.c
View file

@ -111,16 +111,17 @@ typedef struct
#define ID_CHAT2 31
#define ID_CHAT3 32
#define ID_CHAT4 33
#define ID_TOGGLEMENU 34
// all others
#define ID_FREELOOK 34
#define ID_INVERTMOUSE 35
#define ID_ALWAYSRUN 36
#define ID_AUTOSWITCH 37
#define ID_MOUSESPEED 38
#define ID_JOYENABLE 39
#define ID_JOYTHRESHOLD 40
#define ID_SMOOTHMOUSE 41
#define ID_FREELOOK 35
#define ID_INVERTMOUSE 36
#define ID_ALWAYSRUN 37
#define ID_AUTOSWITCH 38
#define ID_MOUSESPEED 39
#define ID_JOYENABLE 40
#define ID_JOYTHRESHOLD 41
#define ID_SMOOTHMOUSE 42
#define ANIM_IDLE 0
#define ANIM_RUN 1
@ -205,6 +206,7 @@ typedef struct
menuaction_s chat2;
menuaction_s chat3;
menuaction_s chat4;
menuaction_s togglemenu;
menuradiobutton_s joyenable;
menuslider_s joythreshold;
int section;
@ -261,6 +263,7 @@ static bind_t g_bindings[] =
{"messagemode2", "chat - team", ID_CHAT2, ANIM_CHAT, -1, -1, -1, -1},
{"messagemode3", "chat - target", ID_CHAT3, ANIM_CHAT, -1, -1, -1, -1},
{"messagemode4", "chat - attacker", ID_CHAT4, ANIM_CHAT, -1, -1, -1, -1},
{"togglemenu", "toggle menu", ID_TOGGLEMENU, ANIM_IDLE, K_ESCAPE, -1, -1, -1},
{(char*)NULL, (char*)NULL, 0, 0, -1, -1, -1, -1},
};
@ -333,6 +336,7 @@ static menucommon_s *g_misc_controls[] = {
(menucommon_s *)&s_controls.chat2,
(menucommon_s *)&s_controls.chat3,
(menucommon_s *)&s_controls.chat4,
(menucommon_s *)&s_controls.togglemenu,
NULL,
};
@ -1532,6 +1536,12 @@ static void Controls_MenuInit( void )
s_controls.chat4.generic.ownerdraw = Controls_DrawKeyBinding;
s_controls.chat4.generic.id = ID_CHAT4;
s_controls.togglemenu.generic.type = MTYPE_ACTION;
s_controls.togglemenu.generic.flags = QMF_LEFT_JUSTIFY|QMF_PULSEIFFOCUS|QMF_GRAYED|QMF_HIDDEN;
s_controls.togglemenu.generic.callback = Controls_ActionEvent;
s_controls.togglemenu.generic.ownerdraw = Controls_DrawKeyBinding;
s_controls.togglemenu.generic.id = ID_TOGGLEMENU;
s_controls.joyenable.generic.type = MTYPE_RADIOBUTTON;
s_controls.joyenable.generic.flags = QMF_SMALLFONT;
s_controls.joyenable.generic.x = SCREEN_WIDTH/2;
@ -1614,6 +1624,7 @@ static void Controls_MenuInit( void )
Menu_AddItem( &s_controls.menu, &s_controls.chat2 );
Menu_AddItem( &s_controls.menu, &s_controls.chat3 );
Menu_AddItem( &s_controls.menu, &s_controls.chat4 );
Menu_AddItem( &s_controls.menu, &s_controls.togglemenu );
Menu_AddItem( &s_controls.menu, &s_controls.back );

9
code/qcommon/files.c
View file

@ -1361,10 +1361,17 @@ long FS_FOpenFileRead(const char *filename, fileHandle_t *file, qboolean uniqueF
#endif
if(file)
{
*file = 0;
return -1;
}
else
{
// When file is NULL, we're querying the existance of the file
// If we've got here, it doesn't exist
return 0;
}
}
/*
=================

2
code/qcommon/q_shared.h
View file

@ -1184,7 +1184,7 @@ typedef struct playerState_s {
// not communicated over the net at all
int ping; // server to game info for scoreboard
int pmove_framecount; // FIXME: don't transmit over the network
int pmove_framecount;
int jumppad_frame;
int entityEventSequence;
} playerState_t;

45
code/rend2/tr_backend.c
View file

@ -21,7 +21,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "tr_local.h"
backEndData_t *backEndData[SMP_FRAMES];
backEndData_t *backEndData;
backEndState_t backEnd;
@ -838,7 +838,7 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
/*
============================================================================
RENDER BACK END THREAD FUNCTIONS
RENDER BACK END FUNCTIONS
============================================================================
*/
@ -913,7 +913,7 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
if ( !tr.registered ) {
return;
}
R_SyncRenderThread();
R_IssuePendingRenderCommands();
// we definately want to sync every frame for the cinematics
qglFinish();
@ -1811,9 +1811,6 @@ const void *RB_PostProcess(const void *data)
/*
====================
RB_ExecuteRenderCommands
This function will be called synchronously if running without
smp extensions, or asynchronously by another thread.
====================
*/
void RB_ExecuteRenderCommands( const void *data ) {
@ -1821,12 +1818,6 @@ void RB_ExecuteRenderCommands( const void *data ) {
t1 = ri.Milliseconds ();
if ( !r_smp->integer || data == backEndData[0]->commands.cmds ) {
backEnd.smpFrame = 0;
} else {
backEnd.smpFrame = 1;
}
while ( 1 ) {
data = PADP(data, sizeof(void *));
@ -1866,7 +1857,7 @@ void RB_ExecuteRenderCommands( const void *data ) {
break;
case RC_END_OF_LIST:
default:
// stop rendering on this thread
// stop rendering
t2 = ri.Milliseconds ();
backEnd.pc.msec = t2 - t1;
return;
@ -1874,31 +1865,3 @@ void RB_ExecuteRenderCommands( const void *data ) {
}
}
/*
================
RB_RenderThread
================
*/
void RB_RenderThread( void ) {
const void *data;
// wait for either a rendering command or a quit command
while ( 1 ) {
// sleep until we have work to do
data = GLimp_RendererSleep();
if ( !data ) {
return; // all done, renderer is shutting down
}
renderThreadActive = qtrue;
RB_ExecuteRenderCommands( data );
renderThreadActive = qfalse;
}
}

4
code/rend2/tr_bsp.c
View file

@ -218,7 +218,7 @@ static void R_LoadLightmaps( lump_t *l, lump_t *surfs ) {
buf = fileBase + l->fileofs;
// we are about to upload textures
R_SyncRenderThread();
R_IssuePendingRenderCommands();
tr.lightmapSize = DEFAULT_LIGHTMAP_SIZE;
numLightmaps = len / (tr.lightmapSize * tr.lightmapSize * 3);
@ -3185,7 +3185,7 @@ void R_MergeLeafSurfaces(void)
}
// finish up the ibo
R_SyncRenderThread();
R_IssuePendingRenderCommands();
qglGenBuffersARB(1, &ibo->indexesVBO);

94
code/rend2/tr_cmds.c
View file

@ -23,9 +23,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
volatile renderCommandList_t *renderCommandList;
volatile qboolean renderThreadActive;
/*
=====================
R_PerformanceCounters
@ -82,49 +79,15 @@ void R_PerformanceCounters( void ) {
}
/*
====================
R_InitCommandBuffers
====================
*/
void R_InitCommandBuffers( void ) {
glConfig.smpActive = qfalse;
if ( r_smp->integer ) {
ri.Printf( PRINT_ALL, "Trying SMP acceleration...\n" );
if ( GLimp_SpawnRenderThread( RB_RenderThread ) ) {
ri.Printf( PRINT_ALL, "...succeeded.\n" );
glConfig.smpActive = qtrue;
} else {
ri.Printf( PRINT_ALL, "...failed.\n" );
}
}
}
/*
====================
R_ShutdownCommandBuffers
====================
*/
void R_ShutdownCommandBuffers( void ) {
// kill the rendering thread
if ( glConfig.smpActive ) {
GLimp_WakeRenderer( NULL );
glConfig.smpActive = qfalse;
}
}
/*
====================
R_IssueRenderCommands
====================
*/
int c_blockedOnRender;
int c_blockedOnMain;
void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
renderCommandList_t *cmdList;
cmdList = &backEndData[tr.smpFrame]->commands;
cmdList = &backEndData->commands;
assert(cmdList);
// add an end-of-list command
*(int *)(cmdList->cmds + cmdList->used) = RC_END_OF_LIST;
@ -132,26 +95,6 @@ void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
// clear it out, in case this is a sync and not a buffer flip
cmdList->used = 0;
if ( glConfig.smpActive ) {
// if the render thread is not idle, wait for it
if ( renderThreadActive ) {
c_blockedOnRender++;
if ( r_showSmp->integer ) {
ri.Printf( PRINT_ALL, "R" );
}
} else {
c_blockedOnMain++;
if ( r_showSmp->integer ) {
ri.Printf( PRINT_ALL, "." );
}
}
// sleep until the renderer has completed
GLimp_FrontEndSleep();
}
// at this point, the back end thread is idle, so it is ok
// to look at its performance counters
if ( runPerformanceCounters ) {
R_PerformanceCounters();
}
@ -159,49 +102,36 @@ void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
// actually start the commands going
if ( !r_skipBackEnd->integer ) {
// let it start on the new batch
if ( !glConfig.smpActive ) {
RB_ExecuteRenderCommands( cmdList->cmds );
} else {
GLimp_WakeRenderer( cmdList );
}
}
}
/*
====================
R_SyncRenderThread
R_IssuePendingRenderCommands
Issue any pending commands and wait for them to complete.
After exiting, the render thread will have completed its work
and will remain idle and the main thread is free to issue
OpenGL calls until R_IssueRenderCommands is called.
====================
*/
void R_SyncRenderThread( void ) {
void R_IssuePendingRenderCommands( void ) {
if ( !tr.registered ) {
return;
}
R_IssueRenderCommands( qfalse );
if ( !glConfig.smpActive ) {
return;
}
GLimp_FrontEndSleep();
}
/*
============
R_GetCommandBuffer
make sure there is enough command space, waiting on the
render thread if needed.
make sure there is enough command space
============
*/
void *R_GetCommandBuffer( int bytes ) {
renderCommandList_t *cmdList;
cmdList = &backEndData[tr.smpFrame]->commands;
cmdList = &backEndData->commands;
bytes = PAD(bytes, sizeof(void *));
// always leave room for the end of list command
@ -423,7 +353,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
}
else
{
R_SyncRenderThread();
R_IssuePendingRenderCommands();
qglEnable( GL_STENCIL_TEST );
qglStencilMask( ~0U );
qglClearStencil( 0U );
@ -436,7 +366,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
{
// this is only reached if it was on and is now off
if ( r_measureOverdraw->modified ) {
R_SyncRenderThread();
R_IssuePendingRenderCommands();
qglDisable( GL_STENCIL_TEST );
}
r_measureOverdraw->modified = qfalse;
@ -446,7 +376,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
// texturemode stuff
//
if ( r_textureMode->modified ) {
R_SyncRenderThread();
R_IssuePendingRenderCommands();
GL_TextureMode( r_textureMode->string );
r_textureMode->modified = qfalse;
}
@ -457,7 +387,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
if ( r_gamma->modified ) {
r_gamma->modified = qfalse;
R_SyncRenderThread();
R_IssuePendingRenderCommands();
R_SetColorMappings();
}
@ -466,7 +396,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
{
int err;
R_SyncRenderThread();
R_IssuePendingRenderCommands();
if ((err = qglGetError()) != GL_NO_ERROR)
ri.Error(ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!", err);
}
@ -612,9 +542,7 @@ void RE_EndFrame( int *frontEndMsec, int *backEndMsec ) {
R_IssueRenderCommands( qtrue );
// use the other buffers next frame, because another CPU
// may still be rendering into the current ones
R_ToggleSmpFrame();
R_InitNextFrame();
if ( frontEndMsec ) {
*frontEndMsec = tr.frontEndMsec;

3
code/rend2/tr_fbo.c
View file

@ -370,8 +370,7 @@ void FBO_Init(void)
GL_CheckErrors();
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
/* if(glRefConfig.textureNonPowerOfTwo)
{

3
code/rend2/tr_font.c
View file

@ -356,8 +356,7 @@ void RE_RegisterFont(const char *fontName, int pointSize, fontInfo_t *font) {
pointSize = 12;
}
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
if (registeredFontCount >= MAX_FONTS) {
ri.Printf(PRINT_WARNING, "RE_RegisterFont: Too many fonts registered already.\n");

3
code/rend2/tr_glsl.c
View file

@ -829,8 +829,7 @@ void GLSL_InitGPUShaders(void)
ri.Printf(PRINT_ALL, "------- GLSL_InitGPUShaders -------\n");
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
startTime = ri.Milliseconds();

3
code/rend2/tr_image.c
View file

@ -3349,8 +3349,7 @@ qhandle_t RE_RegisterSkin( const char *name ) {
Q_strncpyz( skin->name, name, sizeof( skin->name ) );
skin->numSurfaces = 0;
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
// If not a .skin file, load as a single shader
if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) {

33
code/rend2/tr_init.c
View file

@ -55,8 +55,6 @@ cvar_t *r_znear;
cvar_t *r_zproj;
cvar_t *r_stereoSeparation;
cvar_t *r_smp;
cvar_t *r_showSmp;
cvar_t *r_skipBackEnd;
cvar_t *r_stereoEnabled;
@ -268,9 +266,6 @@ static void InitOpenGL( void )
}
}
// init command buffers and SMP
R_InitCommandBuffers();
// set default state
GL_SetDefaultState();
}
@ -1028,9 +1023,6 @@ void GfxInfo_f( void )
{
ri.Printf( PRINT_ALL, "HACK: riva128 approximations\n" );
}
if ( glConfig.smpActive ) {
ri.Printf( PRINT_ALL, "Using dual processor acceleration\n" );
}
if ( r_finish->integer ) {
ri.Printf( PRINT_ALL, "Forcing glFinish\n" );
}
@ -1142,7 +1134,6 @@ void R_Register( void )
r_vertexLight = ri.Cvar_Get( "r_vertexLight", "0", CVAR_ARCHIVE | CVAR_LATCH );
r_uiFullScreen = ri.Cvar_Get( "r_uifullscreen", "0", 0);
r_subdivisions = ri.Cvar_Get ("r_subdivisions", "4", CVAR_ARCHIVE | CVAR_LATCH);
r_smp = ri.Cvar_Get( "r_smp", "0", CVAR_ARCHIVE | CVAR_LATCH);
r_stereoEnabled = ri.Cvar_Get( "r_stereoEnabled", "0", CVAR_ARCHIVE | CVAR_LATCH);
r_greyscale = ri.Cvar_Get("r_greyscale", "0", CVAR_ARCHIVE | CVAR_LATCH);
ri.Cvar_CheckRange(r_greyscale, 0, 1, qfalse);
@ -1256,7 +1247,6 @@ void R_Register( void )
r_flareFade = ri.Cvar_Get ("r_flareFade", "7", CVAR_CHEAT);
r_flareCoeff = ri.Cvar_Get ("r_flareCoeff", FLARE_STDCOEFF, CVAR_CHEAT);
r_showSmp = ri.Cvar_Get ("r_showSmp", "0", CVAR_CHEAT);
r_skipBackEnd = ri.Cvar_Get ("r_skipBackEnd", "0", CVAR_CHEAT);
r_measureOverdraw = ri.Cvar_Get( "r_measureOverdraw", "0", CVAR_CHEAT );
@ -1393,19 +1383,11 @@ void R_Init( void ) {
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();
ptr = ri.Hunk_Alloc( sizeof( *backEndData ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
backEndData = (backEndData_t *) ptr;
backEndData->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData ));
backEndData->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData ) + sizeof(srfPoly_t) * max_polys);
R_InitNextFrame();
InitOpenGL();
@ -1461,8 +1443,7 @@ void RE_Shutdown( qboolean destroyWindow ) {
if ( tr.registered ) {
R_SyncRenderThread();
R_ShutdownCommandBuffers();
R_IssuePendingRenderCommands();
R_ShutDownQueries();
if (glRefConfig.framebufferObject)
FBO_Shutdown();
@ -1490,7 +1471,7 @@ Touch all images to make sure they are resident
=============
*/
void RE_EndRegistration( void ) {
R_SyncRenderThread();
R_IssuePendingRenderCommands();
if (!ri.Sys_LowPhysicalMemory()) {
RB_ShowImages();
}

6
code/rend2/tr_light.c
View file

@ -95,11 +95,11 @@ void R_DlightBmodel( bmodel_t *bmodel ) {
surf = tr.world->surfaces + bmodel->firstSurface + i;
if ( *surf->data == SF_FACE ) {
((srfSurfaceFace_t *)surf->data)->dlightBits[ tr.smpFrame ] = mask;
((srfSurfaceFace_t *)surf->data)->dlightBits = mask;
} else if ( *surf->data == SF_GRID ) {
((srfGridMesh_t *)surf->data)->dlightBits[ tr.smpFrame ] = mask;
((srfGridMesh_t *)surf->data)->dlightBits = mask;
} else if ( *surf->data == SF_TRIANGLES ) {
((srfTriangles_t *)surf->data)->dlightBits[ tr.smpFrame ] = mask;
((srfTriangles_t *)surf->data)->dlightBits = mask;
}
}
}

47
code/rend2/tr_local.h
View file

@ -40,11 +40,6 @@ typedef unsigned int glIndex_t;
#define BUFFER_OFFSET(i) ((char *)NULL + (i))
// everything that is needed by the backend needs
// to be double buffered to allow it to run in
// parallel on a dual cpu machine
#define SMP_FRAMES 2
// 14 bits
// can't be increased without changing bit packing for drawsurfs
// see QSORT_SHADERNUM_SHIFT
@ -1138,8 +1133,8 @@ typedef struct srfGridMesh_s
surfaceType_t surfaceType;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int pshadowBits[SMP_FRAMES];
int dlightBits;
int pshadowBits;
// culling information
vec3_t meshBounds[2];
@ -1182,8 +1177,8 @@ typedef struct
surfaceType_t surfaceType;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int pshadowBits[SMP_FRAMES];
int dlightBits;
int pshadowBits;
// culling information
cplane_t plane;
@ -1214,8 +1209,8 @@ typedef struct
surfaceType_t surfaceType;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int pshadowBits[SMP_FRAMES];
int dlightBits;
int pshadowBits;
// culling information
// vec3_t bounds[2];
@ -1280,8 +1275,8 @@ typedef struct srfVBOMesh_s
int fogIndex;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int pshadowBits[SMP_FRAMES];
int dlightBits;
int pshadowBits;
// culling information
vec3_t bounds[2];
@ -1752,7 +1747,6 @@ typedef struct {
// all state modified by the back end is seperated
// from the front end state
typedef struct {
int smpFrame;
trRefdef_t refdef;
viewParms_t viewParms;
orientationr_t or;
@ -1798,8 +1792,6 @@ typedef struct {
int viewCount; // incremented every view (twice a scene if portaled)
// and every R_MarkFragments call
int smpFrame; // toggles from 0 to 1 every endFrame
int frameSceneNum; // zeroed at RE_BeginFrame
qboolean worldMapLoaded;
@ -2082,8 +2074,6 @@ extern cvar_t *r_portalOnly;
extern cvar_t *r_subdivisions;
extern cvar_t *r_lodCurveError;
extern cvar_t *r_smp;
extern cvar_t *r_showSmp;
extern cvar_t *r_skipBackEnd;
extern cvar_t *r_stereoEnabled;
@ -2327,11 +2317,6 @@ void GLimp_Init( void );
void GLimp_Shutdown( void );
void GLimp_EndFrame( void );
qboolean GLimp_SpawnRenderThread( void (*function)( void ) );
void *GLimp_RendererSleep( void );
void GLimp_FrontEndSleep( void );
void GLimp_WakeRenderer( void *data );
void GLimp_LogComment( char *comment );
void GLimp_Minimize(void);
@ -2586,7 +2571,7 @@ SCENE GENERATION
============================================================
*/
void R_ToggleSmpFrame( void );
void R_InitNextFrame( void );
void RE_ClearScene( void );
void RE_AddRefEntityToScene( const refEntity_t *ent );
@ -2700,7 +2685,6 @@ RENDERER BACK END FUNCTIONS
=============================================================
*/
void RB_RenderThread( void );
void RB_ExecuteRenderCommands( const void *data );
/*
@ -2828,9 +2812,7 @@ typedef enum {
#define MAX_POLYVERTS 3000
// all of the information needed by the back end must be
// contained in a backEndData_t. This entire structure is
// duplicated so the front and back end can run in parallel
// on an SMP machine
// contained in a backEndData_t
typedef struct {
drawSurf_t drawSurfs[MAX_DRAWSURFS];
dlight_t dlights[MAX_DLIGHTS];
@ -2844,20 +2826,15 @@ typedef struct {
extern int max_polys;
extern int max_polyverts;
extern backEndData_t *backEndData[SMP_FRAMES]; // the second one may not be allocated
extern backEndData_t *backEndData; // the second one may not be allocated
extern volatile renderCommandList_t *renderCommandList;
extern volatile qboolean renderThreadActive;
void *R_GetCommandBuffer( int bytes );
void RB_ExecuteRenderCommands( const void *data );
void R_InitCommandBuffers( void );
void R_ShutdownCommandBuffers( void );
void R_SyncRenderThread( void );
void R_IssuePendingRenderCommands( void );
void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );
void R_AddCapShadowmapCmd( int dlight, int cubeSide );

7
code/rend2/tr_main.c
View file

@ -1606,10 +1606,6 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
unsigned int pointOr = 0;
unsigned int pointAnd = (unsigned int)~0;
if ( glConfig.smpActive ) { // FIXME! we can't do RB_BeginSurface/RB_EndSurface stuff with smp!
return qfalse;
}
R_RotateForViewer();
R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted, &pshadowed );
@ -2122,8 +2118,7 @@ void R_DebugGraphics( void ) {
return;
}
// the render thread can't make callbacks to the main thread
R_SyncRenderThread();
R_IssuePendingRenderCommands();
GL_Bind( tr.whiteImage);
GL_Cull( CT_FRONT_SIDED );

5
code/rend2/tr_model.c
View file

@ -307,8 +307,7 @@ qhandle_t RE_RegisterModel( const char *name ) {
Q_strncpyz( mod->name, name, sizeof( mod->name ) );
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
mod->type = MOD_BAD;
mod->numLods = 0;
@ -1305,7 +1304,7 @@ void RE_BeginRegistration( glconfig_t *glconfigOut ) {
*glconfigOut = glConfig;
R_SyncRenderThread();
R_IssuePendingRenderCommands();
tr.visIndex = 0;
memset(tr.visClusters, -2, sizeof(tr.visClusters)); // force markleafs to regenerate

36
code/rend2/tr_scene.c
View file

@ -38,20 +38,12 @@ int r_numpolyverts;
/*
====================
R_ToggleSmpFrame
R_InitNextFrame
====================
*/
void R_ToggleSmpFrame( void ) {
if ( r_smp->integer ) {
// use the other buffers next frame, because another CPU
// may still be rendering into the current ones
tr.smpFrame ^= 1;
} else {
tr.smpFrame = 0;
}
backEndData[tr.smpFrame]->commands.used = 0;
void R_InitNextFrame( void ) {
backEndData->commands.used = 0;
r_firstSceneDrawSurf = 0;
@ -148,11 +140,11 @@ void RE_AddPolyToScene( qhandle_t hShader, int numVerts, const polyVert_t *verts
return;
}
poly = &backEndData[tr.smpFrame]->polys[r_numpolys];
poly = &backEndData->polys[r_numpolys];
poly->surfaceType = SF_POLY;
poly->hShader = hShader;
poly->numVerts = numVerts;
poly->verts = &backEndData[tr.smpFrame]->polyVerts[r_numpolyverts];
poly->verts = &backEndData->polyVerts[r_numpolyverts];
Com_Memcpy( poly->verts, &verts[numVerts*j], numVerts * sizeof( *verts ) );
@ -234,13 +226,13 @@ void RE_AddRefEntityToScene( const refEntity_t *ent ) {
ri.Error( ERR_DROP, "RE_AddRefEntityToScene: bad reType %i", ent->reType );
}
backEndData[tr.smpFrame]->entities[r_numentities].e = *ent;
backEndData[tr.smpFrame]->entities[r_numentities].lightingCalculated = qfalse;
backEndData->entities[r_numentities].e = *ent;
backEndData->entities[r_numentities].lightingCalculated = qfalse;
#ifdef REACTION
// JBravo: Mirrored models
CrossProduct(ent->axis[0], ent->axis[1], cross);
backEndData[tr.smpFrame]->entities[r_numentities].mirrored = (DotProduct(ent->axis[2], cross) < 0.f);
backEndData->entities[r_numentities].mirrored = (DotProduct(ent->axis[2], cross) < 0.f);
#endif
r_numentities++;
@ -269,7 +261,7 @@ void RE_AddDynamicLightToScene( const vec3_t org, float intensity, float r, floa
if ( glConfig.hardwareType == GLHW_RIVA128 || glConfig.hardwareType == GLHW_PERMEDIA2 ) {
return;
}
dl = &backEndData[tr.smpFrame]->dlights[r_numdlights++];
dl = &backEndData->dlights[r_numdlights++];
VectorCopy (org, dl->origin);
dl->radius = intensity;
dl->color[0] = r;
@ -439,19 +431,19 @@ void RE_RenderScene( const refdef_t *fd ) {
tr.refdef.floatTime = tr.refdef.time * 0.001f;
tr.refdef.numDrawSurfs = r_firstSceneDrawSurf;
tr.refdef.drawSurfs = backEndData[tr.smpFrame]->drawSurfs;
tr.refdef.drawSurfs = backEndData->drawSurfs;
tr.refdef.num_entities = r_numentities - r_firstSceneEntity;
tr.refdef.entities = &backEndData[tr.smpFrame]->entities[r_firstSceneEntity];
tr.refdef.entities = &backEndData->entities[r_firstSceneEntity];
tr.refdef.num_dlights = r_numdlights - r_firstSceneDlight;
tr.refdef.dlights = &backEndData[tr.smpFrame]->dlights[r_firstSceneDlight];
tr.refdef.dlights = &backEndData->dlights[r_firstSceneDlight];
tr.refdef.numPolys = r_numpolys - r_firstScenePoly;
tr.refdef.polys = &backEndData[tr.smpFrame]->polys[r_firstScenePoly];
tr.refdef.polys = &backEndData->polys[r_firstScenePoly];
tr.refdef.num_pshadows = 0;
tr.refdef.pshadows = &backEndData[tr.smpFrame]->pshadows[0];
tr.refdef.pshadows = &backEndData->pshadows[0];
// turn off dynamic lighting globally by clearing all the
// dlights if it needs to be disabled or if vertex lighting is enabled

14
code/rend2/tr_shader.c
View file

@ -2499,7 +2499,7 @@ sortedIndex.
==============
*/
static void FixRenderCommandList( int newShader ) {
renderCommandList_t *cmdList = &backEndData[tr.smpFrame]->commands;
renderCommandList_t *cmdList = &backEndData->commands;
if( cmdList ) {
const void *curCmd = cmdList->cmds;
@ -3103,12 +3103,6 @@ shader_t *R_FindShader( const char *name, int lightmapIndex, qboolean mipRawImag
}
}
// make sure the render thread is stopped, because we are probably
// going to have to upload an image
if (r_smp->integer) {
R_SyncRenderThread();
}
// clear the global shader
Com_Memset( &shader, 0, sizeof( shader ) );
Com_Memset( &stages, 0, sizeof( stages ) );
@ -3254,12 +3248,6 @@ qhandle_t RE_RegisterShaderFromImage(const char *name, int lightmapIndex, image_
}
}
// make sure the render thread is stopped, because we are probably
// going to have to upload an image
if (r_smp->integer) {
R_SyncRenderThread();
}
// clear the global shader
Com_Memset( &shader, 0, sizeof( shader ) );
Com_Memset( &stages, 0, sizeof( stages ) );

22
code/rend2/tr_surface.c
View file

@ -574,12 +574,14 @@ RB_SurfaceTriangles
=============
*/
static void RB_SurfaceTriangles( srfTriangles_t *srf ) {
if( RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numTriangles * 3, srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits[backEnd.smpFrame], srf->pshadowBits[backEnd.smpFrame], qtrue ) )
if( RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numTriangles * 3,
srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits, srf->pshadowBits, qtrue ) )
{
return;
}
RB_SurfaceHelper(srf->numVerts, srf->verts, srf->numTriangles, srf->triangles, srf->dlightBits[backEnd.smpFrame], srf->pshadowBits[backEnd.smpFrame]);
RB_SurfaceHelper(srf->numVerts, srf->verts, srf->numTriangles,
srf->triangles, srf->dlightBits, srf->pshadowBits);
}
@ -1305,12 +1307,14 @@ RB_SurfaceFace
==============
*/
static void RB_SurfaceFace( srfSurfaceFace_t *srf ) {
if( RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numTriangles * 3, srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits[backEnd.smpFrame], srf->pshadowBits[backEnd.smpFrame], qtrue ) )
if( RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numTriangles * 3,
srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits, srf->pshadowBits, qtrue ) )
{
return;
}
RB_SurfaceHelper(srf->numVerts, srf->verts, srf->numTriangles, srf->triangles, srf->dlightBits[backEnd.smpFrame], srf->pshadowBits[backEnd.smpFrame]);
RB_SurfaceHelper(srf->numVerts, srf->verts, srf->numTriangles,
srf->triangles, srf->dlightBits, srf->pshadowBits);
}
@ -1372,15 +1376,16 @@ static void RB_SurfaceGrid( srfGridMesh_t *srf ) {
int pshadowBits;
//int *vDlightBits;
if( RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numTriangles * 3, srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits[backEnd.smpFrame], srf->pshadowBits[backEnd.smpFrame], qtrue ) )
if( RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numTriangles * 3,
srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits, srf->pshadowBits, qtrue ) )
{
return;
}
dlightBits = srf->dlightBits[backEnd.smpFrame];
dlightBits = srf->dlightBits;
tess.dlightBits |= dlightBits;
pshadowBits = srf->pshadowBits[backEnd.smpFrame];
pshadowBits = srf->pshadowBits;
tess.pshadowBits |= pshadowBits;
// determine the allowable discrepance
@ -1630,7 +1635,8 @@ static void RB_SurfaceFlare(srfFlare_t *surf)
static void RB_SurfaceVBOMesh(srfVBOMesh_t * srf)
{
RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numIndexes, srf->firstIndex, srf->minIndex, srf->maxIndex, srf->dlightBits[backEnd.smpFrame], srf->pshadowBits[backEnd.smpFrame], qfalse );
RB_SurfaceHelperVBO (srf->vbo, srf->ibo, srf->numVerts, srf->numIndexes, srf->firstIndex,
srf->minIndex, srf->maxIndex, srf->dlightBits, srf->pshadowBits, qfalse );
}
void RB_SurfaceVBOMDVMesh(srfVBOMDVMesh_t * surface)

12
code/rend2/tr_vbo.c
View file

@ -56,8 +56,7 @@ VBO_t *R_CreateVBO(const char *name, byte * vertexes, int vertexesSize,
ri.Error( ERR_DROP, "R_CreateVBO: MAX_VBOS hit\n");
}
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
vbo = tr.vbos[tr.numVBOs] = ri.Hunk_Alloc(sizeof(*vbo), h_low);
tr.numVBOs++;
@ -125,8 +124,7 @@ VBO_t *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * vert
ri.Error( ERR_DROP, "R_CreateVBO2: MAX_VBOS hit\n");
}
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
vbo = tr.vbos[tr.numVBOs] = ri.Hunk_Alloc(sizeof(*vbo), h_low);
tr.numVBOs++;
@ -475,8 +473,7 @@ IBO_t *R_CreateIBO(const char *name, byte * indexes, int indexesSize, v
ri.Error( ERR_DROP, "R_CreateIBO: MAX_IBOS hit\n");
}
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
ibo = tr.ibos[tr.numIBOs] = ri.Hunk_Alloc(sizeof(*ibo), h_low);
tr.numIBOs++;
@ -544,8 +541,7 @@ IBO_t *R_CreateIBO2(const char *name, int numTriangles, srfTriangle_t *
ri.Error( ERR_DROP, "R_CreateIBO2: MAX_IBOS hit\n");
}
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
ibo = tr.ibos[tr.numIBOs] = ri.Hunk_Alloc(sizeof(*ibo), h_low);
tr.numIBOs++;

16
code/rend2/tr_world.c
View file

@ -206,13 +206,13 @@ static int R_DlightSurface( msurface_t *surf, int dlightBits ) {
}
if ( *surf->data == SF_FACE ) {
((srfSurfaceFace_t *)surf->data)->dlightBits[ tr.smpFrame ] = dlightBits;
((srfSurfaceFace_t *)surf->data)->dlightBits = dlightBits;
} else if ( *surf->data == SF_GRID ) {
((srfGridMesh_t *)surf->data)->dlightBits[ tr.smpFrame ] = dlightBits;
((srfGridMesh_t *)surf->data)->dlightBits = dlightBits;
} else if ( *surf->data == SF_TRIANGLES ) {
((srfTriangles_t *)surf->data)->dlightBits[ tr.smpFrame ] = dlightBits;
((srfTriangles_t *)surf->data)->dlightBits = dlightBits;
} else if ( *surf->data == SF_VBO_MESH ) {
((srfVBOMesh_t *)surf->data)->dlightBits[ tr.smpFrame ] = dlightBits;
((srfVBOMesh_t *)surf->data)->dlightBits = dlightBits;
} else {
dlightBits = 0;
}
@ -289,13 +289,13 @@ static int R_PshadowSurface( msurface_t *surf, int pshadowBits ) {
}
if ( *surf->data == SF_FACE ) {
((srfSurfaceFace_t *)surf->data)->pshadowBits[ tr.smpFrame ] = pshadowBits;
((srfSurfaceFace_t *)surf->data)->pshadowBits = pshadowBits;
} else if ( *surf->data == SF_GRID ) {
((srfGridMesh_t *)surf->data)->pshadowBits[ tr.smpFrame ] = pshadowBits;
((srfGridMesh_t *)surf->data)->pshadowBits = pshadowBits;
} else if ( *surf->data == SF_TRIANGLES ) {
((srfTriangles_t *)surf->data)->pshadowBits[ tr.smpFrame ] = pshadowBits;
((srfTriangles_t *)surf->data)->pshadowBits = pshadowBits;
} else if ( *surf->data == SF_VBO_MESH ) {
((srfVBOMesh_t *)surf->data)->pshadowBits[ tr.smpFrame ] = pshadowBits;
((srfVBOMesh_t *)surf->data)->pshadowBits = pshadowBits;
} else {
pshadowBits = 0;
}

44
code/renderer/tr_backend.c
View file

@ -21,7 +21,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "tr_local.h"
backEndData_t *backEndData[SMP_FRAMES];
backEndData_t *backEndData;
backEndState_t backEnd;
@ -682,7 +682,7 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
/*
============================================================================
RENDER BACK END THREAD FUNCTIONS
RENDER BACK END FUNCTIONS
============================================================================
*/
@ -734,7 +734,7 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
if ( !tr.registered ) {
return;
}
R_SyncRenderThread();
R_IssuePendingRenderCommands();
// we definately want to sync every frame for the cinematics
qglFinish();
@ -1111,9 +1111,6 @@ const void *RB_SwapBuffers( const void *data ) {
/*
====================
RB_ExecuteRenderCommands
This function will be called synchronously if running without
smp extensions, or asynchronously by another thread.
====================
*/
void RB_ExecuteRenderCommands( const void *data ) {
@ -1121,12 +1118,6 @@ void RB_ExecuteRenderCommands( const void *data ) {
t1 = ri.Milliseconds ();
if ( !r_smp->integer || data == backEndData[0]->commands.cmds ) {
backEnd.smpFrame = 0;
} else {
backEnd.smpFrame = 1;
}
while ( 1 ) {
data = PADP(data, sizeof(void *));
@ -1160,7 +1151,7 @@ void RB_ExecuteRenderCommands( const void *data ) {
break;
case RC_END_OF_LIST:
default:
// stop rendering on this thread
// stop rendering
t2 = ri.Milliseconds ();
backEnd.pc.msec = t2 - t1;
return;
@ -1168,30 +1159,3 @@ void RB_ExecuteRenderCommands( const void *data ) {
}
}
/*
================
RB_RenderThread
================
*/
void RB_RenderThread( void ) {
const void *data;
// wait for either a rendering command or a quit command
while ( 1 ) {
// sleep until we have work to do
data = GLimp_RendererSleep();
if ( !data ) {
return; // all done, renderer is shutting down
}
renderThreadActive = qtrue;
RB_ExecuteRenderCommands( data );
renderThreadActive = qfalse;
}
}

2
code/renderer/tr_bsp.c
View file

@ -147,7 +147,7 @@ static void R_LoadLightmaps( lump_t *l ) {
buf = fileBase + l->fileofs;
// we are about to upload textures
R_SyncRenderThread();
R_IssuePendingRenderCommands();
// create all the lightmaps
tr.numLightmaps = len / (LIGHTMAP_SIZE * LIGHTMAP_SIZE * 3);

94
code/renderer/tr_cmds.c
View file

@ -23,9 +23,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
volatile renderCommandList_t *renderCommandList;
volatile qboolean renderThreadActive;
/*
=====================
R_PerformanceCounters
@ -75,49 +72,15 @@ void R_PerformanceCounters( void ) {
}
/*
====================
R_InitCommandBuffers
====================
*/
void R_InitCommandBuffers( void ) {
glConfig.smpActive = qfalse;
if ( r_smp->integer ) {
ri.Printf( PRINT_ALL, "Trying SMP acceleration...\n" );
if ( GLimp_SpawnRenderThread( RB_RenderThread ) ) {
ri.Printf( PRINT_ALL, "...succeeded.\n" );
glConfig.smpActive = qtrue;
} else {
ri.Printf( PRINT_ALL, "...failed.\n" );
}
}
}
/*
====================
R_ShutdownCommandBuffers
====================
*/
void R_ShutdownCommandBuffers( void ) {
// kill the rendering thread
if ( glConfig.smpActive ) {
GLimp_WakeRenderer( NULL );
glConfig.smpActive = qfalse;
}
}
/*
====================
R_IssueRenderCommands
====================
*/
int c_blockedOnRender;
int c_blockedOnMain;
void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
renderCommandList_t *cmdList;
cmdList = &backEndData[tr.smpFrame]->commands;
cmdList = &backEndData->commands;
assert(cmdList);
// add an end-of-list command
*(int *)(cmdList->cmds + cmdList->used) = RC_END_OF_LIST;
@ -125,26 +88,6 @@ void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
// clear it out, in case this is a sync and not a buffer flip
cmdList->used = 0;
if ( glConfig.smpActive ) {
// if the render thread is not idle, wait for it
if ( renderThreadActive ) {
c_blockedOnRender++;
if ( r_showSmp->integer ) {
ri.Printf( PRINT_ALL, "R" );
}
} else {
c_blockedOnMain++;
if ( r_showSmp->integer ) {
ri.Printf( PRINT_ALL, "." );
}
}
// sleep until the renderer has completed
GLimp_FrontEndSleep();
}
// at this point, the back end thread is idle, so it is ok
// to look at its performance counters
if ( runPerformanceCounters ) {
R_PerformanceCounters();
}
@ -152,49 +95,36 @@ void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
// actually start the commands going
if ( !r_skipBackEnd->integer ) {
// let it start on the new batch
if ( !glConfig.smpActive ) {
RB_ExecuteRenderCommands( cmdList->cmds );
} else {
GLimp_WakeRenderer( cmdList );
}
}
}
/*
====================
R_SyncRenderThread
R_IssuePendingRenderCommands
Issue any pending commands and wait for them to complete.
After exiting, the render thread will have completed its work
and will remain idle and the main thread is free to issue
OpenGL calls until R_IssueRenderCommands is called.
====================
*/
void R_SyncRenderThread( void ) {
void R_IssuePendingRenderCommands( void ) {
if ( !tr.registered ) {
return;
}
R_IssueRenderCommands( qfalse );
if ( !glConfig.smpActive ) {
return;
}
GLimp_FrontEndSleep();
}
/*
============
R_GetCommandBuffer
make sure there is enough command space, waiting on the
render thread if needed.
make sure there is enough command space
============
*/
void *R_GetCommandBuffer( int bytes ) {
renderCommandList_t *cmdList;
cmdList = &backEndData[tr.smpFrame]->commands;
cmdList = &backEndData->commands;
bytes = PAD(bytes, sizeof(void *));
// always leave room for the end of list command
@ -377,7 +307,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
}
else
{
R_SyncRenderThread();
R_IssuePendingRenderCommands();
qglEnable( GL_STENCIL_TEST );
qglStencilMask( ~0U );
qglClearStencil( 0U );
@ -390,7 +320,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
{
// this is only reached if it was on and is now off
if ( r_measureOverdraw->modified ) {
R_SyncRenderThread();
R_IssuePendingRenderCommands();
qglDisable( GL_STENCIL_TEST );
}
r_measureOverdraw->modified = qfalse;
@ -400,7 +330,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
// texturemode stuff
//
if ( r_textureMode->modified ) {
R_SyncRenderThread();
R_IssuePendingRenderCommands();
GL_TextureMode( r_textureMode->string );
r_textureMode->modified = qfalse;
}
@ -411,7 +341,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
if ( r_gamma->modified ) {
r_gamma->modified = qfalse;
R_SyncRenderThread();
R_IssuePendingRenderCommands();
R_SetColorMappings();
}
@ -420,7 +350,7 @@ void RE_BeginFrame( stereoFrame_t stereoFrame ) {
{
int err;
R_SyncRenderThread();
R_IssuePendingRenderCommands();
if ((err = qglGetError()) != GL_NO_ERROR)
ri.Error(ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!", err);
}
@ -534,9 +464,7 @@ void RE_EndFrame( int *frontEndMsec, int *backEndMsec ) {
R_IssueRenderCommands( qtrue );
// use the other buffers next frame, because another CPU
// may still be rendering into the current ones
R_ToggleSmpFrame();
R_InitNextFrame();
if ( frontEndMsec ) {
*frontEndMsec = tr.frontEndMsec;

3
code/renderer/tr_font.c
View file

@ -356,8 +356,7 @@ void RE_RegisterFont(const char *fontName, int pointSize, fontInfo_t *font) {
pointSize = 12;
}
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
if (registeredFontCount >= MAX_FONTS) {
ri.Printf(PRINT_WARNING, "RE_RegisterFont: Too many fonts registered already.\n");

3
code/renderer/tr_image.c
View file

@ -1495,8 +1495,7 @@ qhandle_t RE_RegisterSkin( const char *name ) {
Q_strncpyz( skin->name, name, sizeof( skin->name ) );
skin->numSurfaces = 0;
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
// If not a .skin file, load as a single shader
if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) {

33
code/renderer/tr_init.c
View file

@ -55,8 +55,6 @@ cvar_t *r_znear;
cvar_t *r_zproj;
cvar_t *r_stereoSeparation;
cvar_t *r_smp;
cvar_t *r_showSmp;
cvar_t *r_skipBackEnd;
cvar_t *r_stereoEnabled;
@ -211,9 +209,6 @@ static void InitOpenGL( void )
}
}
// init command buffers and SMP
R_InitCommandBuffers();
// set default state
GL_SetDefaultState();
}
@ -990,9 +985,6 @@ void GfxInfo_f( void )
{
ri.Printf( PRINT_ALL, "HACK: riva128 approximations\n" );
}
if ( glConfig.smpActive ) {
ri.Printf( PRINT_ALL, "Using dual processor acceleration\n" );
}
if ( r_finish->integer ) {
ri.Printf( PRINT_ALL, "Forcing glFinish\n" );
}
@ -1045,7 +1037,6 @@ void R_Register( void )
r_vertexLight = ri.Cvar_Get( "r_vertexLight", "0", CVAR_ARCHIVE | CVAR_LATCH );
r_uiFullScreen = ri.Cvar_Get( "r_uifullscreen", "0", 0);
r_subdivisions = ri.Cvar_Get ("r_subdivisions", "4", CVAR_ARCHIVE | CVAR_LATCH);
r_smp = ri.Cvar_Get( "r_smp", "0", CVAR_ARCHIVE | CVAR_LATCH);
r_stereoEnabled = ri.Cvar_Get( "r_stereoEnabled", "0", CVAR_ARCHIVE | CVAR_LATCH);
r_ignoreFastPath = ri.Cvar_Get( "r_ignoreFastPath", "1", CVAR_ARCHIVE | CVAR_LATCH );
r_greyscale = ri.Cvar_Get("r_greyscale", "0", CVAR_ARCHIVE | CVAR_LATCH);
@ -1112,7 +1103,6 @@ void R_Register( void )
r_flareFade = ri.Cvar_Get ("r_flareFade", "7", CVAR_CHEAT);
r_flareCoeff = ri.Cvar_Get ("r_flareCoeff", FLARE_STDCOEFF, CVAR_CHEAT);
r_showSmp = ri.Cvar_Get ("r_showSmp", "0", CVAR_CHEAT);
r_skipBackEnd = ri.Cvar_Get ("r_skipBackEnd", "0", CVAR_CHEAT);
r_measureOverdraw = ri.Cvar_Get( "r_measureOverdraw", "0", CVAR_CHEAT );
@ -1228,19 +1218,11 @@ void R_Init( void ) {
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();
ptr = ri.Hunk_Alloc( sizeof( *backEndData ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
backEndData = (backEndData_t *) ptr;
backEndData->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData ));
backEndData->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData ) + sizeof(srfPoly_t) * max_polys);
R_InitNextFrame();
InitOpenGL();
@ -1286,8 +1268,7 @@ void RE_Shutdown( qboolean destroyWindow ) {
if ( tr.registered ) {
R_SyncRenderThread();
R_ShutdownCommandBuffers();
R_IssuePendingRenderCommands();
R_DeleteTextures();
}
@ -1310,7 +1291,7 @@ Touch all images to make sure they are resident
=============
*/
void RE_EndRegistration( void ) {
R_SyncRenderThread();
R_IssuePendingRenderCommands();
if (!ri.Sys_LowPhysicalMemory()) {
RB_ShowImages();
}

6
code/renderer/tr_light.c
View file

@ -95,11 +95,11 @@ void R_DlightBmodel( bmodel_t *bmodel ) {
surf = bmodel->firstSurface + i;
if ( *surf->data == SF_FACE ) {
((srfSurfaceFace_t *)surf->data)->dlightBits[ tr.smpFrame ] = mask;
((srfSurfaceFace_t *)surf->data)->dlightBits = mask;
} else if ( *surf->data == SF_GRID ) {
((srfGridMesh_t *)surf->data)->dlightBits[ tr.smpFrame ] = mask;
((srfGridMesh_t *)surf->data)->dlightBits = mask;
} else if ( *surf->data == SF_TRIANGLES ) {
((srfTriangles_t *)surf->data)->dlightBits[ tr.smpFrame ] = mask;
((srfTriangles_t *)surf->data)->dlightBits = mask;
}
}
}

37
code/renderer/tr_local.h
View file

@ -34,11 +34,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#define GL_INDEX_TYPE GL_UNSIGNED_INT
typedef unsigned int glIndex_t;
// everything that is needed by the backend needs
// to be double buffered to allow it to run in
// parallel on a dual cpu machine
#define SMP_FRAMES 2
// 14 bits
// can't be increased without changing bit packing for drawsurfs
// see QSORT_SHADERNUM_SHIFT
@ -573,7 +568,7 @@ typedef struct srfGridMesh_s {
surfaceType_t surfaceType;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int dlightBits;
// culling information
vec3_t meshBounds[2];
@ -603,7 +598,7 @@ typedef struct {
cplane_t plane;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int dlightBits;
// triangle definitions (no normals at points)
int numPoints;
@ -619,7 +614,7 @@ typedef struct {
surfaceType_t surfaceType;
// dynamic lighting information
int dlightBits[SMP_FRAMES];
int dlightBits;
// culling information (FIXME: use this!)
vec3_t bounds[2];
@ -891,7 +886,6 @@ typedef struct {
// all state modified by the back end is seperated
// from the front end state
typedef struct {
int smpFrame;
trRefdef_t refdef;
viewParms_t viewParms;
orientationr_t or;
@ -923,8 +917,6 @@ typedef struct {
int viewCount; // incremented every view (twice a scene if portaled)
// and every R_MarkFragments call
int smpFrame; // toggles from 0 to 1 every endFrame
int frameSceneNum; // zeroed at RE_BeginFrame
qboolean worldMapLoaded;
@ -1122,8 +1114,6 @@ extern cvar_t *r_portalOnly;
extern cvar_t *r_subdivisions;
extern cvar_t *r_lodCurveError;
extern cvar_t *r_smp;
extern cvar_t *r_showSmp;
extern cvar_t *r_skipBackEnd;
extern cvar_t *r_stereoEnabled;
@ -1300,11 +1290,6 @@ void GLimp_Init( void );
void GLimp_Shutdown( void );
void GLimp_EndFrame( void );
qboolean GLimp_SpawnRenderThread( void (*function)( void ) );
void *GLimp_RendererSleep( void );
void GLimp_FrontEndSleep( void );
void GLimp_WakeRenderer( void *data );
void GLimp_LogComment( char *comment );
void GLimp_Minimize(void);
@ -1480,7 +1465,7 @@ SCENE GENERATION
============================================================
*/
void R_ToggleSmpFrame( void );
void R_InitNextFrame( void );
void RE_ClearScene( void );
void RE_AddRefEntityToScene( const refEntity_t *ent );
@ -1584,7 +1569,6 @@ RENDERER BACK END FUNCTIONS
=============================================================
*/
void RB_RenderThread( void );
void RB_ExecuteRenderCommands( const void *data );
/*
@ -1698,9 +1682,7 @@ typedef enum {
#define MAX_POLYVERTS 3000
// all of the information needed by the back end must be
// contained in a backEndData_t. This entire structure is
// duplicated so the front and back end can run in parallel
// on an SMP machine
// contained in a backEndData_t
typedef struct {
drawSurf_t drawSurfs[MAX_DRAWSURFS];
dlight_t dlights[MAX_DLIGHTS];
@ -1713,20 +1695,15 @@ typedef struct {
extern int max_polys;
extern int max_polyverts;
extern backEndData_t *backEndData[SMP_FRAMES]; // the second one may not be allocated
extern backEndData_t *backEndData; // the second one may not be allocated
extern volatile renderCommandList_t *renderCommandList;
extern volatile qboolean renderThreadActive;
void *R_GetCommandBuffer( int bytes );
void RB_ExecuteRenderCommands( const void *data );
void R_InitCommandBuffers( void );
void R_ShutdownCommandBuffers( void );
void R_SyncRenderThread( void );
void R_IssuePendingRenderCommands( void );
void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );

7
code/renderer/tr_main.c
View file

@ -862,10 +862,6 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
unsigned int pointOr = 0;
unsigned int pointAnd = (unsigned int)~0;
if ( glConfig.smpActive ) { // FIXME! we can't do RB_BeginSurface/RB_EndSurface stuff with smp!
return qfalse;
}
R_RotateForViewer();
R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted );
@ -1352,8 +1348,7 @@ void R_DebugGraphics( void ) {
return;
}
// the render thread can't make callbacks to the main thread
R_SyncRenderThread();
R_IssuePendingRenderCommands();
GL_Bind( tr.whiteImage);
GL_Cull( CT_FRONT_SIDED );

5
code/renderer/tr_model.c
View file

@ -306,8 +306,7 @@ qhandle_t RE_RegisterModel( const char *name ) {
Q_strncpyz( mod->name, name, sizeof( mod->name ) );
// make sure the render thread is stopped
R_SyncRenderThread();
R_IssuePendingRenderCommands();
mod->type = MOD_BAD;
mod->numLods = 0;
@ -1045,7 +1044,7 @@ void RE_BeginRegistration( glconfig_t *glconfigOut ) {
*glconfigOut = glConfig;
R_SyncRenderThread();
R_IssuePendingRenderCommands();
tr.viewCluster = -1; // force markleafs to regenerate
R_ClearFlares();

32
code/renderer/tr_scene.c
View file

@ -38,20 +38,12 @@ int r_numpolyverts;
/*
====================
R_ToggleSmpFrame
R_InitNextFrame
====================
*/
void R_ToggleSmpFrame( void ) {
if ( r_smp->integer ) {
// use the other buffers next frame, because another CPU
// may still be rendering into the current ones
tr.smpFrame ^= 1;
} else {
tr.smpFrame = 0;
}
backEndData[tr.smpFrame]->commands.used = 0;
void R_InitNextFrame( void ) {
backEndData->commands.used = 0;
r_firstSceneDrawSurf = 0;
@ -143,11 +135,11 @@ void RE_AddPolyToScene( qhandle_t hShader, int numVerts, const polyVert_t *verts
return;
}
poly = &backEndData[tr.smpFrame]->polys[r_numpolys];
poly = &backEndData->polys[r_numpolys];
poly->surfaceType = SF_POLY;
poly->hShader = hShader;
poly->numVerts = numVerts;
poly->verts = &backEndData[tr.smpFrame]->polyVerts[r_numpolyverts];
poly->verts = &backEndData->polyVerts[r_numpolyverts];
Com_Memcpy( poly->verts, &verts[numVerts*j], numVerts * sizeof( *verts ) );
@ -224,8 +216,8 @@ void RE_AddRefEntityToScene( const refEntity_t *ent ) {
ri.Error( ERR_DROP, "RE_AddRefEntityToScene: bad reType %i", ent->reType );
}
backEndData[tr.smpFrame]->entities[r_numentities].e = *ent;
backEndData[tr.smpFrame]->entities[r_numentities].lightingCalculated = qfalse;
backEndData->entities[r_numentities].e = *ent;
backEndData->entities[r_numentities].lightingCalculated = qfalse;
r_numentities++;
}
@ -253,7 +245,7 @@ void RE_AddDynamicLightToScene( const vec3_t org, float intensity, float r, floa
if ( glConfig.hardwareType == GLHW_RIVA128 || glConfig.hardwareType == GLHW_PERMEDIA2 ) {
return;
}
dl = &backEndData[tr.smpFrame]->dlights[r_numdlights++];
dl = &backEndData->dlights[r_numdlights++];
VectorCopy (org, dl->origin);
dl->radius = intensity;
dl->color[0] = r;
@ -355,16 +347,16 @@ void RE_RenderScene( const refdef_t *fd ) {
tr.refdef.floatTime = tr.refdef.time * 0.001f;
tr.refdef.numDrawSurfs = r_firstSceneDrawSurf;
tr.refdef.drawSurfs = backEndData[tr.smpFrame]->drawSurfs;
tr.refdef.drawSurfs = backEndData->drawSurfs;
tr.refdef.num_entities = r_numentities - r_firstSceneEntity;
tr.refdef.entities = &backEndData[tr.smpFrame]->entities[r_firstSceneEntity];
tr.refdef.entities = &backEndData->entities[r_firstSceneEntity];
tr.refdef.num_dlights = r_numdlights - r_firstSceneDlight;
tr.refdef.dlights = &backEndData[tr.smpFrame]->dlights[r_firstSceneDlight];
tr.refdef.dlights = &backEndData->dlights[r_firstSceneDlight];
tr.refdef.numPolys = r_numpolys - r_firstScenePoly;
tr.refdef.polys = &backEndData[tr.smpFrame]->polys[r_firstScenePoly];
tr.refdef.polys = &backEndData->polys[r_firstScenePoly];
// turn off dynamic lighting globally by clearing all the
// dlights if it needs to be disabled or if vertex lighting is enabled

14
code/renderer/tr_shader.c
View file

@ -1872,7 +1872,7 @@ sortedIndex.
==============
*/
static void FixRenderCommandList( int newShader ) {
renderCommandList_t *cmdList = &backEndData[tr.smpFrame]->commands;
renderCommandList_t *cmdList = &backEndData->commands;
if( cmdList ) {
const void *curCmd = cmdList->cmds;
@ -2473,12 +2473,6 @@ shader_t *R_FindShader( const char *name, int lightmapIndex, qboolean mipRawImag
}
}
// make sure the render thread is stopped, because we are probably
// going to have to upload an image
if (r_smp->integer) {
R_SyncRenderThread();
}
// clear the global shader
Com_Memset( &shader, 0, sizeof( shader ) );
Com_Memset( &stages, 0, sizeof( stages ) );
@ -2609,12 +2603,6 @@ qhandle_t RE_RegisterShaderFromImage(const char *name, int lightmapIndex, image_
}
}
// make sure the render thread is stopped, because we are probably
// going to have to upload an image
if (r_smp->integer) {
R_SyncRenderThread();
}
// clear the global shader
Com_Memset( &shader, 0, sizeof( shader ) );
Com_Memset( &stages, 0, sizeof( stages ) );

6
code/renderer/tr_surface.c
View file

@ -231,7 +231,7 @@ static void RB_SurfaceTriangles( srfTriangles_t *srf ) {
int dlightBits;
qboolean needsNormal;
dlightBits = srf->dlightBits[backEnd.smpFrame];
dlightBits = srf->dlightBits;
tess.dlightBits |= dlightBits;
RB_CHECKOVERFLOW( srf->numVerts, srf->numIndexes );
@ -915,7 +915,7 @@ static void RB_SurfaceFace( srfSurfaceFace_t *surf ) {
RB_CHECKOVERFLOW( surf->numPoints, surf->numIndices );
dlightBits = surf->dlightBits[backEnd.smpFrame];
dlightBits = surf->dlightBits;
tess.dlightBits |= dlightBits;
indices = ( unsigned * ) ( ( ( char * ) surf ) + surf->ofsIndices );
@ -1007,7 +1007,7 @@ static void RB_SurfaceGrid( srfGridMesh_t *cv ) {
int *vDlightBits;
qboolean needsNormal;
dlightBits = cv->dlightBits[backEnd.smpFrame];
dlightBits = cv->dlightBits;
tess.dlightBits |= dlightBits;
// determine the allowable discrepance

2
code/renderer/tr_types.h
View file

@ -212,7 +212,7 @@ typedef struct {
// used CDS.
qboolean isFullscreen;
qboolean stereoEnabled;
qboolean smpActive; // dual processor
qboolean smpActive; // UNUSED, present for compatibility
} glconfig_t;
#endif // __TR_TYPES_H

8
code/renderer/tr_world.c
View file

@ -180,7 +180,7 @@ static int R_DlightFace( srfSurfaceFace_t *face, int dlightBits ) {
tr.pc.c_dlightSurfacesCulled++;
}
face->dlightBits[ tr.smpFrame ] = dlightBits;
face->dlightBits = dlightBits;
return dlightBits;
}
@ -208,14 +208,14 @@ static int R_DlightGrid( srfGridMesh_t *grid, int dlightBits ) {
tr.pc.c_dlightSurfacesCulled++;
}
grid->dlightBits[ tr.smpFrame ] = dlightBits;
grid->dlightBits = dlightBits;
return dlightBits;
}
static int R_DlightTrisurf( srfTriangles_t *surf, int dlightBits ) {
// FIXME: more dlight culling to trisurfs...
surf->dlightBits[ tr.smpFrame ] = dlightBits;
surf->dlightBits = dlightBits;
return dlightBits;
#if 0
int i;
@ -241,7 +241,7 @@ static int R_DlightTrisurf( srfTriangles_t *surf, int dlightBits ) {
tr.pc.c_dlightSurfacesCulled++;
}
grid->dlightBits[ tr.smpFrame ] = dlightBits;
grid->dlightBits = dlightBits;
return dlightBits;
#endif
}

250
code/sdl/sdl_glimp.c
View file

@ -26,14 +26,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
# include <SDL.h>
#endif
#ifdef SMP
# ifdef USE_LOCAL_HEADERS
# include "SDL_thread.h"
# else
# include <SDL_thread.h>
# endif
#endif
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
@ -827,245 +819,3 @@ void GLimp_EndFrame( void )
r_fullscreen->modified = qfalse;
}
}
#ifdef SMP
/*
===========================================================
SMP acceleration
===========================================================
*/
/*
* I have no idea if this will even work...most platforms don't offer
* thread-safe OpenGL libraries, and it looks like the original Linux
* code counted on each thread claiming the GL context with glXMakeCurrent(),
* which you can't currently do in SDL. We'll just have to hope for the best.
*/
static SDL_mutex *smpMutex = NULL;
static SDL_cond *renderCommandsEvent = NULL;
static SDL_cond *renderCompletedEvent = NULL;
static void (*glimpRenderThread)( void ) = NULL;
static SDL_Thread *renderThread = NULL;
/*
===============
GLimp_ShutdownRenderThread
===============
*/
static void GLimp_ShutdownRenderThread(void)
{
if (smpMutex != NULL)
{
SDL_DestroyMutex(smpMutex);
smpMutex = NULL;
}
if (renderCommandsEvent != NULL)
{
SDL_DestroyCond(renderCommandsEvent);
renderCommandsEvent = NULL;
}
if (renderCompletedEvent != NULL)
{
SDL_DestroyCond(renderCompletedEvent);
renderCompletedEvent = NULL;
}
glimpRenderThread = NULL;
}
/*
===============
GLimp_RenderThreadWrapper
===============
*/
static int GLimp_RenderThreadWrapper( void *arg )
{
Com_Printf( "Render thread starting\n" );
glimpRenderThread();
GLimp_SetCurrentContext(NULL);
Com_Printf( "Render thread terminating\n" );
return 0;
}
/*
===============
GLimp_SpawnRenderThread
===============
*/
qboolean GLimp_SpawnRenderThread( void (*function)( void ) )
{
static qboolean warned = qfalse;
if (!warned)
{
Com_Printf("WARNING: You enable r_smp at your own risk!\n");
warned = qtrue;
}
#ifndef MACOS_X
return qfalse; /* better safe than sorry for now. */
#endif
if (renderThread != NULL) /* hopefully just a zombie at this point... */
{
Com_Printf("Already a render thread? Trying to clean it up...\n");
SDL_WaitThread(renderThread, NULL);
renderThread = NULL;
GLimp_ShutdownRenderThread();
}
smpMutex = SDL_CreateMutex();
if (smpMutex == NULL)
{
Com_Printf( "smpMutex creation failed: %s\n", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
renderCommandsEvent = SDL_CreateCond();
if (renderCommandsEvent == NULL)
{
Com_Printf( "renderCommandsEvent creation failed: %s\n", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
renderCompletedEvent = SDL_CreateCond();
if (renderCompletedEvent == NULL)
{
Com_Printf( "renderCompletedEvent creation failed: %s\n", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
glimpRenderThread = function;
renderThread = SDL_CreateThread(GLimp_RenderThreadWrapper, NULL);
if ( renderThread == NULL )
{
ri.Printf( PRINT_ALL, "SDL_CreateThread() returned %s", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
else
{
// tma 01/09/07: don't think this is necessary anyway?
//
// !!! FIXME: No detach API available in SDL!
//ret = pthread_detach( renderThread );
//if ( ret ) {
//ri.Printf( PRINT_ALL, "pthread_detach returned %d: %s", ret, strerror( ret ) );
//}
}
return qtrue;
}
static volatile void *smpData = NULL;
static volatile qboolean smpDataReady;
/*
===============
GLimp_RendererSleep
===============
*/
void *GLimp_RendererSleep( void )
{
void *data = NULL;
GLimp_SetCurrentContext(NULL);
SDL_LockMutex(smpMutex);
{
smpData = NULL;
smpDataReady = qfalse;
// after this, the front end can exit GLimp_FrontEndSleep
SDL_CondSignal(renderCompletedEvent);
while ( !smpDataReady )
SDL_CondWait(renderCommandsEvent, smpMutex);
data = (void *)smpData;
}
SDL_UnlockMutex(smpMutex);
GLimp_SetCurrentContext(opengl_context);
return data;
}
/*
===============
GLimp_FrontEndSleep
===============
*/
void GLimp_FrontEndSleep( void )
{
SDL_LockMutex(smpMutex);
{
while ( smpData )
SDL_CondWait(renderCompletedEvent, smpMutex);
}
SDL_UnlockMutex(smpMutex);
GLimp_SetCurrentContext(opengl_context);
}
/*
===============
GLimp_WakeRenderer
===============
*/
void GLimp_WakeRenderer( void *data )
{
GLimp_SetCurrentContext(NULL);
SDL_LockMutex(smpMutex);
{
assert( smpData == NULL );
smpData = data;
smpDataReady = qtrue;
// after this, the renderer can continue through GLimp_RendererSleep
SDL_CondSignal(renderCommandsEvent);
}
SDL_UnlockMutex(smpMutex);
}
#else
// No SMP - stubs
void GLimp_RenderThreadWrapper( void *arg )
{
}
qboolean GLimp_SpawnRenderThread( void (*function)( void ) )
{
ri.Printf( PRINT_WARNING, "ERROR: SMP support was disabled at compile time\n");
return qfalse;
}
void *GLimp_RendererSleep( void )
{
return NULL;
}
void GLimp_FrontEndSleep( void )
{
}
void GLimp_WakeRenderer( void *data )
{
}
#endif

41
code/sys/con_win32.c
View file

@ -42,6 +42,7 @@ static int qconsole_history_oldest = 0;
// current edit buffer
static char qconsole_line[ MAX_EDIT_LINE ];
static int qconsole_linelen = 0;
static qboolean qconsole_drawinput = qtrue;
static HANDLE qconsole_hout;
static HANDLE qconsole_hin;
@ -174,6 +175,7 @@ static void CON_Show( void )
COORD writeSize = { MAX_EDIT_LINE, 1 };
COORD writePos = { 0, 0 };
SMALL_RECT writeArea = { 0, 0, 0, 0 };
COORD cursorPos;
int i;
CHAR_INFO line[ MAX_EDIT_LINE ];
WORD attrib;
@ -181,7 +183,7 @@ static void CON_Show( void )
GetConsoleScreenBufferInfo( qconsole_hout, &binfo );
// if we're in the middle of printf, don't bother writing the buffer
if( binfo.dwCursorPosition.X != 0 )
if( !qconsole_drawinput )
return;
writeArea.Left = 0;
@ -219,8 +221,33 @@ static void CON_Show( void )
WriteConsoleOutput( qconsole_hout, line, writeSize,
writePos, &writeArea );
}
// set curor position
cursorPos.Y = binfo.dwCursorPosition.Y;
cursorPos.X = qconsole_linelen > binfo.srWindow.Right ? binfo.srWindow.Right : qconsole_linelen;
SetConsoleCursorPosition( qconsole_hout, cursorPos );
}
/*
==================
CON_Hide
==================
*/
static void CON_Hide( void )
{
int realLen;
realLen = qconsole_linelen;
// remove input line from console output buffer
qconsole_linelen = 0;
CON_Show( );
qconsole_linelen = realLen;
}
/*
==================
CON_Shutdown
@ -228,6 +255,7 @@ CON_Shutdown
*/
void CON_Shutdown( void )
{
CON_Hide( );
SetConsoleMode( qconsole_hin, qconsole_orig_mode );
SetConsoleCursorInfo( qconsole_hout, &qconsole_orig_cursorinfo );
SetConsoleTextAttribute( qconsole_hout, qconsole_attrib );
@ -242,7 +270,6 @@ CON_Init
*/
void CON_Init( void )
{
CONSOLE_CURSOR_INFO curs;
CONSOLE_SCREEN_BUFFER_INFO info;
int i;
@ -271,12 +298,6 @@ void CON_Init( void )
SetConsoleTitle(CLIENT_WINDOW_TITLE " Dedicated Server Console");
// make cursor invisible
GetConsoleCursorInfo( qconsole_hout, &qconsole_orig_cursorinfo );
curs.dwSize = 1;
curs.bVisible = FALSE;
SetConsoleCursorInfo( qconsole_hout, &curs );
// initialize history
for( i = 0; i < QCONSOLE_HISTORY; i++ )
qconsole_history[ i ][ 0 ] = '\0';
@ -408,6 +429,8 @@ void CON_WindowsColorPrint( const char *msg )
while( *msg )
{
qconsole_drawinput = ( *msg == '\n' );
if( Q_IsColorString( msg ) || *msg == '\n' )
{
// First empty the buffer
@ -458,6 +481,8 @@ CON_Print
*/
void CON_Print( const char *msg )
{
CON_Hide( );
CON_WindowsColorPrint( msg );
CON_Show( );

6
make-macosx-ub.sh
View file

@ -42,15 +42,9 @@ MPACK_OBJ="
build/release-darwin-ppc/$MPACKDIR/qagameppc.dylib
"
RENDER_OBJ="
build/release-darwin-x86_64/renderer_opengl1_smp_x86_64.dylib
build/release-darwin-i386/renderer_opengl1_smp_i386.dylib
build/release-darwin-ppc/renderer_opengl1_smp_ppc.dylib
build/release-darwin-x86_64/renderer_opengl1_x86_64.dylib
build/release-darwin-i386/renderer_opengl1_i386.dylib
build/release-darwin-ppc/renderer_opengl1_ppc.dylib
build/release-darwin-x86_64/renderer_rend2_smp_x86_64.dylib
build/release-darwin-i386/renderer_rend2_smp_i386.dylib
build/release-darwin-ppc/renderer_rend2_smp_ppc.dylib
build/release-darwin-x86_64/renderer_rend2_x86_64.dylib
build/release-darwin-i386/renderer_rend2_i386.dylib
build/release-darwin-ppc/renderer_rend2_ppc.dylib

2
make-macosx.sh
View file

@ -51,9 +51,7 @@ MPACK_OBJ="
build/release-darwin-${BUILDARCH}/$MPACKDIR/qagame${BUILDARCH}.dylib
"
RENDER_OBJ="
build/release-darwin-${BUILDARCH}/renderer_opengl1_smp_${BUILDARCH}.dylib
build/release-darwin-${BUILDARCH}/renderer_opengl1_${BUILDARCH}.dylib
build/release-darwin-${BUILDARCH}/renderer_rend2_smp_${BUILDARCH}.dylib
build/release-darwin-${BUILDARCH}/renderer_rend2_${BUILDARCH}.dylib
"