rewrite of all Draw() functions

stepmania/src/Actor.cpp

@@ -11,6 +11,7 @@
 
 #include "Actor.h"
 #include <math.h>
+#include "RageScreen.h"
 
 
 Actor::Actor()
@@ -20,16 +21,12 @@ Actor::Actor()
 
 void Actor::Init()
 {
-	m_size		= D3DXVECTOR2( 0, 0 );
+	m_size			= m_start_pos			= m_end_pos			= D3DXVECTOR2( 0, 0 );
-	m_pos		= D3DXVECTOR2( 0, 0 );
+	m_pos			= m_start_pos			= m_end_pos			= D3DXVECTOR2( 0, 0 );
-	m_rotation	= D3DXVECTOR3( 0, 0, 0 );
+	m_rotation		= m_start_rotation		= m_end_rotation	= D3DXVECTOR3( 0, 0, 0 );
-	m_scale		= D3DXVECTOR2( 1, 1 );
+	m_scale			= m_start_scale			= m_end_scale		= D3DXVECTOR2( 1, 1 );
-	m_color		= D3DXCOLOR( 1, 1, 1, 1 );
+	m_colorDiffuse	= m_start_colorDiffuse	= m_end_colorDiffuse= D3DXCOLOR( 1, 1, 1, 1 );
-
+	m_colorAdd		= m_start_colorAdd		= m_end_colorAdd	= D3DXCOLOR( 0, 0, 0, 0 );
-	m_start_pos		= m_end_pos			= D3DXVECTOR2( 0.0f, 0.0f );
-	m_start_rotation= m_end_rotation	= D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
-	m_start_scale	= m_end_scale		= D3DXVECTOR2( 1.0f, 1.0f );
-	m_start_color	= m_end_color		= D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f );
 
 	m_TweenType	= no_tween;
 	m_fTweenTime = 0.0f;
@@ -37,10 +34,108 @@ void Actor::Init()
 }
 
 
+void Actor::Draw()
+{
+	D3DXVECTOR2 pos				= m_pos;
+	D3DXVECTOR3 rotation		= m_rotation;
+	D3DXVECTOR2 scale			= m_scale;
+
+	// update properties based on SpriteEffects 
+	switch( m_Effect )
+	{
+	case no_effect:
+		break;
+	case blinking:
+		break;
+	case camelion:
+		break;
+	case glowing:
+		break;
+	case wagging:
+		rotation.z = m_fWagRadians * (float)sin( 
+			(m_fWagTimer / m_fWagPeriod)	// percent through wag
+			* 2.0 * D3DX_PI );
+		break;
+	case spinning:
+		// nothing special needed
+		break;
+	case vibrating:
+		pos.x += m_fVibrationDistance * randomf(-1.0f, 1.0f) * GetZoom();
+		pos.y += m_fVibrationDistance * randomf(-1.0f, 1.0f) * GetZoom();
+		break;
+	case flickering:
+		break;
+	}
+
+	
+	LPDIRECT3DDEVICE8 pd3dDevice = SCREEN->GetDevice();
+
+	// calculate and apply world transform
+	D3DXMATRIX matWorld, matTemp;
+	D3DXMatrixIdentity( &matWorld );	// pass this along to each thing we draw and let it set it's own world matrix
+	D3DXMatrixScaling( &matTemp, scale.x, scale.y, 1 );	// add in the zoom
+	matWorld *= matTemp;
+	D3DXMatrixRotationYawPitchRoll( &matTemp, rotation.y, rotation.x, rotation.z );	// add in the rotation
+	matWorld *= matTemp;
+	D3DXMatrixTranslation( &matTemp, pos.x, pos.y, 0 );	// add in the translation
+	matWorld *= matTemp;
+	D3DXMatrixTranslation( &matTemp, -0.5f, -0.5f, 0 );		// shift to align texels with pixels
+	matWorld *= matTemp;
+    pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
+
+}
+
+
 void Actor::Update( const float &fDeltaTime )
 {
 //	RageLog( "Actor::Update( %f )", fDeltaTime );
 
+	// update effect
+	switch( m_Effect )
+	{
+	case no_effect:
+		break;
+	case blinking:
+	case camelion:
+	case glowing:
+		if( m_bTweeningTowardEndColor ) {
+			m_fPercentBetweenColors += m_fDeltaPercentPerSecond * fDeltaTime;
+			if( m_fPercentBetweenColors > 1.0f ) {
+				m_fPercentBetweenColors = 1.0f;
+				m_bTweeningTowardEndColor = FALSE;
+			}
+		}
+		else {		// !m_bTweeningTowardEndColor
+			m_fPercentBetweenColors -= m_fDeltaPercentPerSecond * fDeltaTime;
+			if( m_fPercentBetweenColors < 0.0f ) {
+				m_fPercentBetweenColors = 0.0f;
+				m_bTweeningTowardEndColor = TRUE;
+			}
+		}
+		RageLog( "Actor::m_fPercentBetweenColors %f", m_fPercentBetweenColors );
+		break;
+	case wagging:
+		m_fWagTimer += fDeltaTime;
+		if( m_fWagTimer > m_fWagPeriod )
+			m_fWagTimer -= m_fWagPeriod;
+		break;
+	case spinning:
+		float rotation;
+		rotation = GetRotation();
+		rotation += m_fSpinSpeed * fDeltaTime;
+		if( rotation > 2.0f * D3DX_PI )
+			rotation -= 2.0f * D3DX_PI;
+		else if( rotation < 0.0f )
+			rotation += 2.0f * D3DX_PI;
+		SetRotation( rotation );
+		break;
+	case vibrating:
+		break;
+	case flickering:
+		break;
+	}
+
+
 	// update tweening
 	if( m_TweenType != no_tween )		// we are performing some type of tweening
 	{
@@ -51,16 +146,17 @@ void Actor::Update( const float &fDeltaTime )
 			m_pos = m_end_pos;
 			m_scale = m_end_scale;
 			m_rotation = m_end_rotation;
-			m_color = m_end_color;
+			m_colorDiffuse = m_end_colorDiffuse;
+			m_colorAdd = m_end_colorAdd;
 			m_TweenType = no_tween;
 		}
 		else		// Tweening.  Recalcute the curent position.
 		{
-			FLOAT fPercentThroughTween = m_fTimeIntoTween / m_fTweenTime;
+			float fPercentThroughTween = m_fTimeIntoTween / m_fTweenTime;
 
 			// distort the percentage if appropriate
 			if( m_TweenType == tween_bias_begin )
-				fPercentThroughTween = (FLOAT) sqrt( fPercentThroughTween );
+				fPercentThroughTween = (float) sqrt( fPercentThroughTween );
 			else if( m_TweenType == tweening_bias_end )
 				fPercentThroughTween = fPercentThroughTween * fPercentThroughTween;
 
@@ -68,30 +164,30 @@ void Actor::Update( const float &fDeltaTime )
 			m_pos			= m_start_pos	  + (m_end_pos		- m_start_pos	  )*fPercentThroughTween;
 			m_scale			= m_start_scale	  + (m_end_scale	- m_start_scale	  )*fPercentThroughTween;
 			m_rotation		= m_start_rotation+ (m_end_rotation - m_start_rotation)*fPercentThroughTween;
-			m_color		= m_start_color*(1.0f-fPercentThroughTween) + m_end_color*(fPercentThroughTween);
+			m_colorDiffuse	= m_start_colorDiffuse*(1.0f-fPercentThroughTween) + m_end_colorDiffuse*(fPercentThroughTween);
+			m_colorAdd		= m_start_colorAdd    *(1.0f-fPercentThroughTween) + m_end_colorAdd    *(fPercentThroughTween);
 		}
 	
 	}	// end if m_TweenType != no_tween
 
