DEPEND_ON_MAKEFILE ?= yes
DOWNLOAD_GAMEPACKS ?= yes
# set to no to disable gamepack, set to all to even download undistributable gamepacks
+
+# Support CHECK_DEPENDENCIES with DOWNLOAD_GAMEPACKS semantics
+ifneq ($(CHECK_DEPENDENCIES),)
+DEPENDENCIES_CHECK = $(patsubst yes,quiet,$(patsubst no,off,$(CHECK_DEPENDENCIES)))
+else
DEPENDENCIES_CHECK ?= quiet
# or: off, verbose
+endif
# these are used on Win32 only
GTKDIR ?= $(shell PKG_CONFIG_PATH=$(PKG_CONFIG_PATH) $(PKGCONFIG) gtk+-2.0 --variable=prefix $(STDERR_TO_DEVNULL))
// this is very evil, but right now there is no better way
#include "../../radiant/brush.h"
+#define MAX_MATERIAL_NAME (64+9-1)
+// MAX_QPATH plus "textures/" prefix, allow trailing NUL to fit
+
/*
Abstract baseclass for modelexporters
the class collects all the data which then gets
if(mat != lastMat)
{
- if(limNames && mat.size() > 20)
+ if(limNames && mat.size() > MAX_MATERIAL_NAME)
{
- out << "\nusemtl " << mat.substr(mat.size() - 20, mat.size()).c_str();
+ out << "\nusemtl " << mat.substr(mat.size() - MAX_MATERIAL_NAME, mat.size()).c_str();
} else {
out << "\nusemtl " << mat.c_str();
}
outMtl << "# Material Count: " << (const Unsigned)materials.size() << "\n\n";
for(std::set<std::string>::const_iterator it(materials.begin()); it != materials.end(); ++it)
{
- if(limNames && it->size() > 20)
+ if(limNames && it->size() > MAX_MATERIAL_NAME)
{
- outMtl << "newmtl " << it->substr(it->size() - 20, it->size()).c_str() << "\n";
+ outMtl << "newmtl " << it->substr(it->size() - MAX_MATERIAL_NAME, it->size()).c_str() << "\n";
} else {
outMtl << "newmtl " << it->c_str() << "\n";
}
{
ConnectEntities connector(e1, e2, index);
const char* value = e2->getKeyValue("targetname");
- if(string_empty(value))
- {
- value = e1->getKeyValue(connector.keyname());
- }
if(!string_empty(value))
{
connector.connect(value);
float angle;
float add;
float dist;
- float addDeluxe = 0.0f, addDeluxeBounceScale = 0.25f;\r
- qboolean angledDeluxe = qfalse;\r
+ float addDeluxe = 0.0f, addDeluxeBounceScale = 0.25f;
+ qboolean angledDeluxe = qfalse;
float colorBrightness;
/* get light */
/* clear color */
VectorClear( trace->color );
VectorClear( trace->colorNoShadow );
- VectorClear( trace->directionContribution );\r
-\r
+ VectorClear( trace->directionContribution );
+
colorBrightness = RGBTOGRAY( light->color ) * ( 1.0f/255.0f );
/* ydnar: early out */
add = light->photons / (dist * dist) * angle;
- if( deluxemap )\r
- {\r
- if( angledDeluxe )\r
- addDeluxe = light->photons / (dist * dist) * angle;\r
- else\r
- addDeluxe = light->photons / (dist * dist);\r
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = light->photons / (dist * dist) * angle;
+ else
+ addDeluxe = light->photons / (dist * dist);
}
}
else
/* ydnar: moved to here */
add = factor * light->add;
- if( deluxemap )\r
+ if( deluxemap )
addDeluxe = add;
}
}
if( add < 0.0f )
add = 0.0f;
- if( deluxemap )\r
- {\r
- if( angledDeluxe )\r
- addDeluxe = angle * light->photons * linearScale - (dist * light->fade);\r
- else\r
- addDeluxe = light->photons * linearScale - (dist * light->fade);\r
-\r
- if( addDeluxe < 0.0f )\r
- addDeluxe = 0.0f;\r
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = angle * light->photons * linearScale - (dist * light->fade);
+ else
+ addDeluxe = light->photons * linearScale - (dist * light->fade);
+
+ if( addDeluxe < 0.0f )
+ addDeluxe = 0.0f;
}
}
else
{
add = (light->photons / (dist * dist)) * angle;
- if( add < 0.0f )\r
- add = 0.0f;\r
-\r
- if( deluxemap )\r
- {\r
- if( angledDeluxe )\r
- addDeluxe = (light->photons / (dist * dist)) * angle;\r
- else\r
- addDeluxe = (light->photons / (dist * dist));\r
- }\r
-\r
- if( addDeluxe < 0.0f )\r
+ if( add < 0.0f )
+ add = 0.0f;
+
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = (light->photons / (dist * dist)) * angle;
+ else
+ addDeluxe = (light->photons / (dist * dist));
+ }
+
+ if( addDeluxe < 0.0f )
addDeluxe = 0.0f;
}
if( sampleRadius > (radiusAtDist - 32.0f) )
{
add *= ((radiusAtDist - sampleRadius) / 32.0f);
- if( add < 0.0f )\r
- add = 0.0f;\r
-\r
- addDeluxe *= ((radiusAtDist - sampleRadius) / 32.0f);\r
-\r
- if( addDeluxe < 0.0f )\r
+ if( add < 0.0f )
+ add = 0.0f;
+
+ addDeluxe *= ((radiusAtDist - sampleRadius) / 32.0f);
+
+ if( addDeluxe < 0.0f )
addDeluxe = 0.0f;
}
}
/* attenuate */
add = light->photons * angle;
- if( deluxemap )\r
- {\r
- if( angledDeluxe )\r
- addDeluxe = light->photons * angle;\r
- else\r
- addDeluxe = light->photons;\r
-\r
- if( addDeluxe < 0.0f )\r
- addDeluxe = 0.0f;\r
+ if( deluxemap )
+ {
+ if( angledDeluxe )
+ addDeluxe = light->photons * angle;
+ else
+ addDeluxe = light->photons;
+
+ if( addDeluxe < 0.0f )
+ addDeluxe = 0.0f;
}
if( add <= 0.0f )
/* VorteX: set noShadow color */
VectorScale(light->color, add, trace->colorNoShadow);
- addDeluxe *= colorBrightness;\r
-\r
- if( bouncing )\r
- {\r
- addDeluxe *= addDeluxeBounceScale;\r
- if( addDeluxe < 0.00390625f )\r
- addDeluxe = 0.00390625f;\r
- }\r
-\r
+ addDeluxe *= colorBrightness;
+
+ if( bouncing )
+ {
+ addDeluxe *= addDeluxeBounceScale;
+ if( addDeluxe < 0.00390625f )
+ addDeluxe = 0.00390625f;
+ }
+
VectorScale( trace->direction, addDeluxe, trace->directionContribution );
/* setup trace */
if( add <= 0.0f || (add <= light->falloffTolerance && (light->flags & LIGHT_FAST_ACTUAL)) )
return 0;
- addDeluxe *= colorBrightness;\r
-\r
- /* hack land: scale down the radiosity contribution to light directionality.\r
- Deluxemaps fusion many light directions into one. In a rtl process all lights\r
- would contribute individually to the bump map, so several light sources together\r
- would make it more directional (example: a yellow and red lights received from\r
- opposing sides would light one side in red and the other in blue, adding\r
- the effect of 2 directions applied. In the deluxemapping case, this 2 lights would\r
- neutralize each other making it look like having no direction.\r
- Same thing happens with radiosity. In deluxemapping case the radiosity contribution\r
- is modifying the direction applied from directional lights, making it go closer and closer\r
- to the surface normal the bigger is the amount of radiosity received.\r
- So, for preserving the directional lights contributions, we scale down the radiosity\r
- contribution. It's a hack, but there's a reason behind it */\r
- if( bouncing )\r
- {\r
- addDeluxe *= addDeluxeBounceScale;\r
- if( addDeluxe < 0.00390625f )\r
- addDeluxe = 0.00390625f;\r
- }\r
-\r
+ addDeluxe *= colorBrightness;
+
+ /* hack land: scale down the radiosity contribution to light directionality.
+ Deluxemaps fusion many light directions into one. In a rtl process all lights
+ would contribute individually to the bump map, so several light sources together
+ would make it more directional (example: a yellow and red lights received from
+ opposing sides would light one side in red and the other in blue, adding
+ the effect of 2 directions applied. In the deluxemapping case, this 2 lights would
+ neutralize each other making it look like having no direction.
+ Same thing happens with radiosity. In deluxemapping case the radiosity contribution
+ is modifying the direction applied from directional lights, making it go closer and closer
+ to the surface normal the bigger is the amount of radiosity received.
+ So, for preserving the directional lights contributions, we scale down the radiosity
+ contribution. It's a hack, but there's a reason behind it */
+ if( bouncing )
+ {
+ addDeluxe *= addDeluxeBounceScale;
+ if( addDeluxe < 0.00390625f )
+ addDeluxe = 0.00390625f;
+ }
+
VectorScale( trace->direction, addDeluxe, trace->directionContribution );
/* setup trace */
if( trace->passSolid || trace->opaque )
{
VectorClear( trace->color );
- VectorClear( trace->directionContribution );\r
+ VectorClear( trace->directionContribution );
return -1;
}
}
}
- noDirty = qfalse;\r
- for( i = 0; i < trace.numSurfaces; i++ )\r
- {\r
- /* get surface */\r
- info = &surfaceInfos[ trace.surfaces[ i ] ];\r
-\r
- /* check twosidedness */\r
- if( info->si->noDirty )\r
- {\r
- noDirty = qtrue;\r
- break;\r
- }\r
+ noDirty = qfalse;
+ for( i = 0; i < trace.numSurfaces; i++ )
+ {
+ /* get surface */
+ info = &surfaceInfos[ trace.surfaces[ i ] ];
+
+ /* check twosidedness */
+ if( info->si->noDirty )
+ {
+ noDirty = qtrue;
+ break;
+ }
}
/* gather dirt */
if( *cluster < 0 )
continue;
- /* don't apply dirty on this surface */\r
- if( noDirty )\r
- {\r
- *dirt = 1.0f;\r
- continue;\r
+ /* don't apply dirty on this surface */
+ if( noDirty )
+ {
+ *dirt = 1.0f;
+ continue;
}
/* copy to trace */
LightContributionToSample( &trace );
VectorCopy( trace.color, lightLuxel );
- /* add the contribution to the deluxemap */\r
- if( deluxemap )\r
+ /* add the contribution to the deluxemap */
+ if( deluxemap )
VectorAdd( deluxel, trace.directionContribution, deluxel );
/* add to count */
rawLightmap_t *lm;
bspDrawVert_t *verts;
trace_t trace;
- float floodLightAmount;\r
+ float floodLightAmount;
vec3_t floodColor;
dirt = 1.0f;
/* jal: floodlight */
- floodLightAmount = 0.0f;\r
- VectorClear( floodColor );\r
- if( floodlighty && !bouncing )\r
- {\r
- floodLightAmount = floodlightIntensity * FloodLightForSample( &trace, floodlightDistance, floodlight_lowquality );\r
- VectorScale( floodlightRGB, floodLightAmount, floodColor );\r
+ floodLightAmount = 0.0f;
+ VectorClear( floodColor );
+ if( floodlighty && !bouncing )
+ {
+ floodLightAmount = floodlightIntensity * FloodLightForSample( &trace, floodlightDistance, floodlight_lowquality );
+ VectorScale( floodlightRGB, floodLightAmount, floodColor );
}
/* trace */
if (luxel[3]==0) luxel[3]=1;
/* add to deluxemap */
- if (deluxemap && floodlight[3] > 0)\r
+ if (deluxemap && floodlight[3] > 0)
{
- vec3_t lightvector;\r
-\r
+ vec3_t lightvector;
+
normal = SUPER_NORMAL( x, y );
- brightness = RGBTOGRAY( floodlight ) * ( 1.0f/255.0f ) * floodlight[3];\r
-\r
- // use AT LEAST this amount of contribution from ambient for the deluxemap, fixes points that receive ZERO light\r
- if(brightness < 0.00390625f)\r
- brightness = 0.00390625f;\r
-\r
+ brightness = RGBTOGRAY( floodlight ) * ( 1.0f/255.0f ) * floodlight[3];
+
+ // use AT LEAST this amount of contribution from ambient for the deluxemap, fixes points that receive ZERO light
+ if(brightness < 0.00390625f)
+ brightness = 0.00390625f;
+
VectorScale( normal, brightness, lightvector );
VectorAdd( deluxel, lightvector, deluxel );
}
if( deluxemap )
{
/* normalize average light direction */
- pixel = olm->bspDirBytes + (((oy * olm->customWidth) + ox) * 3);\r
- VectorScale( deluxel, 1000.0f, direction );\r
- VectorNormalize( direction, direction );\r
- VectorScale( direction, 127.5f, direction );\r
- for( i = 0; i < 3; i++ )\r
+ pixel = olm->bspDirBytes + (((oy * olm->customWidth) + ox) * 3);
+ VectorScale( deluxel, 1000.0f, direction );
+ VectorNormalize( direction, direction );
+ VectorScale( direction, 127.5f, direction );
+ for( i = 0; i < 3; i++ )
pixel[ i ] = (byte)( 127.5f + direction[ i ] );
}
}
-/* -------------------------------------------------------------------------------
+/* -------------------------------------------------------------------------------;
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
int uniform, axis;
qboolean texscale;
float *old_xyzst = NULL;
+ float spawn_ref = 0;
/* arg checking */
if( argc < 3 )
{
- Sys_Printf( "Usage: q3map [-v] -scale [-tex] <value> <mapname>\n" );
+ Sys_Printf( "Usage: q3map [-v] -scale [-tex] [-spawn_ref <value>] <value> <mapname>\n" );
return 0;
}
+ texscale = qfalse;
+ for(i = 1; i < argc-2; ++i)
+ {
+ if(!strcmp(argv[i], "-tex"))
+ {
+ texscale = qtrue;
+ }
+ else if(!strcmp(argv[i], "-spawn_ref"))
+ {
+ spawn_ref = atof(argv[i+1]);
+ ++i;
+ }
+ else
+ break;
+ }
+
/* get scale */
- scale[2] = scale[1] = scale[0] = atof( argv[ argc - 2 ] );
- if(argc >= 4)
+ // if(argc-2 >= i) // always true
+ scale[2] = scale[1] = scale[0] = atof( argv[ argc - 2 ] );
+ if(argc-3 >= i)
scale[1] = scale[0] = atof( argv[ argc - 3 ] );
- if(argc >= 5)
+ if(argc-4 >= i)
scale[0] = atof( argv[ argc - 4 ] );
- texscale = !strcmp(argv[1], "-tex");
-
uniform = ((scale[0] == scale[1]) && (scale[1] == scale[2]));
if( scale[0] == 0.0f || scale[1] == 0.0f || scale[2] == 0.0f )
{
- Sys_Printf( "Usage: q3map [-v] -scale [-tex] <value> <mapname>\n" );
+ Sys_Printf( "Usage: q3map [-v] -scale [-tex] [-spawn_ref <value>] <value> <mapname>\n" );
Sys_Printf( "Non-zero scale value required.\n" );
return 0;
}
GetVectorForKey( &entities[ i ], "origin", vec );
if( (vec[ 0 ] || vec[ 1 ] || vec[ 2 ]) )
{
+ if(!strncmp(ValueForKey(&entities[i], "classname"), "info_player_", 12))
+ vec[2] += spawn_ref;
vec[0] *= scale[0];
vec[1] *= scale[1];
vec[2] *= scale[2];
+ if(!strncmp(ValueForKey(&entities[i], "classname"), "info_player_", 12))
+ vec[2] -= spawn_ref;
sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
SetKeyValue( &entities[ i ], "origin", str );
}
/* temp hack */
- if( !si->clipModel && !(si->compileFlags & C_SOLID) )\r
+ if( !si->clipModel && !(si->compileFlags & C_SOLID) )
continue;
/* walk triangle list */
{
/* 'fatten' the winding by the shader mins/maxs (parsed from vertexDeform move) */
/* note this winding is completely invalid (concave, nonplanar, etc) */
- fat = AllocWinding( w->numpoints * 3 );
- fat->numpoints = w->numpoints * 3;
+ fat = AllocWinding( w->numpoints * 3 + 3 );
+ fat->numpoints = w->numpoints * 3 + 3;
for( i = 0; i < w->numpoints; i++ )
{
VectorCopy( w->p[ i ], fat->p[ i ] );
- VectorAdd( w->p[ i ], si->mins, fat->p[ i * 2 ] );
- VectorAdd( w->p[ i ], si->maxs, fat->p[ i * 3 ] );
+ VectorAdd( w->p[ i ], si->mins, fat->p[ i + (w->numpoints+1) ] );
+ VectorAdd( w->p[ i ], si->maxs, fat->p[ i + (w->numpoints+1) * 2 ] );
}
+ VectorCopy( w->p[ 0 ], fat->p[ i ] );
+ VectorAdd( w->p[ 0 ], si->mins, fat->p[ i + w->numpoints ] );
+ VectorAdd( w->p[ 0 ], si->maxs, fat->p[ i + w->numpoints * 2 ] );
+
+ /*
+ * note: this winding is STILL not suitable for ClipWindingEpsilon, and
+ * also does not really fulfill the intention as it only contains
+ * origin, +mins, +maxs, but thanks to the "closing" points I just
+ * added to the three sub-windings, the fattening at least doesn't make
+ * it worse
+ */
FreeWinding( w );
w = fat;