float
vsPerlinOctave::InterpolatedNoise2D(float x, float y, int wrap)
{
int integer_X = vsFloor(x);
float fractional_X = x - integer_X;
int integer_Y = vsFloor(y);
float fractional_Y = y - integer_Y;
vsAssert( fractional_X >= 0.f && fractional_X < 1.f, "Maths error: fractional_X out of bounds!" );
vsAssert( fractional_Y >= 0.f && fractional_Y < 1.f, "Maths error: fractional_Y out of bounds!" );
fractional_X = (3.0f * fractional_X * fractional_X) - (2.0f * fractional_X * fractional_X * fractional_X);
fractional_Y = (3.0f * fractional_Y * fractional_Y) - (2.0f * fractional_Y * fractional_Y * fractional_Y);
float v1 = Noise2D(integer_X, integer_Y, wrap);
float v2 = Noise2D(integer_X + 1, integer_Y, wrap);
float v3 = Noise2D(integer_X, integer_Y + 1, wrap);
float v4 = Noise2D(integer_X + 1, integer_Y + 1, wrap);
float i1 = vsInterpolate(fractional_X, v1 , v2);
float i2 = vsInterpolate(fractional_X, v3 , v4);
return vsInterpolate(fractional_Y, i1 , i2);
}
void
rpFader::DynamicDraw( vsRenderQueue *queue )
{
vsDisplayList *list = queue->MakeTemporaryBatchList(m_material, queue->GetMatrix(), 10 * 1024);
vsVector2D tl = vsSystem::GetScreen()->GetScene(2)->GetTopLeftCorner();
vsVector2D br = vsSystem::GetScreen()->GetScene(2)->GetBottomRightCorner();
vsVector2D v[4];
switch ( m_fadeType )
{
case 0:
{
float x = vsInterpolate( m_alpha, tl.x, br.x );
v[0] = tl;
v[1].Set(x, tl.y);
v[2].Set(x, br.y);
v[3].Set(tl.x,br.y);
break;
}
case 1:
{
float x = vsInterpolate( m_alpha, br.x, tl.x );
v[0].Set(x, tl.y);
v[1].Set(br.x, tl.y);
v[2].Set(br.x, br.y);
v[3].Set(x,br.y);
break;
}
case 2:
{
float y = vsInterpolate( m_alpha, tl.y, br.y );
v[0] = tl;
v[1].Set(br.x, tl.y);
v[2].Set(br.x, y);
v[3].Set(tl.x, y);
break;
}
case 3:
{
float y = vsInterpolate( m_alpha, br.y, tl.y );
v[0].Set(tl.x, br.y);
v[1].Set(br.x, br.y);
v[2].Set(br.x, y);
v[3].Set(tl.x, y);
break;
}
}
int indices[4] = { 0, 1, 2, 3 };
list->SetColor( vsColor(0.f,0.f,0.f,1.f) );
list->VertexArray(v,4);
list->TriangleFan(indices,4);
}
void
astPlayerShip::HandleSpawnTimer( float timeStep )
{
m_timeSinceSpawn += timeStep;
const float c_invulnerableTime = 3.0f; // three seconds of invulnerability
if ( m_spawnInvulnerable )
{
float scale = 1.0f;
vsColor c = vsColor::Blue;
if ( m_timeSinceSpawn > c_invulnerableTime )
{
SetCollisionsActive(true);
m_spawnInvulnerable = false;
}
else if ( m_timeSinceSpawn > 2.0f )
{
float frac = (m_timeSinceSpawn - 2.0f);
float theta = frac * TWOPI;
float pulseAmt = vsFabs(vsSin(theta));
c = vsInterpolate(pulseAmt, vsColor::LightBlue, vsColor::White);
}
else if ( m_timeSinceSpawn > 1.0f )
{
float frac = (m_timeSinceSpawn - 1.0f);
float theta = frac * TWOPI;
float pulseAmt = vsFabs(vsSin(theta));
c = vsInterpolate(pulseAmt, vsColor::LightBlue, vsColor::White);
}
else
{
c = vsInterpolate(m_timeSinceSpawn, vsColor::Black, vsColor::LightBlue);
}
const float c_scaleTime = 3.0f;
if ( m_timeSinceSpawn < c_scaleTime )
{
float frac = m_timeSinceSpawn / c_scaleTime;
frac = 1.0f - ((frac-1.f) * (frac-1.f)); // slam in, ease out
//frac = (3.0f * frac * frac) - (2.0f * frac * frac * frac); // ease in, ease out
scale = vsInterpolate( frac, 5.0f, 1.0f );
}
SetColor(c);
m_transform.SetScale( vsVector2D(scale,scale) );
}
}
float
vsSpline3D::TimeAtLength(float target)
{
// let's take 100 samples, and take the linear distance.
float distance = 0.f;
float timeCursor = 0.f;
vsVector3D cursor = m_start;
while ( timeCursor < 1.f )
{
float nextTime = timeCursor + 0.01f;
vsVector3D next = PositionAtTime(nextTime);
float thisDistance = (cursor - next).Length();
if ( distance + thisDistance > target )
{
// we've gone too far! Interpolate.
float fraction = vsProgressFraction( target, distance, distance + thisDistance );
timeCursor = vsInterpolate( fraction, timeCursor, nextTime );
break;
}
distance += thisDistance;
cursor = next;
timeCursor = nextTime;
}
return timeCursor;
}
vsTransform2D
sstSequence::GetTransformAtTime( float time )
{
float timeFraction = (time - m_start) / ( m_end - m_start );
return vsInterpolate( timeFraction, m_transformA, m_transformB );
}
void
sstSequence::Draw( vsRenderQueue *queue )
{
vsDisplayList *list = queue->GetGenericList();
float musicTime = m_mode->GetMusicTime();
// vsColor baseColor = vsColor::Blue;
// vsColor c = vsColor::Blue;
for ( int i = 0; i < m_beatCount; i++ )
m_segment[i].m_color = vsColor::Blue * GetBrightnessForTimeDelta( musicTime - m_segment[i].m_time );
float starBrightness = 0.5f;
float starFadeInTime = 2.0f;
float starFadeOutTime = 2.0f;
if ( musicTime < m_start + starFadeInTime )
{
starBrightness = vsInterpolate( (musicTime-m_start) / starFadeInTime, 0.f, starBrightness );
}
else if ( musicTime < m_end - starFadeOutTime )
{
starBrightness = 0.5f;
}
else
{
float startFadingOutTime = m_end - starFadeOutTime;
starBrightness = vsInterpolate( (musicTime-startFadingOutTime) / starFadeOutTime, starBrightness, 0.f );
}
list->SetColor( vsColor(1.0f, 1.0f, 1.0f, starBrightness) );
for ( int i = 0; i < m_beatCount; i++ )
{
DrawStar( list, i );
}
for ( int i = 0; i < m_beatCount; i++ )
{
DrawTarget( list, i );
if ( i < m_beatCount-1 )
{
DrawConnectingLine( list, i, i+1 );
}
}
}
float
vsPerlinOctave::InterpolatedNoise1D(float x)
{
int integer_X = int(x);
float fractional_X = x - integer_X;
vsAssert( fractional_X >= 0.f && fractional_X < 1.f, "Maths error: fractional_X out of bounds!" );
fractional_X = (3.0f * fractional_X * fractional_X) - (2.0f * fractional_X * fractional_X * fractional_X);
float v1 = SmoothedNoise1D(integer_X);
float v2 = SmoothedNoise1D(integer_X + 1);
return vsInterpolate(fractional_X, v1 , v2);
}
void
astHud::Update(float timeStep)
{
if ( m_fading )
{
m_fadeTimer += timeStep;
if ( m_fadeTimer > 1.0f )
{
m_fadeTimer = 1.0f;
m_fading = false;
}
m_opacity = vsInterpolate( m_fadeTimer, m_fadingFrom, m_fadingTo );
}
}
void
rpFader::Update( float timeStep )
{
if ( m_fading )
{
m_timer += timeStep;
if ( m_timer > m_fadeDuration )
{
m_alpha = m_endAlpha;
m_fading = false;
}
else
{
m_alpha = vsInterpolate( m_timer / m_fadeDuration, m_startAlpha, m_endAlpha );
}
}
}
void
vsPhysicsEmitter::Update(float timeStep)
{
for ( int i = 0; i < m_particleCount; i++ )
{
if ( m_particleInUse[i] )
{
m_particleLife[i] += timeStep;
if ( m_particleLife[i] > m_particleLifetime )
{
m_particle[i]->SetCollisionsActive( false );
m_particle[i]->Extract();
m_particleLife[i] = 0.f;
m_particleInUse[i] = false;
}
else
{
float amt = /*1.0f -*/ (m_particleLife[i] / m_particleLifetime);
vsColor c = m_particleColor[i];
//c.a = vsInterpolate( amt, c.a, 0.f );
m_particle[i]->SetColor( vsInterpolate( amt, c, c_black ) );
}
}
}
m_hose += timeStep * m_spawnRate;
while ( m_hose > 1.0f )
{
vsVector2D pos = m_position + vsRandom::GetVector2D( m_radius );
vsVector2D vel = m_velocity + vsRandom::GetVector2D( m_velRadius );
Spawn( pos, vel, m_color );
m_hose -= 1.0f;
}
}
void
daSplat::Update( float timeStep )
{
m_timer -= timeStep;
SetScale(vsVector2D(1.2f,1.2f));
if ( m_timer <= 0.f )
{
Extract(); // despawn us.
}
else
{
vsColor grey(0.5f,0.5f,0.5f,1.0f);
if ( m_timer > 1.0f )
SetColor(grey);
else
SetColor( vsInterpolate( m_timer, vsColor::Black, grey ) );
}
}
void
astPlayerShip::HandleThrusters( float timeStep )
{
UNUSED(timeStep);
vsInput *input = core::GetGame()->GetInput();
ControlID thrusterControl[Thruster_MAX] =
{
CID_B,
CID_LeftRightLAxis,
CID_LeftRightLAxis
};
/*
SetColor 1.0 1.0 1.0 0.8
MoveTo -0.75 -1.8
LineTo 7.5 -3.0
LineTo 0.75 1.8
*/
for( int i = 0; i < Thruster_MAX; i++ )
{
float desired = input->GetState( thrusterControl[i] );
float current = m_thrustAmt[i];
if ( i == 1 ) // left
desired = vsMax(0.f, -desired);
else
desired = vsMax(0.f, desired);
m_thrustAmt[i] = vsInterpolate( 0.15f, current, desired );
}
m_thrust->m_transform.SetScale( m_thrustAmt[Thruster_Main], m_thrustAmt[Thruster_Main] );
m_leftAttitude->m_transform.SetScale( m_thrustAmt[Thruster_Left], m_thrustAmt[Thruster_Left] );
m_rightAttitude->m_transform.SetScale( -m_thrustAmt[Thruster_Right], m_thrustAmt[Thruster_Right] );
m_rightRearAttitude->m_transform.SetScale( -m_thrustAmt[Thruster_Left], m_thrustAmt[Thruster_Left] );
m_leftRearAttitude->m_transform.SetScale( m_thrustAmt[Thruster_Right], m_thrustAmt[Thruster_Right] );
}
void
vpDrawable::Draw( vsRenderQueue *queue )
{
if ( m_toDelete )
return;
if ( m_sampleCount >= 2 )
{
vsDisplayList *list = queue->GetGenericList();
if ( m_drawing )
{
vsColor c = m_color;
float pulse = m_colorPulse;
c.a = pulse;
list->SetColor(c);
int i = 0;
list->MoveTo( m_samplePos[i] );
for ( i = 1; i < m_sampleCount; i++ )
{
pulse -= (1.0f/30.0f);
if ( pulse < 0.0f )
pulse += 1.0f;
c.a = vsInterpolate(pulse, 0.8f, 0.3f);
list->SetColor(c);
list->LineTo(m_samplePos[i]);
}
}
else
{
//list->SetShader(m_shader);
if ( m_hilighted )
list->SetColor(vsColor::Red);
else
list->SetColor(m_color);
if ( m_drawMode == DrawMode_Rope )
{
list->MoveTo( m_object[0]->GetPosition() );
for ( int i = 1; i < m_objectCount; i++ )
{
list->LineTo( m_object[i]->GetPosition() );
}
}
else // static
{
vsTransform2D t;
t.SetTranslation( m_object[0]->GetPosition() );
t.SetAngle( m_object[0]->GetAngle() );
list->PushTransform(t);
list->VertexArray( m_samplePos, m_sampleCount );
list->LineStrip( m_optimisedIndex, m_optimisedIndexCount );
list->PopTransform();
}
//list->SetShader(NULL);
}
}
}
void
sstFireworks::Draw( vsRenderQueue *queue )
{
/* vsVector2D tl(-3.f,-3.f);
vsVector2D tr(3.f,-3.f);
vsVector2D bl(-3.f,3.f);
vsVector2D br(3.f,3.f);*/
vsDisplayList *list = queue->GetGenericList();
vsColor c;
vsVector2D pos;
vsVector2D dest;
sstFireworkParticle *p = m_usedList->m_next;
int i = 0;
while( p && p != m_usedList )
{
float backVelTime = 0.5f;
if ( p->m_life < backVelTime )
backVelTime = p->m_life;
pos = p->m_position;
dest = pos - (p->m_velocity * backVelTime);
float lifeFraction = p->m_life / p->m_lifeTime;
c = vsInterpolate( lifeFraction, p->m_color, vsColor::Black );
m_vertexArray[i] = pos;
m_vertexArray[i+1] = dest;
m_colorArray[i] = c;
m_colorArray[i+1].Set(c.r,c.g,c.b,0.f);
m_indexArray[i] = i;
m_indexArray[i+1] = i+1;
i+=2;
/* list->SetColor( c );
list->MoveTo( pos );
c.a = 0.0f;
list->SetColor( c );
list->LineTo( dest );*/
p = p->m_next;
}
if ( i > 0 )
{
m_vertexBuffer->SetArray(m_vertexArray,i);
m_colorBuffer->SetArray(m_colorArray,i);
m_indexBuffer->SetArray(m_indexArray,i);
list->VertexBuffer(m_vertexBuffer);
list->ColorBuffer(m_colorBuffer);
list->LineListBuffer(m_indexBuffer);
// list->VertexArray(m_vertexArray, i);
// list->ColorArray(m_colorArray, i);
// list->LineList(m_indexArray, i);
list->ClearColorArray();
list->ClearVertexArray();
}
}
void
rpModeCredits::Update( float timeStep )
{
int activeLines = 0;
for ( int i = 0; i < MAX_CREDIT_LINES; i++ )
{
if ( m_lineUsed[i] )
activeLines++;
}
const float c_creditsScrollSpeed = 50.0f; // 50 'units' per second
const float c_creditLineSpacing = 50.0f;
float top = vsSystem::GetScreen()->GetScene(1)->GetTopLeftCorner().y - 50.0f;
m_creditsPos += (timeStep * c_creditsScrollSpeed);
for ( int i = 0; i < MAX_CREDIT_LINES; i++ )
{
if ( m_lineUsed[i] )
{
float yCoord = m_lineId[i] * c_creditLineSpacing;
yCoord -= m_creditsPos;
if ( m_creditsDone && m_lineId[i] == m_lineCount-1 && yCoord < top )
m_fadingOut = true;
if ( m_creditsDone && m_lineId[i] == m_lineCount-1 ) // last line
yCoord = vsMax( yCoord, 0.f ); // last line doesn't go past halfway.
if ( yCoord < top )
LoadLine(i);
else
m_line[i]->SetPosition( vsVector2D(0.f, yCoord) );
}
else if ( !m_creditsDone )
LoadLine(i);
}
if ( m_game->GetInput()->WasPressed(CID_A) )
m_fadingOut = true;
if ( m_fadingOut )
{
m_fadingTimer += timeStep;
const float c_fadeDuration = 2.0f;
float frac = m_fadingTimer / c_fadeDuration;
vsColor c = vsColor::Black;
if ( !m_inittedFade )
{
//m_game->FadeOutMusic( c_fadeDuration );
m_inittedFade = true;
}
if ( frac < 1.0f )
{
c = vsInterpolate( frac, vsColor::LightBlue, vsColor::Black );
for ( int i = 0; i < MAX_CREDIT_LINES; i++ )
{
if ( m_lineUsed[i] )
{
m_line[i]->SetColor(c);
}
}
}
else
{
return core::SetExit();
}
}
}
void
daModeTitleScreen::Update( float timeStep )
{
UNUSED(timeStep);
if ( m_menu->GetHilitedItem() != m_menuItemSelected )
{
m_menuItemSelected = m_menu->GetHilitedItem();
m_menuThump->Play();
}
if ( m_transitioningIn || m_transitioningOut )
{
m_transitionTimer += timeStep;
if ( m_transitionTimer > c_transitionDuration )
{
m_transitionTimer = c_transitionDuration;
if ( m_transitioningOut )
{
if ( m_transitioningOutTo == NewGame )
m_game->SetMode(daGame::Mode_InGame); // Mode_LevelSelect? Are levels appropriate for this game?
if ( m_transitioningOutTo == Options )
m_game->GoToPreferences();
if ( m_transitioningOutTo == Credits )
m_game->SetMode(daGame::Mode_Credits);
else if ( m_transitioningOutTo == HowToPlay )
m_game->SetMode(daGame::Mode_Tutorial);
return;
}
m_transitioningIn = false;
m_transitioningOut = false;
}
float timer = m_transitionTimer;
if ( m_transitioningOut )
timer = c_transitionDuration - m_transitionTimer;
float transitionFraction = timer / c_transitionDuration;
transitionFraction = (3.0f * transitionFraction * transitionFraction) - (2.0f * transitionFraction * transitionFraction * transitionFraction);
m_menu->SetPosition( vsInterpolate(transitionFraction, m_iniMenuPos, menuPos) );
m_title->SetPosition( vsInterpolate(transitionFraction, m_iniTitlePos, titlePos) );
m_title->SetColor( vsInterpolate(transitionFraction, vsColor::Black, vsColor::Red) );
}
if ( !m_transitioningIn && !m_transitioningOut )
{
if ( m_menu->WasActionTaken() )
{
utMenuAction a = m_menu->GetAction();
if ( a.type == utMenuAction::Type_Select )
{
switch( a.menuItemId )
{
case NewGame:
StartTransitionOut();
m_transitioningOutTo = NewGame;
break;
case HowToPlay:
StartTransitionOut();
m_transitioningOutTo = HowToPlay;
//m_game->GetHowToPlayScreen()->Show(true);
m_game->FadeOutMusic(c_transitionDuration);
break;
case Options:
StartTransitionOut();
m_transitioningOutTo = Options;
m_game->FadeOutMusic(c_transitionDuration);
break;
case Credits:
StartTransitionOut();
m_transitioningOutTo = Credits;
m_game->FadeOutMusic(c_transitionDuration);
break;
case Quit:
core::SetExitToMenu();
break;
default:
break;
}
}
}
}
}
void
ctCameraScript_LerpFollow::Update( float timeStep )
{
m_position = vsInterpolate( 0.1f, m_position, m_targetPosition );
}