-
 }
 
 
-void Actor::TweenTo( FLOAT time, FLOAT x, FLOAT y, FLOAT zoom, FLOAT rot, D3DXCOLOR col, TweenType tt )
+void Actor::TweenTo( float time, float x, float y, float zoom, float rot, D3DXCOLOR col, TweenType tt )
 {
 	// set our tweeen starting values to the current position
 	m_start_pos			= m_pos;
 	m_start_scale		= m_scale;
 	m_start_rotation	= m_rotation;
-	m_start_color		= m_color;
+	m_start_colorDiffuse		= m_colorDiffuse;
 
 	// set the ending tweening position to what the user asked for
-	m_end_pos.x = (FLOAT)x;
+	m_end_pos.x = (float)x;
-	m_end_pos.y = (FLOAT)y;
+	m_end_pos.y = (float)y;
 	m_end_scale.x = zoom;
 	m_end_scale.y = zoom;
 	m_end_rotation.z = rot;
-	m_end_color = col;
+	m_end_colorDiffuse = col;
 	m_TweenType = tt;
 	m_fTweenTime = time;
 	m_fTimeIntoTween = 0;
@@ -99,27 +195,29 @@ void Actor::TweenTo( FLOAT time, FLOAT x, FLOAT y, FLOAT zoom, FLOAT rot, D3DXCO
 }
 
 
-void Actor::BeginTweening( FLOAT time, TweenType tt )
+void Actor::BeginTweening( float time, TweenType tt )
 {
 	// set our tweeen starting and ending values to the current position
 	m_start_pos				= m_end_pos				= m_pos;
 	m_start_scale			= m_end_scale			= m_scale;
 	m_start_rotation		= m_end_rotation		= m_rotation;
-	m_start_color		= m_end_color		= m_color;
+	m_start_colorDiffuse	= m_end_colorDiffuse	= m_colorDiffuse;
+	m_start_colorAdd		= m_end_colorAdd		= m_colorAdd;
 
 	m_TweenType = tt;
 	m_fTweenTime = time;
 	m_fTimeIntoTween = 0;
 }
 
-void Actor::SetTweenX( FLOAT x )			{ m_end_pos.x = x; } 
+void Actor::SetTweenX( float x )			{ m_end_pos.x = x; } 
-void Actor::SetTweenY( FLOAT y )			{ m_end_pos.y = y; }
+void Actor::SetTweenY( float y )			{ m_end_pos.y = y; }
-void Actor::SetTweenXY( FLOAT x, FLOAT y )	{ SetTweenX(x); SetTweenY(y); }
+void Actor::SetTweenXY( float x, float y )	{ SetTweenX(x); SetTweenY(y); }
-void Actor::SetTweenZoom( FLOAT zoom )		{ m_end_scale.x = zoom;  m_end_scale.y = zoom; }
+void Actor::SetTweenZoom( float zoom )		{ m_end_scale.x = zoom;  m_end_scale.y = zoom; }
-void Actor::SetTweenRotationX( FLOAT r )	{ m_end_rotation.x = r; }
+void Actor::SetTweenRotationX( float r )	{ m_end_rotation.x = r; }
-void Actor::SetTweenRotationY( FLOAT r )	{ m_end_rotation.y = r; }
+void Actor::SetTweenRotationY( float r )	{ m_end_rotation.y = r; }
-void Actor::SetTweenRotationZ( FLOAT r )	{ m_end_rotation.z = r; }
+void Actor::SetTweenRotationZ( float r )	{ m_end_rotation.z = r; }
-void Actor::SetTweenColor( D3DXCOLOR c )	{ m_end_color = c; }
+void Actor::SetTweenDiffuseColor( D3DXCOLOR c )	{ m_end_colorDiffuse = c; }
+void Actor::SetTweenAddColor( D3DXCOLOR c )	{ m_end_colorAdd = c; }
 
 
 void Actor::ScaleTo( LPRECT pRect, StretchType st )
@@ -169,10 +267,75 @@ void Actor::StretchTo( LPRECT pRect )
 	int rect_cy = pRect->top  + rect_height/2;
 
 	// zoom factor needed to scale the Actor to fill the rectangle
-	FLOAT fNewZoomX = (FLOAT)fabs(rect_width  / m_size.x);
+	float fNewZoomX = (float)fabs(rect_width  / m_size.x);
-	FLOAT fNewZoomY = (FLOAT)fabs(rect_height / m_size.y);
+	float fNewZoomY = (float)fabs(rect_height / m_size.y);
 
-	SetXY( (FLOAT)rect_cx, (FLOAT)rect_cy );
+	SetXY( (float)rect_cx, (float)rect_cy );
 	m_scale.x = fNewZoomX;
 	m_scale.y = fNewZoomY;
 }
+
+
+
+
+// effects
+
+void Actor::SetEffectNone()
+{
+	m_Effect = no_effect;
+	//m_color = D3DXCOLOR( 1.0,1.0,1.0,1.0 );
+}
+
+void Actor::SetEffectBlinking( float fDeltaPercentPerSecond, D3DXCOLOR Color, D3DXCOLOR Color2 )
+{
+	m_Effect = blinking;
+	m_start_colorDiffuse = Color;
+	m_end_colorDiffuse = Color2;
+	//m_fPercentBetweenColors = 0.0;
+	//m_bTweeningTowardEndColor = TRUE;
+	m_fDeltaPercentPerSecond = fDeltaPercentPerSecond;
+}
+
+void Actor::SetEffectCamelion( float fDeltaPercentPerSecond, D3DXCOLOR Color, D3DXCOLOR Color2 )
+{
+	m_Effect = camelion;
+	m_start_colorDiffuse = Color;
+	m_end_colorDiffuse = Color2;
+	//m_fPercentBetweenColors = 0.0;
+	//m_bTweeningTowardEndColor = TRUE;
+	m_fDeltaPercentPerSecond = fDeltaPercentPerSecond;
+}
+
+void Actor::SetEffectGlowing( float fDeltaPercentPerSecond, D3DXCOLOR Color, D3DXCOLOR Color2 )
+{
+	m_Effect = glowing;
+	m_start_colorAdd = Color;
+	m_end_colorAdd = Color2;
+	//m_fPercentBetweenColors = 0.0;
+	//m_bTweeningTowardEndColor = TRUE;
+	m_fDeltaPercentPerSecond = fDeltaPercentPerSecond;
+}
+
+void Actor::SetEffectWagging(	float fWagRadians, float fWagPeriod )
+{
+	m_Effect = wagging;
+	m_fWagRadians = fWagRadians;
+	m_fWagPeriod = fWagPeriod;
+}
+
+void Actor::SetEffectSpinning(	float fSpinSpeed /*radians per second*/ )
+{
+	m_Effect = spinning;
+	m_fSpinSpeed = fSpinSpeed;
+}
+
+void Actor::SetEffectVibrating( float fVibrationDistance )
+{
+	m_Effect = vibrating;
+	m_fVibrationDistance = fVibrationDistance;
+}
+
+void Actor::SetEffectFlickering()
+{
+	m_Effect = flickering;
+}

