mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2025-04-09 15:50:57 +00:00
Compare commits
No commits in common. "master" and "v1.39" have entirely different histories.
53 changed files with 1432 additions and 3383 deletions
56
Makefile
56
Makefile
|
|
@ -329,28 +329,15 @@ bin_path=$(shell which $(1) 2> /dev/null)
|
|||
# The autoupdater uses curl, so figure out its flags no matter what.
|
||||
# We won't need this if we only build the server
|
||||
|
||||
# set PKG_CONFIG_PATH or PKG_CONFIG to influence this, e.g.
|
||||
# PKG_CONFIG_PATH=/opt/cross/i386-mingw32msvc/lib/pkgconfig or
|
||||
# PKG_CONFIG=arm-linux-gnueabihf-pkg-config
|
||||
ifeq ($(CROSS_COMPILING),0)
|
||||
PKG_CONFIG ?= pkg-config
|
||||
else
|
||||
ifneq ($(PKG_CONFIG_PATH),)
|
||||
PKG_CONFIG ?= pkg-config
|
||||
else
|
||||
# Don't use host pkg-config when cross-compiling.
|
||||
# (unknown-pkg-config is meant to be a non-existant command.)
|
||||
PKG_CONFIG ?= unknown-pkg-config
|
||||
endif
|
||||
endif
|
||||
|
||||
ifneq ($(call bin_path, $(PKG_CONFIG)),)
|
||||
CURL_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags libcurl)
|
||||
CURL_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs libcurl)
|
||||
OPENAL_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags openal)
|
||||
OPENAL_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs openal)
|
||||
SDL_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags sdl2|sed 's/-Dmain=SDL_main//')
|
||||
SDL_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs sdl2)
|
||||
# set PKG_CONFIG_PATH to influence this, e.g.
|
||||
# PKG_CONFIG_PATH=/opt/cross/i386-mingw32msvc/lib/pkgconfig
|
||||
ifneq ($(call bin_path, pkg-config),)
|
||||
CURL_CFLAGS ?= $(shell pkg-config --silence-errors --cflags libcurl)
|
||||
CURL_LIBS ?= $(shell pkg-config --silence-errors --libs libcurl)
|
||||
OPENAL_CFLAGS ?= $(shell pkg-config --silence-errors --cflags openal)
|
||||
OPENAL_LIBS ?= $(shell pkg-config --silence-errors --libs openal)
|
||||
SDL_CFLAGS ?= $(shell pkg-config --silence-errors --cflags sdl2|sed 's/-Dmain=SDL_main//')
|
||||
SDL_LIBS ?= $(shell pkg-config --silence-errors --libs sdl2)
|
||||
else
|
||||
# assume they're in the system default paths (no -I or -L needed)
|
||||
CURL_LIBS ?= -lcurl
|
||||
|
|
@ -1171,8 +1158,8 @@ ifeq ($(NEED_OPUS),1)
|
|||
-I$(OPUSDIR)/include -I$(OPUSDIR)/celt -I$(OPUSDIR)/silk \
|
||||
-I$(OPUSDIR)/silk/float -I$(OPUSFILEDIR)/include
|
||||
else
|
||||
OPUS_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags opusfile opus || true)
|
||||
OPUS_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs opusfile opus || echo -lopusfile -lopus)
|
||||
OPUS_CFLAGS ?= $(shell pkg-config --silence-errors --cflags opusfile opus || true)
|
||||
OPUS_LIBS ?= $(shell pkg-config --silence-errors --libs opusfile opus || echo -lopusfile -lopus)
|
||||
endif
|
||||
CLIENT_CFLAGS += $(OPUS_CFLAGS)
|
||||
CLIENT_LIBS += $(OPUS_LIBS)
|
||||
|
|
@ -1184,8 +1171,8 @@ ifeq ($(USE_CODEC_VORBIS),1)
|
|||
ifeq ($(USE_INTERNAL_VORBIS),1)
|
||||
CLIENT_CFLAGS += -I$(VORBISDIR)/include -I$(VORBISDIR)/lib
|
||||
else
|
||||
VORBIS_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags vorbisfile vorbis || true)
|
||||
VORBIS_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs vorbisfile vorbis || echo -lvorbisfile -lvorbis)
|
||||
VORBIS_CFLAGS ?= $(shell pkg-config --silence-errors --cflags vorbisfile vorbis || true)
|
||||
VORBIS_LIBS ?= $(shell pkg-config --silence-errors --libs vorbisfile vorbis || echo -lvorbisfile -lvorbis)
|
||||
endif
|
||||
CLIENT_CFLAGS += $(VORBIS_CFLAGS)
|
||||
CLIENT_LIBS += $(VORBIS_LIBS)
|
||||
|
|
@ -1196,8 +1183,8 @@ ifeq ($(NEED_OGG),1)
|
|||
ifeq ($(USE_INTERNAL_OGG),1)
|
||||
OGG_CFLAGS = -I$(OGGDIR)/include
|
||||
else
|
||||
OGG_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags ogg || true)
|
||||
OGG_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs ogg || echo -logg)
|
||||
OGG_CFLAGS ?= $(shell pkg-config --silence-errors --cflags ogg || true)
|
||||
OGG_LIBS ?= $(shell pkg-config --silence-errors --libs ogg || echo -logg)
|
||||
endif
|
||||
CLIENT_CFLAGS += $(OGG_CFLAGS)
|
||||
CLIENT_LIBS += $(OGG_LIBS)
|
||||
|
|
@ -1214,8 +1201,8 @@ endif
|
|||
ifeq ($(USE_INTERNAL_ZLIB),1)
|
||||
ZLIB_CFLAGS = -DNO_GZIP -I$(ZDIR)
|
||||
else
|
||||
ZLIB_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags zlib || true)
|
||||
ZLIB_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs zlib || echo -lz)
|
||||
ZLIB_CFLAGS ?= $(shell pkg-config --silence-errors --cflags zlib || true)
|
||||
ZLIB_LIBS ?= $(shell pkg-config --silence-errors --libs zlib || echo -lz)
|
||||
endif
|
||||
BASE_CFLAGS += $(ZLIB_CFLAGS)
|
||||
LIBS += $(ZLIB_LIBS)
|
||||
|
|
@ -1226,15 +1213,15 @@ ifeq ($(USE_INTERNAL_JPEG),1)
|
|||
else
|
||||
# IJG libjpeg doesn't have pkg-config, but libjpeg-turbo uses libjpeg.pc;
|
||||
# we fall back to hard-coded answers if libjpeg.pc is unavailable
|
||||
JPEG_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags libjpeg || true)
|
||||
JPEG_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs libjpeg || echo -ljpeg)
|
||||
JPEG_CFLAGS ?= $(shell pkg-config --silence-errors --cflags libjpeg || true)
|
||||
JPEG_LIBS ?= $(shell pkg-config --silence-errors --libs libjpeg || echo -ljpeg)
|
||||
BASE_CFLAGS += $(JPEG_CFLAGS)
|
||||
RENDERER_LIBS += $(JPEG_LIBS)
|
||||
endif
|
||||
|
||||
ifeq ($(USE_FREETYPE),1)
|
||||
FREETYPE_CFLAGS ?= $(shell $(PKG_CONFIG) --silence-errors --cflags freetype2 || true)
|
||||
FREETYPE_LIBS ?= $(shell $(PKG_CONFIG) --silence-errors --libs freetype2 || echo -lfreetype)
|
||||
FREETYPE_CFLAGS ?= $(shell pkg-config --silence-errors --cflags freetype2 || true)
|
||||
FREETYPE_LIBS ?= $(shell pkg-config --silence-errors --libs freetype2 || echo -lfreetype)
|
||||
|
||||
BASE_CFLAGS += -DBUILD_FREETYPE $(FREETYPE_CFLAGS)
|
||||
RENDERER_LIBS += $(FREETYPE_LIBS)
|
||||
|
|
@ -1467,7 +1454,6 @@ targets: makedirs
|
|||
@echo " COMPILE_PLATFORM: $(COMPILE_PLATFORM)"
|
||||
@echo " COMPILE_ARCH: $(COMPILE_ARCH)"
|
||||
@echo " HAVE_VM_COMPILED: $(HAVE_VM_COMPILED)"
|
||||
@echo " PKG_CONFIG: $(PKG_CONFIG)"
|
||||
@echo " CC: $(CC)"
|
||||
ifeq ($(PLATFORM),mingw32)
|
||||
@echo " WINDRES: $(WINDRES)"
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
<img src="https://raw.githubusercontent.com/zturtleman/lilium-voyager/master/misc/lilium.png" width="64">
|
||||
|
||||
**Lilium Voyager** is a fork of [ioquake3](https://github.com/ioquake/ioq3) for running _Star Trek Voyager: Elite Force Holomatch_ (multiplayer). It is based on Thilo Schulz' [ioEF engine](http://thilo.kickchat.com/efport-progress/) (also known as iostvoyHM). The focus for Lilium Voyager is to maintain Elite Force multiplayer support on newer ioquake3 versions.
|
||||
**Lilium Voyager** is a fork of [ioquake3](https://github.com/ioquake/ioq3) for running _Star Trek Voyager: Elite Force_ multiplayer. It is based on Thilo Schulz' [ioEF engine](http://thilo.kickchat.com/efport-progress/) (also known as iostvoyHM). The focus for Lilium Voyager is to maintain Elite Force multiplayer support on newer ioquake3 versions.
|
||||
|
||||
Differences from ioEF 1.38-rc1 (2011):
|
||||
|
||||
* Player origin rounding is compatible with the original QVMs (x86, x86_64).
|
||||
* Player origin rounding is compatible with the original QVMs.
|
||||
* Fixed "read past end of server message" error after downloading a pk3 using EF 1.2 protocol (24).
|
||||
* Network compatible with ioEF 1.37.
|
||||
* Dedicated servers are listed on official Raven master server.
|
||||
|
|
@ -31,7 +31,7 @@ Additional make variables not in ioquake3:
|
|||
|
||||
## Discussion
|
||||
|
||||
* [Discord (Fragmint★Wonderland)](https://discord.gg/7J2pjGD)
|
||||
[Magical Clover Forum](https://forum.clover.moe). It supports creating an account or logging in using a GitHub account.
|
||||
|
||||
|
||||
## License
|
||||
|
|
@ -49,5 +49,6 @@ Lilium Voyager is licensed under [the GNU GPLv2](COPYING.txt) (or at your option
|
|||
|
||||
## Contributing
|
||||
|
||||
Please submit all patches as a GitHub pull request.
|
||||
Please submit all patches at the [Magical Clover Forum](https://forum.clover.moe)
|
||||
or as a GitHub pull request.
|
||||
|
||||
|
|
|
|||
|
|
@ -664,44 +664,6 @@ static void CG_Portal( centity_t *cent ) {
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
CG_CreateRotationMatrix
|
||||
================
|
||||
*/
|
||||
void CG_CreateRotationMatrix(vec3_t angles, vec3_t matrix[3]) {
|
||||
AngleVectors(angles, matrix[0], matrix[1], matrix[2]);
|
||||
VectorInverse(matrix[1]);
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
CG_TransposeMatrix
|
||||
================
|
||||
*/
|
||||
void CG_TransposeMatrix(vec3_t matrix[3], vec3_t transpose[3]) {
|
||||
int i, j;
|
||||
for (i = 0; i < 3; i++) {
|
||||
for (j = 0; j < 3; j++) {
|
||||
transpose[i][j] = matrix[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
CG_RotatePoint
|
||||
================
|
||||
*/
|
||||
void CG_RotatePoint(vec3_t point, vec3_t matrix[3]) {
|
||||
vec3_t tvec;
|
||||
|
||||
VectorCopy(point, tvec);
|
||||
point[0] = DotProduct(matrix[0], tvec);
|
||||
point[1] = DotProduct(matrix[1], tvec);
|
||||
point[2] = DotProduct(matrix[2], tvec);
|
||||
}
|
||||
|
||||
/*
|
||||
=========================
|
||||
CG_AdjustPositionForMover
|
||||
|
|
@ -713,8 +675,6 @@ void CG_AdjustPositionForMover(const vec3_t in, int moverNum, int fromTime, int
|
|||
centity_t *cent;
|
||||
vec3_t oldOrigin, origin, deltaOrigin;
|
||||
vec3_t oldAngles, angles, deltaAngles;
|
||||
vec3_t matrix[3], transpose[3];
|
||||
vec3_t org, org2, move2;
|
||||
|
||||
if ( moverNum <= 0 || moverNum >= ENTITYNUM_MAX_NORMAL ) {
|
||||
VectorCopy( in, out );
|
||||
|
|
@ -738,17 +698,9 @@ void CG_AdjustPositionForMover(const vec3_t in, int moverNum, int fromTime, int
|
|||
VectorSubtract( origin, oldOrigin, deltaOrigin );
|
||||
VectorSubtract( angles, oldAngles, deltaAngles );
|
||||
|
||||
// origin change when on a rotating object
|
||||
CG_CreateRotationMatrix( deltaAngles, transpose );
|
||||
CG_TransposeMatrix( transpose, matrix );
|
||||
VectorSubtract( in, oldOrigin, org );
|
||||
VectorCopy( org, org2 );
|
||||
CG_RotatePoint( org2, matrix );
|
||||
VectorSubtract( org2, org, move2 );
|
||||
VectorAdd( deltaOrigin, move2, deltaOrigin );
|
||||
|
||||
VectorAdd( in, deltaOrigin, out );
|
||||
VectorAdd( angles_in, deltaAngles, angles_out );
|
||||
// FIXME: origin change when on a rotating object
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ void CG_SelectNextPlayer( void ) {
|
|||
|
||||
void CG_SelectPrevPlayer( void ) {
|
||||
CG_CheckOrderPending();
|
||||
if (cg_currentSelectedPlayer.integer > 0 && cg_currentSelectedPlayer.integer <= numSortedTeamPlayers) {
|
||||
if (cg_currentSelectedPlayer.integer > 0 && cg_currentSelectedPlayer.integer < numSortedTeamPlayers) {
|
||||
cg_currentSelectedPlayer.integer--;
|
||||
} else {
|
||||
cg_currentSelectedPlayer.integer = numSortedTeamPlayers;
|
||||
|
|
|
|||
|
|
@ -71,7 +71,6 @@ can then be moved around
|
|||
void CG_TestModel_f (void) {
|
||||
vec3_t angles;
|
||||
|
||||
cg.testGun = qfalse;
|
||||
memset( &cg.testModelEntity, 0, sizeof(cg.testModelEntity) );
|
||||
if ( trap_Argc() < 2 ) {
|
||||
return;
|
||||
|
|
@ -97,6 +96,7 @@ void CG_TestModel_f (void) {
|
|||
angles[ROLL] = 0;
|
||||
|
||||
AnglesToAxis( angles, cg.testModelEntity.axis );
|
||||
cg.testGun = qfalse;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -108,11 +108,6 @@ Replaces the current view weapon with the given model
|
|||
*/
|
||||
void CG_TestGun_f (void) {
|
||||
CG_TestModel_f();
|
||||
|
||||
if ( !cg.testModelEntity.hModel ) {
|
||||
return;
|
||||
}
|
||||
|
||||
cg.testGun = qtrue;
|
||||
cg.testModelEntity.renderfx = RF_MINLIGHT | RF_DEPTHHACK | RF_FIRST_PERSON;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -825,7 +825,6 @@ to be configured even if they don't have defined names.
|
|||
*/
|
||||
int Key_StringToKeynum( char *str ) {
|
||||
keyname_t *kn;
|
||||
int n;
|
||||
|
||||
if ( !str || !str[0] ) {
|
||||
return -1;
|
||||
|
|
@ -835,9 +834,12 @@ int Key_StringToKeynum( char *str ) {
|
|||
}
|
||||
|
||||
// check for hex code
|
||||
n = Com_HexStrToInt( str );
|
||||
if ( n >= 0 && n < MAX_KEYS ) {
|
||||
return n;
|
||||
if ( strlen( str ) == 4 ) {
|
||||
int n = Com_HexStrToInt( str );
|
||||
|
||||
if ( n >= 0 ) {
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
// scan for a text match
|
||||
|
|
|
|||
|
|
@ -3186,10 +3186,8 @@ static __attribute__ ((format (printf, 2, 3))) void QDECL CL_RefPrintf( int prin
|
|||
Com_Printf ("%s", msg);
|
||||
} else if ( print_level == PRINT_WARNING ) {
|
||||
Com_Printf (S_COLOR_YELLOW "%s", msg); // yellow
|
||||
} else if ( print_level == PRINT_ERROR ) {
|
||||
Com_Printf (S_COLOR_RED "%s", msg); // red
|
||||
} else if ( print_level == PRINT_DEVELOPER ) {
|
||||
Com_DPrintf (S_COLOR_RED "%s", msg); // red - developer only
|
||||
Com_DPrintf (S_COLOR_RED "%s", msg); // red
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ void S_Base_SoundInfo(void) {
|
|||
if (!s_soundStarted) {
|
||||
Com_Printf ("sound system not started\n");
|
||||
} else {
|
||||
Com_Printf("%5d channels\n", dma.channels);
|
||||
Com_Printf("%5d stereo\n", dma.channels - 1);
|
||||
Com_Printf("%5d samples\n", dma.samples);
|
||||
Com_Printf("%5d samplebits (%s)\n", dma.samplebits, dma.isfloat ? "float" : "int");
|
||||
Com_Printf("%5d submission_chunk\n", dma.submission_chunk);
|
||||
|
|
@ -1256,6 +1256,9 @@ void S_GetSoundtime(void)
|
|||
int samplepos;
|
||||
static int buffers;
|
||||
static int oldsamplepos;
|
||||
int fullsamples;
|
||||
|
||||
fullsamples = dma.samples / dma.channels;
|
||||
|
||||
if( CL_VideoRecording( ) )
|
||||
{
|
||||
|
|
@ -1279,13 +1282,13 @@ void S_GetSoundtime(void)
|
|||
if (s_paintedtime > 0x40000000)
|
||||
{ // time to chop things off to avoid 32 bit limits
|
||||
buffers = 0;
|
||||
s_paintedtime = dma.fullsamples;
|
||||
s_paintedtime = fullsamples;
|
||||
S_Base_StopAllSounds ();
|
||||
}
|
||||
}
|
||||
oldsamplepos = samplepos;
|
||||
|
||||
s_soundtime = buffers*dma.fullsamples + samplepos/dma.channels;
|
||||
s_soundtime = buffers*fullsamples + samplepos/dma.channels;
|
||||
|
||||
#if 0
|
||||
// check to make sure that we haven't overshot
|
||||
|
|
@ -1306,6 +1309,7 @@ void S_GetSoundtime(void)
|
|||
|
||||
void S_Update_(void) {
|
||||
unsigned endtime;
|
||||
int samps;
|
||||
static float lastTime = 0.0f;
|
||||
float ma, op;
|
||||
float thisTime, sane;
|
||||
|
|
@ -1349,8 +1353,9 @@ void S_Update_(void) {
|
|||
& ~(dma.submission_chunk-1);
|
||||
|
||||
// never mix more than the complete buffer
|
||||
if (endtime - s_soundtime > dma.fullsamples)
|
||||
endtime = s_soundtime + dma.fullsamples;
|
||||
samps = dma.samples >> (dma.channels-1);
|
||||
if (endtime - s_soundtime > samps)
|
||||
endtime = s_soundtime + samps;
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -65,7 +65,6 @@ typedef struct sfx_s {
|
|||
typedef struct {
|
||||
int channels;
|
||||
int samples; // mono samples in buffer
|
||||
int fullsamples; // samples with all channels in buffer (samples divided by channels)
|
||||
int submission_chunk; // don't mix less than this #
|
||||
int samplebits;
|
||||
int isfloat;
|
||||
|
|
|
|||
|
|
@ -119,24 +119,24 @@ void S_TransferStereo16 (unsigned long *pbuf, int endtime)
|
|||
while (ls_paintedtime < endtime)
|
||||
{
|
||||
// handle recirculating buffer issues
|
||||
lpos = ls_paintedtime % dma.fullsamples;
|
||||
lpos = ls_paintedtime & ((dma.samples>>1)-1);
|
||||
|
||||
snd_out = (short *) pbuf + (lpos<<1); // lpos * dma.channels
|
||||
snd_out = (short *) pbuf + (lpos<<1);
|
||||
|
||||
snd_linear_count = dma.fullsamples - lpos;
|
||||
snd_linear_count = (dma.samples>>1) - lpos;
|
||||
if (ls_paintedtime + snd_linear_count > endtime)
|
||||
snd_linear_count = endtime - ls_paintedtime;
|
||||
|
||||
snd_linear_count <<= 1; // snd_linear_count *= dma.channels
|
||||
snd_linear_count <<= 1;
|
||||
|
||||
// write a linear blast of samples
|
||||
S_WriteLinearBlastStereo16 ();
|
||||
|
||||
snd_p += snd_linear_count;
|
||||
ls_paintedtime += (snd_linear_count>>1); // snd_linear_count / dma.channels
|
||||
ls_paintedtime += (snd_linear_count>>1);
|
||||
|
||||
if( CL_VideoRecording( ) )
|
||||
CL_WriteAVIAudioFrame( (byte *)snd_out, snd_linear_count << 1 ); // snd_linear_count * (dma.samplebits/8)
|
||||
CL_WriteAVIAudioFrame( (byte *)snd_out, snd_linear_count << 1 );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -150,16 +150,18 @@ void S_TransferPaintBuffer(int endtime)
|
|||
{
|
||||
int out_idx;
|
||||
int count;
|
||||
int out_mask;
|
||||
int *p;
|
||||
int step;
|
||||
int val;
|
||||
int i;
|
||||
unsigned long *pbuf;
|
||||
|
||||
pbuf = (unsigned long *)dma.buffer;
|
||||
|
||||
|
||||
if ( s_testsound->integer ) {
|
||||
int i;
|
||||
|
||||
// write a fixed sine wave
|
||||
count = (endtime - s_paintedtime);
|
||||
for (i=0 ; i<count ; i++)
|
||||
|
|
@ -175,73 +177,53 @@ void S_TransferPaintBuffer(int endtime)
|
|||
{ // general case
|
||||
p = (int *) paintbuffer;
|
||||
count = (endtime - s_paintedtime) * dma.channels;
|
||||
out_idx = (s_paintedtime * dma.channels) % dma.samples;
|
||||
step = 3 - MIN(dma.channels, 2);
|
||||
out_mask = dma.samples - 1;
|
||||
out_idx = s_paintedtime * dma.channels & out_mask;
|
||||
step = 3 - dma.channels;
|
||||
|
||||
if ((dma.isfloat) && (dma.samplebits == 32))
|
||||
{
|
||||
float *out = (float *) pbuf;
|
||||
for (i=0 ; i<count ; i++)
|
||||
while (count--)
|
||||
{
|
||||
if ((i % dma.channels) >= 2)
|
||||
{
|
||||
val = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
val = *p >> 8;
|
||||
p+= step;
|
||||
}
|
||||
val = *p >> 8;
|
||||
p+= step;
|
||||
if (val > 0x7fff)
|
||||
val = 0x7fff;
|
||||
else if (val < -32767) /* clamp to one less than max to make division max out at -1.0f. */
|
||||
val = -32767;
|
||||
out[out_idx] = ((float) val) / 32767.0f;
|
||||
out_idx = (out_idx + 1) % dma.samples;
|
||||
out_idx = (out_idx + 1) & out_mask;
|
||||
}
|
||||
}
|
||||
else if (dma.samplebits == 16)
|
||||
{
|
||||
short *out = (short *) pbuf;
|
||||
for (i=0 ; i<count ; i++)
|
||||
while (count--)
|
||||
{
|
||||
if ((i % dma.channels) >= 2)
|
||||
{
|
||||
val = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
val = *p >> 8;
|
||||
p+= step;
|
||||
}
|
||||
val = *p >> 8;
|
||||
p+= step;
|
||||
if (val > 0x7fff)
|
||||
val = 0x7fff;
|
||||
else if (val < -32768)
|
||||
val = -32768;
|
||||
out[out_idx] = val;
|
||||
out_idx = (out_idx + 1) % dma.samples;
|
||||
out_idx = (out_idx + 1) & out_mask;
|
||||
}
|
||||
}
|
||||
else if (dma.samplebits == 8)
|
||||
{
|
||||
unsigned char *out = (unsigned char *) pbuf;
|
||||
for (i=0 ; i<count ; i++)
|
||||
while (count--)
|
||||
{
|
||||
if ((i % dma.channels) >= 2)
|
||||
{
|
||||
val = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
val = *p >> 8;
|
||||
p+= step;
|
||||
}
|
||||
val = *p >> 8;
|
||||
p+= step;
|
||||
if (val > 0x7fff)
|
||||
val = 0x7fff;
|
||||
else if (val < -32768)
|
||||
val = -32768;
|
||||
out[out_idx] = (val>>8) + 128;
|
||||
out_idx = (out_idx + 1) % dma.samples;
|
||||
out_idx = (out_idx + 1) & out_mask;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5346,33 +5346,7 @@ void BotSetEntityNumForGoal(bot_goal_t *goal, char *classname) {
|
|||
if ( !ent->inuse ) {
|
||||
continue;
|
||||
}
|
||||
if ( Q_stricmp(ent->classname, classname) != 0 ) {
|
||||
continue;
|
||||
}
|
||||
VectorSubtract(goal->origin, ent->s.origin, dir);
|
||||
if (VectorLengthSquared(dir) < Square(10)) {
|
||||
goal->entitynum = i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
BotSetEntityNumForGoalWithActivator
|
||||
==================
|
||||
*/
|
||||
void BotSetEntityNumForGoalWithActivator(bot_goal_t *goal, char *classname) {
|
||||
gentity_t *ent;
|
||||
int i;
|
||||
vec3_t dir;
|
||||
|
||||
ent = &g_entities[0];
|
||||
for (i = 0; i < level.num_entities; i++, ent++) {
|
||||
if ( !ent->inuse || !ent->activator ) {
|
||||
continue;
|
||||
}
|
||||
if ( Q_stricmp(ent->activator->classname, classname) != 0 ) {
|
||||
if ( !Q_stricmp(ent->classname, classname) ) {
|
||||
continue;
|
||||
}
|
||||
VectorSubtract(goal->origin, ent->s.origin, dir);
|
||||
|
|
@ -5453,21 +5427,21 @@ void BotSetupDeathmatchAI(void) {
|
|||
else if (gametype == GT_OBELISK) {
|
||||
if (trap_BotGetLevelItemGoal(-1, "Red Obelisk", &redobelisk) < 0)
|
||||
BotAI_Print(PRT_WARNING, "Overload without Red Obelisk\n");
|
||||
BotSetEntityNumForGoalWithActivator(&redobelisk, "team_redobelisk");
|
||||
BotSetEntityNumForGoal(&redobelisk, "team_redobelisk");
|
||||
if (trap_BotGetLevelItemGoal(-1, "Blue Obelisk", &blueobelisk) < 0)
|
||||
BotAI_Print(PRT_WARNING, "Overload without Blue Obelisk\n");
|
||||
BotSetEntityNumForGoalWithActivator(&blueobelisk, "team_blueobelisk");
|
||||
BotSetEntityNumForGoal(&blueobelisk, "team_blueobelisk");
|
||||
}
|
||||
else if (gametype == GT_HARVESTER) {
|
||||
if (trap_BotGetLevelItemGoal(-1, "Red Obelisk", &redobelisk) < 0)
|
||||
BotAI_Print(PRT_WARNING, "Harvester without Red Obelisk\n");
|
||||
BotSetEntityNumForGoalWithActivator(&redobelisk, "team_redobelisk");
|
||||
BotSetEntityNumForGoal(&redobelisk, "team_redobelisk");
|
||||
if (trap_BotGetLevelItemGoal(-1, "Blue Obelisk", &blueobelisk) < 0)
|
||||
BotAI_Print(PRT_WARNING, "Harvester without Blue Obelisk\n");
|
||||
BotSetEntityNumForGoalWithActivator(&blueobelisk, "team_blueobelisk");
|
||||
BotSetEntityNumForGoal(&blueobelisk, "team_blueobelisk");
|
||||
if (trap_BotGetLevelItemGoal(-1, "Neutral Obelisk", &neutralobelisk) < 0)
|
||||
BotAI_Print(PRT_WARNING, "Harvester without Neutral Obelisk\n");
|
||||
BotSetEntityNumForGoalWithActivator(&neutralobelisk, "team_neutralobelisk");
|
||||
BotSetEntityNumForGoal(&neutralobelisk, "team_neutralobelisk");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -88,7 +88,6 @@ MULTIPLAYER MENU (SERVER BROWSER)
|
|||
#define UIAS_GLOBAL4 5
|
||||
#define UIAS_GLOBAL5 6
|
||||
#define UIAS_FAVORITES 7
|
||||
#define UIAS_NUM_SOURCES 8
|
||||
|
||||
#define UI_MAX_MASTER_SERVERS 6
|
||||
|
||||
|
|
@ -97,14 +96,12 @@ MULTIPLAYER MENU (SERVER BROWSER)
|
|||
#define SORT_CLIENTS 2
|
||||
#define SORT_GAME 3
|
||||
#define SORT_PING 4
|
||||
#define SORT_NUM_SORTS 5
|
||||
|
||||
#define GAMES_ALL 0
|
||||
#define GAMES_FFA 1
|
||||
#define GAMES_TEAMPLAY 2
|
||||
#define GAMES_TOURNEY 3
|
||||
#define GAMES_CTF 4
|
||||
#define GAMES_NUM_GAMES 5
|
||||
|
||||
static const char *master_items[] = {
|
||||
"Local",
|
||||
|
|
@ -1107,7 +1104,7 @@ int ArenaServers_SetType( int type )
|
|||
char masterstr[2], cvarname[sizeof("sv_master1")];
|
||||
int direction;
|
||||
|
||||
if (type == g_servertype || type == ((g_servertype+1) % UIAS_NUM_SOURCES)) {
|
||||
if (type == g_servertype || type == ((g_servertype+1) % (ARRAY_LEN(master_items)-1))) {
|
||||
direction = 1;
|
||||
} else {
|
||||
direction = -1;
|
||||
|
|
@ -1588,12 +1585,12 @@ static void ArenaServers_MenuInit( void ) {
|
|||
|
||||
ArenaServers_LoadFavorites();
|
||||
|
||||
g_arenaservers.master.curvalue = g_servertype = Com_Clamp( 0, UIAS_NUM_SOURCES-1, ui_browserMaster.integer );
|
||||
g_arenaservers.master.curvalue = g_servertype = Com_Clamp( 0, 6, ui_browserMaster.integer );
|
||||
|
||||
g_gametype = Com_Clamp( 0, GAMES_NUM_GAMES-1, ui_browserGameType.integer );
|
||||
g_gametype = Com_Clamp( 0, 4, ui_browserGameType.integer );
|
||||
g_arenaservers.gametype.curvalue = g_gametype;
|
||||
|
||||
g_sortkey = Com_Clamp( 0, SORT_NUM_SORTS-1, ui_browserSortKey.integer );
|
||||
g_sortkey = Com_Clamp( 0, 4, ui_browserSortKey.integer );
|
||||
g_arenaservers.sortkey.curvalue = g_sortkey;
|
||||
|
||||
g_fullservers = Com_Clamp( 0, 1, ui_browserShowFull.integer );
|
||||
|
|
|
|||
|
|
@ -358,7 +358,6 @@ static int resToRatio[ MAX_RESOLUTIONS ];
|
|||
|
||||
static char resbuf[ MAX_STRING_CHARS ];
|
||||
static const char* detectedResolutions[ MAX_RESOLUTIONS ];
|
||||
static char currentResolution[ 20 ];
|
||||
|
||||
static const char** resolutions = builtinResolutions;
|
||||
static qboolean resolutionsDetected = qfalse;
|
||||
|
|
@ -488,7 +487,7 @@ GraphicsOptions_GetResolutions
|
|||
*/
|
||||
static void GraphicsOptions_GetResolutions( void )
|
||||
{
|
||||
trap_Cvar_VariableStringBuffer("r_availableModes", resbuf, sizeof(resbuf));
|
||||
Q_strncpyz(resbuf, UI_Cvar_VariableString("r_availableModes"), sizeof(resbuf));
|
||||
if(*resbuf)
|
||||
{
|
||||
char* s = resbuf;
|
||||
|
|
@ -502,26 +501,11 @@ static void GraphicsOptions_GetResolutions( void )
|
|||
}
|
||||
detectedResolutions[ i ] = NULL;
|
||||
|
||||
// add custom resolution if not in mode list
|
||||
if ( i < ARRAY_LEN(detectedResolutions)-1 )
|
||||
if( i > 0 )
|
||||
{
|
||||
Com_sprintf( currentResolution, sizeof ( currentResolution ), "%dx%d", uis.glconfig.vidWidth, uis.glconfig.vidHeight );
|
||||
|
||||
for( i = 0; detectedResolutions[ i ]; i++ )
|
||||
{
|
||||
if ( strcmp( detectedResolutions[ i ], currentResolution ) == 0 )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( detectedResolutions[ i ] == NULL )
|
||||
{
|
||||
detectedResolutions[ i++ ] = currentResolution;
|
||||
detectedResolutions[ i ] = NULL;
|
||||
}
|
||||
resolutions = detectedResolutions;
|
||||
resolutionsDetected = qtrue;
|
||||
}
|
||||
|
||||
resolutions = detectedResolutions;
|
||||
resolutionsDetected = qtrue;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,28 +23,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
// q_shared.c -- stateless support routines that are included in each code dll
|
||||
#include "q_shared.h"
|
||||
|
||||
// ^[0-9a-zA-Z]
|
||||
qboolean Q_IsColorString(const char *p) {
|
||||
if (!p)
|
||||
return qfalse;
|
||||
|
||||
if (p[0] != Q_COLOR_ESCAPE)
|
||||
return qfalse;
|
||||
|
||||
if (p[1] == 0)
|
||||
return qfalse;
|
||||
|
||||
// isalnum expects a signed integer in the range -1 (EOF) to 255, or it might assert on undefined behaviour
|
||||
// a dereferenced char pointer has the range -128 to 127, so we just need to rangecheck the negative part
|
||||
if (p[1] < 0)
|
||||
return qfalse;
|
||||
|
||||
if (isalnum(p[1]) == 0)
|
||||
return qfalse;
|
||||
|
||||
return qtrue;
|
||||
}
|
||||
|
||||
float Com_Clamp( float min, float max, float value ) {
|
||||
if ( value < min ) {
|
||||
return min;
|
||||
|
|
|
|||
|
|
@ -409,8 +409,6 @@ typedef vec_t vec3_t[3];
|
|||
typedef vec_t vec4_t[4];
|
||||
typedef vec_t vec5_t[5];
|
||||
|
||||
typedef vec_t quat_t[4];
|
||||
|
||||
typedef int fixed4_t;
|
||||
typedef int fixed8_t;
|
||||
typedef int fixed16_t;
|
||||
|
|
@ -452,7 +450,7 @@ extern vec4_t colorMdGrey;
|
|||
extern vec4_t colorDkGrey;
|
||||
|
||||
#define Q_COLOR_ESCAPE '^'
|
||||
qboolean Q_IsColorString(const char *p); // ^[0-9a-zA-Z]
|
||||
#define Q_IsColorString(p) ((p) && *(p) == Q_COLOR_ESCAPE && *((p)+1) && isalnum(*((p)+1))) // ^[0-9a-zA-Z]
|
||||
|
||||
#define COLOR_BLACK '0'
|
||||
#define COLOR_RED '1'
|
||||
|
|
@ -621,8 +619,6 @@ typedef struct {
|
|||
|
||||
#define Byte4Copy(a,b) ((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
|
||||
|
||||
#define QuatCopy(a,b) ((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
|
||||
|
||||
#define SnapVector(v) {v[0]=((int)(v[0]));v[1]=((int)(v[1]));v[2]=((int)(v[2]));}
|
||||
// just in case you don't want to use the macros
|
||||
vec_t _DotProduct( const vec3_t v1, const vec3_t v2 );
|
||||
|
|
|
|||
|
|
@ -45,22 +45,27 @@ extern void (APIENTRYP qglUnlockArraysEXT) (void);
|
|||
// GL function loader, based on https://gist.github.com/rygorous/16796a0c876cf8a5f542caddb55bce8a
|
||||
// get missing functions from code/SDL2/include/SDL_opengl.h
|
||||
|
||||
// OpenGL 1.0/1.1, OpenGL ES 1.0, and OpenGL 3.2 core profile
|
||||
// OpenGL 1.0/1.1 and OpenGL ES 1.0
|
||||
#define QGL_1_1_PROCS \
|
||||
GLE(void, AlphaFunc, GLenum func, GLclampf ref) \
|
||||
GLE(void, BindTexture, GLenum target, GLuint texture) \
|
||||
GLE(void, BlendFunc, GLenum sfactor, GLenum dfactor) \
|
||||
GLE(void, ClearColor, GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) \
|
||||
GLE(void, Clear, GLbitfield mask) \
|
||||
GLE(void, ClearStencil, GLint s) \
|
||||
GLE(void, Color4f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) \
|
||||
GLE(void, ColorMask, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) \
|
||||
GLE(void, ColorPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) \
|
||||
GLE(void, CopyTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) \
|
||||
GLE(void, CullFace, GLenum mode) \
|
||||
GLE(void, DeleteTextures, GLsizei n, const GLuint *textures) \
|
||||
GLE(void, DepthFunc, GLenum func) \
|
||||
GLE(void, DepthMask, GLboolean flag) \
|
||||
GLE(void, DisableClientState, GLenum cap) \
|
||||
GLE(void, Disable, GLenum cap) \
|
||||
GLE(void, DrawArrays, GLenum mode, GLint first, GLsizei count) \
|
||||
GLE(void, DrawElements, GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) \
|
||||
GLE(void, EnableClientState, GLenum cap) \
|
||||
GLE(void, Enable, GLenum cap) \
|
||||
GLE(void, Finish, void) \
|
||||
GLE(void, Flush, void) \
|
||||
|
|
@ -70,67 +75,53 @@ extern void (APIENTRYP qglUnlockArraysEXT) (void);
|
|||
GLE(void, GetIntegerv, GLenum pname, GLint *params) \
|
||||
GLE(const GLubyte *, GetString, GLenum name) \
|
||||
GLE(void, LineWidth, GLfloat width) \
|
||||
GLE(void, LoadIdentity, void) \
|
||||
GLE(void, LoadMatrixf, const GLfloat *m) \
|
||||
GLE(void, MatrixMode, GLenum mode) \
|
||||
GLE(void, PolygonOffset, GLfloat factor, GLfloat units) \
|
||||
GLE(void, PopMatrix, void) \
|
||||
GLE(void, PushMatrix, void) \
|
||||
GLE(void, ReadPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) \
|
||||
GLE(void, Scissor, GLint x, GLint y, GLsizei width, GLsizei height) \
|
||||
GLE(void, ShadeModel, GLenum mode) \
|
||||
GLE(void, StencilFunc, GLenum func, GLint ref, GLuint mask) \
|
||||
GLE(void, StencilMask, GLuint mask) \
|
||||
GLE(void, StencilOp, GLenum fail, GLenum zfail, GLenum zpass) \
|
||||
GLE(void, TexCoordPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) \
|
||||
GLE(void, TexEnvf, GLenum target, GLenum pname, GLfloat param) \
|
||||
GLE(void, TexImage2D, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) \
|
||||
GLE(void, TexParameterf, GLenum target, GLenum pname, GLfloat param) \
|
||||
GLE(void, TexParameteri, GLenum target, GLenum pname, GLint param) \
|
||||
GLE(void, TexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) \
|
||||
GLE(void, Translatef, GLfloat x, GLfloat y, GLfloat z) \
|
||||
GLE(void, VertexPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) \
|
||||
GLE(void, Viewport, GLint x, GLint y, GLsizei width, GLsizei height) \
|
||||
|
||||
// OpenGL 1.0/1.1 and OpenGL ES 1.x but not OpenGL 3.2 core profile
|
||||
#define QGL_1_1_FIXED_FUNCTION_PROCS \
|
||||
GLE(void, AlphaFunc, GLenum func, GLclampf ref) \
|
||||
GLE(void, Color4f, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) \
|
||||
GLE(void, ColorPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) \
|
||||
GLE(void, DisableClientState, GLenum cap) \
|
||||
GLE(void, EnableClientState, GLenum cap) \
|
||||
GLE(void, LoadIdentity, void) \
|
||||
GLE(void, LoadMatrixf, const GLfloat *m) \
|
||||
GLE(void, MatrixMode, GLenum mode) \
|
||||
GLE(void, PopMatrix, void) \
|
||||
GLE(void, PushMatrix, void) \
|
||||
GLE(void, ShadeModel, GLenum mode) \
|
||||
GLE(void, TexCoordPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) \
|
||||
GLE(void, TexEnvf, GLenum target, GLenum pname, GLfloat param) \
|
||||
GLE(void, VertexPointer, GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) \
|
||||
|
||||
// OpenGL 1.0/1.1 and 3.2 core profile but not OpenGL ES 1.x
|
||||
// OpenGL 1.0/1.1 but not OpenGL ES 1.x
|
||||
#define QGL_DESKTOP_1_1_PROCS \
|
||||
GLE(void, ClearDepth, GLclampd depth) \
|
||||
GLE(void, DepthRange, GLclampd near_val, GLclampd far_val) \
|
||||
GLE(void, DrawBuffer, GLenum mode) \
|
||||
GLE(void, PolygonMode, GLenum face, GLenum mode) \
|
||||
|
||||
// OpenGL 1.0/1.1 but not OpenGL 3.2 core profile or OpenGL ES 1.x
|
||||
#define QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS \
|
||||
GLE(void, ArrayElement, GLint i) \
|
||||
GLE(void, Begin, GLenum mode) \
|
||||
GLE(void, ClearDepth, GLclampd depth) \
|
||||
GLE(void, ClipPlane, GLenum plane, const GLdouble *equation) \
|
||||
GLE(void, Color3f, GLfloat red, GLfloat green, GLfloat blue) \
|
||||
GLE(void, Color4ubv, const GLubyte *v) \
|
||||
GLE(void, DepthRange, GLclampd near_val, GLclampd far_val) \
|
||||
GLE(void, DrawBuffer, GLenum mode) \
|
||||
GLE(void, End, void) \
|
||||
GLE(void, Frustum, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) \
|
||||
GLE(void, Ortho, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) \
|
||||
GLE(void, PolygonMode, GLenum face, GLenum mode) \
|
||||
GLE(void, TexCoord2f, GLfloat s, GLfloat t) \
|
||||
GLE(void, TexCoord2fv, const GLfloat *v) \
|
||||
GLE(void, Vertex2f, GLfloat x, GLfloat y) \
|
||||
GLE(void, Vertex3f, GLfloat x, GLfloat y, GLfloat z) \
|
||||
GLE(void, Vertex3fv, const GLfloat *v) \
|
||||
|
||||
// OpenGL ES 1.1 and OpenGL ES 2.0 but not desktop OpenGL 1.x
|
||||
// OpenGL ES 1.1 but not desktop OpenGL 1.x
|
||||
#define QGL_ES_1_1_PROCS \
|
||||
GLE(void, ClearDepthf, GLclampf depth) \
|
||||
GLE(void, DepthRangef, GLclampf near_val, GLclampf far_val) \
|
||||
|
||||
// OpenGL ES 1.1 but not OpenGL ES 2.0 or desktop OpenGL 1.x
|
||||
#define QGL_ES_1_1_FIXED_FUNCTION_PROCS \
|
||||
GLE(void, ClipPlanef, GLenum plane, const GLfloat *equation) \
|
||||
GLE(void, DepthRangef, GLclampf near_val, GLclampf far_val) \
|
||||
GLE(void, Frustumf, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near_val, GLfloat far_val) \
|
||||
GLE(void, Orthof, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near_val, GLfloat far_val) \
|
||||
|
||||
|
|
@ -140,17 +131,14 @@ extern void (APIENTRYP qglUnlockArraysEXT) (void);
|
|||
GLE(void, CompressedTexImage2D, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) \
|
||||
GLE(void, CompressedTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) \
|
||||
|
||||
// GL_ARB_occlusion_query, built-in to OpenGL 1.5 but not OpenGL ES 2.0
|
||||
#define QGL_ARB_occlusion_query_PROCS \
|
||||
// OpenGL 1.5, was GL_ARB_vertex_buffer_object and GL_ARB_occlusion_query
|
||||
#define QGL_1_5_PROCS \
|
||||
GLE(void, GenQueries, GLsizei n, GLuint *ids) \
|
||||
GLE(void, DeleteQueries, GLsizei n, const GLuint *ids) \
|
||||
GLE(void, BeginQuery, GLenum target, GLuint id) \
|
||||
GLE(void, EndQuery, GLenum target) \
|
||||
GLE(void, GetQueryObjectiv, GLuint id, GLenum pname, GLint *params) \
|
||||
GLE(void, GetQueryObjectuiv, GLuint id, GLenum pname, GLuint *params) \
|
||||
|
||||
// OpenGL 1.5, was GL_ARB_vertex_buffer_object
|
||||
#define QGL_1_5_PROCS \
|
||||
GLE(void, BindBuffer, GLenum target, GLuint buffer) \
|
||||
GLE(void, DeleteBuffers, GLsizei n, const GLuint *buffers) \
|
||||
GLE(void, GenBuffers, GLsizei n, GLuint *buffers) \
|
||||
|
|
@ -313,18 +301,14 @@ extern void (APIENTRYP qglUnlockArraysEXT) (void);
|
|||
GLE(GLvoid, NamedFramebufferTexture2DEXT, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) \
|
||||
GLE(GLvoid, NamedFramebufferRenderbufferEXT, GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) \
|
||||
|
||||
#define GLE(ret, name, ...) typedef ret APIENTRY name##proc(__VA_ARGS__);
|
||||
#define GLE(ret, name, ...) typedef ret APIENTRY name##proc(__VA_ARGS__); extern name##proc * qgl##name;
|
||||
QGL_1_1_PROCS;
|
||||
QGL_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_ES_1_1_PROCS;
|
||||
QGL_ES_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
QGL_3_0_PROCS;
|
||||
QGL_ARB_occlusion_query_PROCS;
|
||||
QGL_ARB_framebuffer_object_PROCS;
|
||||
QGL_ARB_vertex_array_object_PROCS;
|
||||
QGL_EXT_direct_state_access_PROCS;
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ IMPLEMENTATION SPECIFIC FUNCTIONS
|
|||
====================================================================
|
||||
*/
|
||||
|
||||
void GLimp_Init( qboolean fixedFunction );
|
||||
void GLimp_Init( qboolean );
|
||||
void GLimp_Shutdown( void );
|
||||
void GLimp_EndFrame( void );
|
||||
|
||||
|
|
|
|||
|
|
@ -766,9 +766,25 @@ void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *
|
|||
ri.Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
|
||||
}
|
||||
|
||||
RE_UploadCinematic (w, h, cols, rows, data, client, dirty);
|
||||
GL_Bind( tr.scratchImage[client] );
|
||||
|
||||
// if the scratchImage isn't in the format we want, specify it as a new texture
|
||||
if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
|
||||
tr.scratchImage[client]->width = tr.scratchImage[client]->uploadWidth = cols;
|
||||
tr.scratchImage[client]->height = tr.scratchImage[client]->uploadHeight = rows;
|
||||
qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
|
||||
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
|
||||
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
|
||||
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
|
||||
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
|
||||
} else {
|
||||
if (dirty) {
|
||||
// otherwise, just subimage upload it so that drivers can tell we are going to be changing
|
||||
// it and don't try and do a texture compression
|
||||
qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
|
||||
}
|
||||
}
|
||||
|
||||
if ( r_speeds->integer ) {
|
||||
end = ri.Milliseconds();
|
||||
ri.Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
|
||||
|
|
|
|||
|
|
@ -206,6 +206,7 @@ void R_ImageList_f( void ) {
|
|||
estSize *= 4;
|
||||
break;
|
||||
case GL_LUMINANCE8:
|
||||
case GL_LUMINANCE16:
|
||||
case GL_LUMINANCE:
|
||||
format = "L ";
|
||||
// 1 byte per pixel?
|
||||
|
|
@ -218,6 +219,7 @@ void R_ImageList_f( void ) {
|
|||
estSize *= 3;
|
||||
break;
|
||||
case GL_LUMINANCE8_ALPHA8:
|
||||
case GL_LUMINANCE16_ALPHA16:
|
||||
case GL_LUMINANCE_ALPHA:
|
||||
format = "LA ";
|
||||
// 2 bytes per pixel?
|
||||
|
|
@ -682,8 +684,10 @@ static void Upload32( unsigned *data,
|
|||
{
|
||||
if(r_greyscale->integer)
|
||||
{
|
||||
if(r_texturebits->integer == 16 || r_texturebits->integer == 32)
|
||||
if(r_texturebits->integer == 16)
|
||||
internalFormat = GL_LUMINANCE8;
|
||||
else if(r_texturebits->integer == 32)
|
||||
internalFormat = GL_LUMINANCE16;
|
||||
else
|
||||
internalFormat = GL_LUMINANCE;
|
||||
}
|
||||
|
|
@ -715,8 +719,10 @@ static void Upload32( unsigned *data,
|
|||
{
|
||||
if(r_greyscale->integer)
|
||||
{
|
||||
if(r_texturebits->integer == 16 || r_texturebits->integer == 32)
|
||||
if(r_texturebits->integer == 16)
|
||||
internalFormat = GL_LUMINANCE8_ALPHA8;
|
||||
else if(r_texturebits->integer == 32)
|
||||
internalFormat = GL_LUMINANCE16_ALPHA16;
|
||||
else
|
||||
internalFormat = GL_LUMINANCE_ALPHA;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -181,6 +181,8 @@ int max_polyverts;
|
|||
*/
|
||||
static void InitOpenGL( void )
|
||||
{
|
||||
char renderer_buffer[1024];
|
||||
|
||||
//
|
||||
// initialize OS specific portions of the renderer
|
||||
//
|
||||
|
|
@ -196,12 +198,15 @@ static void InitOpenGL( void )
|
|||
{
|
||||
GLint temp;
|
||||
|
||||
GLimp_Init( qtrue );
|
||||
GLimp_Init( qfalse );
|
||||
|
||||
#ifdef ELITEFORCE
|
||||
glConfig.textureFilterAnisotropicAvailable = textureFilterAnisotropic;
|
||||
#endif
|
||||
|
||||
strcpy( renderer_buffer, glConfig.renderer_string );
|
||||
Q_strlwr( renderer_buffer );
|
||||
|
||||
// OpenGL driver constants
|
||||
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &temp );
|
||||
glConfig.maxTextureSize = temp;
|
||||
|
|
@ -1317,10 +1322,6 @@ void RE_Shutdown( qboolean destroyWindow ) {
|
|||
GLimp_Shutdown();
|
||||
|
||||
Com_Memset( &glConfig, 0, sizeof( glConfig ) );
|
||||
textureFilterAnisotropic = qfalse;
|
||||
maxAnisotropy = 0;
|
||||
displayAspect = 0.0f;
|
||||
|
||||
Com_Memset( &glState, 0, sizeof( glState ) );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -32,14 +32,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
#include "../renderercommon/iqm.h"
|
||||
#include "../renderercommon/qgl.h"
|
||||
|
||||
#define GLE(ret, name, ...) extern name##proc * qgl##name;
|
||||
QGL_1_1_PROCS;
|
||||
QGL_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_3_0_PROCS;
|
||||
#undef GLE
|
||||
|
||||
#define GL_INDEX_TYPE GL_UNSIGNED_INT
|
||||
typedef unsigned int glIndex_t;
|
||||
|
||||
|
|
@ -590,12 +582,6 @@ typedef struct {
|
|||
drawVert_t *verts;
|
||||
} srfTriangles_t;
|
||||
|
||||
typedef struct {
|
||||
vec3_t translate;
|
||||
quat_t rotate;
|
||||
vec3_t scale;
|
||||
} iqmTransform_t;
|
||||
|
||||
// inter-quake-model
|
||||
typedef struct {
|
||||
int num_vertexes;
|
||||
|
|
@ -606,34 +592,28 @@ typedef struct {
|
|||
int num_poses;
|
||||
struct srfIQModel_s *surfaces;
|
||||
|
||||
int *triangles;
|
||||
|
||||
// vertex arrays
|
||||
float *positions;
|
||||
float *texcoords;
|
||||
float *normals;
|
||||
float *tangents;
|
||||
byte *colors;
|
||||
int *influences; // [num_vertexes] indexes into influenceBlendVertexes
|
||||
|
||||
// unique list of vertex blend indexes/weights for faster CPU vertex skinning
|
||||
byte *influenceBlendIndexes; // [num_influences]
|
||||
byte *blendIndexes;
|
||||
union {
|
||||
float *f;
|
||||
byte *b;
|
||||
} influenceBlendWeights; // [num_influences]
|
||||
} blendWeights;
|
||||
byte *colors;
|
||||
int *triangles;
|
||||
|
||||
// depending upon the exporter, blend indices and weights might be int/float
|
||||
// as opposed to the recommended byte/byte, for example Noesis exports
|
||||
// int/float whereas the official IQM tool exports byte/byte
|
||||
int blendWeightsType; // IQM_UBYTE or IQM_FLOAT
|
||||
byte blendWeightsType; // IQM_UBYTE or IQM_FLOAT
|
||||
|
||||
char *jointNames;
|
||||
int *jointParents;
|
||||
float *bindJoints; // [num_joints * 12]
|
||||
float *invBindJoints; // [num_joints * 12]
|
||||
iqmTransform_t *poses; // [num_frames * num_poses]
|
||||
float *jointMats;
|
||||
float *poseMats;
|
||||
float *bounds;
|
||||
char *names;
|
||||
} iqmData_t;
|
||||
|
||||
// inter-quake-model surface
|
||||
|
|
@ -644,7 +624,6 @@ typedef struct srfIQModel_s {
|
|||
iqmData_t *data;
|
||||
int first_vertex, num_vertexes;
|
||||
int first_triangle, num_triangles;
|
||||
int first_influence, num_influences;
|
||||
} srfIQModel_t;
|
||||
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -56,5 +56,5 @@ void main()
|
|||
current.y *= 0.0625;
|
||||
#endif
|
||||
|
||||
gl_FragColor = vec4(current, 1.0);
|
||||
gl_FragColor = vec4(current, 1.0f);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,9 +6,6 @@ attribute vec4 attr_TexCoord0;
|
|||
#if defined(USE_VERTEX_ANIMATION)
|
||||
attribute vec3 attr_Position2;
|
||||
attribute vec3 attr_Normal2;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
attribute vec4 attr_BoneIndexes;
|
||||
attribute vec4 attr_BoneWeights;
|
||||
#endif
|
||||
|
||||
uniform vec4 u_FogDistance;
|
||||
|
|
@ -25,8 +22,6 @@ uniform mat4 u_ModelViewProjectionMatrix;
|
|||
|
||||
#if defined(USE_VERTEX_ANIMATION)
|
||||
uniform float u_VertexLerp;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
uniform mat4 u_BoneMatrix[MAX_GLSL_BONES];
|
||||
#endif
|
||||
|
||||
uniform vec4 u_Color;
|
||||
|
|
@ -107,15 +102,6 @@ void main()
|
|||
#if defined(USE_VERTEX_ANIMATION)
|
||||
vec3 position = mix(attr_Position, attr_Position2, u_VertexLerp);
|
||||
vec3 normal = mix(attr_Normal, attr_Normal2, u_VertexLerp);
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
mat4 vtxMat = u_BoneMatrix[int(attr_BoneIndexes.x)] * attr_BoneWeights.x;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.y)] * attr_BoneWeights.y;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.z)] * attr_BoneWeights.z;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.w)] * attr_BoneWeights.w;
|
||||
mat3 nrmMat = mat3(cross(vtxMat[1].xyz, vtxMat[2].xyz), cross(vtxMat[2].xyz, vtxMat[0].xyz), cross(vtxMat[0].xyz, vtxMat[1].xyz));
|
||||
|
||||
vec3 position = vec3(vtxMat * vec4(attr_Position, 1.0));
|
||||
vec3 normal = normalize(nrmMat * attr_Normal);
|
||||
#else
|
||||
vec3 position = attr_Position;
|
||||
vec3 normal = attr_Normal;
|
||||
|
|
|
|||
|
|
@ -4,9 +4,6 @@ attribute vec3 attr_Normal;
|
|||
#if defined(USE_VERTEX_ANIMATION)
|
||||
attribute vec3 attr_Position2;
|
||||
attribute vec3 attr_Normal2;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
attribute vec4 attr_BoneIndexes;
|
||||
attribute vec4 attr_BoneWeights;
|
||||
#endif
|
||||
|
||||
attribute vec4 attr_Color;
|
||||
|
|
@ -57,8 +54,6 @@ uniform float u_PortalRange;
|
|||
|
||||
#if defined(USE_VERTEX_ANIMATION)
|
||||
uniform float u_VertexLerp;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
uniform mat4 u_BoneMatrix[MAX_GLSL_BONES];
|
||||
#endif
|
||||
|
||||
varying vec2 var_DiffuseTex;
|
||||
|
|
@ -209,15 +204,6 @@ void main()
|
|||
#if defined(USE_VERTEX_ANIMATION)
|
||||
vec3 position = mix(attr_Position, attr_Position2, u_VertexLerp);
|
||||
vec3 normal = mix(attr_Normal, attr_Normal2, u_VertexLerp);
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
mat4 vtxMat = u_BoneMatrix[int(attr_BoneIndexes.x)] * attr_BoneWeights.x;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.y)] * attr_BoneWeights.y;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.z)] * attr_BoneWeights.z;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.w)] * attr_BoneWeights.w;
|
||||
mat3 nrmMat = mat3(cross(vtxMat[1].xyz, vtxMat[2].xyz), cross(vtxMat[2].xyz, vtxMat[0].xyz), cross(vtxMat[0].xyz, vtxMat[1].xyz));
|
||||
|
||||
vec3 position = vec3(vtxMat * vec4(attr_Position, 1.0));
|
||||
vec3 normal = normalize(nrmMat * attr_Normal);
|
||||
#else
|
||||
vec3 position = attr_Position;
|
||||
vec3 normal = attr_Normal;
|
||||
|
|
|
|||
|
|
@ -143,35 +143,6 @@ float RayIntersectDisplaceMap(vec2 dp, vec2 ds, sampler2D normalMap)
|
|||
|
||||
return bestDepth;
|
||||
}
|
||||
|
||||
float LightRay(vec2 dp, vec2 ds, sampler2D normalMap)
|
||||
{
|
||||
const int linearSearchSteps = 16;
|
||||
|
||||
// current size of search window
|
||||
float size = 1.0 / float(linearSearchSteps);
|
||||
|
||||
// current height from initial texel depth
|
||||
float height = 0.0;
|
||||
|
||||
float startDepth = SampleDepth(normalMap, dp);
|
||||
|
||||
// find a collision or escape
|
||||
for(int i = 0; i < linearSearchSteps - 1; ++i)
|
||||
{
|
||||
height += size;
|
||||
|
||||
if (startDepth < height)
|
||||
return 1.0;
|
||||
|
||||
float t = SampleDepth(normalMap, dp + ds * height);
|
||||
|
||||
if (startDepth > t + height)
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
return 1.0;
|
||||
}
|
||||
#endif
|
||||
|
||||
vec3 CalcDiffuse(vec3 diffuseAlbedo, float NH, float EH, float roughness)
|
||||
|
|
@ -222,37 +193,6 @@ float CalcLightAttenuation(float point, float normDist)
|
|||
return attenuation;
|
||||
}
|
||||
|
||||
#if defined(USE_BOX_CUBEMAP_PARALLAX)
|
||||
vec4 hitCube(vec3 ray, vec3 pos, vec3 invSize, float lod, samplerCube tex)
|
||||
{
|
||||
// find any hits on cubemap faces facing the camera
|
||||
vec3 scale = (sign(ray) - pos) / ray;
|
||||
|
||||
// find the nearest hit
|
||||
float minScale = min(min(scale.x, scale.y), scale.z);
|
||||
|
||||
// if the nearest hit is behind the camera, ignore
|
||||
// should not be necessary as long as pos is inside the cube
|
||||
//if (minScale < 0.0)
|
||||
//return vec4(0.0);
|
||||
|
||||
// calculate the hit position, that's our texture coordinates
|
||||
vec3 tc = pos + ray * minScale;
|
||||
|
||||
// if the texture coordinates are outside the cube, ignore
|
||||
// necessary since we're not fading out outside the cube
|
||||
if (any(greaterThan(abs(tc), vec3(1.00001))))
|
||||
return vec4(0.0);
|
||||
|
||||
// fade out when approaching the cubemap edges
|
||||
//vec3 fade3 = abs(pos);
|
||||
//float fade = max(max(fade3.x, fade3.y), fade3.z);
|
||||
//fade = clamp(1.0 - fade, 0.0, 1.0);
|
||||
|
||||
//return vec4(textureCubeLod(tex, tc, lod).rgb * fade, fade);
|
||||
return vec4(textureCubeLod(tex, tc, lod).rgb, 1.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
void main()
|
||||
{
|
||||
|
|
@ -282,7 +222,7 @@ void main()
|
|||
vec2 texCoords = var_TexCoords.xy;
|
||||
|
||||
#if defined(USE_PARALLAXMAP)
|
||||
vec3 offsetDir = E * tangentToWorld;
|
||||
vec3 offsetDir = viewDir * tangentToWorld;
|
||||
|
||||
offsetDir.xy *= -u_NormalScale.a / offsetDir.z;
|
||||
|
||||
|
|
@ -349,13 +289,6 @@ void main()
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(USE_PARALLAXMAP) && defined(USE_PARALLAXMAP_SHADOWS)
|
||||
offsetDir = L * tangentToWorld;
|
||||
offsetDir.xy *= u_NormalScale.a / offsetDir.z;
|
||||
lightColor *= LightRay(texCoords, offsetDir.xy, u_NormalMap);
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(USE_LIGHT_VECTOR)
|
||||
ambientColor = lightColor;
|
||||
float surfNL = clamp(dot(var_Normal.xyz, L), 0.0, 1.0);
|
||||
|
|
@ -441,11 +374,7 @@ void main()
|
|||
// from http://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/
|
||||
vec3 parallax = u_CubeMapInfo.xyz + u_CubeMapInfo.w * viewDir;
|
||||
|
||||
#if defined(USE_BOX_CUBEMAP_PARALLAX)
|
||||
vec3 cubeLightColor = hitCube(R * u_CubeMapInfo.w, parallax, u_CubeMapInfo.www, ROUGHNESS_MIPS * roughness, u_CubeMap).rgb * u_EnableTextures.w;
|
||||
#else
|
||||
vec3 cubeLightColor = textureCubeLod(u_CubeMap, R + parallax, ROUGHNESS_MIPS * roughness).rgb * u_EnableTextures.w;
|
||||
#endif
|
||||
|
||||
// normalize cubemap based on last roughness mip (~diffuse)
|
||||
// multiplying cubemap values by lighting below depends on either this or the cubemap being normalized at generation
|
||||
|
|
@ -494,12 +423,6 @@ void main()
|
|||
// enable when point lights are supported as primary lights
|
||||
//lightColor *= CalcLightAttenuation(float(u_PrimaryLightDir.w > 0.0), u_PrimaryLightDir.w / sqrLightDist);
|
||||
|
||||
#if defined(USE_PARALLAXMAP) && defined(USE_PARALLAXMAP_SHADOWS)
|
||||
offsetDir = L2 * tangentToWorld;
|
||||
offsetDir.xy *= u_NormalScale.a / offsetDir.z;
|
||||
lightColor *= LightRay(texCoords, offsetDir.xy, u_NormalMap);
|
||||
#endif
|
||||
|
||||
gl_FragColor.rgb += lightColor * reflectance * NL2;
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -12,9 +12,6 @@ attribute vec4 attr_Tangent;
|
|||
attribute vec3 attr_Position2;
|
||||
attribute vec3 attr_Normal2;
|
||||
attribute vec4 attr_Tangent2;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
attribute vec4 attr_BoneIndexes;
|
||||
attribute vec4 attr_BoneWeights;
|
||||
#endif
|
||||
|
||||
#if defined(USE_LIGHT) && !defined(USE_LIGHT_VECTOR)
|
||||
|
|
@ -51,8 +48,6 @@ uniform mat4 u_ModelMatrix;
|
|||
|
||||
#if defined(USE_VERTEX_ANIMATION)
|
||||
uniform float u_VertexLerp;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
uniform mat4 u_BoneMatrix[MAX_GLSL_BONES];
|
||||
#endif
|
||||
|
||||
#if defined(USE_LIGHT_VECTOR)
|
||||
|
|
@ -156,18 +151,6 @@ void main()
|
|||
#if defined(USE_LIGHT) && !defined(USE_FAST_LIGHT)
|
||||
vec3 tangent = mix(attr_Tangent.xyz, attr_Tangent2.xyz, u_VertexLerp);
|
||||
#endif
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
mat4 vtxMat = u_BoneMatrix[int(attr_BoneIndexes.x)] * attr_BoneWeights.x;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.y)] * attr_BoneWeights.y;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.z)] * attr_BoneWeights.z;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.w)] * attr_BoneWeights.w;
|
||||
mat3 nrmMat = mat3(cross(vtxMat[1].xyz, vtxMat[2].xyz), cross(vtxMat[2].xyz, vtxMat[0].xyz), cross(vtxMat[0].xyz, vtxMat[1].xyz));
|
||||
|
||||
vec3 position = vec3(vtxMat * vec4(attr_Position, 1.0));
|
||||
vec3 normal = normalize(nrmMat * attr_Normal);
|
||||
#if defined(USE_LIGHT) && !defined(USE_FAST_LIGHT)
|
||||
vec3 tangent = normalize(nrmMat * attr_Tangent.xyz);
|
||||
#endif
|
||||
#else
|
||||
vec3 position = attr_Position;
|
||||
vec3 normal = attr_Normal;
|
||||
|
|
|
|||
|
|
@ -2,13 +2,10 @@ attribute vec3 attr_Position;
|
|||
attribute vec3 attr_Normal;
|
||||
attribute vec4 attr_TexCoord0;
|
||||
|
||||
#if defined(USE_VERTEX_ANIMATION)
|
||||
//#if defined(USE_VERTEX_ANIMATION)
|
||||
attribute vec3 attr_Position2;
|
||||
attribute vec3 attr_Normal2;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
attribute vec4 attr_BoneIndexes;
|
||||
attribute vec4 attr_BoneWeights;
|
||||
#endif
|
||||
//#endif
|
||||
|
||||
//#if defined(USE_DEFORM_VERTEXES)
|
||||
uniform int u_DeformGen;
|
||||
|
|
@ -20,11 +17,9 @@ uniform mat4 u_ModelViewProjectionMatrix;
|
|||
|
||||
uniform mat4 u_ModelMatrix;
|
||||
|
||||
#if defined(USE_VERTEX_ANIMATION)
|
||||
//#if defined(USE_VERTEX_ANIMATION)
|
||||
uniform float u_VertexLerp;
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
uniform mat4 u_BoneMatrix[MAX_GLSL_BONES];
|
||||
#endif
|
||||
//#endif
|
||||
|
||||
varying vec3 var_Position;
|
||||
|
||||
|
|
@ -83,22 +78,8 @@ vec3 DeformPosition(const vec3 pos, const vec3 normal, const vec2 st)
|
|||
|
||||
void main()
|
||||
{
|
||||
#if defined(USE_VERTEX_ANIMATION)
|
||||
vec3 position = mix(attr_Position, attr_Position2, u_VertexLerp);
|
||||
vec3 normal = mix(attr_Normal, attr_Normal2, u_VertexLerp);
|
||||
#elif defined(USE_BONE_ANIMATION)
|
||||
mat4 vtxMat = u_BoneMatrix[int(attr_BoneIndexes.x)] * attr_BoneWeights.x;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.y)] * attr_BoneWeights.y;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.z)] * attr_BoneWeights.z;
|
||||
vtxMat += u_BoneMatrix[int(attr_BoneIndexes.w)] * attr_BoneWeights.w;
|
||||
mat3 nrmMat = mat3(cross(vtxMat[1].xyz, vtxMat[2].xyz), cross(vtxMat[2].xyz, vtxMat[0].xyz), cross(vtxMat[0].xyz, vtxMat[1].xyz));
|
||||
|
||||
vec3 position = vec3(vtxMat * vec4(attr_Position, 1.0));
|
||||
vec3 normal = normalize(nrmMat * attr_Normal);
|
||||
#else
|
||||
vec3 position = attr_Position;
|
||||
vec3 normal = attr_Normal;
|
||||
#endif
|
||||
|
||||
position = DeformPosition(position, normal, attr_TexCoord0.st);
|
||||
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ float ambientOcclusion(sampler2D depthMap, const vec2 tex, const float zFarDivZN
|
|||
poissonDisc[7] = vec2(-0.5579782, 0.7491854);
|
||||
poissonDisc[8] = vec2(0.7320465, 0.6317794);
|
||||
|
||||
float result = 0.0;
|
||||
float result = 0;
|
||||
|
||||
float sampleZ = getLinearDepth(depthMap, tex, zFarDivZNear);
|
||||
float scaleZ = zFarDivZNear * sampleZ;
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ void GL_BindToTMU( image_t *image, int tmu )
|
|||
ri.Printf(PRINT_WARNING, "GL_BindToTMU: NULL image\n");
|
||||
}
|
||||
|
||||
GL_BindMultiTexture(GL_TEXTURE0 + tmu, target, texture);
|
||||
GL_BindMultiTexture(GL_TEXTURE0_ARB + tmu, target, texture);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -441,6 +441,7 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
|
|||
int oldSort;
|
||||
double originalTime;
|
||||
FBO_t* fbo = NULL;
|
||||
qboolean inQuery = qfalse;
|
||||
|
||||
// save original time for entity shader offsets
|
||||
originalTime = backEnd.refdef.floatTime;
|
||||
|
|
@ -598,6 +599,10 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
|
|||
RB_EndSurface();
|
||||
}
|
||||
|
||||
if (inQuery) {
|
||||
qglEndQuery(GL_SAMPLES_PASSED);
|
||||
}
|
||||
|
||||
if (glRefConfig.framebufferObject)
|
||||
FBO_Bind(fbo);
|
||||
|
||||
|
|
@ -658,6 +663,7 @@ void RB_SetGL2D (void) {
|
|||
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
|
||||
|
||||
GL_Cull( CT_TWO_SIDED );
|
||||
qglDisable( GL_CLIP_PLANE0 );
|
||||
|
||||
// set time for 2D shaders
|
||||
backEnd.refdef.time = ri.Milliseconds();
|
||||
|
|
|
|||
|
|
@ -203,11 +203,11 @@ void R_AddCapShadowmapCmd( int map, int cubeSide ) {
|
|||
|
||||
/*
|
||||
=============
|
||||
R_AddPostProcessCmd
|
||||
R_PostProcessingCmd
|
||||
|
||||
=============
|
||||
*/
|
||||
void R_AddPostProcessCmd( void ) {
|
||||
void R_AddPostProcessCmd( ) {
|
||||
postProcessCommand_t *cmd;
|
||||
|
||||
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ static struct
|
|||
}
|
||||
glDsaState;
|
||||
|
||||
void GL_BindNullTextures(void)
|
||||
void GL_BindNullTextures()
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
@ -141,7 +141,7 @@ GLvoid APIENTRY GLDSA_GenerateTextureMipmapEXT(GLuint texture, GLenum target)
|
|||
qglGenerateMipmap(target);
|
||||
}
|
||||
|
||||
void GL_BindNullProgram(void)
|
||||
void GL_BindNullProgram()
|
||||
{
|
||||
qglUseProgram(0);
|
||||
glDsaState.program = 0;
|
||||
|
|
@ -205,7 +205,7 @@ GLvoid APIENTRY GLDSA_ProgramUniformMatrix4fvEXT(GLuint program, GLint location,
|
|||
qglUniformMatrix4fv(location, count, transpose, value);
|
||||
}
|
||||
|
||||
void GL_BindNullFramebuffers(void)
|
||||
void GL_BindNullFramebuffers()
|
||||
{
|
||||
qglBindFramebuffer(GL_FRAMEBUFFER, 0);
|
||||
glDsaState.drawFramebuffer = glDsaState.readFramebuffer = 0;
|
||||
|
|
|
|||
|
|
@ -30,13 +30,27 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
#include "tr_local.h"
|
||||
#include "tr_dsa.h"
|
||||
|
||||
void GLimp_InitExtraExtensions(void)
|
||||
#define GLE(ret, name, ...) name##proc * qgl##name;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
QGL_ARB_framebuffer_object_PROCS;
|
||||
QGL_ARB_vertex_array_object_PROCS;
|
||||
QGL_EXT_direct_state_access_PROCS;
|
||||
#undef GLE
|
||||
|
||||
void GLimp_InitExtraExtensions()
|
||||
{
|
||||
char *extension;
|
||||
const char* result[3] = { "...ignoring %s\n", "...using %s\n", "...%s not found\n" };
|
||||
qboolean q_gl_version_at_least_3_0;
|
||||
qboolean q_gl_version_at_least_3_2;
|
||||
|
||||
// Check OpenGL version
|
||||
if ( !QGL_VERSION_ATLEAST( 2, 0 ) )
|
||||
ri.Error(ERR_FATAL, "OpenGL 2.0 required!");
|
||||
ri.Printf(PRINT_ALL, "...using OpenGL %s\n", glConfig.version_string);
|
||||
|
||||
q_gl_version_at_least_3_0 = QGL_VERSION_ATLEAST( 3, 0 );
|
||||
q_gl_version_at_least_3_2 = QGL_VERSION_ATLEAST( 3, 2 );
|
||||
|
||||
|
|
@ -53,9 +67,15 @@ void GLimp_InitExtraExtensions(void)
|
|||
// GL function loader, based on https://gist.github.com/rygorous/16796a0c876cf8a5f542caddb55bce8a
|
||||
#define GLE(ret, name, ...) qgl##name = (name##proc *) SDL_GL_GetProcAddress("gl" #name);
|
||||
|
||||
// OpenGL 1.5 - GL_ARB_occlusion_query
|
||||
// OpenGL 1.3, was GL_ARB_texture_compression
|
||||
QGL_1_3_PROCS;
|
||||
|
||||
// OpenGL 1.5, was GL_ARB_vertex_buffer_object and GL_ARB_occlusion_query
|
||||
QGL_1_5_PROCS;
|
||||
glRefConfig.occlusionQuery = qtrue;
|
||||
QGL_ARB_occlusion_query_PROCS;
|
||||
|
||||
// OpenGL 2.0, was GL_ARB_shading_language_100, GL_ARB_vertex_program, GL_ARB_shader_objects, and GL_ARB_vertex_shader
|
||||
QGL_2_0_PROCS;
|
||||
|
||||
// OpenGL 3.0 - GL_ARB_framebuffer_object
|
||||
extension = "GL_ARB_framebuffer_object";
|
||||
|
|
|
|||
|
|
@ -526,6 +526,10 @@ void RB_RenderFlares (void) {
|
|||
return; // none visible
|
||||
}
|
||||
|
||||
if ( backEnd.viewParms.isPortal ) {
|
||||
qglDisable (GL_CLIP_PLANE0);
|
||||
}
|
||||
|
||||
Mat4Copy(glState.projection, oldprojection);
|
||||
Mat4Copy(glState.modelview, oldmodelview);
|
||||
Mat4Identity(matrix);
|
||||
|
|
|
|||
|
|
@ -148,8 +148,6 @@ static uniformInfo_t uniformsInfo[] =
|
|||
{ "u_CubeMapInfo", GLSL_VEC4 },
|
||||
|
||||
{ "u_AlphaTest", GLSL_INT },
|
||||
|
||||
{ "u_BoneMatrix", GLSL_MAT16_BONEMATRIX },
|
||||
};
|
||||
|
||||
typedef enum
|
||||
|
|
@ -333,6 +331,17 @@ static void GLSL_GetShaderHeader( GLenum shaderType, const GLchar *extra, char *
|
|||
AGEN_LIGHTING_SPECULAR,
|
||||
AGEN_PORTAL));
|
||||
|
||||
Q_strcat(dest, size,
|
||||
va("#ifndef texenv_t\n"
|
||||
"#define texenv_t\n"
|
||||
"#define TEXENV_MODULATE %i\n"
|
||||
"#define TEXENV_ADD %i\n"
|
||||
"#define TEXENV_REPLACE %i\n"
|
||||
"#endif\n",
|
||||
GL_MODULATE,
|
||||
GL_ADD,
|
||||
GL_REPLACE));
|
||||
|
||||
fbufWidthScale = 1.0f / ((float)glConfig.vidWidth);
|
||||
fbufHeightScale = 1.0f / ((float)glConfig.vidHeight);
|
||||
Q_strcat(dest, size,
|
||||
|
|
@ -557,12 +566,6 @@ static int GLSL_InitGPUShader2(shaderProgram_t * program, const char *name, int
|
|||
if(attribs & ATTR_LIGHTDIRECTION)
|
||||
qglBindAttribLocation(program->program, ATTR_INDEX_LIGHTDIRECTION, "attr_LightDirection");
|
||||
|
||||
if(attribs & ATTR_BONE_INDEXES)
|
||||
qglBindAttribLocation(program->program, ATTR_INDEX_BONE_INDEXES, "attr_BoneIndexes");
|
||||
|
||||
if(attribs & ATTR_BONE_WEIGHTS)
|
||||
qglBindAttribLocation(program->program, ATTR_INDEX_BONE_WEIGHTS, "attr_BoneWeights");
|
||||
|
||||
if(attribs & ATTR_POSITION2)
|
||||
qglBindAttribLocation(program->program, ATTR_INDEX_POSITION2, "attr_Position2");
|
||||
|
||||
|
|
@ -668,9 +671,6 @@ void GLSL_InitUniforms(shaderProgram_t *program)
|
|||
case GLSL_MAT16:
|
||||
size += sizeof(vec_t) * 16;
|
||||
break;
|
||||
case GLSL_MAT16_BONEMATRIX:
|
||||
size += sizeof(vec_t) * 16 * glRefConfig.glslMaxAnimatedBones;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -854,38 +854,6 @@ void GLSL_SetUniformMat4(shaderProgram_t *program, int uniformNum, const mat4_t
|
|||
qglProgramUniformMatrix4fvEXT(program->program, uniforms[uniformNum], 1, GL_FALSE, matrix);
|
||||
}
|
||||
|
||||
void GLSL_SetUniformMat4BoneMatrix(shaderProgram_t *program, int uniformNum, /*const*/ mat4_t *matrix, int numMatricies)
|
||||
{
|
||||
GLint *uniforms = program->uniforms;
|
||||
vec_t *compare = (float *)(program->uniformBuffer + program->uniformBufferOffsets[uniformNum]);
|
||||
|
||||
if (uniforms[uniformNum] == -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (uniformsInfo[uniformNum].type != GLSL_MAT16_BONEMATRIX)
|
||||
{
|
||||
ri.Printf( PRINT_WARNING, "GLSL_SetUniformMat4BoneMatrix: wrong type for uniform %i in program %s\n", uniformNum, program->name);
|
||||
return;
|
||||
}
|
||||
|
||||
if (numMatricies > glRefConfig.glslMaxAnimatedBones)
|
||||
{
|
||||
ri.Printf( PRINT_WARNING, "GLSL_SetUniformMat4BoneMatrix: too many matricies (%d/%d) for uniform %i in program %s\n",
|
||||
numMatricies, glRefConfig.glslMaxAnimatedBones, uniformNum, program->name);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!memcmp(matrix, compare, numMatricies * sizeof(mat4_t)))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Com_Memcpy(compare, matrix, numMatricies * sizeof(mat4_t));
|
||||
|
||||
qglProgramUniformMatrix4fvEXT(program->program, uniforms[uniformNum], numMatricies, GL_FALSE, &matrix[0][0]);
|
||||
}
|
||||
|
||||
void GLSL_DeleteGPUShader(shaderProgram_t *program)
|
||||
{
|
||||
if(program->program)
|
||||
|
|
@ -929,12 +897,6 @@ void GLSL_InitGPUShaders(void)
|
|||
|
||||
for (i = 0; i < GENERICDEF_COUNT; i++)
|
||||
{
|
||||
if ((i & GENERICDEF_USE_VERTEX_ANIMATION) && (i & GENERICDEF_USE_BONE_ANIMATION))
|
||||
continue;
|
||||
|
||||
if ((i & GENERICDEF_USE_BONE_ANIMATION) && !glRefConfig.glslMaxAnimatedBones)
|
||||
continue;
|
||||
|
||||
attribs = ATTR_POSITION | ATTR_TEXCOORD | ATTR_LIGHTCOORD | ATTR_NORMAL | ATTR_COLOR;
|
||||
extradefines[0] = '\0';
|
||||
|
||||
|
|
@ -952,11 +914,6 @@ void GLSL_InitGPUShaders(void)
|
|||
Q_strcat(extradefines, 1024, "#define USE_VERTEX_ANIMATION\n");
|
||||
attribs |= ATTR_POSITION2 | ATTR_NORMAL2;
|
||||
}
|
||||
else if (i & GENERICDEF_USE_BONE_ANIMATION)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, va("#define USE_BONE_ANIMATION\n#define MAX_GLSL_BONES %d\n", glRefConfig.glslMaxAnimatedBones));
|
||||
attribs |= ATTR_BONE_INDEXES | ATTR_BONE_WEIGHTS;
|
||||
}
|
||||
|
||||
if (i & GENERICDEF_USE_FOG)
|
||||
Q_strcat(extradefines, 1024, "#define USE_FOG\n");
|
||||
|
|
@ -997,28 +954,14 @@ void GLSL_InitGPUShaders(void)
|
|||
|
||||
for (i = 0; i < FOGDEF_COUNT; i++)
|
||||
{
|
||||
if ((i & FOGDEF_USE_VERTEX_ANIMATION) && (i & FOGDEF_USE_BONE_ANIMATION))
|
||||
continue;
|
||||
|
||||
if ((i & FOGDEF_USE_BONE_ANIMATION) && !glRefConfig.glslMaxAnimatedBones)
|
||||
continue;
|
||||
|
||||
attribs = ATTR_POSITION | ATTR_NORMAL | ATTR_TEXCOORD;
|
||||
attribs = ATTR_POSITION | ATTR_POSITION2 | ATTR_NORMAL | ATTR_NORMAL2 | ATTR_TEXCOORD;
|
||||
extradefines[0] = '\0';
|
||||
|
||||
if (i & FOGDEF_USE_DEFORM_VERTEXES)
|
||||
Q_strcat(extradefines, 1024, "#define USE_DEFORM_VERTEXES\n");
|
||||
|
||||
if (i & FOGDEF_USE_VERTEX_ANIMATION)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, "#define USE_VERTEX_ANIMATION\n");
|
||||
attribs |= ATTR_POSITION2 | ATTR_NORMAL2;
|
||||
}
|
||||
else if (i & FOGDEF_USE_BONE_ANIMATION)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, va("#define USE_BONE_ANIMATION\n#define MAX_GLSL_BONES %d\n", glRefConfig.glslMaxAnimatedBones));
|
||||
attribs |= ATTR_BONE_INDEXES | ATTR_BONE_WEIGHTS;
|
||||
}
|
||||
|
||||
if (!GLSL_InitGPUShader(&tr.fogShader[i], "fogpass", attribs, qtrue, extradefines, qtrue, fallbackShader_fogpass_vp, fallbackShader_fogpass_fp))
|
||||
{
|
||||
|
|
@ -1069,12 +1012,6 @@ void GLSL_InitGPUShaders(void)
|
|||
if ((i & LIGHTDEF_USE_SHADOWMAP) && (!lightType || !r_sunlightMode->integer))
|
||||
continue;
|
||||
|
||||
if ((i & LIGHTDEF_ENTITY_VERTEX_ANIMATION) && (i & LIGHTDEF_ENTITY_BONE_ANIMATION))
|
||||
continue;
|
||||
|
||||
if ((i & LIGHTDEF_ENTITY_BONE_ANIMATION) && !glRefConfig.glslMaxAnimatedBones)
|
||||
continue;
|
||||
|
||||
attribs = ATTR_POSITION | ATTR_TEXCOORD | ATTR_COLOR | ATTR_NORMAL;
|
||||
|
||||
extradefines[0] = '\0';
|
||||
|
|
@ -1117,14 +1054,11 @@ void GLSL_InitGPUShaders(void)
|
|||
|
||||
attribs |= ATTR_TANGENT;
|
||||
|
||||
if ((i & LIGHTDEF_USE_PARALLAXMAP) && !(i & LIGHTDEF_ENTITY_VERTEX_ANIMATION) && !(i & LIGHTDEF_ENTITY_BONE_ANIMATION) && r_parallaxMapping->integer)
|
||||
if ((i & LIGHTDEF_USE_PARALLAXMAP) && !(i & LIGHTDEF_ENTITY) && r_parallaxMapping->integer)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, "#define USE_PARALLAXMAP\n");
|
||||
if (r_parallaxMapping->integer > 1)
|
||||
Q_strcat(extradefines, 1024, "#define USE_RELIEFMAP\n");
|
||||
|
||||
if (r_parallaxMapShadows->integer)
|
||||
Q_strcat(extradefines, 1024, "#define USE_PARALLAXMAP_SHADOWS\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1132,15 +1066,9 @@ void GLSL_InitGPUShaders(void)
|
|||
Q_strcat(extradefines, 1024, "#define USE_SPECULARMAP\n");
|
||||
|
||||
if (r_cubeMapping->integer)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, "#define USE_CUBEMAP\n");
|
||||
if (r_cubeMapping->integer == 2)
|
||||
Q_strcat(extradefines, 1024, "#define USE_BOX_CUBEMAP_PARALLAX\n");
|
||||
}
|
||||
else if (r_deluxeSpecular->value > 0.000001f)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, va("#define r_deluxeSpecular %f\n", r_deluxeSpecular->value));
|
||||
}
|
||||
|
||||
switch (r_glossType->integer)
|
||||
{
|
||||
|
|
@ -1176,7 +1104,7 @@ void GLSL_InitGPUShaders(void)
|
|||
Q_strcat(extradefines, 1024, "#define USE_TCMOD\n");
|
||||
}
|
||||
|
||||
if (i & LIGHTDEF_ENTITY_VERTEX_ANIMATION)
|
||||
if (i & LIGHTDEF_ENTITY)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, "#define USE_VERTEX_ANIMATION\n#define USE_MODELMATRIX\n");
|
||||
attribs |= ATTR_POSITION2 | ATTR_NORMAL2;
|
||||
|
|
@ -1186,12 +1114,6 @@ void GLSL_InitGPUShaders(void)
|
|||
attribs |= ATTR_TANGENT2;
|
||||
}
|
||||
}
|
||||
else if (i & LIGHTDEF_ENTITY_BONE_ANIMATION)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, "#define USE_MODELMATRIX\n");
|
||||
Q_strcat(extradefines, 1024, va("#define USE_BONE_ANIMATION\n#define MAX_GLSL_BONES %d\n", glRefConfig.glslMaxAnimatedBones));
|
||||
attribs |= ATTR_BONE_INDEXES | ATTR_BONE_WEIGHTS;
|
||||
}
|
||||
|
||||
if (!GLSL_InitGPUShader(&tr.lightallShader[i], "lightall", attribs, qtrue, extradefines, qtrue, fallbackShader_lightall_vp, fallbackShader_lightall_fp))
|
||||
{
|
||||
|
|
@ -1213,41 +1135,20 @@ void GLSL_InitGPUShaders(void)
|
|||
numLightShaders++;
|
||||
}
|
||||
|
||||
for (i = 0; i < SHADOWMAPDEF_COUNT; i++)
|
||||
attribs = ATTR_POSITION | ATTR_POSITION2 | ATTR_NORMAL | ATTR_NORMAL2 | ATTR_TEXCOORD;
|
||||
|
||||
extradefines[0] = '\0';
|
||||
|
||||
if (!GLSL_InitGPUShader(&tr.shadowmapShader, "shadowfill", attribs, qtrue, extradefines, qtrue, fallbackShader_shadowfill_vp, fallbackShader_shadowfill_fp))
|
||||
{
|
||||
if ((i & SHADOWMAPDEF_USE_VERTEX_ANIMATION) && (i & SHADOWMAPDEF_USE_BONE_ANIMATION))
|
||||
continue;
|
||||
|
||||
if ((i & SHADOWMAPDEF_USE_BONE_ANIMATION) && !glRefConfig.glslMaxAnimatedBones)
|
||||
continue;
|
||||
|
||||
attribs = ATTR_POSITION | ATTR_NORMAL | ATTR_TEXCOORD;
|
||||
|
||||
extradefines[0] = '\0';
|
||||
|
||||
if (i & SHADOWMAPDEF_USE_VERTEX_ANIMATION)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, "#define USE_VERTEX_ANIMATION\n");
|
||||
attribs |= ATTR_POSITION2 | ATTR_NORMAL2;
|
||||
}
|
||||
|
||||
if (i & SHADOWMAPDEF_USE_BONE_ANIMATION)
|
||||
{
|
||||
Q_strcat(extradefines, 1024, va("#define USE_BONE_ANIMATION\n#define MAX_GLSL_BONES %d\n", glRefConfig.glslMaxAnimatedBones));
|
||||
attribs |= ATTR_BONE_INDEXES | ATTR_BONE_WEIGHTS;
|
||||
}
|
||||
|
||||
if (!GLSL_InitGPUShader(&tr.shadowmapShader[i], "shadowfill", attribs, qtrue, extradefines, qtrue, fallbackShader_shadowfill_vp, fallbackShader_shadowfill_fp))
|
||||
{
|
||||
ri.Error(ERR_FATAL, "Could not load shadowfill shader!");
|
||||
}
|
||||
|
||||
GLSL_InitUniforms(&tr.shadowmapShader[i]);
|
||||
GLSL_FinishGPUShader(&tr.shadowmapShader[i]);
|
||||
|
||||
numEtcShaders++;
|
||||
ri.Error(ERR_FATAL, "Could not load shadowfill shader!");
|
||||
}
|
||||
|
||||
GLSL_InitUniforms(&tr.shadowmapShader);
|
||||
GLSL_FinishGPUShader(&tr.shadowmapShader);
|
||||
|
||||
numEtcShaders++;
|
||||
|
||||
attribs = ATTR_POSITION | ATTR_NORMAL;
|
||||
extradefines[0] = '\0';
|
||||
|
||||
|
|
@ -1473,9 +1374,7 @@ void GLSL_ShutdownGPUShaders(void)
|
|||
for ( i = 0; i < LIGHTDEF_COUNT; i++)
|
||||
GLSL_DeleteGPUShader(&tr.lightallShader[i]);
|
||||
|
||||
for ( i = 0; i < SHADOWMAPDEF_COUNT; i++)
|
||||
GLSL_DeleteGPUShader(&tr.shadowmapShader[i]);
|
||||
|
||||
GLSL_DeleteGPUShader(&tr.shadowmapShader);
|
||||
GLSL_DeleteGPUShader(&tr.pshadowShader);
|
||||
GLSL_DeleteGPUShader(&tr.down4xShader);
|
||||
GLSL_DeleteGPUShader(&tr.bokehShader);
|
||||
|
|
@ -1551,10 +1450,6 @@ shaderProgram_t *GLSL_GetGenericShaderProgram(int stage)
|
|||
{
|
||||
shaderAttribs |= GENERICDEF_USE_VERTEX_ANIMATION;
|
||||
}
|
||||
else if (glState.boneAnimation)
|
||||
{
|
||||
shaderAttribs |= GENERICDEF_USE_BONE_ANIMATION;
|
||||
}
|
||||
|
||||
if (pStage->bundle[0].numTexMods)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -222,6 +222,7 @@ void R_ImageList_f( void ) {
|
|||
estSize *= 4;
|
||||
break;
|
||||
case GL_LUMINANCE8:
|
||||
case GL_LUMINANCE16:
|
||||
case GL_LUMINANCE:
|
||||
format = "L ";
|
||||
// 1 byte per pixel?
|
||||
|
|
@ -234,6 +235,7 @@ void R_ImageList_f( void ) {
|
|||
estSize *= 3;
|
||||
break;
|
||||
case GL_LUMINANCE8_ALPHA8:
|
||||
case GL_LUMINANCE16_ALPHA16:
|
||||
case GL_LUMINANCE_ALPHA:
|
||||
format = "LA ";
|
||||
// 2 bytes per pixel?
|
||||
|
|
@ -1722,8 +1724,10 @@ static GLenum RawImage_GetFormat(const byte *data, int numPixels, GLenum picForm
|
|||
{
|
||||
if(r_greyscale->integer)
|
||||
{
|
||||
if(r_texturebits->integer == 16 || r_texturebits->integer == 32)
|
||||
if(r_texturebits->integer == 16)
|
||||
internalFormat = GL_LUMINANCE8;
|
||||
else if(r_texturebits->integer == 32)
|
||||
internalFormat = GL_LUMINANCE16;
|
||||
else
|
||||
internalFormat = GL_LUMINANCE;
|
||||
}
|
||||
|
|
@ -1759,8 +1763,10 @@ static GLenum RawImage_GetFormat(const byte *data, int numPixels, GLenum picForm
|
|||
{
|
||||
if(r_greyscale->integer)
|
||||
{
|
||||
if(r_texturebits->integer == 16 || r_texturebits->integer == 32)
|
||||
if(r_texturebits->integer == 16)
|
||||
internalFormat = GL_LUMINANCE8_ALPHA8;
|
||||
else if(r_texturebits->integer == 32)
|
||||
internalFormat = GL_LUMINANCE16_ALPHA16;
|
||||
else
|
||||
internalFormat = GL_LUMINANCE_ALPHA;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -134,7 +134,6 @@ cvar_t *r_normalMapping;
|
|||
cvar_t *r_specularMapping;
|
||||
cvar_t *r_deluxeMapping;
|
||||
cvar_t *r_parallaxMapping;
|
||||
cvar_t *r_parallaxMapShadows;
|
||||
cvar_t *r_cubeMapping;
|
||||
cvar_t *r_cubemapSize;
|
||||
cvar_t *r_deluxeSpecular;
|
||||
|
|
@ -247,6 +246,8 @@ int max_polyverts;
|
|||
*/
|
||||
static void InitOpenGL( void )
|
||||
{
|
||||
char renderer_buffer[1024];
|
||||
|
||||
//
|
||||
// initialize OS specific portions of the renderer
|
||||
//
|
||||
|
|
@ -262,15 +263,16 @@ static void InitOpenGL( void )
|
|||
{
|
||||
GLint temp;
|
||||
|
||||
GLimp_Init( qfalse );
|
||||
GLimp_Init( qtrue );
|
||||
GLimp_InitExtraExtensions();
|
||||
|
||||
glConfig.textureEnvAddAvailable = qtrue;
|
||||
|
||||
#ifdef ELITEFORCE
|
||||
glConfig.textureFilterAnisotropicAvailable = textureFilterAnisotropic;
|
||||
#endif
|
||||
|
||||
strcpy( renderer_buffer, glConfig.renderer_string );
|
||||
Q_strlwr( renderer_buffer );
|
||||
|
||||
// OpenGL driver constants
|
||||
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &temp );
|
||||
glConfig.maxTextureSize = temp;
|
||||
|
|
@ -280,22 +282,6 @@ static void InitOpenGL( void )
|
|||
{
|
||||
glConfig.maxTextureSize = 0;
|
||||
}
|
||||
|
||||
qglGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS, &temp );
|
||||
glConfig.numTextureUnits = temp;
|
||||
|
||||
// reserve 160 components for other uniforms
|
||||
qglGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS, &temp );
|
||||
glRefConfig.glslMaxAnimatedBones = Com_Clamp( 0, IQM_MAX_JOINTS, ( temp - 160 ) / 16 );
|
||||
if ( glRefConfig.glslMaxAnimatedBones < 12 ) {
|
||||
glRefConfig.glslMaxAnimatedBones = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// check for GLSL function textureCubeLod()
|
||||
if ( r_cubeMapping->integer && !QGL_VERSION_ATLEAST( 3, 0 ) ) {
|
||||
ri.Printf( PRINT_WARNING, "WARNING: Disabled r_cubeMapping because it requires OpenGL 3.0\n" );
|
||||
ri.Cvar_Set( "r_cubeMapping", "0" );
|
||||
}
|
||||
|
||||
// set default state
|
||||
|
|
@ -1070,7 +1056,7 @@ void GfxInfo_f( void )
|
|||
}
|
||||
ri.Printf( PRINT_ALL, "\n" );
|
||||
ri.Printf( PRINT_ALL, "GL_MAX_TEXTURE_SIZE: %d\n", glConfig.maxTextureSize );
|
||||
ri.Printf( PRINT_ALL, "GL_MAX_TEXTURE_IMAGE_UNITS: %d\n", glConfig.numTextureUnits );
|
||||
ri.Printf( PRINT_ALL, "GL_MAX_TEXTURE_UNITS_ARB: %d\n", glConfig.numTextureUnits );
|
||||
ri.Printf( PRINT_ALL, "\nPIXELFORMAT: color(%d-bits) Z(%d-bit) stencil(%d-bits)\n", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
|
||||
ri.Printf( PRINT_ALL, "MODE: %d, %d x %d %s hz:", r_mode->integer, glConfig.vidWidth, glConfig.vidHeight, fsstrings[r_fullscreen->integer == 1] );
|
||||
if ( glConfig.displayFrequency )
|
||||
|
|
@ -1253,7 +1239,6 @@ void R_Register( void )
|
|||
r_specularMapping = ri.Cvar_Get( "r_specularMapping", "1", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
r_deluxeMapping = ri.Cvar_Get( "r_deluxeMapping", "1", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
r_parallaxMapping = ri.Cvar_Get( "r_parallaxMapping", "0", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
r_parallaxMapShadows = ri.Cvar_Get( "r_parallaxMapShadows", "0", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
r_cubeMapping = ri.Cvar_Get( "r_cubeMapping", "0", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
r_cubemapSize = ri.Cvar_Get( "r_cubemapSize", "128", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
r_deluxeSpecular = ri.Cvar_Get("r_deluxeSpecular", "0.3", CVAR_ARCHIVE | CVAR_LATCH);
|
||||
|
|
@ -1574,11 +1559,6 @@ void RE_Shutdown( qboolean destroyWindow ) {
|
|||
GLimp_Shutdown();
|
||||
|
||||
Com_Memset( &glConfig, 0, sizeof( glConfig ) );
|
||||
Com_Memset( &glRefConfig, 0, sizeof( glRefConfig ) );
|
||||
textureFilterAnisotropic = qfalse;
|
||||
maxAnisotropy = 0;
|
||||
displayAspect = 0.0f;
|
||||
|
||||
Com_Memset( &glState, 0, sizeof( glState ) );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -36,19 +36,6 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
#include "../renderercommon/iqm.h"
|
||||
#include "../renderercommon/qgl.h"
|
||||
|
||||
#define GLE(ret, name, ...) extern name##proc * qgl##name;
|
||||
QGL_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
QGL_3_0_PROCS;
|
||||
QGL_ARB_occlusion_query_PROCS;
|
||||
QGL_ARB_framebuffer_object_PROCS;
|
||||
QGL_ARB_vertex_array_object_PROCS;
|
||||
QGL_EXT_direct_state_access_PROCS;
|
||||
#undef GLE
|
||||
|
||||
#define GL_INDEX_TYPE GL_UNSIGNED_INT
|
||||
typedef unsigned int glIndex_t;
|
||||
|
||||
|
|
@ -555,18 +542,16 @@ enum
|
|||
GENERICDEF_USE_VERTEX_ANIMATION = 0x0004,
|
||||
GENERICDEF_USE_FOG = 0x0008,
|
||||
GENERICDEF_USE_RGBAGEN = 0x0010,
|
||||
GENERICDEF_USE_BONE_ANIMATION = 0x0020,
|
||||
GENERICDEF_ALL = 0x003F,
|
||||
GENERICDEF_COUNT = 0x0040,
|
||||
GENERICDEF_ALL = 0x001F,
|
||||
GENERICDEF_COUNT = 0x0020,
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
FOGDEF_USE_DEFORM_VERTEXES = 0x0001,
|
||||
FOGDEF_USE_VERTEX_ANIMATION = 0x0002,
|
||||
FOGDEF_USE_BONE_ANIMATION = 0x0004,
|
||||
FOGDEF_ALL = 0x0007,
|
||||
FOGDEF_COUNT = 0x0008,
|
||||
FOGDEF_ALL = 0x0003,
|
||||
FOGDEF_COUNT = 0x0004,
|
||||
};
|
||||
|
||||
enum
|
||||
|
|
@ -582,21 +567,12 @@ enum
|
|||
LIGHTDEF_USE_LIGHT_VECTOR = 0x0002,
|
||||
LIGHTDEF_USE_LIGHT_VERTEX = 0x0003,
|
||||
LIGHTDEF_LIGHTTYPE_MASK = 0x0003,
|
||||
LIGHTDEF_ENTITY_VERTEX_ANIMATION = 0x0004,
|
||||
LIGHTDEF_ENTITY = 0x0004,
|
||||
LIGHTDEF_USE_TCGEN_AND_TCMOD = 0x0008,
|
||||
LIGHTDEF_USE_PARALLAXMAP = 0x0010,
|
||||
LIGHTDEF_USE_SHADOWMAP = 0x0020,
|
||||
LIGHTDEF_ENTITY_BONE_ANIMATION = 0x0040,
|
||||
LIGHTDEF_ALL = 0x007F,
|
||||
LIGHTDEF_COUNT = 0x0080
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
SHADOWMAPDEF_USE_VERTEX_ANIMATION = 0x0001,
|
||||
SHADOWMAPDEF_USE_BONE_ANIMATION = 0x0002,
|
||||
SHADOWMAPDEF_ALL = 0x0003,
|
||||
SHADOWMAPDEF_COUNT = 0x0004
|
||||
LIGHTDEF_ALL = 0x003F,
|
||||
LIGHTDEF_COUNT = 0x0040
|
||||
};
|
||||
|
||||
enum
|
||||
|
|
@ -607,8 +583,7 @@ enum
|
|||
GLSL_VEC2,
|
||||
GLSL_VEC3,
|
||||
GLSL_VEC4,
|
||||
GLSL_MAT16,
|
||||
GLSL_MAT16_BONEMATRIX
|
||||
GLSL_MAT16
|
||||
};
|
||||
|
||||
typedef enum
|
||||
|
|
@ -699,8 +674,6 @@ typedef enum
|
|||
|
||||
UNIFORM_ALPHATEST,
|
||||
|
||||
UNIFORM_BONEMATRIX,
|
||||
|
||||
UNIFORM_COUNT
|
||||
} uniform_t;
|
||||
|
||||
|
|
@ -864,7 +837,6 @@ typedef enum {
|
|||
SF_FLARE,
|
||||
SF_ENTITY, // beams, rails, lightning, etc that can be determined by entity
|
||||
SF_VAO_MDVMESH,
|
||||
SF_VAO_IQM,
|
||||
|
||||
SF_NUM_SURFACE_TYPES,
|
||||
SF_MAX = 0x7fffffff // ensures that sizeof( surfaceType_t ) == sizeof( int )
|
||||
|
|
@ -955,12 +927,6 @@ typedef struct srfBspSurface_s
|
|||
float *heightLodError;
|
||||
} srfBspSurface_t;
|
||||
|
||||
typedef struct {
|
||||
vec3_t translate;
|
||||
quat_t rotate;
|
||||
vec3_t scale;
|
||||
} iqmTransform_t;
|
||||
|
||||
// inter-quake-model
|
||||
typedef struct {
|
||||
int num_vertexes;
|
||||
|
|
@ -971,37 +937,28 @@ typedef struct {
|
|||
int num_poses;
|
||||
struct srfIQModel_s *surfaces;
|
||||
|
||||
int *triangles;
|
||||
|
||||
// vertex arrays
|
||||
float *positions;
|
||||
float *texcoords;
|
||||
float *normals;
|
||||
float *tangents;
|
||||
byte *colors;
|
||||
int *influences; // [num_vertexes] indexes into influenceBlendVertexes
|
||||
|
||||
// unique list of vertex blend indexes/weights for faster CPU vertex skinning
|
||||
byte *influenceBlendIndexes; // [num_influences]
|
||||
byte *blendIndexes;
|
||||
union {
|
||||
float *f;
|
||||
byte *b;
|
||||
} influenceBlendWeights; // [num_influences]
|
||||
} blendWeights;
|
||||
byte *colors;
|
||||
int *triangles;
|
||||
|
||||
// depending upon the exporter, blend indices and weights might be int/float
|
||||
// as opposed to the recommended byte/byte, for example Noesis exports
|
||||
// int/float whereas the official IQM tool exports byte/byte
|
||||
int blendWeightsType; // IQM_UBYTE or IQM_FLOAT
|
||||
byte blendWeightsType; // IQM_UBYTE or IQM_FLOAT
|
||||
|
||||
char *jointNames;
|
||||
int *jointParents;
|
||||
float *bindJoints; // [num_joints * 12]
|
||||
float *invBindJoints; // [num_joints * 12]
|
||||
iqmTransform_t *poses; // [num_frames * num_poses]
|
||||
float *jointMats;
|
||||
float *poseMats;
|
||||
float *bounds;
|
||||
|
||||
int numVaoSurfaces;
|
||||
struct srfVaoIQModel_s *vaoSurfaces;
|
||||
char *names;
|
||||
} iqmData_t;
|
||||
|
||||
// inter-quake-model surface
|
||||
|
|
@ -1012,24 +969,8 @@ typedef struct srfIQModel_s {
|
|||
iqmData_t *data;
|
||||
int first_vertex, num_vertexes;
|
||||
int first_triangle, num_triangles;
|
||||
int first_influence, num_influences;
|
||||
} srfIQModel_t;
|
||||
|
||||
typedef struct srfVaoIQModel_s
|
||||
{
|
||||
surfaceType_t surfaceType;
|
||||
|
||||
iqmData_t *iqmData;
|
||||
struct srfIQModel_s *iqmSurface;
|
||||
|
||||
// backEnd stats
|
||||
int numIndexes;
|
||||
int numVerts;
|
||||
|
||||
// static render data
|
||||
vao_t *vao;
|
||||
} srfVaoIQModel_t;
|
||||
|
||||
typedef struct srfVaoMdvMesh_s
|
||||
{
|
||||
surfaceType_t surfaceType;
|
||||
|
|
@ -1368,8 +1309,6 @@ typedef struct {
|
|||
uint32_t storedGlState;
|
||||
float vertexAttribsInterpolation;
|
||||
qboolean vertexAnimation;
|
||||
int boneAnimation; // number of bones
|
||||
mat4_t boneMatrix[IQM_MAX_JOINTS];
|
||||
uint32_t vertexAttribsEnabled; // global if no VAOs, tess only otherwise
|
||||
FBO_t *currentFBO;
|
||||
vao_t *currentVao;
|
||||
|
|
@ -1399,7 +1338,6 @@ typedef struct {
|
|||
|
||||
int glslMajorVersion;
|
||||
int glslMinorVersion;
|
||||
int glslMaxAnimatedBones;
|
||||
|
||||
memInfo_t memInfo;
|
||||
|
||||
|
|
@ -1580,7 +1518,7 @@ typedef struct {
|
|||
shaderProgram_t fogShader[FOGDEF_COUNT];
|
||||
shaderProgram_t dlightShader[DLIGHTDEF_COUNT];
|
||||
shaderProgram_t lightallShader[LIGHTDEF_COUNT];
|
||||
shaderProgram_t shadowmapShader[SHADOWMAPDEF_COUNT];
|
||||
shaderProgram_t shadowmapShader;
|
||||
shaderProgram_t pshadowShader;
|
||||
shaderProgram_t down4xShader;
|
||||
shaderProgram_t bokehShader;
|
||||
|
|
@ -1778,7 +1716,6 @@ extern cvar_t *r_normalMapping;
|
|||
extern cvar_t *r_specularMapping;
|
||||
extern cvar_t *r_deluxeMapping;
|
||||
extern cvar_t *r_parallaxMapping;
|
||||
extern cvar_t *r_parallaxMapShadows;
|
||||
extern cvar_t *r_cubeMapping;
|
||||
extern cvar_t *r_cubemapSize;
|
||||
extern cvar_t *r_deluxeSpecular;
|
||||
|
|
@ -2066,7 +2003,7 @@ void RB_EndSurface(void);
|
|||
void RB_CheckOverflow( int verts, int indexes );
|
||||
#define RB_CHECKOVERFLOW(v,i) if (tess.numVertexes + (v) >= SHADER_MAX_VERTEXES || tess.numIndexes + (i) >= SHADER_MAX_INDEXES ) {RB_CheckOverflow(v,i);}
|
||||
|
||||
void R_DrawElements( int numIndexes, int firstIndex );
|
||||
void R_DrawElements( int numIndexes, glIndex_t firstIndex );
|
||||
void RB_StageIteratorGeneric( void );
|
||||
void RB_StageIteratorSky( void );
|
||||
void RB_StageIteratorVertexLitTexture( void );
|
||||
|
|
@ -2234,7 +2171,6 @@ void GLSL_SetUniformVec2(shaderProgram_t *program, int uniformNum, const vec2_t
|
|||
void GLSL_SetUniformVec3(shaderProgram_t *program, int uniformNum, const vec3_t v);
|
||||
void GLSL_SetUniformVec4(shaderProgram_t *program, int uniformNum, const vec4_t v);
|
||||
void GLSL_SetUniformMat4(shaderProgram_t *program, int uniformNum, const mat4_t matrix);
|
||||
void GLSL_SetUniformMat4BoneMatrix(shaderProgram_t *program, int uniformNum, /*const*/ mat4_t *matrix, int numMatricies);
|
||||
|
||||
shaderProgram_t *GLSL_GetGenericShaderProgram(int stage);
|
||||
|
||||
|
|
@ -2289,7 +2225,6 @@ void RB_MDRSurfaceAnim( mdrSurface_t *surface );
|
|||
qboolean R_LoadIQM (model_t *mod, void *buffer, int filesize, const char *name );
|
||||
void R_AddIQMSurfaces( trRefEntity_t *ent );
|
||||
void RB_IQMSurfaceAnim( surfaceType_t *surface );
|
||||
void RB_IQMSurfaceAnimVao( srfVaoIQModel_t *surface );
|
||||
int R_IQMLerpTag( orientation_t *tag, iqmData_t *data,
|
||||
int startFrame, int endFrame,
|
||||
float frac, const char *tagName );
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -437,7 +437,7 @@ void RE_BeginScene(const refdef_t *fd)
|
|||
}
|
||||
|
||||
|
||||
void RE_EndScene(void)
|
||||
void RE_EndScene()
|
||||
{
|
||||
// the next scene rendered in this frame will tack on after this one
|
||||
r_firstSceneDrawSurf = tr.refdef.numDrawSurfs;
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ R_DrawElements
|
|||
==================
|
||||
*/
|
||||
|
||||
void R_DrawElements( int numIndexes, int firstIndex )
|
||||
void R_DrawElements( int numIndexes, glIndex_t firstIndex)
|
||||
{
|
||||
qglDrawElements(GL_TRIANGLES, numIndexes, GL_INDEX_TYPE, BUFFER_OFFSET(firstIndex * sizeof(glIndex_t)));
|
||||
}
|
||||
|
|
@ -908,8 +908,6 @@ static void RB_FogPass( void ) {
|
|||
|
||||
if (glState.vertexAnimation)
|
||||
index |= FOGDEF_USE_VERTEX_ANIMATION;
|
||||
else if (glState.boneAnimation)
|
||||
index |= FOGDEF_USE_BONE_ANIMATION;
|
||||
|
||||
sp = &tr.fogShader[index];
|
||||
}
|
||||
|
|
@ -923,11 +921,6 @@ static void RB_FogPass( void ) {
|
|||
GLSL_SetUniformMat4(sp, UNIFORM_MODELVIEWPROJECTIONMATRIX, glState.modelviewProjection);
|
||||
|
||||
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
||||
|
||||
if (glState.boneAnimation)
|
||||
{
|
||||
GLSL_SetUniformMat4BoneMatrix(sp, UNIFORM_BONEMATRIX, glState.boneMatrix, glState.boneAnimation);
|
||||
}
|
||||
|
||||
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
||||
if (deformGen != DGEN_NONE)
|
||||
|
|
@ -1038,14 +1031,7 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
|
|||
|
||||
if (backEnd.currentEntity && backEnd.currentEntity != &tr.worldEntity)
|
||||
{
|
||||
if (glState.boneAnimation)
|
||||
{
|
||||
index |= LIGHTDEF_ENTITY_BONE_ANIMATION;
|
||||
}
|
||||
else
|
||||
{
|
||||
index |= LIGHTDEF_ENTITY_VERTEX_ANIMATION;
|
||||
}
|
||||
index |= LIGHTDEF_ENTITY;
|
||||
}
|
||||
|
||||
if (pStage->stateBits & GLS_ATEST_BITS)
|
||||
|
|
@ -1068,10 +1054,6 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
|
|||
{
|
||||
shaderAttribs |= GENERICDEF_USE_VERTEX_ANIMATION;
|
||||
}
|
||||
else if (glState.boneAnimation)
|
||||
{
|
||||
shaderAttribs |= GENERICDEF_USE_BONE_ANIMATION;
|
||||
}
|
||||
|
||||
if (pStage->stateBits & GLS_ATEST_BITS)
|
||||
{
|
||||
|
|
@ -1087,14 +1069,7 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
|
|||
|
||||
if (backEnd.currentEntity && backEnd.currentEntity != &tr.worldEntity)
|
||||
{
|
||||
if (glState.boneAnimation)
|
||||
{
|
||||
index |= LIGHTDEF_ENTITY_BONE_ANIMATION;
|
||||
}
|
||||
else
|
||||
{
|
||||
index |= LIGHTDEF_ENTITY_VERTEX_ANIMATION;
|
||||
}
|
||||
index |= LIGHTDEF_ENTITY;
|
||||
}
|
||||
|
||||
if (r_sunlightMode->integer && (backEnd.viewParms.flags & VPF_USESUNLIGHT) && (index & LIGHTDEF_LIGHTTYPE_MASK))
|
||||
|
|
@ -1125,11 +1100,6 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
|
|||
GLSL_SetUniformVec3(sp, UNIFORM_LOCALVIEWORIGIN, backEnd.or.viewOrigin);
|
||||
|
||||
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
||||
|
||||
if (glState.boneAnimation)
|
||||
{
|
||||
GLSL_SetUniformMat4BoneMatrix(sp, UNIFORM_BONEMATRIX, glState.boneMatrix, glState.boneAnimation);
|
||||
}
|
||||
|
||||
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
||||
if (deformGen != DGEN_NONE)
|
||||
|
|
@ -1432,16 +1402,7 @@ static void RB_RenderShadowmap( shaderCommands_t *input )
|
|||
ComputeDeformValues(&deformGen, deformParams);
|
||||
|
||||
{
|
||||
shaderProgram_t *sp = &tr.shadowmapShader[0];
|
||||
|
||||
if (glState.vertexAnimation)
|
||||
{
|
||||
sp = &tr.shadowmapShader[SHADOWMAPDEF_USE_VERTEX_ANIMATION];
|
||||
}
|
||||
else if (glState.boneAnimation)
|
||||
{
|
||||
sp = &tr.shadowmapShader[SHADOWMAPDEF_USE_BONE_ANIMATION];
|
||||
}
|
||||
shaderProgram_t *sp = &tr.shadowmapShader;
|
||||
|
||||
vec4_t vector;
|
||||
|
||||
|
|
@ -1453,11 +1414,6 @@ static void RB_RenderShadowmap( shaderCommands_t *input )
|
|||
|
||||
GLSL_SetUniformFloat(sp, UNIFORM_VERTEXLERP, glState.vertexAttribsInterpolation);
|
||||
|
||||
if (glState.boneAnimation)
|
||||
{
|
||||
GLSL_SetUniformMat4BoneMatrix(sp, UNIFORM_BONEMATRIX, glState.boneMatrix, glState.boneAnimation);
|
||||
}
|
||||
|
||||
GLSL_SetUniformInt(sp, UNIFORM_DEFORMGEN, deformGen);
|
||||
if (deformGen != DGEN_NONE)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -43,8 +43,8 @@ typedef struct {
|
|||
|
||||
static edgeDef_t edgeDefs[SHADER_MAX_VERTEXES][MAX_EDGE_DEFS];
|
||||
static int numEdgeDefs[SHADER_MAX_VERTEXES];
|
||||
//static int facing[SHADER_MAX_INDEXES/3];
|
||||
//static vec3_t shadowXyz[SHADER_MAX_VERTEXES];
|
||||
static int facing[SHADER_MAX_INDEXES/3];
|
||||
static vec3_t shadowXyz[SHADER_MAX_VERTEXES];
|
||||
|
||||
void R_AddEdgeDef( int i1, int i2, int facing ) {
|
||||
int c;
|
||||
|
|
@ -60,8 +60,6 @@ void R_AddEdgeDef( int i1, int i2, int facing ) {
|
|||
}
|
||||
|
||||
void R_RenderShadowEdges( void ) {
|
||||
// FIXME: implement this
|
||||
#if 0
|
||||
int i;
|
||||
|
||||
#if 0
|
||||
|
|
@ -140,7 +138,6 @@ void R_RenderShadowEdges( void ) {
|
|||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -156,8 +153,6 @@ triangleFromEdge[ v1 ][ v2 ]
|
|||
=================
|
||||
*/
|
||||
void RB_ShadowTessEnd( void ) {
|
||||
// FIXME: implement this
|
||||
#if 0
|
||||
int i;
|
||||
int numTris;
|
||||
vec3_t lightDir;
|
||||
|
|
@ -235,7 +230,6 @@ void RB_ShadowTessEnd( void ) {
|
|||
|
||||
// reenable writing to the color buffer
|
||||
qglColorMask(rgba[0], rgba[1], rgba[2], rgba[3]);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -250,8 +244,6 @@ overlap and double darken.
|
|||
=================
|
||||
*/
|
||||
void RB_ShadowFinish( void ) {
|
||||
// FIXME: implement this
|
||||
#if 0
|
||||
if ( r_shadows->integer != 2 ) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -261,6 +253,7 @@ void RB_ShadowFinish( void ) {
|
|||
qglEnable( GL_STENCIL_TEST );
|
||||
qglStencilFunc( GL_NOTEQUAL, 0, 255 );
|
||||
|
||||
qglDisable (GL_CLIP_PLANE0);
|
||||
GL_Cull( CT_TWO_SIDED );
|
||||
|
||||
GL_BindToTMU( tr.whiteImage, TB_COLORMAP );
|
||||
|
|
@ -282,7 +275,6 @@ void RB_ShadowFinish( void ) {
|
|||
|
||||
qglColor4f(1,1,1,1);
|
||||
qglDisable( GL_STENCIL_TEST );
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1913,5 +1913,4 @@ void (*rb_surfaceTable[SF_NUM_SURFACE_TYPES])( void *) = {
|
|||
(void(*)(void*))RB_SurfaceFlare, // SF_FLARE,
|
||||
(void(*)(void*))RB_SurfaceEntity, // SF_ENTITY
|
||||
(void(*)(void*))RB_SurfaceVaoMdvMesh, // SF_VAO_MDVMESH
|
||||
(void(*)(void*))RB_IQMSurfaceAnimVao, // SF_VAO_IQM
|
||||
};
|
||||
|
|
|
|||
|
|
@ -687,13 +687,8 @@ vcq;
|
|||
// srfVert_t is 60 bytes
|
||||
// assuming each vert is referenced 4 times, need 16 bytes (4 glIndex_t) per vert
|
||||
// -> need about 4/15ths the space for indexes as vertexes
|
||||
#if GL_INDEX_TYPE == GL_UNSIGNED_SHORT
|
||||
#define VAOCACHE_VERTEX_BUFFER_SIZE (sizeof(srfVert_t) * USHRT_MAX)
|
||||
#define VAOCACHE_INDEX_BUFFER_SIZE (sizeof(glIndex_t) * USHRT_MAX * 4)
|
||||
#else // GL_UNSIGNED_INT
|
||||
#define VAOCACHE_VERTEX_BUFFER_SIZE (16 * 1024 * 1024)
|
||||
#define VAOCACHE_INDEX_BUFFER_SIZE (5 * 1024 * 1024)
|
||||
#endif
|
||||
|
||||
typedef struct buffered_s
|
||||
{
|
||||
|
|
@ -751,7 +746,7 @@ void VaoCache_Commit(void)
|
|||
if (indexSet < vc.surfaceIndexSets + vc.numSurfaces)
|
||||
{
|
||||
tess.firstIndex = indexSet->bufferOffset / sizeof(glIndex_t);
|
||||
//ri.Printf(PRINT_ALL, "firstIndex %d numIndexes %d as %d\n", tess.firstIndex, tess.numIndexes, (int)(batchLength - vc.batchLengths));
|
||||
//ri.Printf(PRINT_ALL, "firstIndex %d numIndexes %d as %d\n", tess.firstIndex, tess.numIndexes, batchLength - vc.batchLengths);
|
||||
//ri.Printf(PRINT_ALL, "vc.numSurfaces %d vc.numBatches %d\n", vc.numSurfaces, vc.numBatches);
|
||||
}
|
||||
// If not, rebuffer the batch
|
||||
|
|
@ -792,7 +787,7 @@ void VaoCache_Commit(void)
|
|||
vcq.indexCommitSize += indexesSize;
|
||||
}
|
||||
|
||||
//ri.Printf(PRINT_ALL, "committing %d to %d, %d to %d as %d\n", vcq.vertexCommitSize, vc.vertexOffset, vcq.indexCommitSize, vc.indexOffset, (int)(batchLength - vc.batchLengths));
|
||||
//ri.Printf(PRINT_ALL, "committing %d to %d, %d to %d as %d\n", vcq.vertexCommitSize, vc.vertexOffset, vcq.indexCommitSize, vc.indexOffset, batchLength - vc.batchLengths);
|
||||
|
||||
if (vcq.vertexCommitSize)
|
||||
{
|
||||
|
|
@ -812,6 +807,9 @@ void VaoCache_Commit(void)
|
|||
|
||||
void VaoCache_Init(void)
|
||||
{
|
||||
srfVert_t vert;
|
||||
int dataSize;
|
||||
|
||||
vc.vao = R_CreateVao("VaoCache", NULL, VAOCACHE_VERTEX_BUFFER_SIZE, NULL, VAOCACHE_INDEX_BUFFER_SIZE, VAO_USAGE_DYNAMIC);
|
||||
|
||||
vc.vao->attribs[ATTR_INDEX_POSITION].enabled = 1;
|
||||
|
|
@ -846,21 +844,21 @@ void VaoCache_Init(void)
|
|||
vc.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].normalized = GL_TRUE;
|
||||
vc.vao->attribs[ATTR_INDEX_COLOR].normalized = GL_TRUE;
|
||||
|
||||
vc.vao->attribs[ATTR_INDEX_POSITION].offset = offsetof(srfVert_t, xyz);
|
||||
vc.vao->attribs[ATTR_INDEX_TEXCOORD].offset = offsetof(srfVert_t, st);
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTCOORD].offset = offsetof(srfVert_t, lightmap);
|
||||
vc.vao->attribs[ATTR_INDEX_NORMAL].offset = offsetof(srfVert_t, normal);
|
||||
vc.vao->attribs[ATTR_INDEX_TANGENT].offset = offsetof(srfVert_t, tangent);
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].offset = offsetof(srfVert_t, lightdir);
|
||||
vc.vao->attribs[ATTR_INDEX_COLOR].offset = offsetof(srfVert_t, color);
|
||||
vc.vao->attribs[ATTR_INDEX_POSITION].offset = 0; dataSize = sizeof(vert.xyz);
|
||||
vc.vao->attribs[ATTR_INDEX_TEXCOORD].offset = dataSize; dataSize += sizeof(vert.st);
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTCOORD].offset = dataSize; dataSize += sizeof(vert.lightmap);
|
||||
vc.vao->attribs[ATTR_INDEX_NORMAL].offset = dataSize; dataSize += sizeof(vert.normal);
|
||||
vc.vao->attribs[ATTR_INDEX_TANGENT].offset = dataSize; dataSize += sizeof(vert.tangent);
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].offset = dataSize; dataSize += sizeof(vert.lightdir);
|
||||
vc.vao->attribs[ATTR_INDEX_COLOR].offset = dataSize; dataSize += sizeof(vert.color);
|
||||
|
||||
vc.vao->attribs[ATTR_INDEX_POSITION].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_TEXCOORD].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTCOORD].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_NORMAL].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_TANGENT].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_COLOR].stride = sizeof(srfVert_t);
|
||||
vc.vao->attribs[ATTR_INDEX_POSITION].stride = dataSize;
|
||||
vc.vao->attribs[ATTR_INDEX_TEXCOORD].stride = dataSize;
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTCOORD].stride = dataSize;
|
||||
vc.vao->attribs[ATTR_INDEX_NORMAL].stride = dataSize;
|
||||
vc.vao->attribs[ATTR_INDEX_TANGENT].stride = dataSize;
|
||||
vc.vao->attribs[ATTR_INDEX_LIGHTDIRECTION].stride = dataSize;
|
||||
vc.vao->attribs[ATTR_INDEX_COLOR].stride = dataSize;
|
||||
|
||||
Vao_SetVertexPointers(vc.vao);
|
||||
|
||||
|
|
@ -885,7 +883,7 @@ void VaoCache_CheckAdd(qboolean *endSurface, qboolean *recycleVertexBuffer, qboo
|
|||
|
||||
if (vc.vao->vertexesSize < vc.vertexOffset + vcq.vertexCommitSize + vertexesSize)
|
||||
{
|
||||
//ri.Printf(PRINT_ALL, "out of space in vertex cache: %d < %d + %d + %d\n", vc.vao->vertexesSize, vc.vertexOffset, vcq.vertexCommitSize, vertexesSize);
|
||||
//ri.Printf(PRINT_ALL, "out of space in vertex cache: %d < %d + %d + %d\n", vc.vao->vertexesSize, vc.vertexOffset, vc.vertexCommitSize, vertexesSize);
|
||||
*recycleVertexBuffer = qtrue;
|
||||
*recycleIndexBuffer = qtrue;
|
||||
*endSurface = qtrue;
|
||||
|
|
@ -963,6 +961,6 @@ void VaoCache_AddSurface(srfVert_t *verts, int numVerts, glIndex_t *indexes, int
|
|||
queueEntry->numIndexes = numIndexes;
|
||||
vcq.numSurfaces++;
|
||||
|
||||
vcq.vertexCommitSize += sizeof(srfVert_t) * numVerts;
|
||||
vcq.vertexCommitSize += sizeof(srfVert_t) * numVerts;;
|
||||
vcq.indexCommitSize += sizeof(glIndex_t) * numIndexes;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,19 +65,9 @@ void (APIENTRYP qglUnlockArraysEXT) (void);
|
|||
|
||||
#define GLE(ret, name, ...) name##proc * qgl##name;
|
||||
QGL_1_1_PROCS;
|
||||
QGL_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_ES_1_1_PROCS;
|
||||
QGL_ES_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
QGL_3_0_PROCS;
|
||||
QGL_ARB_occlusion_query_PROCS;
|
||||
QGL_ARB_framebuffer_object_PROCS;
|
||||
QGL_ARB_vertex_array_object_PROCS;
|
||||
QGL_EXT_direct_state_access_PROCS;
|
||||
#undef GLE
|
||||
|
||||
/*
|
||||
|
|
@ -237,7 +227,7 @@ GLimp_GetProcAddresses
|
|||
Get addresses for OpenGL functions.
|
||||
===============
|
||||
*/
|
||||
static qboolean GLimp_GetProcAddresses( qboolean fixedFunction ) {
|
||||
static qboolean GLimp_GetProcAddresses( void ) {
|
||||
qboolean success = qtrue;
|
||||
const char *version;
|
||||
|
||||
|
|
@ -276,41 +266,17 @@ static qboolean GLimp_GetProcAddresses( qboolean fixedFunction ) {
|
|||
sscanf( version, "%d.%d", &qglMajorVersion, &qglMinorVersion );
|
||||
}
|
||||
|
||||
if ( fixedFunction ) {
|
||||
if ( QGL_VERSION_ATLEAST( 1, 2 ) ) {
|
||||
QGL_1_1_PROCS;
|
||||
QGL_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS;
|
||||
} else if ( qglesMajorVersion == 1 && qglesMinorVersion >= 1 ) {
|
||||
// OpenGL ES 1.1 (2.0 is not backward compatible)
|
||||
QGL_1_1_PROCS;
|
||||
QGL_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_ES_1_1_PROCS;
|
||||
QGL_ES_1_1_FIXED_FUNCTION_PROCS;
|
||||
// error so this doesn't segfault due to NULL desktop GL functions being used
|
||||
Com_Error( ERR_FATAL, "Unsupported OpenGL Version: %s\n", version );
|
||||
} else {
|
||||
Com_Error( ERR_FATAL, "Unsupported OpenGL Version (%s), OpenGL 1.2 is required\n", version );
|
||||
}
|
||||
if ( QGL_VERSION_ATLEAST( 1, 2 ) ) {
|
||||
QGL_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
} else if ( qglesMajorVersion == 1 && qglesMinorVersion >= 1 ) {
|
||||
// OpenGL ES 1.1 (2.0 is not backward compatible)
|
||||
QGL_1_1_PROCS;
|
||||
QGL_ES_1_1_PROCS;
|
||||
// error so this doesn't segfault due to NULL desktop GL functions being used
|
||||
Com_Error( ERR_FATAL, "Unsupported OpenGL Version: %s\n", version );
|
||||
} else {
|
||||
if ( QGL_VERSION_ATLEAST( 2, 0 ) ) {
|
||||
QGL_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
} else if ( QGLES_VERSION_ATLEAST( 2, 0 ) ) {
|
||||
QGL_1_1_PROCS;
|
||||
QGL_ES_1_1_PROCS;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
// error so this doesn't segfault due to NULL desktop GL functions being used
|
||||
Com_Error( ERR_FATAL, "Unsupported OpenGL Version: %s\n", version );
|
||||
} else {
|
||||
Com_Error( ERR_FATAL, "Unsupported OpenGL Version (%s), OpenGL 2.0 is required\n", version );
|
||||
}
|
||||
Com_Error( ERR_FATAL, "Unsupported OpenGL Version: %s\n", version );
|
||||
}
|
||||
|
||||
if ( QGL_VERSION_ATLEAST( 3, 0 ) || QGLES_VERSION_ATLEAST( 3, 0 ) ) {
|
||||
|
|
@ -338,26 +304,9 @@ static void GLimp_ClearProcAddresses( void ) {
|
|||
qglesMinorVersion = 0;
|
||||
|
||||
QGL_1_1_PROCS;
|
||||
QGL_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_DESKTOP_1_1_PROCS;
|
||||
QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_ES_1_1_PROCS;
|
||||
QGL_ES_1_1_FIXED_FUNCTION_PROCS;
|
||||
QGL_1_3_PROCS;
|
||||
QGL_1_5_PROCS;
|
||||
QGL_2_0_PROCS;
|
||||
QGL_3_0_PROCS;
|
||||
QGL_ARB_occlusion_query_PROCS;
|
||||
QGL_ARB_framebuffer_object_PROCS;
|
||||
QGL_ARB_vertex_array_object_PROCS;
|
||||
QGL_EXT_direct_state_access_PROCS;
|
||||
|
||||
qglActiveTextureARB = NULL;
|
||||
qglClientActiveTextureARB = NULL;
|
||||
qglMultiTexCoord2fARB = NULL;
|
||||
|
||||
qglLockArraysEXT = NULL;
|
||||
qglUnlockArraysEXT = NULL;
|
||||
|
||||
#undef GLE
|
||||
}
|
||||
|
|
@ -367,7 +316,7 @@ static void GLimp_ClearProcAddresses( void ) {
|
|||
GLimp_SetMode
|
||||
===============
|
||||
*/
|
||||
static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder, qboolean fixedFunction)
|
||||
static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder, qboolean coreContext)
|
||||
{
|
||||
const char *glstring;
|
||||
int perChannelColorBits;
|
||||
|
|
@ -631,7 +580,7 @@ static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder, qbool
|
|||
|
||||
SDL_SetWindowIcon( SDL_window, icon );
|
||||
|
||||
if (!fixedFunction)
|
||||
if (coreContext)
|
||||
{
|
||||
int profileMask, majorVersion, minorVersion;
|
||||
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profileMask);
|
||||
|
|
@ -657,7 +606,7 @@ static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder, qbool
|
|||
|
||||
ri.Printf(PRINT_ALL, "SDL_GL_CreateContext succeeded.\n");
|
||||
|
||||
if ( GLimp_GetProcAddresses( fixedFunction ) )
|
||||
if ( GLimp_GetProcAddresses() )
|
||||
{
|
||||
renderer = (const char *)qglGetString(GL_RENDERER);
|
||||
}
|
||||
|
|
@ -697,7 +646,7 @@ static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder, qbool
|
|||
continue;
|
||||
}
|
||||
|
||||
if ( !GLimp_GetProcAddresses( fixedFunction ) )
|
||||
if ( !GLimp_GetProcAddresses() )
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "GLimp_GetProcAddresses() failed\n" );
|
||||
GLimp_ClearProcAddresses();
|
||||
|
|
@ -802,7 +751,7 @@ static qboolean GLimp_StartDriverAndSetMode(int mode, qboolean fullscreen, qbool
|
|||
GLimp_InitExtensions
|
||||
===============
|
||||
*/
|
||||
static void GLimp_InitExtensions( qboolean fixedFunction )
|
||||
static void GLimp_InitExtensions( void )
|
||||
{
|
||||
if ( !r_allowExtensions->integer )
|
||||
{
|
||||
|
|
@ -854,92 +803,89 @@ static void GLimp_InitExtensions( qboolean fixedFunction )
|
|||
}
|
||||
}
|
||||
|
||||
// OpenGL 1 fixed function pipeline
|
||||
if ( fixedFunction )
|
||||
|
||||
// GL_EXT_texture_env_add
|
||||
glConfig.textureEnvAddAvailable = qfalse;
|
||||
if ( SDL_GL_ExtensionSupported( "GL_EXT_texture_env_add" ) )
|
||||
{
|
||||
// GL_EXT_texture_env_add
|
||||
glConfig.textureEnvAddAvailable = qfalse;
|
||||
if ( SDL_GL_ExtensionSupported( "GL_EXT_texture_env_add" ) )
|
||||
if ( r_ext_texture_env_add->integer )
|
||||
{
|
||||
if ( r_ext_texture_env_add->integer )
|
||||
{
|
||||
glConfig.textureEnvAddAvailable = qtrue;
|
||||
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
|
||||
}
|
||||
else
|
||||
{
|
||||
glConfig.textureEnvAddAvailable = qfalse;
|
||||
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
|
||||
}
|
||||
glConfig.textureEnvAddAvailable = qtrue;
|
||||
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
|
||||
glConfig.textureEnvAddAvailable = qfalse;
|
||||
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
|
||||
}
|
||||
|
||||
// GL_ARB_multitexture
|
||||
qglMultiTexCoord2fARB = NULL;
|
||||
qglActiveTextureARB = NULL;
|
||||
qglClientActiveTextureARB = NULL;
|
||||
if ( SDL_GL_ExtensionSupported( "GL_ARB_multitexture" ) )
|
||||
// GL_ARB_multitexture
|
||||
qglMultiTexCoord2fARB = NULL;
|
||||
qglActiveTextureARB = NULL;
|
||||
qglClientActiveTextureARB = NULL;
|
||||
if ( SDL_GL_ExtensionSupported( "GL_ARB_multitexture" ) )
|
||||
{
|
||||
if ( r_ext_multitexture->value )
|
||||
{
|
||||
if ( r_ext_multitexture->value )
|
||||
{
|
||||
qglMultiTexCoord2fARB = SDL_GL_GetProcAddress( "glMultiTexCoord2fARB" );
|
||||
qglActiveTextureARB = SDL_GL_GetProcAddress( "glActiveTextureARB" );
|
||||
qglClientActiveTextureARB = SDL_GL_GetProcAddress( "glClientActiveTextureARB" );
|
||||
qglMultiTexCoord2fARB = SDL_GL_GetProcAddress( "glMultiTexCoord2fARB" );
|
||||
qglActiveTextureARB = SDL_GL_GetProcAddress( "glActiveTextureARB" );
|
||||
qglClientActiveTextureARB = SDL_GL_GetProcAddress( "glClientActiveTextureARB" );
|
||||
|
||||
if ( qglActiveTextureARB )
|
||||
if ( qglActiveTextureARB )
|
||||
{
|
||||
GLint glint = 0;
|
||||
qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glint );
|
||||
glConfig.numTextureUnits = (int) glint;
|
||||
if ( glConfig.numTextureUnits > 1 )
|
||||
{
|
||||
GLint glint = 0;
|
||||
qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glint );
|
||||
glConfig.numTextureUnits = (int) glint;
|
||||
if ( glConfig.numTextureUnits > 1 )
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
|
||||
}
|
||||
else
|
||||
{
|
||||
qglMultiTexCoord2fARB = NULL;
|
||||
qglActiveTextureARB = NULL;
|
||||
qglClientActiveTextureARB = NULL;
|
||||
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
|
||||
}
|
||||
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
|
||||
}
|
||||
else
|
||||
{
|
||||
qglMultiTexCoord2fARB = NULL;
|
||||
qglActiveTextureARB = NULL;
|
||||
qglClientActiveTextureARB = NULL;
|
||||
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
|
||||
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
|
||||
}
|
||||
|
||||
// GL_EXT_compiled_vertex_array
|
||||
if ( SDL_GL_ExtensionSupported( "GL_EXT_compiled_vertex_array" ) )
|
||||
// GL_EXT_compiled_vertex_array
|
||||
if ( SDL_GL_ExtensionSupported( "GL_EXT_compiled_vertex_array" ) )
|
||||
{
|
||||
if ( r_ext_compiled_vertex_array->value )
|
||||
{
|
||||
if ( r_ext_compiled_vertex_array->value )
|
||||
ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
|
||||
qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) SDL_GL_GetProcAddress( "glLockArraysEXT" );
|
||||
qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) SDL_GL_GetProcAddress( "glUnlockArraysEXT" );
|
||||
if (!qglLockArraysEXT || !qglUnlockArraysEXT)
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
|
||||
qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) SDL_GL_GetProcAddress( "glLockArraysEXT" );
|
||||
qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) SDL_GL_GetProcAddress( "glUnlockArraysEXT" );
|
||||
if (!qglLockArraysEXT || !qglUnlockArraysEXT)
|
||||
{
|
||||
ri.Error (ERR_FATAL, "bad getprocaddress");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
|
||||
ri.Error (ERR_FATAL, "bad getprocaddress");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
|
||||
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
|
||||
}
|
||||
|
||||
textureFilterAnisotropic = qfalse;
|
||||
if ( SDL_GL_ExtensionSupported( "GL_EXT_texture_filter_anisotropic" ) )
|
||||
|
|
@ -977,7 +923,7 @@ This routine is responsible for initializing the OS specific portions
|
|||
of OpenGL
|
||||
===============
|
||||
*/
|
||||
void GLimp_Init( qboolean fixedFunction )
|
||||
void GLimp_Init( qboolean coreContext)
|
||||
{
|
||||
ri.Printf( PRINT_DEVELOPER, "Glimp_Init( )\n" );
|
||||
|
||||
|
|
@ -997,13 +943,13 @@ void GLimp_Init( qboolean fixedFunction )
|
|||
ri.Sys_GLimpInit( );
|
||||
|
||||
// Create the window and set up the context
|
||||
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, r_noborder->integer, fixedFunction))
|
||||
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, r_noborder->integer, coreContext))
|
||||
goto success;
|
||||
|
||||
// Try again, this time in a platform specific "safe mode"
|
||||
ri.Sys_GLimpSafeInit( );
|
||||
|
||||
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse, fixedFunction))
|
||||
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse, coreContext))
|
||||
goto success;
|
||||
|
||||
// Finally, try the default screen resolution
|
||||
|
|
@ -1012,7 +958,7 @@ void GLimp_Init( qboolean fixedFunction )
|
|||
ri.Printf( PRINT_ALL, "Setting r_mode %d failed, falling back on r_mode %d\n",
|
||||
r_mode->integer, R_MODE_FALLBACK );
|
||||
|
||||
if(GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse, fixedFunction))
|
||||
if(GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse, coreContext))
|
||||
goto success;
|
||||
}
|
||||
|
||||
|
|
@ -1067,7 +1013,7 @@ success:
|
|||
}
|
||||
|
||||
// initialize extensions
|
||||
GLimp_InitExtensions( fixedFunction );
|
||||
GLimp_InitExtensions( );
|
||||
|
||||
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
|
||||
|
||||
|
|
|
|||
|
|
@ -188,6 +188,9 @@ qboolean SNDDMA_Init(void)
|
|||
SDL_AudioSpec desired;
|
||||
SDL_AudioSpec obtained;
|
||||
int tmp;
|
||||
#ifdef USE_SDL_AUDIO_CAPTURE
|
||||
SDL_version sdlVersion;
|
||||
#endif
|
||||
|
||||
if (snd_inited)
|
||||
return qtrue;
|
||||
|
|
@ -264,15 +267,20 @@ qboolean SNDDMA_Init(void)
|
|||
if (!tmp)
|
||||
tmp = (obtained.samples * obtained.channels) * 10;
|
||||
|
||||
// samples must be divisible by number of channels
|
||||
tmp -= tmp % obtained.channels;
|
||||
if (tmp & (tmp - 1)) // not a power of two? Seems to confuse something.
|
||||
{
|
||||
int val = 1;
|
||||
while (val < tmp)
|
||||
val <<= 1;
|
||||
|
||||
tmp = val;
|
||||
}
|
||||
|
||||
dmapos = 0;
|
||||
dma.samplebits = SDL_AUDIO_BITSIZE(obtained.format);
|
||||
dma.isfloat = SDL_AUDIO_ISFLOAT(obtained.format);
|
||||
dma.channels = obtained.channels;
|
||||
dma.samples = tmp;
|
||||
dma.fullsamples = dma.samples / dma.channels;
|
||||
dma.submission_chunk = 1;
|
||||
dma.speed = obtained.freq;
|
||||
dmasize = (dma.samples * (dma.samplebits/8));
|
||||
|
|
@ -281,10 +289,11 @@ qboolean SNDDMA_Init(void)
|
|||
#ifdef USE_SDL_AUDIO_CAPTURE
|
||||
// !!! FIXME: some of these SDL_OpenAudioDevice() values should be cvars.
|
||||
s_sdlCapture = Cvar_Get( "s_sdlCapture", "1", CVAR_ARCHIVE | CVAR_LATCH );
|
||||
// !!! FIXME: pulseaudio capture records audio the entire time the program is running. https://bugzilla.libsdl.org/show_bug.cgi?id=4087
|
||||
if (Q_stricmp(SDL_GetCurrentAudioDriver(), "pulseaudio") == 0)
|
||||
// !!! FIXME: hopefully pulseaudio capture will be fixed in SDL 2.0.9... https://bugzilla.libsdl.org/show_bug.cgi?id=4087
|
||||
SDL_GetVersion(&sdlVersion);
|
||||
if (sdlVersion.major == 2 && sdlVersion.minor == 0 && sdlVersion.patch < 9 && Q_stricmp(SDL_GetCurrentAudioDriver(), "pulseaudio") == 0)
|
||||
{
|
||||
Com_Printf("SDL audio capture support disabled for pulseaudio (https://bugzilla.libsdl.org/show_bug.cgi?id=4087)\n");
|
||||
Com_Printf("SDL audio capture support disabled (pulseaudio capture does not work correctly with SDL %d.%d.%d)\n", sdlVersion.major, sdlVersion.minor, sdlVersion.patch);
|
||||
}
|
||||
else if (!s_sdlCapture->integer)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -112,14 +112,6 @@ Restart the input subsystem
|
|||
*/
|
||||
void Sys_In_Restart_f( void )
|
||||
{
|
||||
#ifndef DEDICATED
|
||||
if( !SDL_WasInit( SDL_INIT_VIDEO ) )
|
||||
{
|
||||
Com_Printf( "in_restart: Cannot restart input while video is shutdown\n" );
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
IN_Restart( );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3086,7 +3086,6 @@ static void UI_Update(const char *name) {
|
|||
trap_Cvar_SetValue( "r_stencilbits", 8 );
|
||||
trap_Cvar_SetValue( "r_picmip", 0 );
|
||||
trap_Cvar_SetValue( "r_mode", 4 );
|
||||
trap_Cvar_Set( "ui_videomode", "800x600" );
|
||||
trap_Cvar_SetValue( "r_texturebits", 32 );
|
||||
trap_Cvar_SetValue( "r_fastSky", 0 );
|
||||
trap_Cvar_SetValue( "r_inGameVideo", 1 );
|
||||
|
|
@ -3104,7 +3103,6 @@ static void UI_Update(const char *name) {
|
|||
trap_Cvar_Reset( "r_stencilbits" );
|
||||
trap_Cvar_SetValue( "r_picmip", 1 );
|
||||
trap_Cvar_SetValue( "r_mode", 3 );
|
||||
trap_Cvar_Set( "ui_videomode", "640x480" );
|
||||
trap_Cvar_SetValue( "r_texturebits", 0 );
|
||||
trap_Cvar_SetValue( "r_fastSky", 0 );
|
||||
trap_Cvar_SetValue( "r_inGameVideo", 1 );
|
||||
|
|
@ -3122,7 +3120,6 @@ static void UI_Update(const char *name) {
|
|||
trap_Cvar_Reset( "r_stencilbits" );
|
||||
trap_Cvar_SetValue( "r_picmip", 1 );
|
||||
trap_Cvar_SetValue( "r_mode", 3 );
|
||||
trap_Cvar_Set( "ui_videomode", "640x480" );
|
||||
trap_Cvar_SetValue( "r_texturebits", 0 );
|
||||
trap_Cvar_SetValue( "cg_shadows", 0 );
|
||||
trap_Cvar_SetValue( "r_fastSky", 1 );
|
||||
|
|
@ -3139,7 +3136,6 @@ static void UI_Update(const char *name) {
|
|||
trap_Cvar_SetValue( "r_depthbits", 16 );
|
||||
trap_Cvar_SetValue( "r_stencilbits", 0 );
|
||||
trap_Cvar_SetValue( "r_mode", 3 );
|
||||
trap_Cvar_Set( "ui_videomode", "640x480" );
|
||||
trap_Cvar_SetValue( "r_picmip", 2 );
|
||||
trap_Cvar_SetValue( "r_texturebits", 16 );
|
||||
trap_Cvar_SetValue( "cg_shadows", 0 );
|
||||
|
|
@ -5083,8 +5079,6 @@ void _UI_Init( qboolean inGameLoad ) {
|
|||
// cache redundant calulations
|
||||
trap_GetGlconfig( &uiInfo.uiDC.glconfig );
|
||||
|
||||
trap_Cvar_Set("ui_videomode", va( "%dx%d", uiInfo.uiDC.glconfig.vidWidth, uiInfo.uiDC.glconfig.vidHeight ) );
|
||||
|
||||
// for 640x480 virtualized screen
|
||||
uiInfo.uiDC.yscale = uiInfo.uiDC.glconfig.vidHeight * (1.0/480.0);
|
||||
uiInfo.uiDC.xscale = uiInfo.uiDC.glconfig.vidWidth * (1.0/640.0);
|
||||
|
|
@ -5877,7 +5871,6 @@ static cvarTable_t cvarTable[] = {
|
|||
{ &ui_realCaptureLimit, "capturelimit", "8", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART},
|
||||
{ &ui_serverStatusTimeOut, "ui_serverStatusTimeOut", "7000", CVAR_ARCHIVE},
|
||||
|
||||
{ NULL, "ui_videomode", "", CVAR_ROM },
|
||||
{ NULL, "g_localTeamPref", "", 0 },
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -2055,26 +2055,6 @@ qboolean Item_Multi_HandleKey(itemDef_t *item, int key) {
|
|||
} else if ( current >= max ) {
|
||||
current = 0;
|
||||
}
|
||||
|
||||
if (multiPtr->videoMode) {
|
||||
if (multiPtr->cvarValue[current] != -1) {
|
||||
DC->setCVar("r_mode", va("%i", (int) multiPtr->cvarValue[current] ));
|
||||
} else {
|
||||
int w, h;
|
||||
char *x;
|
||||
char str[8];
|
||||
|
||||
x = strchr( multiPtr->cvarStr[current], 'x' ) + 1;
|
||||
Q_strncpyz( str, multiPtr->cvarStr[current], MIN( x-multiPtr->cvarStr[current], sizeof( str ) ) );
|
||||
w = atoi( str );
|
||||
h = atoi( x );
|
||||
|
||||
DC->setCVar("r_mode", "-1");
|
||||
DC->setCVar("r_customwidth", va("%i", w));
|
||||
DC->setCVar("r_customheight", va("%i", h));
|
||||
}
|
||||
}
|
||||
|
||||
if (multiPtr->strDef) {
|
||||
DC->setCVar(item->cvar, multiPtr->cvarStr[current]);
|
||||
} else {
|
||||
|
|
@ -5023,7 +5003,6 @@ qboolean ItemParse_cvarStrList( itemDef_t *item, int handle ) {
|
|||
multiPtr = (multiDef_t*)item->typeData;
|
||||
multiPtr->count = 0;
|
||||
multiPtr->strDef = qtrue;
|
||||
multiPtr->videoMode = qfalse;
|
||||
|
||||
if (!trap_PC_ReadToken(handle, &token))
|
||||
return qfalse;
|
||||
|
|
@ -5072,7 +5051,6 @@ qboolean ItemParse_cvarFloatList( itemDef_t *item, int handle ) {
|
|||
multiPtr = (multiDef_t*)item->typeData;
|
||||
multiPtr->count = 0;
|
||||
multiPtr->strDef = qfalse;
|
||||
multiPtr->videoMode = qfalse;
|
||||
|
||||
if (!trap_PC_ReadToken(handle, &token))
|
||||
return qfalse;
|
||||
|
|
@ -5249,61 +5227,6 @@ void Item_SetupKeywordHash(void) {
|
|||
}
|
||||
}
|
||||
|
||||
static const char *builtinResolutions[ ] =
|
||||
{
|
||||
"320x240",
|
||||
"400x300",
|
||||
"512x384",
|
||||
"640x480",
|
||||
"800x600",
|
||||
"960x720",
|
||||
"1024x768",
|
||||
"1152x864",
|
||||
"1280x1024",
|
||||
"1600x1200",
|
||||
"2048x1536",
|
||||
"856x480",
|
||||
NULL
|
||||
};
|
||||
|
||||
static const char *knownRatios[ ][2] =
|
||||
{
|
||||
{ "1.25:1", "5:4" },
|
||||
{ "1.33:1", "4:3" },
|
||||
{ "1.50:1", "3:2" },
|
||||
{ "1.56:1", "14:9" },
|
||||
{ "1.60:1", "16:10" },
|
||||
{ "1.67:1", "5:3" },
|
||||
{ "1.78:1", "16:9" },
|
||||
{ NULL , NULL }
|
||||
};
|
||||
|
||||
/*
|
||||
===============
|
||||
UI_ResolutionToAspect
|
||||
===============
|
||||
*/
|
||||
static void UI_ResolutionToAspect( const char *resolution, char *aspect, size_t aspectLength ) {
|
||||
int i, w, h;
|
||||
char *x;
|
||||
char str[8];
|
||||
|
||||
// calculate resolution's aspect ratio
|
||||
x = strchr( resolution, 'x' ) + 1;
|
||||
Q_strncpyz( str, resolution, MIN( x-resolution, sizeof( str ) ) );
|
||||
w = atoi( str );
|
||||
h = atoi( x );
|
||||
Com_sprintf( aspect, aspectLength, "%.2f:1", (float)w / (float)h );
|
||||
|
||||
// rename common ratios ("1.33:1" -> "4:3")
|
||||
for( i = 0; knownRatios[i][0]; i++ ) {
|
||||
if( !Q_stricmp( aspect, knownRatios[i][0] ) ) {
|
||||
Q_strncpyz( aspect, knownRatios[i][1], aspectLength );
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
Item_ApplyHacks
|
||||
|
|
@ -5338,89 +5261,6 @@ static void Item_ApplyHacks( itemDef_t *item ) {
|
|||
}
|
||||
}
|
||||
|
||||
// Replace mode list and use a temporary ui_videomode cvar for handling custom modes
|
||||
if ( item->type == ITEM_TYPE_MULTI && item->cvar && !Q_stricmp( item->cvar, "r_mode" ) ) {
|
||||
multiDef_t *multiPtr = (multiDef_t*)item->typeData;
|
||||
int i, oldCount;
|
||||
char resbuf[MAX_STRING_CHARS];
|
||||
char modeName[32], aspect[8];
|
||||
|
||||
item->cvar = "ui_videomode";
|
||||
multiPtr->strDef = qtrue;
|
||||
multiPtr->videoMode = qtrue;
|
||||
|
||||
oldCount = multiPtr->count;
|
||||
multiPtr->count = 0;
|
||||
|
||||
DC->getCVarString( "r_availableModes", resbuf, sizeof( resbuf ) );
|
||||
|
||||
if ( *resbuf ) {
|
||||
char *s = resbuf, *mode;
|
||||
|
||||
while ( s && multiPtr->count < MAX_MULTI_CVARS ) {
|
||||
mode = s;
|
||||
|
||||
s = strchr(s, ' ');
|
||||
if( s )
|
||||
*s++ = '\0';
|
||||
|
||||
UI_ResolutionToAspect( mode, aspect, sizeof( aspect ) );
|
||||
Com_sprintf( modeName, sizeof( modeName ), "%s (%s)", mode, aspect );
|
||||
|
||||
multiPtr->cvarList[multiPtr->count] = String_Alloc( modeName );
|
||||
|
||||
for ( i = 0; builtinResolutions[i]; i++ ) {
|
||||
if( !Q_stricmp( builtinResolutions[i], mode ) ) {
|
||||
multiPtr->cvarStr[multiPtr->count] = builtinResolutions[i];
|
||||
multiPtr->cvarValue[multiPtr->count] = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ( builtinResolutions[i] == NULL ) {
|
||||
multiPtr->cvarStr[multiPtr->count] = String_Alloc( mode );
|
||||
multiPtr->cvarValue[multiPtr->count] = -1;
|
||||
}
|
||||
|
||||
multiPtr->count++;
|
||||
}
|
||||
} else {
|
||||
for ( i = 0; builtinResolutions[i] && multiPtr->count < MAX_MULTI_CVARS; i++ ) {
|
||||
UI_ResolutionToAspect( builtinResolutions[i], aspect, sizeof( aspect ) );
|
||||
Com_sprintf( modeName, sizeof( modeName ), "%s (%s)", builtinResolutions[i], aspect );
|
||||
|
||||
multiPtr->cvarList[multiPtr->count] = String_Alloc( modeName );
|
||||
multiPtr->cvarStr[multiPtr->count] = builtinResolutions[i];
|
||||
multiPtr->cvarValue[multiPtr->count] = i;
|
||||
multiPtr->count++;
|
||||
}
|
||||
}
|
||||
|
||||
// Add custom resolution if not in mode list
|
||||
if ( multiPtr->count < MAX_MULTI_CVARS ) {
|
||||
char currentResolution[20];
|
||||
|
||||
Com_sprintf( currentResolution, sizeof ( currentResolution ), "%dx%d", DC->glconfig.vidWidth, DC->glconfig.vidHeight );
|
||||
for ( i = 0; i < multiPtr->count; i++ ) {
|
||||
if ( !Q_stricmp( multiPtr->cvarStr[i], currentResolution ) ) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ( i == multiPtr->count ) {
|
||||
UI_ResolutionToAspect( currentResolution, aspect, sizeof( aspect ) );
|
||||
Com_sprintf( modeName, sizeof( modeName ), "%s (%s)", currentResolution, aspect );
|
||||
|
||||
multiPtr->cvarList[multiPtr->count] = String_Alloc( modeName );
|
||||
multiPtr->cvarStr[multiPtr->count] = String_Alloc( currentResolution );
|
||||
multiPtr->cvarValue[multiPtr->count] = -1;
|
||||
multiPtr->count++;
|
||||
}
|
||||
}
|
||||
|
||||
Com_Printf( "Found video mode list with %d modes, replaced list with %d modes\n", oldCount, multiPtr->count );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -203,7 +203,6 @@ typedef struct multiDef_s {
|
|||
float cvarValue[MAX_MULTI_CVARS];
|
||||
int count;
|
||||
qboolean strDef;
|
||||
qboolean videoMode;
|
||||
} multiDef_t;
|
||||
|
||||
typedef struct modelDef_s {
|
||||
|
|
|
|||
338
misc/msvc12/.gitignore
vendored
338
misc/msvc12/.gitignore
vendored
|
|
@ -1,338 +0,0 @@
|
|||
## Ignore Visual Studio temporary files, build results, and
|
||||
## files generated by popular Visual Studio add-ons.
|
||||
##
|
||||
## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
|
||||
|
||||
# User-specific files
|
||||
*.rsuser
|
||||
*.suo
|
||||
*.user
|
||||
*.userosscache
|
||||
*.sln.docstates
|
||||
|
||||
# User-specific files (MonoDevelop/Xamarin Studio)
|
||||
*.userprefs
|
||||
|
||||
# Build results
|
||||
[Dd]ebug/
|
||||
[Dd]ebugPublic/
|
||||
[Rr]elease/
|
||||
[Rr]eleases/
|
||||
x64/
|
||||
x86/
|
||||
[Aa][Rr][Mm]/
|
||||
[Aa][Rr][Mm]64/
|
||||
bld/
|
||||
[Bb]in/
|
||||
[Oo]bj/
|
||||
[Ll]og/
|
||||
|
||||
# Visual Studio 2015/2017 cache/options directory
|
||||
.vs/
|
||||
# Uncomment if you have tasks that create the project's static files in wwwroot
|
||||
#wwwroot/
|
||||
|
||||
# Visual Studio 2017 auto generated files
|
||||
Generated\ Files/
|
||||
|
||||
# MSTest test Results
|
||||
[Tt]est[Rr]esult*/
|
||||
[Bb]uild[Ll]og.*
|
||||
|
||||
# NUNIT
|
||||
*.VisualState.xml
|
||||
TestResult.xml
|
||||
|
||||
# Build Results of an ATL Project
|
||||
[Dd]ebugPS/
|
||||
[Rr]eleasePS/
|
||||
dlldata.c
|
||||
|
||||
# Benchmark Results
|
||||
BenchmarkDotNet.Artifacts/
|
||||
|
||||
# .NET Core
|
||||
project.lock.json
|
||||
project.fragment.lock.json
|
||||
artifacts/
|
||||
|
||||
# StyleCop
|
||||
StyleCopReport.xml
|
||||
|
||||
# Files built by Visual Studio
|
||||
*_i.c
|
||||
*_p.c
|
||||
*_h.h
|
||||
*.ilk
|
||||
*.meta
|
||||
*.obj
|
||||
*.iobj
|
||||
*.pch
|
||||
*.pdb
|
||||
*.ipdb
|
||||
*.pgc
|
||||
*.pgd
|
||||
*.rsp
|
||||
*.sbr
|
||||
*.tlb
|
||||
*.tli
|
||||
*.tlh
|
||||
*.tmp
|
||||
*.tmp_proj
|
||||
*_wpftmp.csproj
|
||||
*.log
|
||||
*.vspscc
|
||||
*.vssscc
|
||||
.builds
|
||||
*.pidb
|
||||
*.svclog
|
||||
*.scc
|
||||
|
||||
# Chutzpah Test files
|
||||
_Chutzpah*
|
||||
|
||||
# Visual C++ cache files
|
||||
ipch/
|
||||
*.aps
|
||||
*.ncb
|
||||
*.opendb
|
||||
*.opensdf
|
||||
*.sdf
|
||||
*.cachefile
|
||||
*.VC.db
|
||||
*.VC.VC.opendb
|
||||
|
||||
# Visual Studio profiler
|
||||
*.psess
|
||||
*.vsp
|
||||
*.vspx
|
||||
*.sap
|
||||
|
||||
# Visual Studio Trace Files
|
||||
*.e2e
|
||||
|
||||
# TFS 2012 Local Workspace
|
||||
$tf/
|
||||
|
||||
# Guidance Automation Toolkit
|
||||
*.gpState
|
||||
|
||||
# ReSharper is a .NET coding add-in
|
||||
_ReSharper*/
|
||||
*.[Rr]e[Ss]harper
|
||||
*.DotSettings.user
|
||||
|
||||
# JustCode is a .NET coding add-in
|
||||
.JustCode
|
||||
|
||||
# TeamCity is a build add-in
|
||||
_TeamCity*
|
||||
|
||||
# DotCover is a Code Coverage Tool
|
||||
*.dotCover
|
||||
|
||||
# AxoCover is a Code Coverage Tool
|
||||
.axoCover/*
|
||||
!.axoCover/settings.json
|
||||
|
||||
# Visual Studio code coverage results
|
||||
*.coverage
|
||||
*.coveragexml
|
||||
|
||||
# NCrunch
|
||||
_NCrunch_*
|
||||
.*crunch*.local.xml
|
||||
nCrunchTemp_*
|
||||
|
||||
# MightyMoose
|
||||
*.mm.*
|
||||
AutoTest.Net/
|
||||
|
||||
# Web workbench (sass)
|
||||
.sass-cache/
|
||||
|
||||
# Installshield output folder
|
||||
[Ee]xpress/
|
||||
|
||||
# DocProject is a documentation generator add-in
|
||||
DocProject/buildhelp/
|
||||
DocProject/Help/*.HxT
|
||||
DocProject/Help/*.HxC
|
||||
DocProject/Help/*.hhc
|
||||
DocProject/Help/*.hhk
|
||||
DocProject/Help/*.hhp
|
||||
DocProject/Help/Html2
|
||||
DocProject/Help/html
|
||||
|
||||
# Click-Once directory
|
||||
publish/
|
||||
|
||||
# Publish Web Output
|
||||
*.[Pp]ublish.xml
|
||||
*.azurePubxml
|
||||
# Note: Comment the next line if you want to checkin your web deploy settings,
|
||||
# but database connection strings (with potential passwords) will be unencrypted
|
||||
*.pubxml
|
||||
*.publishproj
|
||||
|
||||
# Microsoft Azure Web App publish settings. Comment the next line if you want to
|
||||
# checkin your Azure Web App publish settings, but sensitive information contained
|
||||
# in these scripts will be unencrypted
|
||||
PublishScripts/
|
||||
|
||||
# NuGet Packages
|
||||
*.nupkg
|
||||
# The packages folder can be ignored because of Package Restore
|
||||
**/[Pp]ackages/*
|
||||
# except build/, which is used as an MSBuild target.
|
||||
!**/[Pp]ackages/build/
|
||||
# Uncomment if necessary however generally it will be regenerated when needed
|
||||
#!**/[Pp]ackages/repositories.config
|
||||
# NuGet v3's project.json files produces more ignorable files
|
||||
*.nuget.props
|
||||
*.nuget.targets
|
||||
|
||||
# Microsoft Azure Build Output
|
||||
csx/
|
||||
*.build.csdef
|
||||
|
||||
# Microsoft Azure Emulator
|
||||
ecf/
|
||||
rcf/
|
||||
|
||||
# Windows Store app package directories and files
|
||||
AppPackages/
|
||||
BundleArtifacts/
|
||||
Package.StoreAssociation.xml
|
||||
_pkginfo.txt
|
||||
*.appx
|
||||
|
||||
# Visual Studio cache files
|
||||
# files ending in .cache can be ignored
|
||||
*.[Cc]ache
|
||||
# but keep track of directories ending in .cache
|
||||
!*.[Cc]ache/
|
||||
|
||||
# Others
|
||||
ClientBin/
|
||||
~$*
|
||||
*~
|
||||
*.dbmdl
|
||||
*.dbproj.schemaview
|
||||
*.jfm
|
||||
*.pfx
|
||||
*.publishsettings
|
||||
orleans.codegen.cs
|
||||
|
||||
# Including strong name files can present a security risk
|
||||
# (https://github.com/github/gitignore/pull/2483#issue-259490424)
|
||||
#*.snk
|
||||
|
||||
# Since there are multiple workflows, uncomment next line to ignore bower_components
|
||||
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
|
||||
#bower_components/
|
||||
# ASP.NET Core default setup: bower directory is configured as wwwroot/lib/ and bower restore is true
|
||||
**/wwwroot/lib/
|
||||
|
||||
# RIA/Silverlight projects
|
||||
Generated_Code/
|
||||
|
||||
# Backup & report files from converting an old project file
|
||||
# to a newer Visual Studio version. Backup files are not needed,
|
||||
# because we have git ;-)
|
||||
_UpgradeReport_Files/
|
||||
Backup*/
|
||||
UpgradeLog*.XML
|
||||
UpgradeLog*.htm
|
||||
ServiceFabricBackup/
|
||||
*.rptproj.bak
|
||||
|
||||
# SQL Server files
|
||||
*.mdf
|
||||
*.ldf
|
||||
*.ndf
|
||||
|
||||
# Business Intelligence projects
|
||||
*.rdl.data
|
||||
*.bim.layout
|
||||
*.bim_*.settings
|
||||
*.rptproj.rsuser
|
||||
|
||||
# Microsoft Fakes
|
||||
FakesAssemblies/
|
||||
|
||||
# GhostDoc plugin setting file
|
||||
*.GhostDoc.xml
|
||||
|
||||
# Node.js Tools for Visual Studio
|
||||
.ntvs_analysis.dat
|
||||
node_modules/
|
||||
|
||||
# Visual Studio 6 build log
|
||||
*.plg
|
||||
|
||||
# Visual Studio 6 workspace options file
|
||||
*.opt
|
||||
|
||||
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
|
||||
*.vbw
|
||||
|
||||
# Visual Studio LightSwitch build output
|
||||
**/*.HTMLClient/GeneratedArtifacts
|
||||
**/*.DesktopClient/GeneratedArtifacts
|
||||
**/*.DesktopClient/ModelManifest.xml
|
||||
**/*.Server/GeneratedArtifacts
|
||||
**/*.Server/ModelManifest.xml
|
||||
_Pvt_Extensions
|
||||
|
||||
# Paket dependency manager
|
||||
.paket/paket.exe
|
||||
paket-files/
|
||||
|
||||
# FAKE - F# Make
|
||||
.fake/
|
||||
|
||||
# JetBrains Rider
|
||||
.idea/
|
||||
*.sln.iml
|
||||
|
||||
# CodeRush personal settings
|
||||
.cr/personal
|
||||
|
||||
# Python Tools for Visual Studio (PTVS)
|
||||
__pycache__/
|
||||
*.pyc
|
||||
|
||||
# Cake - Uncomment if you are using it
|
||||
# tools/**
|
||||
# !tools/packages.config
|
||||
|
||||
# Tabs Studio
|
||||
*.tss
|
||||
|
||||
# Telerik's JustMock configuration file
|
||||
*.jmconfig
|
||||
|
||||
# BizTalk build output
|
||||
*.btp.cs
|
||||
*.btm.cs
|
||||
*.odx.cs
|
||||
*.xsd.cs
|
||||
|
||||
# OpenCover UI analysis results
|
||||
OpenCover/
|
||||
|
||||
# Azure Stream Analytics local run output
|
||||
ASALocalRun/
|
||||
|
||||
# MSBuild Binary and Structured Log
|
||||
*.binlog
|
||||
|
||||
# NVidia Nsight GPU debugger configuration file
|
||||
*.nvuser
|
||||
|
||||
# MFractors (Xamarin productivity tool) working folder
|
||||
.mfractor/
|
||||
|
||||
# Local History for Visual Studio
|
||||
.localhistory/
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
#!/bin/sh
|
||||
rmdir --ignore-fail-on-non-empty demoq3 missionpack >/dev/null 2>&1
|
||||
rmdir --ignore-fail-on-non-empty demoq3 missionpack >& /dev/null
|
||||
if test -e "$SETUP_INSTALLPATH"/ioquake3.desktop.in; then
|
||||
xdg_desktop_menu=`which xdg-desktop-menu 2>/dev/null`
|
||||
if test "x$xdg_desktop_menu" = x; then
|
||||
|
|
|
|||
|
|
@ -184,11 +184,6 @@ Cvars for advanced material usage:
|
|||
1 - Use parallax occlusion mapping.
|
||||
2 - Use relief mapping. (slower)
|
||||
|
||||
* `r_parallaxMapShadows` - Enable self-shadowing on parallax map
|
||||
supported materials.
|
||||
0 - No. (default)
|
||||
1 - Yes.
|
||||
|
||||
* `r_baseSpecular` - Set the specular reflectance of materials
|
||||
which don't include a specular map or
|
||||
use the specularReflectance keyword.
|
||||
|
|
|
|||
Loading…
Reference in a new issue