float
balance(float* left, float* right, unsigned n_samples)
{
float r = 0.0;
float l = 0.0;
float rbuf[n_samples];
float lbuf[n_samples];
VectorPower(rbuf, right, 2.0, n_samples);
VectorPower(lbuf, left, 2.0, n_samples);
r = VectorSum(rbuf, n_samples);
l = VectorSum(lbuf, n_samples);
return (r - l) / ((r + l) + FLT_MIN);
}
///////////////////////////////////////////////////////////////////////////////
// Function: SetMouseForce
// Purpose: Allows the user to interact with selected points by dragging
// Arguments: Delta distance from clicked point, local x and y axes
///////////////////////////////////////////////////////////////////////////////
void CPhysEnv::SetMouseForce(int deltaX,int deltaY, tVector *localX, tVector *localY)
{
/// Local Variables ///////////////////////////////////////////////////////////
tVector tempX,tempY;
///////////////////////////////////////////////////////////////////////////////
ScaleVector(localX, (float)deltaX * 0.03f, &tempX);
ScaleVector(localY, -(float)deltaY * 0.03f, &tempY);
if (m_Pick[0] > -1)
{
VectorSum(&m_CurrentSys[m_Pick[0]].pos,&tempX,&m_MouseDragPos[0]);
VectorSum(&m_MouseDragPos[0],&tempY,&m_MouseDragPos[0]);
}
if (m_Pick[1] > -1)
{
VectorSum(&m_CurrentSys[m_Pick[1]].pos,&tempX,&m_MouseDragPos[1]);
VectorSum(&m_MouseDragPos[1],&tempY,&m_MouseDragPos[1]);
}
}
static void SP_worldspawn (const localEntityParse_t *entData)
{
const int dayLightmap = CL_GetConfigStringInteger(CS_LIGHTMAP);
int i;
/* maximum level */
cl.mapMaxLevel = entData->maxLevel;
if (GAME_IsMultiplayer()) {
if (cl_teamnum->integer > entData->maxMultiplayerTeams || cl_teamnum->integer <= TEAM_CIVILIAN) {
Com_Printf("The selected team is not usable. "
"The map doesn't support %i teams but only %i teams\n",
cl_teamnum->integer, entData->maxMultiplayerTeams);
Cvar_SetValue("cl_teamnum", TEAM_DEFAULT);
Com_Printf("Set teamnum to %i\n", cl_teamnum->integer);
}
}
/** @todo - make sun position/color vary based on local time at location? */
if (dayLightmap)
VectorCopy(entData->ambientDayColor, sun.ambientColor);
else
VectorCopy(entData->ambientNightColor, sun.ambientColor);
/* clamp it */
for (i = 0; i < 3; i++)
if (sun.ambientColor[i] < MIN_AMBIENT_COMPONENT)
sun.ambientColor[i] = MIN_AMBIENT_COMPONENT;
/* scale it into a reasonable range, the clamp above ensures this will work */
while (VectorSum(sun.ambientColor) < MIN_AMBIENT_SUM)
VectorScale(sun.ambientColor, 1.25, sun.ambientColor);
/* set up "global" (ie. directional) light sources */
Vector4Set(sun.loc, 0, 0, -1, 0.0);
sun.constantAttenuation = 1.0;
sun.linearAttenuation = 0.0;
sun.quadraticAttenuation = 0.0;
sun.enabled = qtrue;
if (dayLightmap) { /* sunlight color */
Vector4Set(sun.diffuseColor, 0.8, 0.8, 0.8, 1);
Vector4Set(sun.specularColor, 1.0, 1.0, 0.9, 1);
} else { /* moonlight color */
Vector4Set(sun.diffuseColor, 0.2, 0.2, 0.3, 1);
Vector4Set(sun.specularColor, 0.5, 0.5, 0.7, 1);
}
/** @todo Parse fog from worldspawn config */
refdef.weather = WEATHER_NONE;
refdef.fogColor[3] = 1.0;
VectorSet(refdef.fogColor, 0.75, 0.75, 0.75);
}
void CPhysEnv::ComputeForces( tParticle *system )
{
int loop;
tParticle *curParticle,*p1, *p2;
tSpring *spring;
float dist, Hterm, Dterm;
tVector springForce,deltaV,deltaP;
curParticle = system;
for (loop = 0; loop < m_ParticleCnt; loop++)
{
MAKEVECTOR(curParticle->f,0.0f,0.0f,0.0f) // CLEAR FORCE VECTOR
if (m_UseGravity && curParticle->oneOverM != 0)
{
curParticle->f.x += (m_Gravity.x / curParticle->oneOverM);
curParticle->f.y += (m_Gravity.y / curParticle->oneOverM);
curParticle->f.z += (m_Gravity.z / curParticle->oneOverM);
}
if (m_UseDamping)
{
curParticle->f.x += (-m_Kd * curParticle->v.x);
curParticle->f.y += (-m_Kd * curParticle->v.y);
curParticle->f.z += (-m_Kd * curParticle->v.z);
}
else
{
curParticle->f.x += (-DEFAULT_DAMPING * curParticle->v.x);
curParticle->f.y += (-DEFAULT_DAMPING * curParticle->v.y);
curParticle->f.z += (-DEFAULT_DAMPING * curParticle->v.z);
}
curParticle++;
}
// CHECK IF THERE IS A USER FORCE BEING APPLIED
if (m_UserForceActive)
{
if (m_Pick[0] != -1)
{
VectorSum(&system[m_Pick[0]].f,&m_UserForce,&system[m_Pick[0]].f);
}
if (m_Pick[1] != -1)
{
VectorSum(&system[m_Pick[1]].f,&m_UserForce,&system[m_Pick[1]].f);
}
MAKEVECTOR(m_UserForce,0.0f,0.0f,0.0f); // CLEAR USER FORCE
}
// NOW DO ALL THE SPRINGS
spring = m_Spring;
for (loop = 0; loop < m_SpringCnt; loop++)
{
p1 = &system[spring->p1];
p2 = &system[spring->p2];
VectorDifference(&p1->pos,&p2->pos,&deltaP); // Vector distance
dist = VectorLength(&deltaP); // Magnitude of deltaP
Hterm = (dist - spring->restLen) * spring->Ks; // Ks * (dist - rest)
VectorDifference(&p1->v,&p2->v,&deltaV); // Delta Velocity Vector
Dterm = (DotProduct(&deltaV,&deltaP) * spring->Kd) / dist; // Damping Term
ScaleVector(&deltaP,1.0f / dist, &springForce); // Normalize Distance Vector
ScaleVector(&springForce,-(Hterm + Dterm),&springForce); // Calc Force
VectorSum(&p1->f,&springForce,&p1->f); // Apply to Particle 1
VectorDifference(&p2->f,&springForce,&p2->f); // - Force on Particle 2
spring++; // DO THE NEXT SPRING
}
// APPLY THE MOUSE DRAG FORCES IF THEY ARE ACTIVE
if (m_MouseForceActive)
{
// APPLY TO EACH PICKED PARTICLE
if (m_Pick[0] > -1)
{
p1 = &system[m_Pick[0]];
VectorDifference(&p1->pos,&m_MouseDragPos[0],&deltaP); // Vector distance
dist = VectorLength(&deltaP); // Magnitude of deltaP
if (dist != 0.0f)
{
Hterm = (dist) * m_MouseForceKs; // Ks * dist
ScaleVector(&deltaP,1.0f / dist, &springForce); // Normalize Distance Vector
ScaleVector(&springForce,-(Hterm),&springForce); // Calc Force
VectorSum(&p1->f,&springForce,&p1->f); // Apply to Particle 1
}
}
if (m_Pick[1] > -1)
{
p1 = &system[m_Pick[1]];
VectorDifference(&p1->pos,&m_MouseDragPos[1],&deltaP); // Vector distance
dist = VectorLength(&deltaP); // Magnitude of deltaP
if (dist != 0.0f)
{
Hterm = (dist) * m_MouseForceKs; // Ks * dist
ScaleVector(&deltaP,1.0f / dist, &springForce); // Normalize Distance Vector
ScaleVector(&springForce,-(Hterm),&springForce); // Calc Force
VectorSum(&p1->f,&springForce,&p1->f); // Apply to Particle 1
}
}
}
}
/** @note Defaults should match those of ufo2map, or lighting will be inconsistent between world and models */
static void SP_worldspawn (const localEntityParse_t* entData)
{
/* maximum level */
cl.mapMaxLevel = entData->maxLevel;
if (GAME_IsMultiplayer()) {
if (cl_teamnum->integer > entData->maxMultiplayerTeams || cl_teamnum->integer <= TEAM_CIVILIAN) {
Com_Printf("The selected team is not usable. "
"The map doesn't support %i teams but only %i teams\n",
cl_teamnum->integer, entData->maxMultiplayerTeams);
Cvar_SetValue("cl_teamnum", TEAM_DEFAULT);
Com_Printf("Set teamnum to %i\n", cl_teamnum->integer);
}
}
/** @todo - make sun position/color vary based on local time at location? */
const int dayLightmap = CL_GetConfigStringInteger(CS_LIGHTMAP);
/** @note Some vectors have exra elements to comply with mathlib and/or OpenGL conventions, but handled as shorter ones */
vec3_t sunAngles;
vec4_t sunColor;
vec_t sunIntensity;
if (dayLightmap) {
/* set defaults for daylight */
Vector4Set(refdef.ambientColor, 0.26, 0.26, 0.26, 1.0);
sunIntensity = 280;
VectorSet(sunAngles, -75, 100, 0);
Vector4Set(sunColor, 0.90, 0.75, 0.65, 1.0);
/* override defaults with data from worldspawn entity, if any */
if (VectorNotEmpty(entData->ambientDayColor))
VectorCopy(entData->ambientDayColor, refdef.ambientColor);
if (entData->dayLight)
sunIntensity = entData->dayLight;
if (Vector2NotEmpty(entData->daySunAngles))
Vector2Copy(entData->daySunAngles, sunAngles);
if (VectorNotEmpty(entData->daySunColor))
VectorCopy(entData->daySunColor, sunColor);
Vector4Set(refdef.sunSpecularColor, 1.0, 1.0, 0.9, 1);
} else {
/* set defaults for night light */
Vector4Set(refdef.ambientColor, 0.16, 0.16, 0.17, 1.0);
sunIntensity = 15;
VectorSet(sunAngles, -80, 220, 0);
Vector4Set(sunColor, 0.25, 0.25, 0.35, 1.0);
/* override defaults with data from worldspawn entity, if any */
if (VectorNotEmpty(entData->ambientNightColor))
VectorCopy(entData->ambientNightColor, refdef.ambientColor);
if (entData->nightLight)
sunIntensity = entData->nightLight;
if (Vector2NotEmpty(entData->nightSunAngles))
Vector2Copy(entData->nightSunAngles, sunAngles);
if (VectorNotEmpty(entData->nightSunColor))
VectorCopy(entData->nightSunColor, sunColor);
Vector4Set(refdef.sunSpecularColor, 0.5, 0.5, 0.7, 1);
}
ColorNormalize(sunColor, sunColor);
VectorScale(sunColor, sunIntensity/255.0, sunColor);
Vector4Copy(sunColor, refdef.sunDiffuseColor);
/* clamp ambient for models */
Vector4Copy(refdef.ambientColor, refdef.modelAmbientColor);
for (int i = 0; i < 3; i++)
if (refdef.modelAmbientColor[i] < MIN_AMBIENT_COMPONENT)
refdef.modelAmbientColor[i] = MIN_AMBIENT_COMPONENT;
/* scale it into a reasonable range, the clamp above ensures this will work */
while (VectorSum(refdef.modelAmbientColor) < MIN_AMBIENT_SUM)
VectorScale(refdef.modelAmbientColor, 1.25, refdef.modelAmbientColor);
AngleVectors(sunAngles, refdef.sunVector, nullptr, nullptr);
refdef.sunVector[3] = 0.0; /* to use as directional light source in OpenGL */
/** @todo Parse fog from worldspawn config */
refdef.weather = WEATHER_NONE;
refdef.fogColor[3] = 1.0;
VectorSet(refdef.fogColor, 0.75, 0.75, 0.75);
}
TEST(DSPSingle, TestVectorSum)
{
float in[5] = {1.0, 2.0, 3.0, 4.0, 0.0};
ASSERT_FLOAT_EQ(10.0, VectorSum(in, 5));
}