stepmania/src/Actor.h

@@ -25,12 +25,17 @@ public:
 	Actor();
 
 	enum TweenType { no_tween, tween_linear, tween_bias_begin, tweening_bias_end };
+	enum Effect { no_effect,
+				blinking,	camelion,   glowing,
+				wagging,	spinning,
+				vibrating,	flickering
+				};
 
 	// let subclasses override
 	virtual void Restore() {};
 	virtual void Invalidate() {};
 
-	virtual void Draw() PURE;
+	virtual void Draw();
 	virtual void Update( const float &fDeltaTime );
 
 	virtual float GetX()					{ return m_pos.x; };
@@ -55,14 +60,16 @@ public:
 	virtual float GetRotationY()			{ return m_rotation.y; }
 	virtual void  SetRotationY( float rot )	{ m_rotation.y = rot; }
 
-	virtual void SetColor( D3DXCOLOR newColor ) { m_color = newColor; };
+	virtual void SetDiffuseColor( D3DXCOLOR colorDiffuse ) { m_colorDiffuse = colorDiffuse; };
-	virtual D3DXCOLOR GetColor()				{ return m_color; };
+	virtual D3DXCOLOR GetDiffuseColor()				{ return m_colorDiffuse; };
+	virtual void SetAddColor( D3DXCOLOR colorAdd ) { m_colorAdd = colorAdd; };
+	virtual D3DXCOLOR GetAddColor()				{ return m_colorAdd; };
 
 	virtual void TweenTo( float time, 
 						  float x, float y, 
 						  float zoom = 1.0, 
 						  float rot = 0.0, 
-						  D3DXCOLOR col = D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ),
+						  D3DXCOLOR colDiffuse = D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ),
 						  TweenType tt = tween_linear );
 
 	virtual void BeginTweening( float time, TweenType tt = tween_linear );
@@ -73,14 +80,15 @@ public:
 	virtual void SetTweenRotationX( float r );
 	virtual void SetTweenRotationY( float r );
 	virtual void SetTweenRotationZ( float r );
-	virtual void SetTweenColor( D3DXCOLOR c );
+	virtual void SetTweenDiffuseColor( D3DXCOLOR c );
+	virtual void SetTweenAddColor( D3DXCOLOR c );
 
 
 	// NOTE: GetEdge functions don't consider rotation
-	virtual float GetLeftEdge()		{ return m_pos.x - GetZoomedWidth()/2.0f; };
+	//virtual float GetLeftEdge()		{ return m_pos.x - GetZoomedWidth()/2.0f; };
-	virtual float GetRightEdge()	{ return m_pos.x + GetZoomedWidth()/2.0f; };
+	//virtual float GetRightEdge()	{ return m_pos.x + GetZoomedWidth()/2.0f; };
-	virtual float GetTopEdge()		{ return m_pos.y - GetZoomedHeight()/2.0f; };
+	//virtual float GetTopEdge()		{ return m_pos.y - GetZoomedHeight()/2.0f; };
-	virtual float GetBottomEdge()	{ return m_pos.y + GetZoomedHeight()/2.0f; };
+	//virtual float GetBottomEdge()	{ return m_pos.y + GetZoomedHeight()/2.0f; };
 	
 	enum StretchType { fit_inside, cover };
 
@@ -90,6 +98,26 @@ public:
 
 	void StretchTo( LPRECT rect );
 
+
+	// effects
+	void SetEffectNone();
+	void SetEffectBlinking( float fDeltaPercentPerSecond = 2.5,
+						    D3DXCOLOR Color  = D3DXCOLOR(0.5f,0.5f,0.5f,1), 
+						    D3DXCOLOR Color2 = D3DXCOLOR(1,1,1,1) );
+	void SetEffectCamelion( float fDeltaPercentPerSecond = 2.5,
+						    D3DXCOLOR Color  = D3DXCOLOR(0,0,0,1), 
+						    D3DXCOLOR Color2 = D3DXCOLOR(1,1,1,1) );
+	void SetEffectGlowing( float fDeltaPercentPerSecond = 2.5,
+						   D3DXCOLOR Color  = D3DXCOLOR(1,1,1,0.2f),
+						   D3DXCOLOR Color2 = D3DXCOLOR(1,1,1,0.8f) );
+	void SetEffectWagging( float fWagRadians =  0.2,
+						   float fWagPeriod = 2.0 );
+	void SetEffectSpinning( float fRadsPerSpeed = 2.0 );
+	void SetEffectVibrating( float fVibrationDistance = 5.0 );
+	void SetEffectFlickering();
+	Effect GetEffect() { return m_Effect; };
+
+
 protected:
 
 	void Init();
@@ -98,19 +126,43 @@ protected:
 	D3DXVECTOR2 m_pos;		// X-Y coordinate of where the center point will appear on screen
 	D3DXVECTOR3 m_rotation;	// X, Y, and Z m_rotation
 	D3DXVECTOR2 m_scale;	// X and Y zooming
-	D3DXCOLOR   m_color;
+	D3DXCOLOR   m_colorDiffuse;
+	D3DXCOLOR   m_colorAdd;
 
 	// start and end position for tweening
 	D3DXVECTOR2 m_start_pos,			m_end_pos;
 	D3DXVECTOR3 m_start_rotation,		m_end_rotation;
 	D3DXVECTOR2 m_start_scale,			m_end_scale;
-	D3DXCOLOR   m_start_color,		m_end_color;
+	D3DXCOLOR   m_start_colorDiffuse,	m_end_colorDiffuse;
+	D3DXCOLOR   m_start_colorAdd,		m_end_colorAdd;
 
 	// counters for tweening
 	TweenType	m_TweenType;
 	float		m_fTweenTime;		// seconds between Start and End positions/zooms
 	float		m_fTimeIntoTween;	// how long we have been tweening for
 
+	// effect
+	Effect m_Effect;
+
+	// Counting variables for sprite effects:
+	// camelion and glowing:
+	float m_fPercentBetweenColors;
+	bool  m_bTweeningTowardEndColor;	// TRUE is fading toward end_color, FALSE if fading toward start_color
+	float m_fDeltaPercentPerSecond;	// percentage change in tweening per second
+
+	// wagging:
+	float m_fWagRadians;
+	float m_fWagPeriod;		// seconds to complete a wag (back and forth)
+	float m_fWagTimer;		// num of seconds into this wag
+
+	// spinning:
+	float m_fSpinSpeed;		// radians per second
+
+	// vibrating:
+	float m_fVibrationDistance;
+
+	// flickering:
+	bool m_bVisibleThisFrame;
 };
 
 

stepmania/src/Background.cpp

