actions/itgmania212121
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

name cleanup. Replace:

Browse Source 
StartDrawingAtPixels
 FirstPixelToDraw
 YStartOffset
 DrawFarY
with:
 DrawDistanceAfterTargetsPixels
This commit is contained in:
Chris Danford
2006-11-13 06:12:38 +00:00
parent 06e30d1f45
commit bf20880ba9
9 changed files with 108 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
stepmania/Themes/default/metrics.ini
+3 -2
View File
@@ -2569,8 +2569,8 @@ AttackDisplayYReverse=70
HoldJudgmentYStandard=-90 HoldJudgmentYStandard=-90
HoldJudgmentYReverse=90 HoldJudgmentYReverse=90
BrightGhostComboThreshold=100 BrightGhostComboThreshold=100
StartDrawingAtPixels=-60 DrawDistanceBeforeTargetsPixels=400
StopDrawingAtPixels=400 DrawDistanceAfterTargetsPixels=-60
TapJudgmentsUnderField=false TapJudgmentsUnderField=false
HoldJudgmentsUnderField=false HoldJudgmentsUnderField=false
@@ -4783,3 +4783,4 @@ ShowCoinData=true
[NoteField] [NoteField]
ShowBoard=false ShowBoard=false
ShowBeatBars=false ShowBeatBars=false
FadeBeforeTargetsPercent=0
stepmania/src/ArrowEffects.cpp
+4 -4
View File
@@ -512,7 +512,7 @@ float ArrowGetPercentVisible( const PlayerState* pPlayerState, int iCol, float f
return clamp( 1+fVisibleAdjust, 0, 1 ); return clamp( 1+fVisibleAdjust, 0, 1 );
} }
float ArrowEffects::GetAlpha( const PlayerState* pPlayerState, int iCol, float fYOffset, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ) float ArrowEffects::GetAlpha( const PlayerState* pPlayerState, int iCol, float fYOffset, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar )
{ {
float fPercentVisible = ArrowGetPercentVisible(pPlayerState,iCol,fYOffset,fYReverseOffsetPixels); float fPercentVisible = ArrowGetPercentVisible(pPlayerState,iCol,fYOffset,fYReverseOffsetPixels);
@@ -523,10 +523,10 @@ float ArrowEffects::GetAlpha( const PlayerState* pPlayerState, int iCol, float f
/* Get the YPos without reverse (that is, factor in EFFECT_TIPSY). */ /* Get the YPos without reverse (that is, factor in EFFECT_TIPSY). */
float fYPos = ArrowEffects::GetYPos( pPlayerState, iCol, fYOffset, fYReverseOffsetPixels, false ); float fYPos = ArrowEffects::GetYPos( pPlayerState, iCol, fYOffset, fYReverseOffsetPixels, false );
float fFullAlphaY = fDrawFarY*(1-fFadeInPercentOfDrawFar); float fFullAlphaY = fDrawDistanceBeforeTargetsPixels*(1-fFadeInPercentOfDrawFar);
if( fYPos > fFullAlphaY ) if( fYPos > fFullAlphaY )
{ {
float f = SCALE( fYPos, fFullAlphaY, fDrawFarY, 1.0f, 0.0f ); float f = SCALE( fYPos, fFullAlphaY, fDrawDistanceBeforeTargetsPixels, 1.0f, 0.0f );
return f; return f;
} }
@@ -534,7 +534,7 @@ float ArrowEffects::GetAlpha( const PlayerState* pPlayerState, int iCol, float f
return (fPercentVisible>0.5f) ? 1.0f : 0.0f; return (fPercentVisible>0.5f) ? 1.0f : 0.0f;
} }
float ArrowEffects::GetGlow( const PlayerState* pPlayerState, int iCol, float fYOffset, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ) float ArrowEffects::GetGlow( const PlayerState* pPlayerState, int iCol, float fYOffset, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar )
{ {
float fPercentVisible = ArrowGetPercentVisible(pPlayerState,iCol,fYOffset,fYReverseOffsetPixels); float fPercentVisible = ArrowGetPercentVisible(pPlayerState,iCol,fYOffset,fYReverseOffsetPixels);
stepmania/src/ArrowEffects.h
+2 -2
View File
@@ -48,12 +48,12 @@ public:
// fAlpha is the transparency of the arrow. It depends on fYPos and the // fAlpha is the transparency of the arrow. It depends on fYPos and the
// AppearanceType. // AppearanceType.
static float GetAlpha( const PlayerState* pPlayerState, int iCol, float fYPos, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ); static float GetAlpha( const PlayerState* pPlayerState, int iCol, float fYPos, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar );
// fAlpha is the transparency of the arrow. It depends on fYPos and the // fAlpha is the transparency of the arrow. It depends on fYPos and the
// AppearanceType. // AppearanceType.
static float GetGlow( const PlayerState* pPlayerState, int iCol, float fYPos, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ); static float GetGlow( const PlayerState* pPlayerState, int iCol, float fYPos, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar );
// Depends on fYOffset. // Depends on fYOffset.
stepmania/src/NoteDisplay.cpp
+41 -39
View File
@@ -329,12 +329,12 @@ Sprite *NoteDisplay::GetHoldSprite( NoteColorSprite ncs[NUM_HoldType][NUM_Active
return pSpriteOut; return pSpriteOut;
} }
static float ArrowGetAlphaOrGlow( bool bGlow, const PlayerState* pPlayerState, int iCol, float fYOffset, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ) static float ArrowGetAlphaOrGlow( bool bGlow, const PlayerState* pPlayerState, int iCol, float fYOffset, float fPercentFadeToFail, float fYReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar )
{ {
if( bGlow ) if( bGlow )
return ArrowEffects::GetGlow( pPlayerState, iCol, fYOffset, fPercentFadeToFail, fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); return ArrowEffects::GetGlow( pPlayerState, iCol, fYOffset, fPercentFadeToFail, fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
else else
return ArrowEffects::GetAlpha( pPlayerState, iCol, fYOffset, fPercentFadeToFail, fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); return ArrowEffects::GetAlpha( pPlayerState, iCol, fYOffset, fPercentFadeToFail, fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
} }
struct StripBuffer struct StripBuffer
@@ -365,7 +365,7 @@ struct StripBuffer
}; };
void NoteDisplay::DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, float fColorScale, void NoteDisplay::DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ) bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar )
{ {
// //
// Draw the top cap (always wavy) // Draw the top cap (always wavy)
@@ -404,8 +404,8 @@ void NoteDisplay::DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bI
float fDrawYCapTop; float fDrawYCapTop;
float fDrawYCapBottom; float fDrawYCapBottom;
{ {
float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYStartOffset, m_fYReverseOffsetPixels ); float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fDrawDistanceAfterTargetsPixels, m_fYReverseOffsetPixels );
float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYEndOffset, m_fYReverseOffsetPixels ); float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fDrawDistanceBeforeTargetsPixels, m_fYReverseOffsetPixels );
fDrawYCapTop = max( fYCapTop, bReverse ? fYEndPos : fYStartPos ); fDrawYCapTop = max( fYCapTop, bReverse ? fYEndPos : fYStartPos );
fDrawYCapBottom = min( fYCapBottom, bReverse ? fYStartPos : fYEndPos ); fDrawYCapBottom = min( fYCapBottom, bReverse ? fYStartPos : fYEndPos );
} }
@@ -434,7 +434,7 @@ void NoteDisplay::DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bI
const float fTexCoordTop = SCALE( fTopDistFromHeadTop, 0, fFrameHeight, pRect->top, pRect->bottom ); const float fTexCoordTop = SCALE( fTopDistFromHeadTop, 0, fFrameHeight, pRect->top, pRect->bottom );
const float fTexCoordLeft = pRect->left; const float fTexCoordLeft = pRect->left;
const float fTexCoordRight = pRect->right; const float fTexCoordRight = pRect->right;
const float fAlpha = ArrowGetAlphaOrGlow( bGlow, m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fAlpha = ArrowGetAlphaOrGlow( bGlow, m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const RageColor color = RageColor(fColorScale,fColorScale,fColorScale,fAlpha); const RageColor color = RageColor(fColorScale,fColorScale,fColorScale,fAlpha);
if( fAlpha > 0 ) if( fAlpha > 0 )
@@ -477,7 +477,7 @@ void NoteDisplay::DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bI
void NoteDisplay::DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, float fColorScale, bool bGlow, void NoteDisplay::DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, float fColorScale, bool bGlow,
float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ) float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar )
{ {
// //
// Draw the body (always wavy) // Draw the body (always wavy)
@@ -520,8 +520,8 @@ void NoteDisplay::DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsB
float fDrawYBodyTop; float fDrawYBodyTop;
float fDrawYBodyBottom; float fDrawYBodyBottom;
{ {
float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYStartOffset, m_fYReverseOffsetPixels ); float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fDrawDistanceAfterTargetsPixels, m_fYReverseOffsetPixels );
float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYEndOffset, m_fYReverseOffsetPixels ); float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fDrawDistanceBeforeTargetsPixels, m_fYReverseOffsetPixels );
fDrawYBodyTop = max( fYBodyTop, bReverse ? fYEndPos : fYStartPos ); fDrawYBodyTop = max( fYBodyTop, bReverse ? fYEndPos : fYStartPos );
fDrawYBodyBottom = min( fYBodyBottom, bReverse ? fYStartPos : fYEndPos ); fDrawYBodyBottom = min( fYBodyBottom, bReverse ? fYStartPos : fYEndPos );
@@ -554,7 +554,7 @@ void NoteDisplay::DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsB
fTexCoordTop -= fVertTexCoordOffset; fTexCoordTop -= fVertTexCoordOffset;
const float fTexCoordLeft = pRect->left; const float fTexCoordLeft = pRect->left;
const float fTexCoordRight = pRect->right; const float fTexCoordRight = pRect->right;
const float fAlpha = ArrowGetAlphaOrGlow( bGlow, m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fAlpha = ArrowGetAlphaOrGlow( bGlow, m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const RageColor color = RageColor(fColorScale,fColorScale,fColorScale,fAlpha); const RageColor color = RageColor(fColorScale,fColorScale,fColorScale,fAlpha);
if( fAlpha > 0 ) if( fAlpha > 0 )
@@ -599,7 +599,8 @@ void NoteDisplay::DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsB
} }
} }
void NoteDisplay::DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, float fColorScale, bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ) void NoteDisplay::DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar )
{ {
// //
// Draw the bottom cap (always wavy) // Draw the bottom cap (always wavy)
@@ -638,8 +639,8 @@ void NoteDisplay::DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool
float fDrawYCapTop; float fDrawYCapTop;
float fDrawYCapBottom; float fDrawYCapBottom;
{ {
float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYStartOffset, m_fYReverseOffsetPixels ); float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fDrawDistanceAfterTargetsPixels, m_fYReverseOffsetPixels );
float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYEndOffset, m_fYReverseOffsetPixels ); float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fDrawDistanceBeforeTargetsPixels, m_fYReverseOffsetPixels );
fDrawYCapTop = max( fYCapTop, bReverse ? fYEndPos : fYStartPos ); fDrawYCapTop = max( fYCapTop, bReverse ? fYEndPos : fYStartPos );
fDrawYCapBottom = min( fYCapBottom, bReverse ? fYStartPos : fYEndPos ); fDrawYCapBottom = min( fYCapBottom, bReverse ? fYStartPos : fYEndPos );
} }
@@ -665,7 +666,7 @@ void NoteDisplay::DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool
const float fTexCoordTop = SCALE( fTopDistFromTail, 0, fFrameHeight, pRect->top, pRect->bottom ); const float fTexCoordTop = SCALE( fTopDistFromTail, 0, fFrameHeight, pRect->top, pRect->bottom );
const float fTexCoordLeft = pRect->left; const float fTexCoordLeft = pRect->left;
const float fTexCoordRight = pRect->right; const float fTexCoordRight = pRect->right;
const float fAlpha = ArrowGetAlphaOrGlow( bGlow, m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fAlpha = ArrowGetAlphaOrGlow( bGlow, m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const RageColor color = RageColor(fColorScale,fColorScale,fColorScale,fAlpha); const RageColor color = RageColor(fColorScale,fColorScale,fColorScale,fAlpha);
if( fAlpha > 0 ) if( fAlpha > 0 )
@@ -706,7 +707,8 @@ void NoteDisplay::DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool
} }
} }
void NoteDisplay::DrawHoldTail( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYTail, float fPercentFadeToFail, float fColorScale, bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ) void NoteDisplay::DrawHoldTail( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYTail, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar )
{ {
// //
// Draw the tail // Draw the tail
@@ -717,12 +719,12 @@ void NoteDisplay::DrawHoldTail( const TapNote& tn, int iCol, int iRow, bool bIsB
const float fY = fYTail; const float fY = fYTail;
const float fYOffset = ArrowEffects::GetYOffsetFromYPos( m_pPlayerState, iCol, fY, m_fYReverseOffsetPixels ); const float fYOffset = ArrowEffects::GetYOffsetFromYPos( m_pPlayerState, iCol, fY, m_fYReverseOffsetPixels );
if( fYOffset < fYStartOffset || fYOffset > fYEndOffset ) if( fYOffset < fDrawDistanceAfterTargetsPixels || fYOffset > fDrawDistanceBeforeTargetsPixels )
return; return;
const float fX = ArrowEffects::GetXPos( m_pPlayerState, iCol, fYOffset ); const float fX = ArrowEffects::GetXPos( m_pPlayerState, iCol, fYOffset );
const float fZ = ArrowEffects::GetZPos( m_pPlayerState, iCol, fYOffset ); const float fZ = ArrowEffects::GetZPos( m_pPlayerState, iCol, fYOffset );
const float fAlpha = ArrowEffects::GetAlpha( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fAlpha = ArrowEffects::GetAlpha( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const float fGlow = ArrowEffects::GetGlow( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fGlow = ArrowEffects::GetGlow( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const RageColor colorDiffuse = RageColor(fColorScale,fColorScale,fColorScale,fAlpha); const RageColor colorDiffuse = RageColor(fColorScale,fColorScale,fColorScale,fAlpha);
const RageColor colorGlow = RageColor(1,1,1,fGlow); const RageColor colorGlow = RageColor(1,1,1,fGlow);
@@ -773,7 +775,8 @@ void NoteDisplay::DrawHoldTail( const TapNote& tn, int iCol, int iRow, bool bIsB
} }
} }
void NoteDisplay::DrawHoldHead( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fPercentFadeToFail, float fColorScale, bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ) void NoteDisplay::DrawHoldHead( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar )
{ {
// //
// Draw the head // Draw the head
@@ -785,12 +788,12 @@ void NoteDisplay::DrawHoldHead( const TapNote& tn, int iCol, int iRow, bool bIsB
// draw with normal Sprite // draw with normal Sprite
const float fY = fYHead; const float fY = fYHead;
const float fYOffset = ArrowEffects::GetYOffsetFromYPos( m_pPlayerState, iCol, fY, m_fYReverseOffsetPixels ); const float fYOffset = ArrowEffects::GetYOffsetFromYPos( m_pPlayerState, iCol, fY, m_fYReverseOffsetPixels );
if( fYOffset < fYStartOffset || fYOffset > fYEndOffset ) if( fYOffset < fDrawDistanceAfterTargetsPixels || fYOffset > fDrawDistanceBeforeTargetsPixels )
return; return;
const float fX = ArrowEffects::GetXPos( m_pPlayerState, iCol, fYOffset ); const float fX = ArrowEffects::GetXPos( m_pPlayerState, iCol, fYOffset );
const float fZ = ArrowEffects::GetZPos( m_pPlayerState, iCol, fYOffset ); const float fZ = ArrowEffects::GetZPos( m_pPlayerState, iCol, fYOffset );
const float fAlpha = ArrowEffects::GetAlpha( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fAlpha = ArrowEffects::GetAlpha( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const float fGlow = ArrowEffects::GetGlow( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fGlow = ArrowEffects::GetGlow( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const RageColor colorDiffuse= RageColor(fColorScale,fColorScale,fColorScale,fAlpha); const RageColor colorDiffuse= RageColor(fColorScale,fColorScale,fColorScale,fAlpha);
const RageColor colorGlow = RageColor(1,1,1,fGlow); const RageColor colorGlow = RageColor(1,1,1,fGlow);
@@ -842,9 +845,8 @@ void NoteDisplay::DrawHoldHead( const TapNote& tn, int iCol, int iRow, bool bIsB
} }
} }
void NoteDisplay::DrawHold( const TapNote &tn, int iCol, int iRow, bool bIsBeingHeld, bool bIsActive, const HoldNoteResult &Result, void NoteDisplay::DrawHold( const TapNote &tn, int iCol, int iRow, bool bIsBeingHeld, bool bIsActive, const HoldNoteResult &Result, float fPercentFadeToFail,
float fPercentFadeToFail, bool bDrawGlowOnly, float fReverseOffsetPixels, float fYStartOffset, float fYEndOffset, bool bDrawGlowOnly, float fReverseOffsetPixels, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar )
float fDrawFarY, float fFadeInPercentOfDrawFar )
{ {
int iEndRow = iRow + tn.iDuration; int iEndRow = iRow + tn.iDuration;
@@ -891,9 +893,9 @@ void NoteDisplay::DrawHold( const TapNote &tn, int iCol, int iRow, bool bIsBeing
/* The body and caps should have no overlap, so their order doesn't matter. /* The body and caps should have no overlap, so their order doesn't matter.
* Draw the head last, so it appears on top. */ * Draw the head last, so it appears on top. */
if( !cache->m_bHoldHeadIsAboveWavyParts ) if( !cache->m_bHoldHeadIsAboveWavyParts )
DrawHoldHead( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYTail : fYHead, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldHead( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYTail : fYHead, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
if( !cache->m_bHoldTailIsAboveWavyParts ) if( !cache->m_bHoldTailIsAboveWavyParts )
DrawHoldTail( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYHead : fYTail, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldTail( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYHead : fYTail, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
if( bDrawGlowOnly ) if( bDrawGlowOnly )
DISPLAY->SetTextureModeGlow(); DISPLAY->SetTextureModeGlow();
@@ -903,31 +905,31 @@ void NoteDisplay::DrawHold( const TapNote &tn, int iCol, int iRow, bool bIsBeing
DISPLAY->SetZWrite( WavyPartsNeedZBuffer ); DISPLAY->SetZWrite( WavyPartsNeedZBuffer );
if( !bFlipHeadAndTail ) if( !bFlipHeadAndTail )
DrawHoldBottomCap( tn, iCol, iRow, bIsBeingHeld, fYHead, fYTail, fYStep, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldBottomCap( tn, iCol, iRow, bIsBeingHeld, fYHead, fYTail, fYStep, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
DrawHoldBody( tn, iCol, iRow, bIsBeingHeld, fYHead, fYTail, fYStep, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldBody( tn, iCol, iRow, bIsBeingHeld, fYHead, fYTail, fYStep, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
if( bFlipHeadAndTail ) if( bFlipHeadAndTail )
DrawHoldTopCap( tn, iCol, iRow, bIsBeingHeld, fYHead, fYTail, fYStep, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldTopCap( tn, iCol, iRow, bIsBeingHeld, fYHead, fYTail, fYStep, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
/* These set the texture mode themselves. */ /* These set the texture mode themselves. */
if( cache->m_bHoldTailIsAboveWavyParts ) if( cache->m_bHoldTailIsAboveWavyParts )
DrawHoldTail( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYHead : fYTail, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldTail( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYHead : fYTail, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
if( cache->m_bHoldHeadIsAboveWavyParts ) if( cache->m_bHoldHeadIsAboveWavyParts )
DrawHoldHead( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYTail : fYHead, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHoldHead( tn, iCol, iRow, bIsBeingHeld, bFlipHeadAndTail ? fYTail : fYHead, fPercentFadeToFail, fColorScale, bDrawGlowOnly, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
// now, draw the glow pass // now, draw the glow pass
if( !bDrawGlowOnly ) if( !bDrawGlowOnly )
DrawHold( tn, iCol, iRow, bIsBeingHeld, bIsActive, Result, fPercentFadeToFail, true, fReverseOffsetPixels, fYStartOffset, fYEndOffset, fDrawFarY, fFadeInPercentOfDrawFar ); DrawHold( tn, iCol, iRow, bIsBeingHeld, bIsActive, Result, fPercentFadeToFail, true, fReverseOffsetPixels, fDrawDistanceAfterTargetsPixels, fDrawDistanceBeforeTargetsPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
} }
void NoteDisplay::DrawActor( Actor* pActor, int iCol, float fBeat, float fPercentFadeToFail, float fLife, float fReverseOffsetPixels, bool bUseLighting, NotePart part, float fDrawFarY, float fFadeInPercentOfDrawFar ) void NoteDisplay::DrawActor( Actor* pActor, int iCol, float fBeat, float fPercentFadeToFail, float fLife, float fReverseOffsetPixels, bool bUseLighting, NotePart part, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar )
{ {
const float fYOffset = ArrowEffects::GetYOffset( m_pPlayerState, iCol, fBeat ); const float fYOffset = ArrowEffects::GetYOffset( m_pPlayerState, iCol, fBeat );
const float fYPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYOffset, fReverseOffsetPixels ); const float fYPos = ArrowEffects::GetYPos( m_pPlayerState, iCol, fYOffset, fReverseOffsetPixels );
const float fRotation = ArrowEffects::GetRotation( m_pPlayerState, fBeat ); const float fRotation = ArrowEffects::GetRotation( m_pPlayerState, fBeat );
const float fXPos = ArrowEffects::GetXPos( m_pPlayerState, iCol, fYOffset ); const float fXPos = ArrowEffects::GetXPos( m_pPlayerState, iCol, fYOffset );
const float fZPos = ArrowEffects::GetZPos( m_pPlayerState, iCol, fYOffset ); const float fZPos = ArrowEffects::GetZPos( m_pPlayerState, iCol, fYOffset );
const float fAlpha = ArrowEffects::GetAlpha( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fAlpha = ArrowEffects::GetAlpha( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const float fGlow = ArrowEffects::GetGlow( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawFarY, fFadeInPercentOfDrawFar ); const float fGlow = ArrowEffects::GetGlow( m_pPlayerState, iCol, fYOffset, fPercentFadeToFail, m_fYReverseOffsetPixels, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
const float fColorScale = ArrowEffects::GetBrightness( m_pPlayerState, fBeat ) * SCALE(fLife,0,1,0.2f,1); const float fColorScale = ArrowEffects::GetBrightness( m_pPlayerState, fBeat ) * SCALE(fLife,0,1,0.2f,1);
const float fZoom = ArrowEffects::GetZoom( m_pPlayerState ); const float fZoom = ArrowEffects::GetZoom( m_pPlayerState );
RageColor diffuse = RageColor(fColorScale,fColorScale,fColorScale,fAlpha); RageColor diffuse = RageColor(fColorScale,fColorScale,fColorScale,fAlpha);
@@ -973,7 +975,7 @@ void NoteDisplay::DrawActor( Actor* pActor, int iCol, float fBeat, float fPercen
} }
} }
void NoteDisplay::DrawTap( int iCol, float fBeat, bool bOnSameRowAsHoldStart, bool bIsAddition, bool bIsMine, bool bIsLift, float fPercentFadeToFail, float fLife, float fReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ) void NoteDisplay::DrawTap( int iCol, float fBeat, bool bOnSameRowAsHoldStart, bool bIsAddition, bool bIsMine, bool bIsLift, float fPercentFadeToFail, float fLife, float fReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar )
{ {
Actor* pActor = NULL; Actor* pActor = NULL;
bool bUseLighting = false; bool bUseLighting = false;
@@ -1007,7 +1009,7 @@ void NoteDisplay::DrawTap( int iCol, float fBeat, bool bOnSameRowAsHoldStart, bo
bUseLighting = cache->m_bTapNoteUseLighting; bUseLighting = cache->m_bTapNoteUseLighting;
} }
DrawActor( pActor, iCol, fBeat, fPercentFadeToFail, fLife, fReverseOffsetPixels, bUseLighting, part, fDrawFarY, fFadeInPercentOfDrawFar ); DrawActor( pActor, iCol, fBeat, fPercentFadeToFail, fLife, fReverseOffsetPixels, bUseLighting, part, fDrawDistanceBeforeTargetsPixels, fFadeInPercentOfDrawFar );
} }
/* /*
stepmania/src/NoteDisplay.h
+9 -9
View File
@@ -79,12 +79,12 @@ public:
static void Update( float fDeltaTime ); static void Update( float fDeltaTime );
void DrawActor( Actor* pActor, int iCol, float fBeat, float fPercentFadeToFail, float fLife, void DrawActor( Actor* pActor, int iCol, float fBeat, float fPercentFadeToFail, float fLife,
float fReverseOffsetPixels, bool bUseLighting, NotePart part, float fDrawFarY, float fFadeInPercentOfDrawFar ); float fReverseOffsetPixels, bool bUseLighting, NotePart part, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar );
void DrawTap( int iCol, float fBeat, bool bOnSameRowAsHoldStart, bool bIsAddition, bool bIsMine, bool bIsLift, void DrawTap( int iCol, float fBeat, bool bOnSameRowAsHoldStart, bool bIsAddition, bool bIsMine, bool bIsLift,
float fPercentFadeToFail, float fLife, float fReverseOffsetPixels, float fDrawFarY, float fFadeInPercentOfDrawFar ); float fPercentFadeToFail, float fLife, float fReverseOffsetPixels, float fDrawDistanceBeforeTargetsPixels, float fFadeInPercentOfDrawFar );
void DrawHold( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, bool bIsActive, const HoldNoteResult &Result, void DrawHold( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, bool bIsActive, const HoldNoteResult &Result,
float fPercentFadeToFail, bool bDrawGlowOnly, float fReverseOffsetPixels, float fYStartOffset, float fYEndOffset, float fPercentFadeToFail, bool bDrawGlowOnly, float fReverseOffsetPixels, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels,
float fDrawFarY, float fFadeInPercentOfDrawFar ); float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar );
bool DrawHoldHeadForTapsOnSameRow() const; bool DrawHoldHeadForTapsOnSameRow() const;
@@ -96,17 +96,17 @@ private:
void DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, void DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep,
float fPercentFadeToFail, float fColorScale, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ); bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar );
void DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, void DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep,
float fPercentFadeToFail, float fColorScale, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ); bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar );
void DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail, void DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fYTail, int fYStep, float fPercentFadeToFail,
float fColorScale, float fColorScale,
bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ); bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar );
void DrawHoldTail( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYTail, float fPercentFadeToFail, float fColorScale, void DrawHoldTail( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYTail, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ); bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar );
void DrawHoldHead( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fPercentFadeToFail, float fColorScale, void DrawHoldHead( const TapNote& tn, int iCol, int iRow, bool bIsBeingHeld, float fYHead, float fPercentFadeToFail, float fColorScale,
bool bGlow, float fYStartOffset, float fYEndOffset, float fDrawFarY, float fFadeInPercentOfDrawFar ); bool bGlow, float fDrawDistanceAfterTargetsPixels, float fDrawDistanceBeforeTargetsPixels, float fDrawDistanceBeforeTargetsPixels2, float fFadeInPercentOfDrawFar );
const PlayerState *m_pPlayerState; // to look up PlayerOptions const PlayerState *m_pPlayerState; // to look up PlayerOptions
NoteMetricCache_t *cache; NoteMetricCache_t *cache;
stepmania/src/NoteField.cpp
+36 -36
View File
@@ -22,7 +22,7 @@
static ThemeMetric<bool> SHOW_BOARD( "NoteField", "ShowBoard" ); static ThemeMetric<bool> SHOW_BOARD( "NoteField", "ShowBoard" );
static ThemeMetric<bool> SHOW_BEAT_BARS( "NoteField", "ShowBeatBars" ); static ThemeMetric<bool> SHOW_BEAT_BARS( "NoteField", "ShowBeatBars" );
static ThemeMetric<float> FADE_IN_PERCENT( "NoteField", "FadeInPercent" ); static ThemeMetric<float> FADE_BEFORE_TARGETS_PERCENT( "NoteField", "FadeBeforeTargetsPercent" );
NoteField::NoteField() NoteField::NoteField()
{ {
@@ -138,14 +138,14 @@ void NoteField::Init( const PlayerState* pPlayerState, float fYReverseOffsetPixe
void NoteField::Load( void NoteField::Load(
const NoteData *pNoteData, const NoteData *pNoteData,
int iFirstPixelToDraw, int iDrawDistanceAfterTargetsPixels,
int iLastPixelToDraw ) int iDrawDistanceBeforeTargetsPixels )
{ {
ASSERT( pNoteData ); ASSERT( pNoteData );
m_pNoteData = pNoteData; m_pNoteData = pNoteData;
m_iStartDrawingPixel = iFirstPixelToDraw; m_iDrawDistanceAfterTargetsPixels = iDrawDistanceAfterTargetsPixels;
m_iEndDrawingPixel = iLastPixelToDraw; m_iDrawDistanceBeforeTargetsPixels = iDrawDistanceBeforeTargetsPixels;
ASSERT( m_iEndDrawingPixel >= m_iStartDrawingPixel ); ASSERT( m_iDrawDistanceBeforeTargetsPixels >= m_iDrawDistanceAfterTargetsPixels );
m_fPercentFadeToFail = -1; m_fPercentFadeToFail = -1;
@@ -276,7 +276,7 @@ void NoteField::DrawBeatBar( const float fBeat )
} }
} }
void NoteField::DrawBoard( int iFirstPixelToDraw, int iLastPixelToDraw ) void NoteField::DrawBoard( int iDrawDistanceAfterTargetsPixels, int iDrawDistanceBeforeTargetsPixels )
{ {
const float fYOffsetAt0 = ArrowEffects::GetYOffset( m_pPlayerState, 0, GAMESTATE->m_fSongBeat ); const float fYOffsetAt0 = ArrowEffects::GetYOffset( m_pPlayerState, 0, GAMESTATE->m_fSongBeat );
const float fYOffsetAtNeg1 = ArrowEffects::GetYOffset( m_pPlayerState, 0, GAMESTATE->m_fSongBeat-1 ); const float fYOffsetAtNeg1 = ArrowEffects::GetYOffset( m_pPlayerState, 0, GAMESTATE->m_fSongBeat-1 );
@@ -295,7 +295,7 @@ void NoteField::DrawBoard( int iFirstPixelToDraw, int iLastPixelToDraw )
float fTexCoordOffset = fPixels / fBoardGraphicHeightPixels; float fTexCoordOffset = fPixels / fBoardGraphicHeightPixels;
{ {
// top half // top half
const float fHeight = iLastPixelToDraw; const float fHeight = iDrawDistanceBeforeTargetsPixels;
m_sprBoard.ZoomToHeight( fHeight ); m_sprBoard.ZoomToHeight( fHeight );
wrap( fPixels, fHeight ); wrap( fPixels, fHeight );
@@ -307,7 +307,7 @@ void NoteField::DrawBoard( int iFirstPixelToDraw, int iLastPixelToDraw )
m_sprBoard.Draw(); m_sprBoard.Draw();
} }
{ {
const float fHeight = -iFirstPixelToDraw; const float fHeight = -iDrawDistanceAfterTargetsPixels;
m_sprBoard.ZoomToHeight( fHeight ); m_sprBoard.ZoomToHeight( fHeight );
wrap( fPixels, fHeight ); wrap( fPixels, fHeight );
@@ -335,10 +335,10 @@ void NoteField::DrawAreaHighlight( int iStartBeat, int iEndBeat )
{ {
float fStartBeat = NoteRowToBeat( iStartBeat ); float fStartBeat = NoteRowToBeat( iStartBeat );
float fEndBeat = NoteRowToBeat( iEndBeat ); float fEndBeat = NoteRowToBeat( iEndBeat );
float fYStartOffset = ArrowEffects::GetYOffset( m_pPlayerState, 0, fStartBeat ); float fDrawDistanceAfterTargetsPixels = ArrowEffects::GetYOffset( m_pPlayerState, 0, fStartBeat );
float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, 0, fYStartOffset, m_fYReverseOffsetPixels ); float fYStartPos = ArrowEffects::GetYPos( m_pPlayerState, 0, fDrawDistanceAfterTargetsPixels, m_fYReverseOffsetPixels );
float fYEndOffset = ArrowEffects::GetYOffset( m_pPlayerState, 0, fEndBeat ); float fDrawDistanceBeforeTargetsPixels = ArrowEffects::GetYOffset( m_pPlayerState, 0, fEndBeat );
float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, 0, fYEndOffset, m_fYReverseOffsetPixels ); float fYEndPos = ArrowEffects::GetYPos( m_pPlayerState, 0, fDrawDistanceBeforeTargetsPixels, m_fYReverseOffsetPixels );
// The caller should have clamped these to reasonable values // The caller should have clamped these to reasonable values
ASSERT( fYStartPos > -1000 ); ASSERT( fYStartPos > -1000 );
@@ -413,7 +413,7 @@ void NoteField::DrawBGChangeText( const float fBeat, const RString sNewBGName )
// CPU OPTIMIZATION OPPORTUNITY: // CPU OPTIMIZATION OPPORTUNITY:
// change this probing to binary search // change this probing to binary search
float FindFirstDisplayedBeat( const PlayerState* pPlayerState, int iFirstPixelToDraw ) float FindFirstDisplayedBeat( const PlayerState* pPlayerState, int iDrawDistanceAfterTargetsPixels )
{ {
float fFirstBeatToDraw = GAMESTATE->m_fSongBeat-4; // Adjust to balance off performance and showing enough notes. float fFirstBeatToDraw = GAMESTATE->m_fSongBeat-4; // Adjust to balance off performance and showing enough notes.
@@ -435,7 +435,7 @@ float FindFirstDisplayedBeat( const PlayerState* pPlayerState, int iFirstPixelTo
if( bBoomerang && bIsPastPeakYOffset ) if( bBoomerang && bIsPastPeakYOffset )
break; // stop probing break; // stop probing
else if( fYOffset < iFirstPixelToDraw ) // off screen else if( fYOffset < iDrawDistanceAfterTargetsPixels ) // off screen
fFirstBeatToDraw += 0.1f; // move toward fSongBeat fFirstBeatToDraw += 0.1f; // move toward fSongBeat
else // on screen else // on screen
break; // stop probing break; // stop probing
@@ -444,7 +444,7 @@ float FindFirstDisplayedBeat( const PlayerState* pPlayerState, int iFirstPixelTo
return fFirstBeatToDraw; return fFirstBeatToDraw;
} }
float FindLastDisplayedBeat( const PlayerState* pPlayerState, int iLastPixelToDraw ) float FindLastDisplayedBeat( const PlayerState* pPlayerState, int iDrawDistanceBeforeTargetsPixels )
{ {
// //
// Probe for last note to draw. // Probe for last note to draw.
@@ -470,7 +470,7 @@ float FindLastDisplayedBeat( const PlayerState* pPlayerState, int iLastPixelToDr
if( bBoomerang && !bIsPastPeakYOffset ) if( bBoomerang && !bIsPastPeakYOffset )
fLastBeatToDraw += fSearchDistance; fLastBeatToDraw += fSearchDistance;
else if( fYOffset > iLastPixelToDraw ) // off screen else if( fYOffset > iDrawDistanceBeforeTargetsPixels ) // off screen
fLastBeatToDraw -= fSearchDistance; fLastBeatToDraw -= fSearchDistance;
else // on screen else // on screen
fLastBeatToDraw += fSearchDistance; fLastBeatToDraw += fSearchDistance;
@@ -481,15 +481,15 @@ float FindLastDisplayedBeat( const PlayerState* pPlayerState, int iLastPixelToDr
return fLastBeatToDraw; return fLastBeatToDraw;
} }
bool NoteField::IsOnScreen( float fBeat, int iCol, int iFirstPixelToDraw, int iLastPixelToDraw ) const bool NoteField::IsOnScreen( float fBeat, int iCol, int iDrawDistanceAfterTargetsPixels, int iDrawDistanceBeforeTargetsPixels ) const
{ {
// TRICKY: If boomerang is on, then ones in the range // TRICKY: If boomerang is on, then ones in the range
// [iFirstIndexToDraw,iLastIndexToDraw] aren't necessarily visible. // [iFirstIndexToDraw,iLastIndexToDraw] aren't necessarily visible.
// Test to see if this beat is visible before drawing. // Test to see if this beat is visible before drawing.
float fYOffset = ArrowEffects::GetYOffset( m_pPlayerState, iCol, fBeat ); float fYOffset = ArrowEffects::GetYOffset( m_pPlayerState, iCol, fBeat );
if( fYOffset > iLastPixelToDraw ) // off screen if( fYOffset > iDrawDistanceBeforeTargetsPixels ) // off screen
return false; return false;
if( fYOffset < iFirstPixelToDraw ) // off screen if( fYOffset < iDrawDistanceAfterTargetsPixels ) // off screen
return false; return false;
return true; return true;
@@ -511,26 +511,26 @@ void NoteField::DrawPrimitives()
// //
// Adjust draw range depending on some effects // Adjust draw range depending on some effects
// //
int iFirstPixelToDraw = m_iStartDrawingPixel; int iDrawDistanceAfterTargetsPixels = m_iDrawDistanceAfterTargetsPixels;
// HACK: if boomerang and centered are on, then we want to draw much // HACK: if boomerang and centered are on, then we want to draw much
// earlier to that the notes don't pop on screen. // earlier to that the notes don't pop on screen.
float fCenteredTimesBoomerang = float fCenteredTimesBoomerang =
current_po.m_fScrolls[PlayerOptions::SCROLL_CENTERED] * current_po.m_fScrolls[PlayerOptions::SCROLL_CENTERED] *
current_po.m_fAccels[PlayerOptions::ACCEL_BOOMERANG]; current_po.m_fAccels[PlayerOptions::ACCEL_BOOMERANG];
iFirstPixelToDraw += int(SCALE( fCenteredTimesBoomerang, 0.f, 1.f, 0.f, -SCREEN_HEIGHT/2 )); iDrawDistanceAfterTargetsPixels += int(SCALE( fCenteredTimesBoomerang, 0.f, 1.f, 0.f, -SCREEN_HEIGHT/2 ));
int iLastPixelToDraw = m_iEndDrawingPixel; int iDrawDistanceBeforeTargetsPixels = m_iDrawDistanceBeforeTargetsPixels;
float fDrawScale = 1; float fDrawScale = 1;
fDrawScale *= 1 + 0.5f * fabsf( current_po.m_fPerspectiveTilt ); fDrawScale *= 1 + 0.5f * fabsf( current_po.m_fPerspectiveTilt );
fDrawScale *= 1 + fabsf( current_po.m_fEffects[PlayerOptions::EFFECT_TINY] ); fDrawScale *= 1 + fabsf( current_po.m_fEffects[PlayerOptions::EFFECT_TINY] );
iFirstPixelToDraw = (int)(iFirstPixelToDraw * fDrawScale); iDrawDistanceAfterTargetsPixels = (int)(iDrawDistanceAfterTargetsPixels * fDrawScale);
iLastPixelToDraw = (int)(iLastPixelToDraw * fDrawScale); iDrawDistanceBeforeTargetsPixels = (int)(iDrawDistanceBeforeTargetsPixels * fDrawScale);
// Probe for first and last notes on the screen // Probe for first and last notes on the screen
float fFirstBeatToDraw = FindFirstDisplayedBeat( m_pPlayerState, iFirstPixelToDraw ); float fFirstBeatToDraw = FindFirstDisplayedBeat( m_pPlayerState, iDrawDistanceAfterTargetsPixels );
float fLastBeatToDraw = FindLastDisplayedBeat( m_pPlayerState, iLastPixelToDraw ); float fLastBeatToDraw = FindLastDisplayedBeat( m_pPlayerState, iDrawDistanceBeforeTargetsPixels );
m_pPlayerState->m_fLastDrawnBeat = fLastBeatToDraw; m_pPlayerState->m_fLastDrawnBeat = fLastBeatToDraw;
@@ -540,14 +540,14 @@ void NoteField::DrawPrimitives()
// LOG->Trace( "start = %f.1, end = %f.1", fFirstBeatToDraw-fSongBeat, fLastBeatToDraw-fSongBeat ); // LOG->Trace( "start = %f.1, end = %f.1", fFirstBeatToDraw-fSongBeat, fLastBeatToDraw-fSongBeat );
// LOG->Trace( "Drawing elements %d through %d", iFirstIndexToDraw, iLastIndexToDraw ); // LOG->Trace( "Drawing elements %d through %d", iFirstIndexToDraw, iLastIndexToDraw );
#define IS_ON_SCREEN( fBeat ) IsOnScreen( fBeat, 0, iFirstPixelToDraw, iLastPixelToDraw ) #define IS_ON_SCREEN( fBeat ) IsOnScreen( fBeat, 0, iDrawDistanceAfterTargetsPixels, iDrawDistanceBeforeTargetsPixels )
// //
// Draw board // Draw board
// //
if( SHOW_BOARD ) if( SHOW_BOARD )
{ {
DrawBoard( iFirstPixelToDraw, iLastPixelToDraw ); DrawBoard( iDrawDistanceAfterTargetsPixels, iDrawDistanceBeforeTargetsPixels );
} }
// //
@@ -761,9 +761,9 @@ void NoteField::DrawPrimitives()
float fStartYOffset = ArrowEffects::GetYOffset( m_pPlayerState, c, NoteRowToBeat(iStartRow), fThrowAway, bStartIsPastPeak ); float fStartYOffset = ArrowEffects::GetYOffset( m_pPlayerState, c, NoteRowToBeat(iStartRow), fThrowAway, bStartIsPastPeak );
float fEndYOffset = ArrowEffects::GetYOffset( m_pPlayerState, c, NoteRowToBeat(iEndRow), fThrowAway, bEndIsPastPeak ); float fEndYOffset = ArrowEffects::GetYOffset( m_pPlayerState, c, NoteRowToBeat(iEndRow), fThrowAway, bEndIsPastPeak );
bool bTailIsOnVisible = iFirstPixelToDraw <= fEndYOffset && fEndYOffset <= iLastPixelToDraw; bool bTailIsOnVisible = iDrawDistanceAfterTargetsPixels <= fEndYOffset && fEndYOffset <= iDrawDistanceBeforeTargetsPixels;
bool bHeadIsVisible = iFirstPixelToDraw <= fStartYOffset && fStartYOffset <= iLastPixelToDraw; bool bHeadIsVisible = iDrawDistanceAfterTargetsPixels <= fStartYOffset && fStartYOffset <= iDrawDistanceBeforeTargetsPixels;
bool bStraddlingVisible = fStartYOffset <= iFirstPixelToDraw && iLastPixelToDraw <= fEndYOffset; bool bStraddlingVisible = fStartYOffset <= iDrawDistanceAfterTargetsPixels && iDrawDistanceBeforeTargetsPixels <= fEndYOffset;
bool bStaddlingPeak = bStartIsPastPeak && !bEndIsPastPeak; bool bStaddlingPeak = bStartIsPastPeak && !bEndIsPastPeak;
if( !(bTailIsOnVisible || bHeadIsVisible || bStraddlingVisible || bStaddlingPeak) ) if( !(bTailIsOnVisible || bHeadIsVisible || bStraddlingVisible || bStaddlingPeak) )
{ {
@@ -784,7 +784,7 @@ void NoteField::DrawPrimitives()
NoteDisplayCols *displayCols = tn.pn == PLAYER_INVALID ? m_pCurDisplay : m_pDisplays[tn.pn]; NoteDisplayCols *displayCols = tn.pn == PLAYER_INVALID ? m_pCurDisplay : m_pDisplays[tn.pn];
displayCols->display[c].DrawHold( tn, c, iStartRow, bIsHoldingNote, bIsActive, Result, bIsInSelectionRange ? fSelectedRangeGlow : m_fPercentFadeToFail, displayCols->display[c].DrawHold( tn, c, iStartRow, bIsHoldingNote, bIsActive, Result, bIsInSelectionRange ? fSelectedRangeGlow : m_fPercentFadeToFail,
false, m_fYReverseOffsetPixels, (float) iFirstPixelToDraw, (float) iLastPixelToDraw, iLastPixelToDraw, FADE_IN_PERCENT ); false, m_fYReverseOffsetPixels, (float) iDrawDistanceAfterTargetsPixels, (float) iDrawDistanceBeforeTargetsPixels, iDrawDistanceBeforeTargetsPixels, FADE_BEFORE_TARGETS_PERCENT );
} }
} }
@@ -817,7 +817,7 @@ void NoteField::DrawPrimitives()
// TRICKY: If boomerang is on, then all notes in the range // TRICKY: If boomerang is on, then all notes in the range
// [iFirstIndexToDraw,iLastIndexToDraw] aren't necessarily visible. // [iFirstIndexToDraw,iLastIndexToDraw] aren't necessarily visible.
// Test every note to make sure it's on screen before drawing // Test every note to make sure it's on screen before drawing
if( !IsOnScreen( NoteRowToBeat(i), c, iFirstPixelToDraw, iLastPixelToDraw ) ) if( !IsOnScreen( NoteRowToBeat(i), c, iDrawDistanceAfterTargetsPixels, iDrawDistanceBeforeTargetsPixels ) )
continue; // skip continue; // skip
ASSERT_M( NoteRowToBeat(i) > -2000, ssprintf("%i %i %i, %f %f", i, iLastIndexToDraw, iFirstIndexToDraw, GAMESTATE->m_fSongBeat, GAMESTATE->m_fMusicSeconds) ); ASSERT_M( NoteRowToBeat(i) > -2000, ssprintf("%i %i %i, %f %f", i, iLastIndexToDraw, iFirstIndexToDraw, GAMESTATE->m_fSongBeat, GAMESTATE->m_fMusicSeconds) );
@@ -852,11 +852,11 @@ void NoteField::DrawPrimitives()
Sprite sprite; Sprite sprite;
sprite.Load( THEME->GetPathG("NoteField","attack "+tn.sAttackModifiers) ); sprite.Load( THEME->GetPathG("NoteField","attack "+tn.sAttackModifiers) );
float fBeat = NoteRowToBeat(i); float fBeat = NoteRowToBeat(i);
displayCols->display[c].DrawActor( &sprite, c, fBeat, bIsInSelectionRange ? fSelectedRangeGlow : m_fPercentFadeToFail, 1, m_fYReverseOffsetPixels, false, NotePart_Tap, iLastPixelToDraw, FADE_IN_PERCENT ); displayCols->display[c].DrawActor( &sprite, c, fBeat, bIsInSelectionRange ? fSelectedRangeGlow : m_fPercentFadeToFail, 1, m_fYReverseOffsetPixels, false, NotePart_Tap, iDrawDistanceBeforeTargetsPixels, FADE_BEFORE_TARGETS_PERCENT );
} }
else else
{ {
displayCols->display[c].DrawTap( c, NoteRowToBeat(i), bHoldNoteBeginsOnThisBeat, bIsAddition, bIsMine, bIsLift, bIsInSelectionRange ? fSelectedRangeGlow : m_fPercentFadeToFail, 1, m_fYReverseOffsetPixels, iLastPixelToDraw, FADE_IN_PERCENT ); displayCols->display[c].DrawTap( c, NoteRowToBeat(i), bHoldNoteBeginsOnThisBeat, bIsAddition, bIsMine, bIsLift, bIsInSelectionRange ? fSelectedRangeGlow : m_fPercentFadeToFail, 1, m_fYReverseOffsetPixels, iDrawDistanceBeforeTargetsPixels, FADE_BEFORE_TARGETS_PERCENT );
} }
} }
} }
stepmania/src/NoteField.h
+6 -6
View File
@@ -26,8 +26,8 @@ public:
virtual void Init( const PlayerState* pPlayerState, float fYReverseOffsetPixels ); virtual void Init( const PlayerState* pPlayerState, float fYReverseOffsetPixels );
virtual void Load( virtual void Load(
const NoteData* pNoteData, const NoteData* pNoteData,
int iStartDrawingPixel, int iDrawDistanceAfterTargetsPixels,
int iEndDrawingPixel ); int iDrawDistanceBeforeTargetsPixels );
virtual void Unload(); virtual void Unload();
// This is done automatically by Init(), but can be re-called explicitly if the // This is done automatically by Init(), but can be re-called explicitly if the
@@ -48,9 +48,9 @@ protected:
void CacheNoteSkin( const RString &sNoteSkin ); void CacheNoteSkin( const RString &sNoteSkin );
void UncacheNoteSkin( const RString &sNoteSkin ); void UncacheNoteSkin( const RString &sNoteSkin );
bool IsOnScreen( float fBeat, int iCol, int iFirstPixelToDraw, int iLastPixelToDraw ) const; bool IsOnScreen( float fBeat, int iCol, int iDrawDistanceAfterTargetsPixels, int iDrawDistanceBeforeTargetsPixels ) const;
void DrawBoard( int iFirstPixelToDraw, int iLastPixelToDraw ); void DrawBoard( int iDrawDistanceAfterTargetsPixels, int iDrawDistanceBeforeTargetsPixels );
void DrawBeatBar( const float fBeat ); void DrawBeatBar( const float fBeat );
void DrawMarkerBar( int fBeat ); void DrawMarkerBar( int fBeat );
void DrawAreaHighlight( int iStartBeat, int iEndBeat ); void DrawAreaHighlight( int iStartBeat, int iEndBeat );
@@ -65,8 +65,8 @@ protected:
float m_fPercentFadeToFail; // -1 if not fading to fail float m_fPercentFadeToFail; // -1 if not fading to fail
const PlayerState* m_pPlayerState; const PlayerState* m_pPlayerState;
int m_iStartDrawingPixel; // this should be a negative number int m_iDrawDistanceAfterTargetsPixels; // this should be a negative number
int m_iEndDrawingPixel; // this should be a positive number int m_iDrawDistanceBeforeTargetsPixels; // this should be a positive number
float m_fYReverseOffsetPixels; float m_fYReverseOffsetPixels;
// color arrows // color arrows
stepmania/src/Player.cpp
+5 -5
View File
@@ -143,8 +143,8 @@ void Player::Init(
BRIGHT_GHOST_COMBO_THRESHOLD.Load( sType, "BrightGhostComboThreshold" ); BRIGHT_GHOST_COMBO_THRESHOLD.Load( sType, "BrightGhostComboThreshold" );
TAP_JUDGMENTS_UNDER_FIELD.Load( sType, "TapJudgmentsUnderField" ); TAP_JUDGMENTS_UNDER_FIELD.Load( sType, "TapJudgmentsUnderField" );
HOLD_JUDGMENTS_UNDER_FIELD.Load( sType, "HoldJudgmentsUnderField" ); HOLD_JUDGMENTS_UNDER_FIELD.Load( sType, "HoldJudgmentsUnderField" );
START_DRAWING_AT_PIXELS.Load( sType, "StartDrawingAtPixels" ); DRAW_DISTANCE_AFTER_TARGET_PIXELS.Load( sType, "DrawDistanceAfterTargetsPixels" );
STOP_DRAWING_AT_PIXELS.Load( sType, "StopDrawingAtPixels" ); DRAW_DISTANCE_BEFORE_TARGET_PIXELS.Load( sType, "DrawDistanceBeforeTargetsPixels" );
if( m_pJudgment ) if( m_pJudgment )
{ {
@@ -389,15 +389,15 @@ void Player::Load()
break; break;
} }
int iStartDrawingAtPixels = GAMESTATE->IsEditing() ? -100 : START_DRAWING_AT_PIXELS; int iDrawDistanceAfterTargetsPixels = GAMESTATE->IsEditing() ? -100 : DRAW_DISTANCE_AFTER_TARGET_PIXELS;
int iStopDrawingAtPixels = GAMESTATE->IsEditing() ? 400 : STOP_DRAWING_AT_PIXELS; int iDrawDistanceBeforeTargetsPixels = GAMESTATE->IsEditing() ? 400 : DRAW_DISTANCE_BEFORE_TARGET_PIXELS;
float fNoteFieldMiddle = (GRAY_ARROWS_Y_STANDARD+GRAY_ARROWS_Y_REVERSE)/2; float fNoteFieldMiddle = (GRAY_ARROWS_Y_STANDARD+GRAY_ARROWS_Y_REVERSE)/2;
if( m_pNoteField && !bOniDead ) if( m_pNoteField && !bOniDead )
{ {
m_pNoteField->SetY( fNoteFieldMiddle ); m_pNoteField->SetY( fNoteFieldMiddle );
m_pNoteField->Load( &m_NoteData, iStartDrawingAtPixels, iStopDrawingAtPixels ); m_pNoteField->Load( &m_NoteData, iDrawDistanceAfterTargetsPixels, iDrawDistanceBeforeTargetsPixels );
} }
const bool bReverse = m_pPlayerState->m_PlayerOptions.GetStage().GetReversePercentForColumn( 0 ) == 1; const bool bReverse = m_pPlayerState->m_PlayerOptions.GetStage().GetReversePercentForColumn( 0 ) == 1;
stepmania/src/Player.h
+2 -2
View File
@@ -214,8 +214,8 @@ protected:
ThemeMetric<int> BRIGHT_GHOST_COMBO_THRESHOLD; ThemeMetric<int> BRIGHT_GHOST_COMBO_THRESHOLD;
ThemeMetric<bool> TAP_JUDGMENTS_UNDER_FIELD; ThemeMetric<bool> TAP_JUDGMENTS_UNDER_FIELD;
ThemeMetric<bool> HOLD_JUDGMENTS_UNDER_FIELD; ThemeMetric<bool> HOLD_JUDGMENTS_UNDER_FIELD;
ThemeMetric<int> START_DRAWING_AT_PIXELS; ThemeMetric<int> DRAW_DISTANCE_AFTER_TARGET_PIXELS;
ThemeMetric<int> STOP_DRAWING_AT_PIXELS; ThemeMetric<int> DRAW_DISTANCE_BEFORE_TARGET_PIXELS;
#define NUM_REVERSE 2 #define NUM_REVERSE 2
#define NUM_CENTERED 2 #define NUM_CENTERED 2