@@ -20,7 +20,7 @@ void Background::LoadFromSong( Song& song )
 {
 	Sprite::LoadFromTexture( song.GetBackgroundPath() );
 	Sprite::StretchTo( CRect(0,0,640,480) );
-	Sprite::SetColor( D3DXCOLOR(0.7f,0.7f,0.7f,1) );
+	Sprite::SetDiffuseColor( D3DXCOLOR(0.7f,0.7f,0.7f,1) );
 
 	CStringArray sVisualizationPaths;
 	GetDirListing( sVisDir + "*.*", sVisualizationPaths );

stepmania/src/Player.cpp

@@ -180,7 +180,7 @@ Player::Player()
 		m_sprGrayArrowGhost[c].SetRotation( m_ColumnToRotation[c] );
 		m_sprGrayArrowGhost[c].StopAnimating();
 		m_sprGrayArrowGhost[c].SetState( 1 );
-		m_sprGrayArrowGhost[c].SetColor( D3DXCOLOR(1,1,1,0) );
+		m_sprGrayArrowGhost[c].SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
 
 		// color arrows
 		m_sprColorArrow[c].LoadFromSpriteFile( SPRITE_COLOR_ARROW );
@@ -212,16 +212,16 @@ Player::Player()
 }
 
 
-void Player::SetX( int iX )
+void Player::SetX( float fX )
 {
-	m_iArrowsCenterX = iX;
+	m_fArrowsCenterX = fX;
 
-	SetGrayArrowsX(iX); 
+	SetGrayArrowsX(fX); 
-	SetColorArrowsX(iX);	
+	SetColorArrowsX(fX);	
-	SetJudgementX(iX);	
+	SetJudgementX(fX);	
-	SetComboX(iX);	
+	SetComboX(fX);	
-	SetScoreX(iX);	
+	SetScoreX(fX);	
-	SetLifeMeterX(iX);	
+	SetLifeMeterX(fX);	
 }
 
 
@@ -238,6 +238,8 @@ void Player::Update( const float &fDeltaTime, float fSongBeat, float fMaxBeatDif
 {
 	//RageLog( "Player::Update(%f, %f, %f)", fDeltaTime, fSongBeat, fMaxBeatDifference );
 
+	m_fSongBeat = fSongBeat;	// save song beat
+
 	int iNumMisses = UpdateStepsMissedOlderThan( fSongBeat-fMaxBeatDifference );
 	if( iNumMisses > 0 )
 	{
@@ -257,14 +259,14 @@ void Player::Update( const float &fDeltaTime, float fSongBeat, float fMaxBeatDif
 	UpdateLifeMeter( fDeltaTime );
 }
 
-void Player::Draw( float fSongBeat )
+void Player::Draw()
 {
 	DrawGrayArrows(); 
-	DrawColorArrows( fSongBeat );
+	DrawColorArrows();
 	DrawJudgement();
 	DrawCombo();
 	DrawScore();
-	DrawLifeMeter( fSongBeat );	
+	DrawLifeMeter();	
 }
 
 
@@ -420,9 +422,9 @@ ScoreSummary Player::GetScoreSummary()
 }
 
 
-int Player::GetArrowColumnX( int iColNum ) 
+float Player::GetArrowColumnX( int iColNum ) 
 { 
-	return m_iArrowsCenterX + (iColNum - (m_iNumColumns-1)/2) * ARROW_SIZE;
+	return m_fArrowsCenterX + (iColNum - (m_iNumColumns-1)/2) * ARROW_SIZE;
 }
 
 void Player::UpdateGrayArrows( const float &fDeltaTime )
@@ -463,10 +465,10 @@ void Player::GrayArrowGhostStep( int index )
 {
 	m_sprGrayArrowGhost[index].SetXY( GetArrowColumnX(index), GRAY_ARROW_Y );
 	m_sprGrayArrowGhost[index].SetZoom( 1 );
-	m_sprGrayArrowGhost[index].SetColor( D3DXCOLOR(1,1,0.5f,1) );
+	m_sprGrayArrowGhost[index].SetDiffuseColor( D3DXCOLOR(1,1,0.5f,1) );
 	m_sprGrayArrowGhost[index].BeginTweening( 0.3f );
 	m_sprGrayArrowGhost[index].SetTweenZoom( 1.5 );
-	m_sprGrayArrowGhost[index].SetTweenColor( D3DXCOLOR(1,1,0.5f,0) );		
+	m_sprGrayArrowGhost[index].SetTweenDiffuseColor( D3DXCOLOR(1,1,0.5f,0) );		
 }
 
 void Player::UpdateColorArrows( const float &fDeltaTime )
@@ -474,15 +476,15 @@ void Player::UpdateColorArrows( const float &fDeltaTime )
 
 }
 
-void Player::DrawColorArrows( float fSongBeat )
+void Player::DrawColorArrows()
 {
 	//RageLog( "ColorArrows::Draw(%f)", fSongBeat );
 
-	int iBaseFrameNo = (int)(fSongBeat*2.5) % 12;	// 2.5 is a "fudge number" :-)  This should be based on BPM
+	int iBaseFrameNo = (int)(m_fSongBeat*2.5) % 12;	// 2.5 is a "fudge number" :-)  This should be based on BPM
 
-	int iIndexFirstArrowToDraw = BeatToStepIndex( fSongBeat - 2.0f );	// 2 beats earlier
+	int iIndexFirstArrowToDraw = BeatToStepIndex( m_fSongBeat - 2.0f );	// 2 beats earlier
 	if( iIndexFirstArrowToDraw < 0 ) iIndexFirstArrowToDraw = 0;
-	int iIndexLastArrowToDraw  = BeatToStepIndex( fSongBeat + 7.0f );	// 7 beats later
+	int iIndexLastArrowToDraw  = BeatToStepIndex( m_fSongBeat + 7.0f );	// 7 beats later
 
 	//RageLog( "Drawing elements %d through %d", iIndexFirstArrowToDraw, iIndexLastArrowToDraw );
 
@@ -490,7 +492,7 @@ void Player::DrawColorArrows( float fSongBeat )
 	{				
 		if( m_LeftToStepOn[i] != 0 )	// this step is not yet complete 
 		{		
-			int iYPos = GetColorArrowYPos( i, fSongBeat );
+			float fYPos = GetColorArrowYPos( i, m_fSongBeat );
 
 			// calculate which frame to display
 			int iFrameNo = iBaseFrameNo + m_iColorArrowFrameOffset[i];
@@ -500,7 +502,7 @@ void Player::DrawColorArrows( float fSongBeat )
 
 			for( int c=0; c < m_iNumColumns; c++ ) {	// for each arrow column
 				if( m_OriginalStep[i] & m_ColumnNumberToStep[c] ) {	// this column is still unstepped on?
-					m_sprColorArrow[c].SetY( iYPos );
+					m_sprColorArrow[c].SetY( fYPos );
 					m_sprColorArrow[c].SetState( iFrameNo );
 					m_sprColorArrow[c].Draw();
 				}
@@ -519,7 +521,7 @@ void Player::DrawColorArrows( float fSongBeat )
 
 
 
-int Player::GetColorArrowYPos( int iStepIndex, float fSongBeat )
+float Player::GetColorArrowYPos( int iStepIndex, float fSongBeat )
 {
 	float fBeatsUntilStep = StepIndexToBeat( iStepIndex ) - fSongBeat;
 	return (int)(fBeatsUntilStep * ARROW_GAP) + GRAY_ARROW_Y;
@@ -629,14 +631,14 @@ void Player::UpdateLifeMeter( const float &fDeltaTime )
 	m_sprLifeMeterPills.Update( fDeltaTime );
 }
 
-void Player::DrawLifeMeter( float fSongBeat )
+void Player::DrawLifeMeter()
 {
-	float fBeatPercentage = fSongBeat - (int)fSongBeat;
+	float fBeatPercentage = m_fSongBeat - (int)m_fSongBeat;
 	int iOffsetStart = roundf( LIEFMETER_NUM_PILLS*fBeatPercentage );
 
 	m_sprLifeMeterFrame.Draw();
 
-	float iX = m_sprLifeMeterFrame.GetLeftEdge() + 27;
+	float iX = m_sprLifeMeterFrame.GetX() - m_sprLifeMeterFrame.GetZoomedWidth()/2 + 27;
 	int iNumPills = (int)(m_sprLifeMeterPills.GetNumStates() * m_fLifePercentage);
 	int iPillWidth = m_sprLifeMeterPills.GetZoomedWidth();
 
@@ -724,16 +726,16 @@ void Player::ChangeScore( StepScore score, int iCurCombo )
 
 	float M = iCurCombo/4.0f;
 
-	int iScoreToAdd = 0;
+	float fScoreToAdd = 0;
 	switch( score )
 	{
 	case miss:											break;
 	case boo:											break;
-	case good:		iScoreToAdd = M * 100     + 100;	break;
+	case good:		fScoreToAdd = M * 100     + 100;	break;
-	case great:		iScoreToAdd = M * M * 100 + 300;	break;
+	case great:		fScoreToAdd = M * M * 100 + 300;	break;
-	case perfect:	iScoreToAdd = M * M * 300 + 500;	break;
+	case perfect:	fScoreToAdd = M * M * 300 + 500;	break;
 	}
-	m_fScore += iScoreToAdd;
+	m_fScore += fScoreToAdd;
 	ASSERT( m_fScore > 0 );
 
 	

stepmania/src/Player.h

@@ -27,9 +27,9 @@ public:
 	Player();
 
 	void SetSteps( const Steps& newSteps );
-	void SetX( int iX );
+	void SetX( float fX );
 	void Update( const float &fDeltaTime, float fSongBeat, float fMaxBeatDifference );
-	void Draw( float fSongBeat );
+	void Draw();
 
 
 	ScoreSummary GetScoreSummary();
@@ -42,6 +42,7 @@ protected:
 
 	int		m_iCurCombo;
 	int		m_iMaxCombo;
+	float	m_fSongBeat;
 
 	enum StepScore{ none, perfect, great, good, boo, miss };
 	enum StepTiming{ no_timing, early, late };
@@ -53,19 +54,19 @@ protected:
 
 
 	// common to color and gray arrows
-	int m_iArrowsCenterX;
+	float m_fArrowsCenterX;
 
 	int m_iNumColumns;	// will vary depending on the number panels (4,6,8,etc)
 	CMap<Step, Step, int, int>	m_StepToColumnNumber;
 	CMap<int, int, Step, Step>	m_ColumnNumberToStep;
 	CMap<int, int, float, float&>	m_ColumnToRotation;
-	int GetArrowColumnX( int iColNum );
+	float GetArrowColumnX( int iColNum );
 
 	// color arrows
 	void SetColorArrowsX( int iX );
 	void UpdateColorArrows( const float& fDeltaTime );
-	int	 GetColorArrowYPos( int iStepIndex, float fSongBeat );
+	float GetColorArrowYPos( int iStepIndex, float fSongBeat );
-	void DrawColorArrows( float fSongBeat );
+	void DrawColorArrows();
 	Sprite		m_sprColorArrow[MAX_NUM_COLUMNS];
 	int			m_iColorArrowFrameOffset[MAX_STEP_ELEMENTS];
 
@@ -92,14 +93,14 @@ protected:
 	void UpdateCombo( const float& fDeltaTime );
 	void DrawCombo();
 	void SetCombo( int iNum );
-	BOOL		m_bComboVisible;
+	bool		m_bComboVisible;
 	Sprite		m_sprCombo;
 	SpriteSequence	m_ComboNumber;
 
 	// life meter
 	void SetLifeMeterX( int iX );
 	void UpdateLifeMeter( const float& fDeltaTime );
-	void DrawLifeMeter( float fSongBeat );
+	void DrawLifeMeter();
 	void ChangeLife( StepScore score );
 public:
 	float GetLifePercentage() { return m_fLifePercentage; };

stepmania/src/Sprite.cpp

@@ -52,7 +52,7 @@ Sprite::~Sprite()
 }
 
 
-BOOL Sprite::LoadFromTexture( CString sTexturePath )
+bool Sprite::LoadFromTexture( CString sTexturePath )
 {
 	RageLog( ssprintf("Sprite::LoadFromTexture(%s)", sTexturePath) );
 
@@ -68,7 +68,7 @@ BOOL Sprite::LoadFromTexture( CString sTexturePath )
 // Delay0000=1.0
 // Frame0001=3
 // Delay0000=2.0
-BOOL Sprite::LoadFromSpriteFile( CString sSpritePath )
+bool Sprite::LoadFromSpriteFile( CString sSpritePath )
 {
 	RageLog( ssprintf("Sprite::LoadFromSpriteFile(%s)", sSpritePath) );
 
@@ -119,7 +119,7 @@ BOOL Sprite::LoadFromSpriteFile( CString sSpritePath )
 	return TRUE;
 }
 
-BOOL Sprite::LoadTexture( CString sTexturePath )
+bool Sprite::LoadTexture( CString sTexturePath )
 {
 	if( m_sTexturePath != "" )			// If there was a previous bitmap...
 		TM->UnloadTexture( m_sTexturePath );	// Unload it.
@@ -131,8 +131,8 @@ BOOL Sprite::LoadTexture( CString sTexturePath )
 	assert( m_pTexture != NULL );
 
 	// the size of the sprite is the size of the image before it was scaled
-	SetWidth( (FLOAT)m_pTexture->GetSourceFrameWidth() );
+	SetWidth( (float)m_pTexture->GetSourceFrameWidth() );
-	SetHeight( (FLOAT)m_pTexture->GetSourceFrameHeight() );		
+	SetHeight( (float)m_pTexture->GetSourceFrameHeight() );		
 
 	// Assume the frames of this animation play in sequential order with 0.2 second delay.
 	for( UINT i=0; i<m_pTexture->GetNumFrames(); i++ )
@@ -156,7 +156,7 @@ void Sprite::PrintDebugInfo()
 }
 
 
-void Sprite::Update( const FLOAT &fDeltaTime )
+void Sprite::Update( const float &fDeltaTime )
 {
 	//PrintDebugInfo();
 
@@ -178,48 +178,7 @@ void Sprite::Update( const FLOAT &fDeltaTime )
 		}
 	}
 
-	// update SpriteEffect
+
-	switch( m_Effect )
-	{
-	case no_effect:
-		break;
-	case blinking:
-	case camelion:
-	case glowing:
-		if( m_bTweeningTowardEndColor ) {
-			m_fPercentBetweenColors += m_fDeltaPercentPerSecond * fDeltaTime;
-			if( m_fPercentBetweenColors > 1.0f ) {
-				m_fPercentBetweenColors = 1.0f;
-				m_bTweeningTowardEndColor = FALSE;
-			}
-		}
-		else {		// !m_bTweeningTowardEndColor
-			m_fPercentBetweenColors -= m_fDeltaPercentPerSecond * fDeltaTime;
-			if( m_fPercentBetweenColors < 0.0f ) {
-				m_fPercentBetweenColors = 0.0f;
-				m_bTweeningTowardEndColor = TRUE;
-			}
-		}
-	case wagging:
-		m_fWagTimer += fDeltaTime;
-		if( m_fWagTimer > m_fWagPeriod )
-			m_fWagTimer -= m_fWagPeriod;
-		break;
-	case spinning:
-		FLOAT rotation;
-		rotation = GetRotation();
-		rotation += m_fSpinSpeed * fDeltaTime;
-		if( rotation > 2.0f * D3DX_PI )
-			rotation -= 2.0f * D3DX_PI;
-		else if( rotation < 0.0f )
-			rotation += 2.0f * D3DX_PI;
-		SetRotation( rotation );
-		break;
-	case vibrating:
-		break;
-	case flickering:
-		break;
-	}
 
 
 }
@@ -227,6 +186,8 @@ void Sprite::Update( const FLOAT &fDeltaTime )
 
 void Sprite::Draw()
 {
+	Actor::Draw();	// set up our world matrix
+
 	if( m_pTexture == NULL )
 		return;
 	
@@ -238,11 +199,9 @@ void Sprite::Draw()
 		pTexCoordRect = m_pTexture->GetTextureCoordRect( uFrameNo );
 	}
 
-	D3DXCOLOR	color	= m_color;
+
-	D3DXVECTOR2 pos		= m_pos;
+	D3DXCOLOR	colorDiffuse	= m_colorDiffuse;
-	D3DXVECTOR3 rotation = m_rotation;
+	D3DXCOLOR	colorAdd		= m_colorAdd;
-	D3DXVECTOR2 scale	= m_scale;
-	bool bBlendAdd		= false;
 
 	// update properties based on SpriteEffects 
 	switch( m_Effect )
@@ -250,65 +209,66 @@ void Sprite::Draw()
 	case no_effect:
 		break;
 	case blinking:
-		color = m_bTweeningTowardEndColor ? m_start_color : m_end_color;
+		colorDiffuse = m_bTweeningTowardEndColor ? m_start_colorDiffuse : m_end_colorDiffuse;
 		break;
 	case camelion:
-		color = m_start_color*m_fPercentBetweenColors + m_end_color*(1.0f-m_fPercentBetweenColors);
+		colorDiffuse = m_start_colorDiffuse*m_fPercentBetweenColors + m_end_colorDiffuse*(1.0f-m_fPercentBetweenColors);
 		break;
 	case glowing:
-		color = m_start_color*m_fPercentBetweenColors + m_end_color*(1.0f-m_fPercentBetweenColors);
+		colorAdd = m_start_colorAdd*m_fPercentBetweenColors + m_end_colorAdd*(1.0f-m_fPercentBetweenColors);
-		bBlendAdd = true;
 		break;
 	case wagging:
-		rotation.z = m_fWagRadians * (FLOAT)sin( 
-			(m_fWagTimer / m_fWagPeriod)	// percent through wag
-			* 2.0 * D3DX_PI );
 		break;
 	case spinning:
 		// nothing special needed
 		break;
 	case vibrating:
-		pos.x += m_fVibrationDistance * randomf(-1.0f, 1.0f) * GetZoom();
-		pos.y += m_fVibrationDistance * randomf(-1.0f, 1.0f) * GetZoom();
 		break;
 	case flickering:
 		m_bVisibleThisFrame = !m_bVisibleThisFrame;
-		if( m_bVisibleThisFrame )
+		if( !m_bVisibleThisFrame )
-			return;		// don't draw the frame
+			colorDiffuse = D3DXCOLOR(0,0,0,0);		// don't draw the frame
 		break;
 	}
 
 
-	// make a 1x1 rect centered at the origin
+	// make the object in logical units centered at the origin
 	LPDIRECT3DVERTEXBUFFER8 pVB = SCREEN->GetVertexBuffer();
 	CUSTOMVERTEX* v;
 	pVB->Lock( 0, 0, (BYTE**)&v, 0 );
 
-	v[0].p = D3DXVECTOR3( -0.5f,	 0.5f,		0 );	// bottom left
+	float fHalfSizeX = m_size.x/2;
-	v[1].p = D3DXVECTOR3( -0.5f,	-0.5f,		0 );	// top left
+	float fHalfSizeY = m_size.y/2;
-	v[2].p = D3DXVECTOR3(  0.5f,	 0.5f,		0 );	// bottom right
+
-	v[3].p = D3DXVECTOR3(  0.5f,	-0.5f,		0 );	// top right
+	v[0].p = D3DXVECTOR3( -fHalfSizeX,	 fHalfSizeY,	0 );	// bottom left
+	v[1].p = D3DXVECTOR3( -fHalfSizeX,	-fHalfSizeY,	0 );	// top left
+	v[2].p = D3DXVECTOR3(  fHalfSizeX,	 fHalfSizeY,	0 );	// bottom right
+	v[3].p = D3DXVECTOR3(  fHalfSizeX,	-fHalfSizeY,	0 );	// top right
 
 	v[0].tu = pTexCoordRect->left;		v[0].tv = pTexCoordRect->bottom;	// bottom left
 	v[1].tu = pTexCoordRect->left;		v[1].tv = pTexCoordRect->top;		// top left
 	v[2].tu = pTexCoordRect->right;		v[2].tv = pTexCoordRect->bottom;	// bottom right
 	v[3].tu = pTexCoordRect->right;		v[3].tv = pTexCoordRect->top;		// top right
 
-	v[0].color = v[1].color = v[2].color = v[3].color = color;
+	v[0].color = v[1].color = v[2].color = v[3].color = colorDiffuse;
 	
 	pVB->Unlock();
 
 
+	//////////////////////
+	// render the diffuse pass
+	//////////////////////
+
 	// set texture and alpha properties
 	LPDIRECT3DDEVICE8 pd3dDevice = SCREEN->GetDevice();
     pd3dDevice->SetTexture( 0, m_pTexture->GetD3DTexture() );
 
 	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
 	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
-	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   bBlendAdd ? D3DTOP_ADD : D3DTOP_MODULATE );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );//bBlendAdd ? D3DTOP_ADD : D3DTOP_MODULATE );
 	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
 	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
-	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   bBlendAdd ? D3DTOP_ADD : D3DTOP_MODULATE );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );//bBlendAdd ? D3DTOP_ADD : D3DTOP_MODULATE );
 	pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
 	pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
 	//pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  bBlendAdd ? D3DBLEND_ONE : D3DBLEND_SRCALPHA );
@@ -317,128 +277,32 @@ void Sprite::Draw()
 	pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
 
 
-	// calculate transforms
-	D3DXMATRIX matWorld, matTemp;
-	D3DXMatrixIdentity( &matWorld );		// initialize world
-	D3DXMatrixScaling( &matTemp, m_size.x, m_size.y, 1 );	// scale to the native height and width
-	matWorld *= matTemp;
-	D3DXMatrixScaling( &matTemp, scale.x, scale.y, 1 );	// add in the zoom
-	matWorld *= matTemp;
-	D3DXMatrixRotationYawPitchRoll( &matTemp, rotation.y, rotation.x, rotation.z );	// add in the rotation
-	matWorld *= matTemp;
-	D3DXMatrixTranslation( &matTemp, pos.x, pos.y, 0 );	// add in the translation
-	matWorld *= matTemp;
-	D3DXMatrixTranslation( &matTemp, -0.5f, -0.5f, 0 );		// shift to align texels with pixels
-	matWorld *= matTemp;
-    pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
-
-	D3DXMATRIX matView;
-    D3DXMatrixIdentity( &matView );
-	pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
-
-	D3DXMATRIX matProj;
-    D3DXMatrixOrthoOffCenterLH( &matProj, 0, 640, 480, 0, -100, 100 );
-	pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
-
-
 	// finally!  Pump those triangles!	
 	pd3dDevice->SetVertexShader( D3DFVF_CUSTOMVERTEX );
 	pd3dDevice->SetStreamSource( 0, pVB, sizeof(CUSTOMVERTEX) );
 	pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
 
 
-
+	//////////////////////
-
+	// render the diffuse pass
-/*  WORKS!
+	//////////////////////
-
+	if( colorAdd.a == 0 )	// no need to render an add pass
-	LPDIRECT3DVERTEXBUFFER8 pVB2        = NULL; // Buffer to hold vertices
-
-	// A structure for our custom vertex type
-	struct CUSTOMVERTEX
-	{
-		FLOAT x, y, z;      // The untransformed, 3D position for the vertex
-		DWORD color;        // The vertex color
-	};
-
-	// Our custom FVF, which describes our custom vertex structure
-	#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)
-
-    // Initialize three vertices for rendering a triangle
-    CUSTOMVERTEX g_Vertices[] =
-    {
-        { -15.0f,-15.0f, 0.0f, 0xffff0000, },
-        {  15.0f,-15.0f, 0.0f, 0xff0000ff, },
-        {  00.0f, 15.0f, 0.0f, 0xffffffff, },
-    };
-
-    // Create the vertex buffer.
-    if( FAILED( pd3dDevice->CreateVertexBuffer( 3*sizeof(CUSTOMVERTEX),
-                                                  0, D3DFVF_CUSTOMVERTEX,
-                                                  D3DPOOL_DEFAULT, &pVB2 ) ) )
-    {
  		return;
-    }
 
-    // Turn off culling, so we see the front and back of the triangle
+	pVB->Lock( 0, 0, (BYTE**)&v, 0 );
-    pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
-
-    // Turn off D3D lighting, since we are providing our own vertex colors
-    pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
-
-
-    // Fill the vertex buffer.
-    void* pVertices;
-    if( FAILED( pVB2->Lock( 0, sizeof(g_Vertices), (BYTE**)&pVertices, 0 ) ) )
-        return;
-    memcpy( pVertices, g_Vertices, sizeof(g_Vertices) );
-    pVB2->Unlock();
-
-
-    // For our world matrix, we will just rotate the object about the y-axis.
-    //D3DXMATRIX matWorld;
-    D3DXMatrixRotationY( &matWorld, GetTickCount()/150.0f );
-    pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
-
-    // Set up our view matrix. A view matrix can be defined given an eye point,
-    // a point to lookat, and a direction for which way is up. Here, we set the
-    // eye five units back along the z-axis and up three units, look at the
-    // origin, and define "up" to be in the y-direction.
-    //D3DXMATRIX matView;
-    //D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3( 0.0f, 3.0f,-5.0f ),
-    //                              &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
-    //                              &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
-    D3DXMatrixIdentity( &matView );
-	pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
-
-    // For the projection matrix, we set up a perspective transform (which
-    // transforms geometry from 3D view space to 2D viewport space, with
-    // a perspective divide making objects smaller in the distance). To build
-    // a perpsective transform, we need the field of view (1/4 pi is common),
-    // the aspect ratio, and the near and far clipping planes (which define at
-    // what distances geometry should be no longer be rendered).
-    //D3DXMATRIX matProj;
-    //D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f );
-    //D3DXMatrixOrthoLH( &matProj, 640, -480, -100, 100 );
-    D3DXMatrixOrthoOffCenterLH( &matProj, 0, 320, 480, 0, -100, 100 );
-//    D3DXMatrixOrthoOffCenterLH( &matProj, -20, 20, 20, -20, -100, 100 );
-   
-	pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
-
-    // Render the vertex buffer contents
-    pd3dDevice->SetStreamSource( 0, pVB2, sizeof(CUSTOMVERTEX) );
-    pd3dDevice->SetVertexShader( D3DFVF_CUSTOMVERTEX );
-    pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 1 );
-
-
-
-
-    if( pVB2 != NULL )
-        pVB2->Release();
-*/
 
+	v[0].color = v[1].color = v[2].color = v[3].color = colorAdd;
 	
+	pVB->Unlock();
 
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG2 );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
+	pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
 	
+	pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 );
 
 }
 
@@ -456,62 +320,4 @@ void Sprite::SetCustomSrcRect(	FRECT new_texcoord_frect )
 	m_CustomTexCoordRect = new_texcoord_frect; 
 }
 
-void Sprite::SetEffectNone()
-{
-	m_Effect = no_effect;
-	//m_color = D3DXCOLOR( 1.0,1.0,1.0,1.0 );
-}
 
-void Sprite::SetEffectBlinking( FLOAT fDeltaPercentPerSecond, D3DXCOLOR Color, D3DXCOLOR Color2 )
-{
-	m_Effect = blinking;
-	m_start_color = Color;
-	m_end_color = Color2;
-	//m_fPercentBetweenColors = 0.0;
-	//m_bTweeningTowardEndColor = TRUE;
-	m_fDeltaPercentPerSecond = fDeltaPercentPerSecond;
-}
-
-void Sprite::SetEffectCamelion( FLOAT fDeltaPercentPerSecond, D3DXCOLOR Color, D3DXCOLOR Color2 )
-{
-	m_Effect = camelion;
-	m_start_color = Color;
-	m_end_color = Color2;
-	//m_fPercentBetweenColors = 0.0;
-	//m_bTweeningTowardEndColor = TRUE;
-	m_fDeltaPercentPerSecond = fDeltaPercentPerSecond;
-}
-
-void Sprite::SetEffectGlowing( FLOAT fDeltaPercentPerSecond, D3DXCOLOR Color, D3DXCOLOR Color2 )
-{
-	m_Effect = glowing;
-	m_start_color = Color;
-	m_end_color = Color2;
-	//m_fPercentBetweenColors = 0.0;
-	//m_bTweeningTowardEndColor = TRUE;
-	m_fDeltaPercentPerSecond = fDeltaPercentPerSecond;
-}
-
-void Sprite::SetEffectWagging(	FLOAT fWagRadians, FLOAT fWagPeriod )
-{
-	m_Effect = wagging;
-	m_fWagRadians = fWagRadians;
-	m_fWagPeriod = fWagPeriod;
-}
-
-void Sprite::SetEffectSpinning(	FLOAT fSpinSpeed /*radians per second*/ )
-{
-	m_Effect = spinning;
-	m_fSpinSpeed = fSpinSpeed;
-}
-
-void Sprite::SetEffectVibrating( FLOAT fVibrationDistance )
-{
-	m_Effect = vibrating;
-	m_fVibrationDistance = fVibrationDistance;
-}
-
-void Sprite::SetEffectFlickering()
-{
-	m_Effect = flickering;
-}

stepmania/src/Sprite.h

@@ -29,20 +29,15 @@ public:
 	virtual ~Sprite();
 
 
-	enum SpriteEffect { no_effect,
-						blinking,	camelion,   glowing,
-						wagging,	spinning,
-						vibrating,	flickering
-						 };
 	
 
-	BOOL LoadFromTexture( CString sTexturePath );
+	bool LoadFromTexture( CString sTexturePath );
-	BOOL LoadFromSpriteFile( CString sSpritePath );
+	bool LoadFromSpriteFile( CString sSpritePath );
 
 	void PrintDebugInfo();
 
 	virtual void Draw();
-	virtual void Update( const FLOAT &fDeltaTime );
+	virtual void Update( const float &fDeltaTime );
 
 	void StartAnimating()	{ m_bIsAnimating = TRUE; };
 	void StopAnimating()	{ m_bIsAnimating = FALSE; };
@@ -55,65 +50,25 @@ public:
 	void SetCustomSrcRect( FRECT new_texcoord_frect );	// for cropping
 
 
-	void SetEffectNone();
-	void SetEffectBlinking( FLOAT fDeltaPercentPerSecond = 2.5,
-						    D3DXCOLOR Color  = D3DXCOLOR(0.5f,0.5f,0.5f,1), 
-						    D3DXCOLOR Color2 = D3DXCOLOR(1,1,1,1) );
-	void SetEffectCamelion( FLOAT fDeltaPercentPerSecond = 2.5,
-						    D3DXCOLOR Color  = D3DXCOLOR(0,0,0,1), 
-						    D3DXCOLOR Color2 = D3DXCOLOR(1,1,1,1) );
-	void SetEffectGlowing( FLOAT fDeltaPercentPerSecond = 2.5,
-						   D3DXCOLOR Color  = D3DXCOLOR(0.2f,0.2f,0.2f,0),
-						   D3DXCOLOR Color2 = D3DXCOLOR(0.8f,0.8f,0.8f,0) );
-	void SetEffectWagging( FLOAT fWagRadians =  0.2,
-						   FLOAT fWagPeriod = 2.0 );
-	void SetEffectSpinning( FLOAT fRadsPerSpeed = 2.0 );
-	void SetEffectVibrating( FLOAT fVibrationDistance = 5.0 );
-	void SetEffectFlickering();
-	SpriteEffect GetEffect() { return m_Effect; };
 
 protected:
 	void Init();
 	
-	BOOL LoadTexture( CString sTexture );
+	bool LoadTexture( CString sTexture );
 
 	CString	m_sSpritePath;
 	LPRageTexture m_pTexture;
 	CString	m_sTexturePath;
 
 	UINT	m_uFrame[MAX_SPRITE_STATES];	// array of indicies into m_rectBitmapFrames
-	FLOAT	m_fDelay[MAX_SPRITE_STATES];
+	float	m_fDelay[MAX_SPRITE_STATES];
 	UINT	m_uNumStates;
 	UINT	m_uCurState;
-	BOOL	m_bIsAnimating;
+	bool	m_bIsAnimating;
-	FLOAT	m_fSecsIntoState;	// number of seconds that have elapsed since we switched to this frame
+	float	m_fSecsIntoState;	// number of seconds that have elapsed since we switched to this frame
 
-	BOOL m_bUsingCustomTexCoordRect;
+	bool m_bUsingCustomTexCoordRect;
 	FRECT m_CustomTexCoordRect;
-
-	SpriteEffect m_Effect;
-
-	// Counting variables for sprite effects:
-	// camelion and glowing:
-//	D3DXCOLOR m_Color2;
-	FLOAT m_fPercentBetweenColors;
-	BOOL  m_bTweeningTowardEndColor;	// TRUE is fading toward end_color, FALSE if fading toward start_color
-	FLOAT m_fDeltaPercentPerSecond;	// percentage change in tweening per second
-
-	// wagging:
-	FLOAT m_fWagRadians;
-	FLOAT m_fWagPeriod;		// seconds to complete a wag (back and forth)
-	FLOAT m_fWagTimer;		// num of seconds into this wag
-
-	// spinning:
-	FLOAT m_fSpinSpeed;		// radians per second
-
-	// vibrating:
-	FLOAT m_fVibrationDistance;
-
-	// flickering:
-	BOOL m_bVisibleThisFrame;
-
 };
 
 

stepmania/src/StepMania.cpp

@@ -447,11 +447,29 @@ void Render()
 
 			break;
 		case S_OK:
+			{
+				// set texture and alpha properties
+				LPDIRECT3DDEVICE8 pd3dDevice = SCREEN->GetDevice();
+
+				// calculate view and projection transforms
+
+				D3DXMATRIX matView;
+				D3DXMatrixIdentity( &matView );
+				pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
+
+				D3DXMATRIX matProj;
+				D3DXMatrixOrthoOffCenterLH( &matProj, 0, 640, 480, 0, -100, 100 );
+				pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
+
+				D3DXCOLOR colorDiffuse = D3DXCOLOR(1,1,1,1);
+				D3DXCOLOR colorAdd = D3DXCOLOR(0,0,0,0);
+
 				// draw the game
 				WM->Draw();
 
 
 				SCREEN->EndFrame();
+			}
 			break;
 	}
 }

stepmania/src/Transition.h

@@ -40,10 +40,10 @@ public:
 	virtual void CloseWipingRight(WindowMessage send_when_done );
 	virtual void CloseWipingLeft( WindowMessage send_when_done );
 
-	BOOL IsClosed() { return m_TransitionState == closed; };
+	bool IsClosed() { return m_TransitionState == closed; };
-	BOOL IsClosing() { return m_TransitionState == closing_right  ||  m_TransitionState == closing_left; };
+	bool IsClosing() { return m_TransitionState == closing_right  ||  m_TransitionState == closing_left; };
 
-	VOID SetTransitionTime( FLOAT fNewTransitionTime ) { m_fTransitionTime = fNewTransitionTime; };
+	void SetTransitionTime( FLOAT fNewTransitionTime ) { m_fTransitionTime = fNewTransitionTime; };
 
 	void SetColor( D3DXCOLOR new_color ) { m_Color = new_color; };
 	void SetCloseWipingRightSound( CString sSoundPath );
@@ -56,13 +56,13 @@ protected:
 						   closing_right, closing_left };
 
 	TransitionState	m_TransitionState;
-	FLOAT			m_fTransitionTime;
+	float			m_fTransitionTime;
-	FLOAT			m_fPercentThroughTransition;
+	float			m_fPercentThroughTransition;
 
 	WindowMessage	m_MessageToSendWhenDone;
 
-	BOOL m_bPlayCloseWipingRightSound;
+	bool m_bPlayCloseWipingRightSound;
-	BOOL m_bPlayCloseWipingLeftSound;
+	bool m_bPlayCloseWipingLeftSound;
 	HSAMPLE m_hCloseWipingRightSound;
 	HSAMPLE m_hCloseWipingLeftSound;
 

stepmania/src/TransitionFade.cpp

@@ -35,7 +35,7 @@ TransitionFade::~TransitionFade()
 
 void TransitionFade::Draw()
 {
-	FLOAT fPercentageOpaque;
+	float fPercentageOpaque;
 	switch( m_TransitionState )
 	{
 	case opened:

stepmania/src/TransitionStarWipe.cpp

@@ -39,7 +39,7 @@ void TransitionStarWipe::Draw()
 		return;
 	}
 
-	FLOAT fPercentOpen;
+	float fPercentOpen;
 	switch( m_TransitionState )
 	{
 	case opening_right: