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

Clean up math functions

Browse Source 
- Remove checking for standard functions from the build system
- Prefix all invocations with std::
- Replace suffixed functions with unprefixed versions
- Include <cmath> in all files that use it and remove the global include

e.g. floorf(x) -> std::floor(x)
This commit is contained in:
Martin Natano
2023-04-19 19:31:40 +02:00
parent f39ed52dbf
commit b68ca517e6
111 changed files with 1831 additions and 1785 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StepmaniaCore.cmake
-9
View File
@@ -106,15 +106,6 @@ check_cxx_symbol_exists(strcasecmp cstring HAVE_STRCASECMP)
check_function_exists(waitpid HAVE_WAITPID)
# Mostly universal symbols.
check_cxx_symbol_exists(powf cmath HAVE_POWF)
check_cxx_symbol_exists(sqrtf cmath HAVE_SQRTF)
check_cxx_symbol_exists(sinf cmath HAVE_SINF)
check_cxx_symbol_exists(tanf cmath HAVE_TANF)
check_cxx_symbol_exists(cosf cmath HAVE_COSF)
check_cxx_symbol_exists(acosf cmath HAVE_ACOSF)
check_cxx_symbol_exists(truncf cmath HAVE_TRUNCF)
check_cxx_symbol_exists(roundf cmath HAVE_ROUNDF)
check_cxx_symbol_exists(lrintf cmath HAVE_LRINTF)
check_cxx_symbol_exists(strtof cstdlib HAVE_STRTOF)
check_symbol_exists(M_PI math.h HAVE_M_PI)
check_symbol_exists(size_t stddef.h HAVE_SIZE_T_STDDEF)
src/Actor.cpp
+4 -2
View File
@@ -13,6 +13,8 @@
#include "LightsManager.h" // for NUM_CabinetLight
#include "ActorUtil.h"
#include "Preference.h"
#include <cmath>
#include <typeinfo>
static Preference<bool> g_bShowMasks("ShowMasks", false);
@@ -1080,8 +1082,8 @@ void Actor::ScaleTo( const RectF &rect, StretchType st )
if( rect_height < 0 ) SetRotationX( 180 );
// zoom fActor needed to scale the Actor to fill the rectangle
float fNewZoomX = fabsf(rect_width / m_size.x);
float fNewZoomY = fabsf(rect_height / m_size.y);
float fNewZoomX = std::abs(rect_width / m_size.x);
float fNewZoomY = std::abs(rect_height / m_size.y);
float fNewZoom = 0.f;
switch( st )
src/ActorScroller.cpp
+8 -6
View File
@@ -8,6 +8,8 @@
#include "ActorUtil.h"
#include "LuaBinding.h"
#include <cmath>
/* Tricky: We need ActorFrames created in Lua to auto delete their children.
* We don't want classes that derive from ActorFrame to auto delete their
* children. The name "ActorFrame" is widely used in Lua, so we'll have
@@ -116,7 +118,7 @@ float ActorScroller::GetSecondsForCompleteScrollThrough() const
float ActorScroller::GetSecondsToDestination() const
{
float fTotalItemsToMove = fabsf(m_fCurrentItem - m_fDestinationItem);
float fTotalItemsToMove = std::abs(m_fCurrentItem - m_fDestinationItem);
return fTotalItemsToMove * m_fSecondsPerItem;
}
@@ -195,7 +197,7 @@ void ActorScroller::UpdateInternal( float fDeltaTime )
float fApproachSpeed = fDeltaTime/m_fSecondsPerItem;
if( m_bFastCatchup )
{
float fDistanceToMove = fabsf(m_fCurrentItem - m_fDestinationItem);
float fDistanceToMove = std::abs(m_fCurrentItem - m_fDestinationItem);
if( fDistanceToMove > 1 )
fApproachSpeed *= fDistanceToMove*fDistanceToMove;
}
@@ -210,13 +212,13 @@ void ActorScroller::UpdateInternal( float fDeltaTime )
if( m_bWrap )
{
float Delta = m_fDestinationItem - m_fCurrentItem;
m_fCurrentItem = fmodf( m_fCurrentItem, (float) m_iNumItems );
m_fCurrentItem = std::fmod( m_fCurrentItem, (float) m_iNumItems );
m_fDestinationItem = m_fCurrentItem + Delta;
}
if( m_bLoop )
{
m_fCurrentItem = fmodf( m_fCurrentItem, (float) m_iNumItems );
m_fCurrentItem = std::fmod( m_fCurrentItem, (float) m_iNumItems );
}
}
@@ -261,8 +263,8 @@ void ActorScroller::PositionItemsAndDrawPrimitives( bool bDrawPrimitives )
float fFirstItemToDraw = m_fCurrentItem - fNumItemsToDraw/2.f;
float fLastItemToDraw = m_fCurrentItem + fNumItemsToDraw/2.f;
int iFirstItemToDraw = (int) ceilf( fFirstItemToDraw );
int iLastItemToDraw = (int) ceilf( fLastItemToDraw );
int iFirstItemToDraw = std::ceil( fFirstItemToDraw );
int iLastItemToDraw = std::ceil( fLastItemToDraw );
if( !m_bLoop && !m_bWrap )
{
iFirstItemToDraw = clamp( iFirstItemToDraw, 0, m_iNumItems );
src/AdjustSync.cpp
+7 -5
View File
@@ -42,6 +42,8 @@
#include "PrefsManager.h"
#include "ScreenManager.h"
#include <cmath>
std::vector<TimingData> AdjustSync::s_vpTimingDataOriginal;
float AdjustSync::s_fGlobalOffsetSecondsOriginal = 0.0f;
@@ -314,7 +316,7 @@ void AdjustSync::GetSyncChangeTextGlobal( std::vector<RString> &vsAddTo )
float fNew = Quantize( PREFSMAN->m_fGlobalOffsetSeconds, 0.001f ) ;
float fDelta = fNew - fOld;
if( fabsf(fDelta) > 0.0001f )
if( std::abs(fDelta) > 0.0001f )
{
vsAddTo.push_back( ssprintf(
GLOBAL_OFFSET_FROM.GetValue(),
@@ -344,7 +346,7 @@ void AdjustSync::GetSyncChangeTextSong( std::vector<RString> &vsAddTo )
float fNew = Quantize( testing.m_fBeat0OffsetInSeconds, 0.001f );
float fDelta = fNew - fOld;
if( fabsf(fDelta) > 0.0001f )
if( std::abs(fDelta) > 0.0001f )
{
vsAddTo.push_back( ssprintf(
SONG_OFFSET_FROM.GetValue(),
@@ -362,7 +364,7 @@ void AdjustSync::GetSyncChangeTextSong( std::vector<RString> &vsAddTo )
float fNew = Quantize( ToBPM(bpmTest[i])->GetBPM(), 0.001f );
float fOld = Quantize( ToBPM(bpmOrig[i])->GetBPM(), 0.001f );
if( fabsf(fNew - fOld) < 1e-4 )
if( std::abs(fNew - fOld) < 1e-4 )
continue;
if ( i >= 4 )
@@ -387,7 +389,7 @@ void AdjustSync::GetSyncChangeTextSong( std::vector<RString> &vsAddTo )
float fNew = Quantize( ToStop(stopTest[i])->GetPause(), 0.001f );
float fDelta = fNew - fOld;
if( fabsf(fDelta) < 1e-4 )
if( std::abs(fDelta) < 1e-4 )
continue;
if ( i >= 4 )
@@ -413,7 +415,7 @@ void AdjustSync::GetSyncChangeTextSong( std::vector<RString> &vsAddTo )
float fNew = Quantize( ToDelay(delyTest[i])->GetPause(), 0.001f );
float fDelta = fNew - fOld;
if( fabsf(fDelta) < 1e-4 )
if( std::abs(fDelta) < 1e-4 )
continue;
if ( i >= 4 )
src/ArrowEffects.cpp
+29 -27
View File
@@ -12,7 +12,9 @@
#include "GameState.h"
#include "Style.h"
#include "ThemeMetric.h"
#include <float.h>
#include <cfloat>
#include <cmath>
static char const dimension_names[4]= "XYZ";
@@ -84,7 +86,7 @@ float ArrowGetPercentVisible(float fYPosWithoutReverse, int iCol, float fYOffset
static float GetNoteFieldHeight()
{
return SCREEN_HEIGHT + fabsf(curr_options->m_fPerspectiveTilt)*200;
return SCREEN_HEIGHT + std::abs(curr_options->m_fPerspectiveTilt)*200;
}
float ArrowEffects::GetTime()
@@ -158,7 +160,7 @@ static float CalculateTornadoOffsetFromMagnitude(int dimension, int col_id,
data.m_MaxTornado[dimension][col_id] * field_zoom,
tornado_position_scale_to_low[dimension],
tornado_position_scale_to_high[dimension]);
float rads= acosf(position_between);
float rads= std::acos(position_between);
float frequency= tornado_offset_frequency[dimension];
rads+= (y_offset + effect_offset) * ((period * frequency) + frequency) / SCREEN_HEIGHT;
float processed_rads = is_tan ? SelectTanType(rads, curr_options->m_bCosecant) : RageFastCos(rads);
@@ -201,9 +203,9 @@ static void UpdateBeat(int dimension, PerPlayerData &data, const SongPosition &p
return;
// -100.2 -> -0.2 -> 0.2
fBeat -= truncf( fBeat );
fBeat -= std::trunc( fBeat );
fBeat += 1;
fBeat -= truncf( fBeat );
fBeat -= std::trunc( fBeat );
if( fBeat >= fTotalTime )
return;
@@ -333,9 +335,9 @@ void ArrowEffects::Update()
if( !position.m_bFreeze || !position.m_bDelay )
{
data.m_fExpandSeconds += fTime - fLastTime;
data.m_fExpandSeconds = fmodf( data.m_fExpandSeconds, (PI*2)/(accels[PlayerOptions::ACCEL_EXPAND_PERIOD]+1) );
data.m_fExpandSeconds = std::fmod( data.m_fExpandSeconds, (PI*2)/(accels[PlayerOptions::ACCEL_EXPAND_PERIOD]+1) );
data.m_fTanExpandSeconds += fTime - fLastTime;
data.m_fTanExpandSeconds = fmodf( data.m_fTanExpandSeconds, (PI*2)/(accels[PlayerOptions::ACCEL_TAN_EXPAND_PERIOD]+1) );
data.m_fTanExpandSeconds = std::fmod( data.m_fTanExpandSeconds, (PI*2)/(accels[PlayerOptions::ACCEL_TAN_EXPAND_PERIOD]+1) );
}
// Update Invert
@@ -609,7 +611,7 @@ static void ArrowGetReverseShiftAndScale(int iCol, float fYReverseOffsetPixels,
float fZoom = 1 - fMiniPercent*0.5f;
// don't divide by 0
if( fabsf(fZoom) < 0.01 )
if( std::abs(fZoom) < 0.01 )
fZoom = 0.01f;
float fPercentReverse = curr_options->GetReversePercentForColumn(iCol);
@@ -662,7 +664,7 @@ float ArrowEffects::GetYPos( const PlayerState* pPlayerState, int iCol, float fY
// floored, making arrows show on integer Y coordinates. Supposedly it makes
// the arrows look better, but testing needs to be done.
// todo: make this a noteskin metric instead of a theme metric? -aj
return QUANTIZE_ARROW_Y ? floor(f) : f;
return QUANTIZE_ARROW_Y ? std::floor(f) : f;
}
float ArrowEffects::GetYOffsetFromYPos(int iCol, float YPos, float fYReverseOffsetPixels)
@@ -775,7 +777,7 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
if( fEffects[PlayerOptions::EFFECT_SAWTOOTH] != 0 )
fPixelOffsetFromCenter += (fEffects[PlayerOptions::EFFECT_SAWTOOTH]*ARROW_SIZE) *
((0.5f / (fEffects[PlayerOptions::EFFECT_SAWTOOTH_PERIOD]+1) * fYOffset) / ARROW_SIZE -
floor((0.5f / (fEffects[PlayerOptions::EFFECT_SAWTOOTH_PERIOD]+1) * fYOffset) / ARROW_SIZE) );
std::floor((0.5f / (fEffects[PlayerOptions::EFFECT_SAWTOOTH_PERIOD]+1) * fYOffset) / ARROW_SIZE) );
if( fEffects[PlayerOptions::EFFECT_PARABOLA_X] != 0 )
fPixelOffsetFromCenter += fEffects[PlayerOptions::EFFECT_PARABOLA_X] * (fYOffset/ARROW_SIZE) * (fYOffset/ARROW_SIZE);
@@ -788,14 +790,14 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
if( fEffects[PlayerOptions::EFFECT_DIGITAL] != 0 )
fPixelOffsetFromCenter += (fEffects[PlayerOptions::EFFECT_DIGITAL] * ARROW_SIZE * 0.5f) *
round((fEffects[PlayerOptions::EFFECT_DIGITAL_STEPS]+1) * RageFastSin(
std::round((fEffects[PlayerOptions::EFFECT_DIGITAL_STEPS]+1) * RageFastSin(
CalculateDigitalAngle(fYOffset,
fEffects[PlayerOptions::EFFECT_DIGITAL_OFFSET],
fEffects[PlayerOptions::EFFECT_DIGITAL_PERIOD]) ) )/(fEffects[PlayerOptions::EFFECT_DIGITAL_STEPS]+1);
if( fEffects[PlayerOptions::EFFECT_TAN_DIGITAL] != 0 )
fPixelOffsetFromCenter += (fEffects[PlayerOptions::EFFECT_TAN_DIGITAL] * ARROW_SIZE * 0.5f) *
round((fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_STEPS]+1) * SelectTanType(
std::round((fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_STEPS]+1) * SelectTanType(
CalculateDigitalAngle(fYOffset,
fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_OFFSET],
fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_PERIOD]), curr_options->m_bCosecant ) )/(fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_STEPS]+1);
@@ -811,7 +813,7 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
if( fEffects[PlayerOptions::EFFECT_BOUNCE] != 0 )
{
float fBounceAmt = fabsf( RageFastSin( ( (fYOffset + (1.0f * (fEffects[PlayerOptions::EFFECT_BOUNCE_OFFSET]) ) ) /
float fBounceAmt = std::abs( RageFastSin( ( (fYOffset + (1.0f * (fEffects[PlayerOptions::EFFECT_BOUNCE_OFFSET]) ) ) /
( 60 + (fEffects[PlayerOptions::EFFECT_BOUNCE_PERIOD]*60) ) ) ) );
fPixelOffsetFromCenter += fEffects[PlayerOptions::EFFECT_BOUNCE] * ARROW_SIZE * 0.5f * fBounceAmt;
@@ -828,7 +830,7 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
{
// find the middle, and split based on iColNum
// it's unknown if this will work for routine.
const int iMiddleColumn = static_cast<int>(floor(pStyle->m_iColsPerPlayer/2.0f));
const int iMiddleColumn = std::floor(pStyle->m_iColsPerPlayer/2.0f);
if( iColNum > iMiddleColumn-1 )
fPixelOffsetFromCenter += fEffects[PlayerOptions::EFFECT_XMODE]*-(fYOffset);
else
@@ -855,7 +857,7 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
{
// Allow Tiny to pull tracks together, but not to push them apart.
float fTinyPercent = fEffects[PlayerOptions::EFFECT_TINY];
fTinyPercent = std::min( powf(TINY_PERCENT_BASE, fTinyPercent), (float)TINY_PERCENT_GATE );
fTinyPercent = std::min( std::pow(TINY_PERCENT_BASE, fTinyPercent), (float)TINY_PERCENT_GATE );
fPixelOffsetFromCenter *= fTinyPercent;
}
@@ -907,7 +909,7 @@ float ArrowEffects::GetRotationZ( const PlayerState* pPlayerState, float fNoteBe
const float fSongBeat = pPlayerState->m_Position.m_fSongBeatVisible;
float fDizzyRotation = fNoteBeat - fSongBeat;
fDizzyRotation *= fEffects[PlayerOptions::EFFECT_DIZZY];
fDizzyRotation = fmodf( fDizzyRotation, 2*PI );
fDizzyRotation = std::fmod( fDizzyRotation, 2*PI );
fDizzyRotation *= 180/PI;
fRotation += fDizzyRotation;
}
@@ -929,7 +931,7 @@ float ArrowEffects::ReceptorGetRotationZ( const PlayerState* pPlayerState, int i
{
float fConfRotation = pPlayerState->m_Position.m_fSongBeatVisible;
fConfRotation *= fEffects[PlayerOptions::EFFECT_CONFUSION];
fConfRotation = fmodf( fConfRotation, 2*PI );
fConfRotation = std::fmod( fConfRotation, 2*PI );
fConfRotation *= -180/PI;
fRotation += fConfRotation;
}
@@ -952,7 +954,7 @@ float ArrowEffects::ReceptorGetRotationX( const PlayerState* pPlayerState, int i
{
float fConfRotation = pPlayerState->m_Position.m_fSongBeatVisible;
fConfRotation *= fEffects[PlayerOptions::EFFECT_CONFUSION_X];
fConfRotation = fmodf( fConfRotation, 2*PI );
fConfRotation = std::fmod( fConfRotation, 2*PI );
fConfRotation *= -180/PI;
fRotation += fConfRotation;
}
@@ -975,7 +977,7 @@ float ArrowEffects::ReceptorGetRotationY( const PlayerState* pPlayerState, int i
{
float fConfRotation = pPlayerState->m_Position.m_fSongBeatVisible;
fConfRotation *= fEffects[PlayerOptions::EFFECT_CONFUSION_Y];
fConfRotation = fmodf( fConfRotation, 2*PI );
fConfRotation = std::fmod( fConfRotation, 2*PI );
fConfRotation *= -180/PI;
fRotation += fConfRotation;
}
@@ -1115,7 +1117,7 @@ float ArrowGetPercentVisible(float fYPosWithoutReverse, int iCol, float fYOffset
if( fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH] != 0 )
{
const float fRealFadeDist = 80;
fVisibleAdjust += SCALE( fabsf(fDistFromCenterLine), fRealFadeDist, 2*fRealFadeDist, -1, 0 )
fVisibleAdjust += SCALE( std::abs(fDistFromCenterLine), fRealFadeDist, 2*fRealFadeDist, -1, 0 )
* fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH];
}
@@ -1152,7 +1154,7 @@ float ArrowEffects::GetGlow( const PlayerState* pPlayerState, int iCol, float fY
if( fPercentFadeToFail != -1 )
fPercentVisible = 1 - fPercentFadeToFail;
const float fDistFromHalf = fabsf( fPercentVisible - 0.5f );
const float fDistFromHalf = std::abs( fPercentVisible - 0.5f );
return SCALE( fDistFromHalf, 0, 0.5f, 1.3f, 0 );
}
@@ -1227,7 +1229,7 @@ float ArrowEffects::GetZPos( const PlayerState* pPlayerState, int iCol, float fY
if( fEffects[PlayerOptions::EFFECT_SAWTOOTH_Z] != 0 )
fZPos += (fEffects[PlayerOptions::EFFECT_SAWTOOTH_Z]*ARROW_SIZE) *
((0.5f/(fEffects[PlayerOptions::EFFECT_SAWTOOTH_Z_PERIOD]+1)*fYOffset)/ARROW_SIZE -
floor((0.5f/(fEffects[PlayerOptions::EFFECT_SAWTOOTH_Z_PERIOD]+1)*fYOffset)/ARROW_SIZE));
std::floor((0.5f/(fEffects[PlayerOptions::EFFECT_SAWTOOTH_Z_PERIOD]+1)*fYOffset)/ARROW_SIZE));
if( fEffects[PlayerOptions::EFFECT_PARABOLA_Z] != 0 )
fZPos += fEffects[PlayerOptions::EFFECT_PARABOLA_Z] * (fYOffset/ARROW_SIZE) * (fYOffset/ARROW_SIZE);
@@ -1262,14 +1264,14 @@ float ArrowEffects::GetZPos( const PlayerState* pPlayerState, int iCol, float fY
if( fEffects[PlayerOptions::EFFECT_DIGITAL_Z] != 0 )
fZPos += (fEffects[PlayerOptions::EFFECT_DIGITAL_Z] * ARROW_SIZE * 0.5f) *
round((fEffects[PlayerOptions::EFFECT_DIGITAL_Z_STEPS]+1) * RageFastSin(
std::round((fEffects[PlayerOptions::EFFECT_DIGITAL_Z_STEPS]+1) * RageFastSin(
CalculateDigitalAngle(fYOffset,
fEffects[PlayerOptions::EFFECT_DIGITAL_Z_OFFSET],
fEffects[PlayerOptions::EFFECT_DIGITAL_Z_PERIOD]) ) ) /(fEffects[PlayerOptions::EFFECT_DIGITAL_Z_STEPS]+1);
if( fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z] != 0 )
fZPos += (fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z] * ARROW_SIZE * 0.5f) *
round((fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z_STEPS]+1) * SelectTanType(
std::round((fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z_STEPS]+1) * SelectTanType(
CalculateDigitalAngle(fYOffset,
fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z_OFFSET],
fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z_PERIOD]), curr_options->m_bCosecant ) ) /(fEffects[PlayerOptions::EFFECT_TAN_DIGITAL_Z_STEPS]+1);
@@ -1284,7 +1286,7 @@ float ArrowEffects::GetZPos( const PlayerState* pPlayerState, int iCol, float fY
if( fEffects[PlayerOptions::EFFECT_BOUNCE_Z] != 0 )
{
float fBounceAmt = fabsf( RageFastSin( ( (fYOffset + (1.0f * (fEffects[PlayerOptions::EFFECT_BOUNCE_Z_OFFSET]) ) ) /
float fBounceAmt = std::abs( RageFastSin( ( (fYOffset + (1.0f * (fEffects[PlayerOptions::EFFECT_BOUNCE_Z_OFFSET]) ) ) /
( 60 + (fEffects[PlayerOptions::EFFECT_BOUNCE_Z_PERIOD]*60) ) ) ) );
fZPos += fEffects[PlayerOptions::EFFECT_BOUNCE_Z] * ARROW_SIZE * 0.5f * fBounceAmt;
@@ -1344,12 +1346,12 @@ float ArrowEffects::GetZoom( const PlayerState* pPlayerState, float fYOffset, in
float fTinyPercent = curr_options->m_fEffects[PlayerOptions::EFFECT_TINY];
if( fTinyPercent != 0 )
{
fTinyPercent = powf( 0.5f, fTinyPercent );
fTinyPercent = std::pow( 0.5f, fTinyPercent );
fZoom *= fTinyPercent;
}
if( curr_options->m_fTiny[iCol] != 0 )
{
fTinyPercent = powf( 0.5f, curr_options->m_fTiny[iCol] );
fTinyPercent = std::pow( 0.5f, curr_options->m_fTiny[iCol] );
fZoom *= fTinyPercent;
}
return fZoom;
src/Attack.cpp
+4 -3
View File
@@ -3,10 +3,11 @@
#include "GameState.h"
#include "RageUtil.h"
#include "Song.h"
#include "PlayerOptions.h"
#include "PlayerState.h"
#include <cmath>
void Attack::GetAttackBeats( const Song *pSong, float &fStartBeat, float &fEndBeat ) const
{
ASSERT( pSong != nullptr );
@@ -34,13 +35,13 @@ void Attack::GetRealtimeAttackBeats( const Song *pSong, const PlayerState* pPlay
/* If reasonable, push the attack forward 8 beats so that notes on screen don't change suddenly. */
fStartBeat = std::min( GAMESTATE->m_Position.m_fSongBeat+8, pPlayerState->m_fLastDrawnBeat );
fStartBeat = truncf(fStartBeat)+1;
fStartBeat = std::trunc(fStartBeat) + 1;
const TimingData &timing = pSong->m_SongTiming;
const float lStartSecond = timing.GetElapsedTimeFromBeat( fStartBeat );
const float fEndSecond = lStartSecond + fSecsRemaining;
fEndBeat = timing.GetBeatFromElapsedTime( fEndSecond );
fEndBeat = truncf(fEndBeat)+1;
fEndBeat = std::trunc(fEndBeat) + 1;
// loading the course should have caught this.
ASSERT_M( fEndBeat >= fStartBeat, ssprintf("EndBeat %f >= StartBeat %f", fEndBeat, fStartBeat) );
src/AutoKeysounds.cpp
+2 -2
View File
@@ -322,8 +322,8 @@ void AutoKeysounds::Update( float fDelta )
iRowNow = std::max( 0, iRowNow );
static int iRowLastCrossed = 0;
float fBeatLast = roundf(NoteRowToBeat(iRowLastCrossed));
float fBeatNow = roundf(NoteRowToBeat(iRowNow));
float fBeatLast = std::round(NoteRowToBeat(iRowLastCrossed));
float fBeatNow = std::round(NoteRowToBeat(iRowNow));
bCrossedABeat = fBeatLast != fBeatNow;
src/BGAnimationLayer.cpp
+4 -2
View File
@@ -14,6 +14,8 @@
#include "AutoActor.h"
#include "ThemeManager.h"
#include <cmath>
const float PARTICLE_SPEED = 300;
@@ -627,8 +629,8 @@ void BGAnimationLayer::UpdateInternal( float fDeltaTime )
fX += m_fTilesSpacingX/2;
fY += m_fTilesSpacingY/2;
fX = fmodf( fX, fTotalWidth );
fY = fmodf( fY, fTotalHeight );
fX = std::fmod( fX, fTotalWidth );
fY = std::fmod( fY, fTotalHeight );
if( fX < 0 ) fX += fTotalWidth;
if( fY < 0 ) fY += fTotalHeight;
src/BPMDisplay.cpp
+3 -2
View File
@@ -11,6 +11,7 @@
#include "Song.h"
#include "Steps.h"
#include <cmath>
#include <limits.h>
REGISTER_ACTOR_CLASS( BPMDisplay );
@@ -117,8 +118,8 @@ void BPMDisplay::SetBPMRange( const DisplayBpms &bpms )
int MaxBPM = INT_MIN;
for( unsigned i = 0; i < BPMS.size(); ++i )
{
MinBPM = std::min( MinBPM, (int) lrintf(BPMS[i]) );
MaxBPM = std::max( MaxBPM, (int) lrintf(BPMS[i]) );
MinBPM = std::min( MinBPM, static_cast<int>(std::lrint(BPMS[i])) );
MaxBPM = std::max( MaxBPM, static_cast<int>(std::lrint(BPMS[i])) );
}
if( MinBPM == MaxBPM )
{
src/Background.cpp
+2 -1
View File
@@ -17,13 +17,14 @@
#include "ThemeMetric.h"
#include "PlayerState.h"
#include "ActorUtil.h"
#include <float.h>
#include "XmlFile.h"
#include "XmlFileUtil.h"
#include "BackgroundUtil.h"
#include "Song.h"
#include "AutoActor.h"
#include <cfloat>
static ThemeMetric<float> LEFT_EDGE ("Background","LeftEdge");
static ThemeMetric<float> TOP_EDGE ("Background","TopEdge");
static ThemeMetric<float> RIGHT_EDGE ("Background","RightEdge");
src/BitmapText.cpp
+9 -7
View File
@@ -10,6 +10,8 @@
#include "ActorUtil.h"
#include "LuaBinding.h"
#include <cmath>
REGISTER_ACTOR_CLASS( BitmapText );
@@ -277,7 +279,7 @@ void BitmapText::BuildChars()
m_size.y += iPadding * int(m_wTextLines.size()-1);
// the top position of the first row of characters
int iY = lrintf(-m_size.y/2.0f);
int iY = std::lrint(-m_size.y/2.0f);
for( unsigned i=0; i<m_wTextLines.size(); i++ ) // foreach line
{
@@ -289,7 +291,7 @@ void BitmapText::BuildChars()
const int iLineWidth = m_iLineWidths[i];
float fX = SCALE( m_fHorizAlign, 0.0f, 1.0f, -m_size.x/2.0f, +m_size.x/2.0f - iLineWidth );
int iX = lrintf( fX );
int iX = std::lrint( fX );
for( unsigned j = 0; j < sLine.size(); ++j )
{
@@ -326,7 +328,7 @@ void BitmapText::BuildChars()
if( m_bUsingDistortion )
{
int iSeed = lrintf( RageTimer::GetTimeSinceStartFast()*500000.0f );
int iSeed = std::lrint( RageTimer::GetTimeSinceStartFast()*500000.0f );
RandomGen rnd( iSeed );
for(unsigned int i= 0; i < m_aVertices.size(); i+=4)
{
@@ -349,8 +351,8 @@ void BitmapText::DrawChars( bool bUseStrokeTexture )
return;
const int iNumGlyphs = m_vpFontPageTextures.size();
int iStartGlyph = lrintf( SCALE( m_pTempState->crop.left, 0.f, 1.f, 0, (float) iNumGlyphs ) );
int iEndGlyph = lrintf( SCALE( m_pTempState->crop.right, 0.f, 1.f, (float) iNumGlyphs, 0 ) );
int iStartGlyph = std::lrint( SCALE( m_pTempState->crop.left, 0.f, 1.f, 0, (float) iNumGlyphs ) );
int iEndGlyph = std::lrint( SCALE( m_pTempState->crop.right, 0.f, 1.f, (float) iNumGlyphs, 0 ) );
iStartGlyph = clamp( iStartGlyph, 0, iNumGlyphs );
iEndGlyph = clamp( iEndGlyph, 0, iNumGlyphs );
@@ -612,7 +614,7 @@ void BitmapText::UpdateBaseZoom()
} \
if(dimension != 0) \
{ \
const float zoom= fmin(1, dimension_max / dimension); \
const float zoom= std::fmin(1, dimension_max / dimension); \
base_zoom_set(zoom); \
} \
}
@@ -766,7 +768,7 @@ void BitmapText::DrawPrimitives()
std::vector<RageVector3> vGlyphJitter;
if( m_bJitter )
{
int iSeed = lrintf( RageTimer::GetTimeSinceStartFast()*8 );
int iSeed = std::lrint( RageTimer::GetTimeSinceStartFast()*8 );
RandomGen rnd( iSeed );
for( unsigned i=0; i<m_aVertices.size(); i+=4 )
src/CourseLoaderCRS.cpp
+2 -1
View File
@@ -14,7 +14,8 @@
#include "CourseWriterCRS.h"
#include "RageUtil.h"
#include "CourseUtil.h"
#include <float.h>
#include <cfloat>
/** @brief Edit courses can only be so big before they are rejected. */
const int MAX_EDIT_COURSE_SIZE_BYTES = 32*1024; // 32KB
src/DynamicActorScroller.cpp
+3 -1
View File
@@ -7,6 +7,8 @@
#include "RageUtil.h"
#include "LuaBinding.h"
#include <cmath>
DynamicActorScroller *DynamicActorScroller::Copy() const { return new DynamicActorScroller(*this); }
void DynamicActorScroller::LoadFromNode( const XNode *pNode )
@@ -84,7 +86,7 @@ void DynamicActorScroller::ShiftSubActors( int iDist )
* reconfigures much fewer actors. */
int iWrapped = iDist;
wrap( iWrapped, m_iNumItems );
if( abs(iWrapped) < abs(iDist) )
if( std::abs(iWrapped) < std::abs(iDist) )
iDist = iWrapped;
}
src/Font.cpp
+3 -1
View File
@@ -11,6 +11,8 @@
#include "FontCharAliases.h"
#include "arch/Dialog/Dialog.h"
#include <cmath>
FontPage::FontPage(): m_iHeight(0), m_iLineSpacing(0), m_fVshift(0),
m_iDrawExtraPixelsLeft(0), m_iDrawExtraPixelsRight(0),
m_FontPageTextures(), m_sTexturePath(""), m_aGlyphs(),
@@ -101,7 +103,7 @@ void FontPage::Load( const FontPageSettings &cfg )
if( cfg.m_fScaleAllWidthsBy != 1 )
{
for( int i=0; i<m_FontPageTextures.m_pTextureMain->GetNumFrames(); i++ )
aiFrameWidths[i] = lrintf( aiFrameWidths[i] * cfg.m_fScaleAllWidthsBy );
aiFrameWidths[i] = std::lrint( aiFrameWidths[i] * cfg.m_fScaleAllWidthsBy );
}
m_iCharToGlyphNo = cfg.CharToGlyphNo;
src/GameConstantsAndTypes.cpp
+4 -2
View File
@@ -9,7 +9,9 @@
#include "GameManager.h"
#include "LocalizedString.h"
#include "PlayerNumber.h"
#include <float.h>
#include <cfloat>
#include <cmath>
RString StepsTypeToString( StepsType st );
@@ -406,7 +408,7 @@ float DisplayBpms::GetMaxWithin(float highest) const
bool DisplayBpms::BpmIsConstant() const
{
return fabsf( GetMin() - GetMax() ) < 0.001f;
return std::abs( GetMin() - GetMax() ) < 0.001f;
}
bool DisplayBpms::IsSecret() const
src/GameConstantsAndTypes.h
+2 -1
View File
@@ -4,7 +4,8 @@
#define GAME_CONSTANTS_AND_TYPES_H
#include "EnumHelper.h"
#include <float.h> // need the max for default.
#include <cfloat>
// Note definitions
/** @brief Define the mininum difficulty value allowed. */
src/GameLoop.cpp
+3 -1
View File
@@ -21,6 +21,8 @@
#include "RageTimer.h"
#include "RageInput.h"
#include <cmath>
static RageTimer g_GameplayTimer;
static Preference<bool> g_bNeverBoostAppPriority( "NeverBoostAppPriority", false );
@@ -56,7 +58,7 @@ static void CheckGameLoopTimerSkips( float fDeltaTime )
const float fExpectedTime = 1.0f / iThisFPS;
const float fDifference = fDeltaTime - fExpectedTime;
if( fabsf(fDifference) > 0.002f && fabsf(fDifference) < 0.100f )
if( std::abs(fDifference) > 0.002f && std::abs(fDifference) < 0.100f )
LOG->Trace( "GameLoop timer skip: %i FPS, expected %.3f, got %.3f (%.3f difference)",
iThisFPS, fExpectedTime, fDeltaTime, fDifference );
}
src/GameSoundManager.cpp
+8 -6
View File
@@ -20,13 +20,15 @@
#include "arch/Sound/RageSoundDriver.h"
#include <cmath>
GameSoundManager *SOUND = nullptr;
/*
* When playing music, automatically search for an SM file for timing data. If one is
* found, automatically handle GAMESTATE->m_fSongBeat, etc.
*
* modf(GAMESTATE->m_fSongBeat) should always be continuously moving from 0 to 1. To do
* std::modf(GAMESTATE->m_fSongBeat) should always be continuously moving from 0 to 1. To do
* this, wait before starting a sound until the fractional portion of the beat will be
* the same.
*
@@ -236,7 +238,7 @@ static void StartMusic( MusicToPlay &ToPlay )
const float fStartBeat = NewMusic->m_NewTiming.GetBeatFromElapsedTimeNoOffset( ToPlay.fStartSecond );
const float fStartBeatFraction = fmodfp( fStartBeat, 1 );
float fCurBeatToStartOn = truncf(fCurBeat) + fStartBeatFraction;
float fCurBeatToStartOn = std::trunc(fCurBeat) + fStartBeatFraction;
if( fCurBeatToStartOn < fCurBeat )
fCurBeatToStartOn += 1.0f;
@@ -503,7 +505,7 @@ float GameSoundManager::GetFrameTimingAdjustment( float fDeltaTime )
const float fExpectedDelay = 1.0f / iThisFPS;
const float fExtraDelay = fDeltaTime - fExpectedDelay;
if( fabsf(fExtraDelay) >= fExpectedDelay/2 )
if( std::abs(fExtraDelay) >= fExpectedDelay/2 )
return 0;
/* Subtract the extra delay. */
@@ -550,7 +552,7 @@ void GameSoundManager::Update( float fDeltaTime )
case FADE_NONE: break;
case FADE_OUT:
fapproach( fVolume, g_fDimVolume, fDeltaTime/fFadeOutSpeed );
if( fabsf(fVolume-g_fDimVolume) < 0.001f )
if( std::abs(fVolume-g_fDimVolume) < 0.001f )
g_FadeState = FADE_WAIT;
break;
case FADE_WAIT:
@@ -560,7 +562,7 @@ void GameSoundManager::Update( float fDeltaTime )
break;
case FADE_IN:
fapproach( fVolume, g_fOriginalVolume, fDeltaTime/fFadeInSpeed );
if( fabsf(fVolume-g_fOriginalVolume) < 0.001f )
if( std::abs(fVolume-g_fOriginalVolume) < 0.001f )
g_FadeState = FADE_NONE;
break;
}
@@ -604,7 +606,7 @@ void GameSoundManager::Update( float fDeltaTime )
const RString ThisFile = g_Playing->m_Music->GetLoadedFilePath();
/* If fSoundTimePassed < 0, the sound has probably looped. */
if( sLastFile == ThisFile && fSoundTimePassed >= 0 && fabsf(fDiff) > 0.003f )
if( sLastFile == ThisFile && fSoundTimePassed >= 0 && std::abs(fDiff) > 0.003f )
LOG->Trace("Song position skip in %s: expected %.3f, got %.3f (cur %f, prev %f) (%.3f difference)",
Basename(ThisFile).c_str(), fExpectedTimePassed, fSoundTimePassed, fSeconds, GAMESTATE->m_Position.m_fMusicSeconds, fDiff );
sLastFile = ThisFile;
src/GameState.cpp
+2 -1
View File
@@ -42,6 +42,7 @@
#include "ScreenManager.h"
#include "Screen.h"
#include <cmath>
#include <ctime>
#include <set>
@@ -1853,7 +1854,7 @@ StageResult GameState::GetStageResult( PlayerNumber pn ) const
{
case PLAY_MODE_BATTLE:
case PLAY_MODE_RAVE:
if( fabsf(m_fTugLifePercentP1 - 0.5f) < 0.0001f )
if( std::abs(m_fTugLifePercentP1 - 0.5f) < 0.0001f )
return RESULT_DRAW;
switch( pn )
{
src/GraphDisplay.cpp
+3 -1
View File
@@ -11,6 +11,8 @@
#include "Song.h"
#include "XmlFile.h"
#include <cmath>
//#define DIVIDE_LINE_WIDTH THEME->GetMetricI(m_sName,"TexturedBottomHalf")
REGISTER_ACTOR_CLASS( GraphDisplay );
@@ -76,7 +78,7 @@ public:
float opp = p2.p.x - p1.p.x;
float adj = p2.p.y - p1.p.y;
float hyp = powf(opp*opp + adj*adj, 0.5f);
float hyp = std::pow(opp*opp + adj*adj, 0.5f);
float lsin = opp/hyp;
float lcos = adj/hyp;
src/ImageCache.cpp
+3 -2
View File
@@ -17,9 +17,10 @@
#include "RageSurfaceUtils_Dither.h"
#include "RageSurfaceUtils_Zoom.h"
#include "SpecialFiles.h"
#include "Banner.h"
#include <cmath>
static Preference<bool> g_bPalettedImageCache( "PalettedImageCache", false );
/* Neither a global or a file scope static can be used for this because
@@ -325,7 +326,7 @@ RageTextureID ImageCache::LoadCachedImage( RString sImageDir, RString sImagePath
static inline int closest( int num, int n1, int n2 )
{
if( abs(num - n1) > abs(num - n2) )
if( std::abs(num - n1) > std::abs(num - n2) )
return n2;
return n1;
}
src/LifeMeterBattery.cpp
+3 -1
View File
@@ -7,6 +7,8 @@
#include "Course.h"
#include "ActorUtil.h"
#include <cmath>
LifeMeterBattery::LifeMeterBattery()
{
m_iLivesLeft= 4;
@@ -144,7 +146,7 @@ void LifeMeterBattery::AddLives( int iLives )
void LifeMeterBattery::ChangeLives(int iLifeDiff)
{
if( iLifeDiff < 0 )
SubtractLives( abs(iLifeDiff) );
SubtractLives( std::abs(iLifeDiff) );
else if( iLifeDiff > 0 )
AddLives(iLifeDiff);
}
src/LightsManager.cpp
+3 -1
View File
@@ -14,6 +14,8 @@
#include "CommonMetrics.h"
#include "Style.h"
#include <cmath>
const RString DEFAULT_LIGHTS_DRIVER = "SystemMessage,Export";
static Preference<RString> g_sLightsDriver( "LightsDriver", "" ); // "" == DEFAULT_LIGHTS_DRIVER
Preference<float> g_fLightsFalloffSeconds( "LightsFalloffSeconds", 0.1f );
@@ -203,7 +205,7 @@ void LightsManager::Update( float fDeltaTime )
if( m_LightsMode == LIGHTSMODE_TEST_AUTO_CYCLE )
{
m_fTestAutoCycleCurrentIndex += fDeltaTime;
m_fTestAutoCycleCurrentIndex = fmodf( m_fTestAutoCycleCurrentIndex, NUM_CabinetLight*100 );
m_fTestAutoCycleCurrentIndex = std::fmod( m_fTestAutoCycleCurrentIndex, NUM_CabinetLight*100 );
}
switch( m_LightsMode )
src/LuaManager.cpp
+2 -1
View File
@@ -16,6 +16,7 @@
#include <sstream> // conversion for lua functions.
#include <csetjmp>
#include <cassert>
#include <cmath>
#include <map>
LuaManager *LUA = nullptr;
@@ -740,7 +741,7 @@ XNode *LuaHelpers::GetLuaInformation()
XNode *pConstantNode = pConstantsNode->AppendChild( "Constant" );
pConstantNode->AppendAttr( "name", c.first );
if( c.second == truncf(c.second) )
if( c.second == std::trunc(c.second) )
pConstantNode->AppendAttr( "value", static_cast<int>(c.second) );
else
pConstantNode->AppendAttr( "value", c.second );
src/MenuTimer.cpp
+3 -1
View File
@@ -9,6 +9,8 @@
#include "ThemeMetric.h"
#include "ActorUtil.h"
#include <cmath>
RString WARNING_COMMAND_NAME( size_t i ) { return ssprintf("Warning%dCommand",int(i)); }
static const float TIMER_PAUSE_SECONDS = 99.99f;
@@ -100,7 +102,7 @@ void MenuTimer::Update( float fDeltaTime )
SOUND->PlayOnceFromAnnouncer( "hurry up" );
int iCrossed = (int)floorf(fOldSecondsLeft);
int iCrossed = std::floor(fOldSecondsLeft);
if( fOldSecondsLeft > iCrossed && fNewSecondsLeft < iCrossed ) // crossed
{
if( iCrossed <= WARNING_START )
src/ModelTypes.cpp
+2 -1
View File
@@ -9,6 +9,7 @@
#include "RageLog.h"
#include "RageDisplay.h"
#include <cmath>
#include <numeric>
#define MS_MAX_NAME 32
@@ -155,7 +156,7 @@ float AnimatedTexture::GetAnimationLengthSeconds() const
void AnimatedTexture::SetSecondsIntoAnimation( float fSeconds )
{
fSeconds = fmodf( fSeconds, GetAnimationLengthSeconds() );
fSeconds = std::fmod( fSeconds, GetAnimationLengthSeconds() );
m_iCurState = 0;
for( unsigned i=0; i<vFrames.size(); i++ )
src/MusicWheel.cpp
+3 -1
View File
@@ -23,10 +23,12 @@
#include "MessageManager.h"
#include "LocalizedString.h"
#include <cmath>
static Preference<bool> g_bMoveRandomToEnd( "MoveRandomToEnd", false );
static Preference<bool> g_bPrecacheAllSorts( "PreCacheAllWheelSorts", false);
#define NUM_WHEEL_ITEMS ((int)ceil(NUM_WHEEL_ITEMS_TO_DRAW+2))
#define NUM_WHEEL_ITEMS ((int)std::ceil(NUM_WHEEL_ITEMS_TO_DRAW+2))
#define WHEEL_TEXT(s) THEME->GetString( "MusicWheel", ssprintf("%sText",s.c_str()) );
#define CUSTOM_ITEM_WHEEL_TEXT(s) THEME->GetString( "MusicWheel", ssprintf("CustomItem%sText",s.c_str()) );
src/NoteDataUtil.cpp
+12 -10
View File
@@ -9,6 +9,8 @@
#include "GameState.h"
#include "RadarValues.h"
#include "TimingData.h"
#include <cmath>
#include <utility>
// TODO: Remove these constants that aren't time signature-aware
@@ -29,7 +31,7 @@ NoteType NoteDataUtil::GetSmallestNoteTypeInRange( const NoteData &n, int iStart
FOREACH_ENUM(NoteType, nt)
{
float fBeatSpacing = NoteTypeToBeat( nt );
int iRowSpacing = lrintf( fBeatSpacing * ROWS_PER_BEAT );
int iRowSpacing = std::lrint( fBeatSpacing * ROWS_PER_BEAT );
bool bFoundSmallerNote = false;
// for each index in this measure
@@ -375,7 +377,7 @@ void NoteDataUtil::GetSMNoteDataString( const NoteData &in, RString &sRet )
if( nt == NoteType_Invalid )
iRowSpacing = 1;
else
iRowSpacing = lrintf( NoteTypeToBeat(nt) * ROWS_PER_BEAT );
iRowSpacing = std::lrint( NoteTypeToBeat(nt) * ROWS_PER_BEAT );
// (verify first)
// iRowSpacing = BeatToNoteRow( NoteTypeToBeat(nt) );
@@ -515,7 +517,7 @@ void NoteDataUtil::LoadTransformedSlidingWindow( const NoteData &in, NoteData &o
int iCurTrackOffset = 0;
int iTrackOffsetMin = 0;
int iTrackOffsetMax = abs( iNewNumTracks - in.GetNumTracks() );
int iTrackOffsetMax = std::abs( iNewNumTracks - in.GetNumTracks() );
int bOffsetIncreasing = true;
int iLastMeasure = 0;
@@ -2188,7 +2190,7 @@ void NoteDataUtil::Wide( NoteData &inout, int iStartIndex, int iEndIndex )
continue; // skip
// add a note determinitsitcally
int iBeat = lrintf( NoteRowToBeat(i) );
int iBeat = std::lrint( NoteRowToBeat(i) );
int iTrackOfNote = inout.GetFirstTrackWithTap(i);
int iTrackToAdd = iTrackOfNote + (iBeat%5)-2; // won't be more than 2 tracks away from the existing note
CLAMP( iTrackToAdd, 0, inout.GetNumTracks()-1 );
@@ -2294,7 +2296,7 @@ void NoteDataUtil::InsertIntelligentTaps(
{
iTrackOfNoteToAdd = iTrackOfNoteEarlier;
}
else if( abs(iTrackOfNoteEarlier-iTrackOfNoteLater) >= 2 )
else if( std::abs(iTrackOfNoteEarlier-iTrackOfNoteLater) >= 2 )
{
// try to choose a track between the earlier and later notes
iTrackOfNoteToAdd = std::min(iTrackOfNoteEarlier,iTrackOfNoteLater)+1;
@@ -2628,7 +2630,7 @@ void NoteDataUtil::SnapToNearestNoteType( NoteData &inout, NoteType nt1, NoteTyp
int iNewIndex1 = Quantize( iOldIndex, BeatToNoteRow(fSnapInterval1) );
int iNewIndex2 = Quantize( iOldIndex, BeatToNoteRow(fSnapInterval2) );
bool bNewBeat1IsCloser = abs(iNewIndex1-iOldIndex) < abs(iNewIndex2-iOldIndex);
bool bNewBeat1IsCloser = std::abs(iNewIndex1-iOldIndex) < std::abs(iNewIndex2-iOldIndex);
int iNewIndex = bNewBeat1IsCloser? iNewIndex1 : iNewIndex2;
for( int c=0; c<inout.GetNumTracks(); c++ )
@@ -2981,8 +2983,8 @@ void NoteDataUtil::Scale( NoteData &nd, float fScale )
for( NoteData::const_iterator iter = nd.begin(t); iter != nd.end(t); ++iter )
{
TapNote tn = iter->second;
int iNewRow = lrintf( fScale * iter->first );
int iNewDuration = lrintf( fScale * (iter->first + tn.iDuration) );
int iNewRow = std::lrint( fScale * iter->first );
int iNewDuration = std::lrint( fScale * (iter->first + tn.iDuration) );
tn.iDuration = iNewDuration;
ndOut.SetTapNote( t, iNewRow, tn );
}
@@ -2998,9 +3000,9 @@ static inline int GetScaledRow( float fScale, int iStartIndex, int iEndIndex, in
if( iRow < iStartIndex )
return iRow;
else if( iRow > iEndIndex )
return iRow + lrintf( (iEndIndex - iStartIndex) * (fScale - 1) );
return iRow + std::lrint( (iEndIndex - iStartIndex) * (fScale - 1) );
else
return lrintf( (iRow - iStartIndex) * fScale ) + iStartIndex;
return std::lrint( (iRow - iStartIndex) * fScale ) + iStartIndex;
}
void NoteDataUtil::ScaleRegion( NoteData &nd, float fScale, int iStartIndex, int iEndIndex )
src/NoteDisplay.cpp
+11 -9
View File
@@ -19,6 +19,8 @@
#include "Sprite.h"
#include "Style.h"
#include <cmath>
static Preference<bool> g_bRenderEarlierNotesOnTop( "RenderEarlierNotesOnTop", false );
static const double PI_180= PI / 180.0;
@@ -664,13 +666,13 @@ void NoteDisplay::SetActiveFrame( float fNoteBeat, Actor &actorToSet, float fAni
/* -inf ... inf */
float fBeatOrSecond = cache->m_bAnimationBasedOnBeats ? m_pPlayerState->m_Position.m_fSongBeat : m_pPlayerState->m_Position.m_fMusicSeconds;
/* -len ... +len */
float fPercentIntoAnimation = fmodf( fBeatOrSecond, fAnimationLength );
float fPercentIntoAnimation = std::fmod( fBeatOrSecond, fAnimationLength );
/* -1 ... 1 */
fPercentIntoAnimation /= fAnimationLength;
if( bVivid )
{
float fNoteBeatFraction = fmodf( fNoteBeat, 1.0f );
float fNoteBeatFraction = std::fmod( fNoteBeat, 1.0f );
const float fInterval = 1.f / fAnimationLength;
fPercentIntoAnimation += QuantizeDown( fNoteBeatFraction, fInterval );
@@ -776,7 +778,7 @@ void NoteDisplay::DrawHoldPart(std::vector<Sprite*> &vpSpr,
float y_start_pos = (part_type == hpt_body) ? part_args.y_top : std::max(part_args.y_top, part_args.y_start_pos);
if (part_args.y_top < part_args.y_start_pos - unzoomed_frame_height)
{
y_start_pos = fmod((y_start_pos - part_args.y_start_pos), unzoomed_frame_height) + part_args.y_start_pos;
y_start_pos = std::fmod((y_start_pos - part_args.y_start_pos), unzoomed_frame_height) + part_args.y_start_pos;
}
float y_end_pos = std::min(part_args.y_bottom, part_args.y_end_pos);
const float color_scale= glow ? 1 : part_args.color_scale;
@@ -800,7 +802,7 @@ void NoteDisplay::DrawHoldPart(std::vector<Sprite*> &vpSpr,
{
float tex_coord_bottom= SCALE(part_args.y_bottom - part_args.y_top,
0, unzoomed_frame_height, rect.top, rect.bottom);
float want_tex_coord_bottom = ceilf(tex_coord_bottom - 0.0001f);
float want_tex_coord_bottom = std::ceil(tex_coord_bottom - 0.0001f);
add_to_tex_coord = want_tex_coord_bottom - tex_coord_bottom;
}
@@ -811,7 +813,7 @@ void NoteDisplay::DrawHoldPart(std::vector<Sprite*> &vpSpr,
const float fDistFromTop = y_start_pos - part_args.y_top;
float fTexCoordTop = SCALE(fDistFromTop, 0, unzoomed_frame_height, rect.top, rect.bottom);
fTexCoordTop += add_to_tex_coord;
add_to_tex_coord -= floorf(fTexCoordTop);
add_to_tex_coord -= std::floor(fTexCoordTop);
}
}
// The bottom caps mysteriously hate me and their texture coords need to be
@@ -1078,7 +1080,7 @@ void NoteDisplay::DrawHoldBodyInternal(std::vector<Sprite*>& sprite_top,
part_args.y_top = y_tail + overlap_hack;
part_args.y_bottom = tail_plus_bottom + overlap_hack;
part_args.top_beat = bottom_beat;
part_args.y_start_pos = fmaxf(part_args.y_start_pos, y_head);
part_args.y_start_pos = std::fmax(part_args.y_start_pos, y_head);
part_args.wrapping = false;
DrawHoldPart(sprite_bottom, field_args, column_args, part_args, glow, hpt_bottom);
}
@@ -1352,15 +1354,15 @@ void NoteDisplay::DrawActor(const TapNote& tn, Actor* pActor, NotePart part,
color = clamp( color, 0.0f, (float) (cache->m_iNoteColorCount[part]-1) );
break;
case NoteColorType_Progress:
color = fmodf( ceilf( fBeat * cache->m_iNoteColorCount[part] ), (float)cache->m_iNoteColorCount[part] );
color = std::fmod( std::ceil( fBeat * cache->m_iNoteColorCount[part] ), (float)cache->m_iNoteColorCount[part] );
break;
case NoteColorType_ProgressAlternate:
fScaledBeat = fBeat * cache->m_iNoteColorCount[part];
if( fScaledBeat - int64_t(fScaledBeat) == 0.0f )
//we're on a boundary, so move to the previous frame.
//doing it this way ensures that fScaledBeat is never negative so fmodf works.
//doing it this way ensures that fScaledBeat is never negative so std::fmod works.
fScaledBeat += cache->m_iNoteColorCount[part] - 1;
color = fmodf( ceilf( fScaledBeat ), (float)cache->m_iNoteColorCount[part] );
color = std::fmod( std::ceil( fScaledBeat ), (float)cache->m_iNoteColorCount[part] );
break;
default:
FAIL_M(ssprintf("Invalid NoteColorType: %i", cache->m_NoteColorType[part]));
src/NoteField.cpp
+5 -3
View File
@@ -15,12 +15,14 @@
#include "PlayerState.h"
#include "Style.h"
#include "CommonMetrics.h"
#include <float.h>
#include "BackgroundUtil.h"
#include "Course.h"
#include "NoteData.h"
#include "RageDisplay.h"
#include <cfloat>
#include <cmath>
float FindFirstDisplayedBeat( const PlayerState* pPlayerState, int iDrawDistanceAfterTargetsPixels );
float FindLastDisplayedBeat( const PlayerState* pPlayerState, int iDrawDistanceBeforeTargetsPixels );
@@ -735,8 +737,8 @@ void NoteField::CalcPixelsBeforeAndAfterTargets()
m_iDrawDistanceBeforeTargetsPixels * (1.f + curr_options.m_fDrawSize);
float draw_scale= 1;
draw_scale*= 1 + 0.5f * fabsf(curr_options.m_fPerspectiveTilt);
draw_scale*= 1 + fabsf(curr_options.m_fEffects[PlayerOptions::EFFECT_MINI]);
draw_scale*= 1 + 0.5f * std::abs(curr_options.m_fPerspectiveTilt);
draw_scale*= 1 + std::abs(curr_options.m_fEffects[PlayerOptions::EFFECT_MINI]);
m_FieldRenderArgs.draw_pixels_after_targets=
(int)(m_FieldRenderArgs.draw_pixels_after_targets * draw_scale);
src/NoteTypes.h
+5 -3
View File
@@ -7,6 +7,8 @@
#include "PlayerNumber.h"
#include "RageLog.h"
#include <cmath>
class XNode;
/** @brief The result of hitting (or missing) a tap note. */
@@ -280,16 +282,16 @@ bool IsNoteOfType( int row, NoteType t );
/*
inline int BeatToNoteRow( float fBeatNum )
{
float fraction = fBeatNum - truncf(fBeatNum);
float fraction = fBeatNum - std::trunc(fBeatNum);
int integer = int(fBeatNum) * ROWS_PER_BEAT;
return integer + lrintf(fraction * ROWS_PER_BEAT);
return integer + std::lrint(fraction * ROWS_PER_BEAT);
}
*/
/**
* @brief Convert the beat into a note row.
* @param fBeatNum the beat to convert.
* @return the note row. */
inline int BeatToNoteRow( float fBeatNum ) { return lrintf( fBeatNum * ROWS_PER_BEAT ); } // round
inline int BeatToNoteRow( float fBeatNum ) { return std::lrint( fBeatNum * ROWS_PER_BEAT ); } // round
/**
* @brief Convert the beat into a note row without rounding.
* @param fBeatNum the beat to convert.
src/NotesWriterDWI.cpp
+4 -2
View File
@@ -11,6 +11,8 @@
#include "Song.h"
#include "Steps.h"
#include <cmath>
RString OptimizeDWIString( RString holds, RString taps );
/**
@@ -360,7 +362,7 @@ bool NotesWriterDWI::Write( RString sPath, const Song &out )
ssprintf("The first BPM Segment must be defined at row 0, not %d!", bpms[0]->GetRow()) );
f.PutLine( ssprintf("#FILE:%s;", DwiEscape(out.m_sMusicFile).c_str()) );
f.PutLine( ssprintf("#BPM:%.3f;", static_cast<BPMSegment *>(bpms[0])->GetBPM()) );
f.PutLine( ssprintf("#GAP:%ld;", -lrintf( out.m_SongTiming.m_fBeat0OffsetInSeconds*1000 )) );
f.PutLine( ssprintf("#GAP:%ld;", -std::lrint( out.m_SongTiming.m_fBeat0OffsetInSeconds*1000 )) );
f.PutLine( ssprintf("#SAMPLESTART:%.3f;", out.m_fMusicSampleStartSeconds) );
f.PutLine( ssprintf("#SAMPLELENGTH:%.3f;", out.m_fMusicSampleLengthSeconds) );
if( out.m_sCDTitleFile.size() )
@@ -393,7 +395,7 @@ bool NotesWriterDWI::Write( RString sPath, const Song &out )
{
const StopSegment *fs = static_cast<StopSegment *>(stops[i]);
f.Write( ssprintf("%.3f=%.3f", fs->GetRow() * 4.0f / ROWS_PER_BEAT,
roundf(fs->GetPause()*1000)) );
std::round(fs->GetPause()*1000)) );
if( i != stops.size()-1 )
f.Write( "," );
}
src/OptionRow.cpp
+5 -3
View File
@@ -11,6 +11,8 @@
#include "Style.h"
#include "ActorUtil.h"
#include <cmath>
const RString NEXT_ROW_NAME = "NextRow";
const RString EXIT_NAME = "Exit";
@@ -681,9 +683,9 @@ void OptionRow::GetWidthXY( PlayerNumber pn, int iChoiceOnRow, int &iWidthOut, i
{
const BitmapText &text = GetTextItemForRow( pn, iChoiceOnRow );
iWidthOut = lrintf( text.GetZoomedWidth() );
iXOut = lrintf( text.GetDestX() );
iYOut = lrintf( m_Frame.GetDestY() );
iWidthOut = std::lrint( text.GetZoomedWidth() );
iXOut = std::lrint( text.GetDestX() );
iYOut = std::lrint( m_Frame.GetDestY() );
}
int OptionRow::GetOneSelection( PlayerNumber pn, bool bAllowFail ) const
src/OptionsCursor.cpp
+3 -1
View File
@@ -4,6 +4,8 @@
#include "ThemeManager.h"
#include "ActorUtil.h"
#include <cmath>
OptionsCursor::OptionsCursor()
{
m_iOriginalLeftX = 0;
@@ -108,7 +110,7 @@ void OptionsCursor::BeginTweening( float fSecs, TweenType tt )
void OptionsCursor::SetBarWidth( int iWidth )
{
float fWidth = ceilf(iWidth/2.0f)*2.0f; // round up to nearest even number
float fWidth = std::ceil(iWidth/2.0f)*2.0f; // round up to nearest even number
m_sprMiddle->ZoomToWidth( fWidth );
src/Player.cpp
+8 -6
View File
@@ -41,6 +41,8 @@
#include "LocalizedString.h"
#include "AdjustSync.h"
#include <cmath>
RString ATTACK_DISPLAY_X_NAME( size_t p, size_t both_sides );
void TimingWindowSecondsInit( size_t /*TimingWindow*/ i, RString &sNameOut, float &defaultValueOut );
@@ -879,7 +881,7 @@ void Player::Update( float fDeltaTime )
float fMiniPercent = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_MINI];
float fTinyPercent = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_TINY];
float fJudgmentZoom = std::min( powf(0.5f, fMiniPercent+fTinyPercent), 1.0f );
float fJudgmentZoom = std::min( std::pow(0.5f, fMiniPercent+fTinyPercent), 1.0f );
// Update Y positions
{
@@ -1042,7 +1044,7 @@ void Player::Update( float fDeltaTime )
continue;
const float notePosition = m_Timing->GetElapsedTimeFromBeat(NoteRowToBeat(row));
const float offset = fabsf((notePosition - musicPosition) / rate);
const float offset = std::abs((notePosition - musicPosition) / rate);
// Skip if we are outside of the largest timing window
if (offset > largestWindow)
@@ -1883,7 +1885,7 @@ int Player::GetClosestNote( int col, int iNoteRow, int iMaxRowsAhead, int iMaxRo
return iNextIndex;
/* Figure out which row is closer. */
if( abs(iNoteRow-iNextIndex) > abs(iNoteRow-iPrevIndex) )
if( std::abs(iNoteRow-iNextIndex) > std::abs(iNoteRow-iPrevIndex) )
return iPrevIndex;
else
return iNextIndex;
@@ -1948,7 +1950,7 @@ int Player::GetClosestNonEmptyRow( int iNoteRow, int iMaxRowsAhead, int iMaxRows
float fPrevTime = m_Timing->GetElapsedTimeFromBeat(NoteRowToBeat(iPrevRow));
/* Figure out which row is closer. */
if( fabsf(fNoteTime-fNextTime) > fabsf(fNoteTime-fPrevTime) )
if( std::abs(fNoteTime-fNextTime) > std::abs(fNoteTime-fPrevTime) )
return iPrevRow;
else
return iNextRow;
@@ -2240,7 +2242,7 @@ void Player::Step( int col, int row, const RageTimer &tm, bool bHeld, bool bRele
*/
}
const float fSecondsFromExact = fabsf( fNoteOffset );
const float fSecondsFromExact = std::abs( fNoteOffset );
TapNote tnDummy = TAP_ORIGINAL_TAP;
TapNote *pTN = nullptr;
@@ -3325,7 +3327,7 @@ void Player::SetCombo( unsigned int iCombo, unsigned int iMisses )
{
int iSongIndexStartColoring = GAMESTATE->m_pCurCourse->GetEstimatedNumStages();
iSongIndexStartColoring =
static_cast<int>(floor(iSongIndexStartColoring*PERCENT_UNTIL_COLOR_COMBO));
static_cast<int>(std::floor(iSongIndexStartColoring*PERCENT_UNTIL_COLOR_COMBO));
bPastBeginning = GAMESTATE->GetCourseSongIndex() >= iSongIndexStartColoring;
}
else
src/PlayerOptions.cpp
+8 -6
View File
@@ -9,7 +9,9 @@
#include "ThemeManager.h"
#include "Style.h"
#include "CommonMetrics.h"
#include <float.h>
#include <cfloat>
#include <cmath>
#include <sstream>
static const char *LifeTypeNames[] = {
@@ -199,7 +201,7 @@ static void AddPart( std::vector<RString> &AddTo, float level, RString name )
if( level == 0 )
return;
const RString LevelStr = (level == 1)? RString(""): ssprintf( "%ld%% ", lrintf(level*100) );
const RString LevelStr = (level == 1)? RString(""): ssprintf( "%ld%% ", std::lrint(level*100) );
AddTo.push_back( LevelStr + name );
}
@@ -540,11 +542,11 @@ void PlayerOptions::GetMods( std::vector<RString> &AddTo, bool bForceNoteSkin )
else
AddPart( AddTo, -m_fPerspectiveTilt, "Hallway" );
}
else if( fabsf(m_fSkew-m_fPerspectiveTilt) < 0.0001f )
else if( std::abs(m_fSkew-m_fPerspectiveTilt) < 0.0001f )
{
AddPart( AddTo, m_fSkew, "Space" );
}
else if( fabsf(m_fSkew+m_fPerspectiveTilt) < 0.0001f )
else if( std::abs(m_fSkew+m_fPerspectiveTilt) < 0.0001f )
{
AddPart( AddTo, m_fSkew, "Incoming" );
}
@@ -562,7 +564,7 @@ void PlayerOptions::GetMods( std::vector<RString> &AddTo, bool bForceNoteSkin )
AddTo.push_back( s );
}
if ( fabsf(m_fVisualDelay) > 0.0001f )
if ( std::abs(m_fVisualDelay) > 0.0001f )
{
// Format the string to be something like "10ms VisualDelay".
// Note that we don't process sub-millisecond visual delay.
@@ -1393,7 +1395,7 @@ float PlayerOptions::GetReversePercentForColumn( int iCol ) const
f += m_fScrolls[SCROLL_CROSS];
if( f > 2 )
f = fmodf( f, 2 );
f = std::fmod( f, 2 );
if( f > 1 )
f = SCALE( f, 1.f, 2.f, 1.f, 0.f );
return f;
src/PlayerStageStats.cpp
+5 -4
View File
@@ -3,7 +3,6 @@
#include "RageLog.h"
#include "ThemeManager.h"
#include "LuaManager.h"
#include <float.h>
#include "GameState.h"
#include "Course.h"
#include "Steps.h"
@@ -11,6 +10,8 @@
#include "PrefsManager.h"
#include "CommonMetrics.h"
#include <cfloat>
#include <cmath>
#include <numeric>
#define GRADE_PERCENT_TIER(i) THEME->GetMetricF("PlayerStageStats",ssprintf("GradePercent%s",GradeToString((Grade)i).c_str()))
@@ -151,7 +152,7 @@ void PlayerStageStats::AddStats( const PlayerStageStats& other )
Combo_t &combo = m_ComboList[i];
const float PrevComboEnd = prevcombo.m_fStartSecond + prevcombo.m_fSizeSeconds;
const float ThisComboStart = combo.m_fStartSecond;
if( fabsf(PrevComboEnd - ThisComboStart) > 0.001 )
if( std::abs(PrevComboEnd - ThisComboStart) > 0.001 )
continue;
// These are really the same combo.
@@ -261,7 +262,7 @@ float PlayerStageStats::MakePercentScore( int iActual, int iPossible )
// TRICKY: printf will round, but we want to truncate. Otherwise, we may display
// a percent score that's too high and doesn't match up with the calculated grade.
float fTruncInterval = powf( 0.1f, (float)iPercentTotalDigits-1 );
float fTruncInterval = std::pow( 0.1f, (float)iPercentTotalDigits-1 );
// TRICKY: ftruncf is rounding 1.0000000 to 0.99990004. Give a little boost
// to fPercentDancePoints to correct for this.
@@ -338,7 +339,7 @@ int PlayerStageStats::GetLessonScoreNeeded() const
{
float fScore = std::accumulate(m_vpPossibleSteps.begin(), m_vpPossibleSteps.end(), 0.f,
[](float total, Steps const *steps) { return total + steps->GetRadarValues(PLAYER_1)[RadarCategory_TapsAndHolds]; });
return lrintf( fScore * LESSON_PASS_THRESHOLD );
return std::lrint( fScore * LESSON_PASS_THRESHOLD );
}
void PlayerStageStats::ResetScoreForLesson()
src/RageBitmapTexture.cpp
+4 -2
View File
@@ -13,6 +13,8 @@
#include "arch/Dialog/Dialog.h"
#include "StepMania.h"
#include <cmath>
static void GetResolutionFromFileName( RString sPath, int &iWidth, int &iHeight )
{
/* Match:
@@ -302,8 +304,8 @@ void RageBitmapTexture::Create()
{
float fFrameWidth = this->GetSourceWidth() / (float)this->GetFramesWide();
float fFrameHeight = this->GetSourceHeight() / (float)this->GetFramesHigh();
float fBetterFrameWidth = ceilf(fFrameWidth/iDimensionMultiple) * iDimensionMultiple;
float fBetterFrameHeight = ceilf(fFrameHeight/iDimensionMultiple) * iDimensionMultiple;
float fBetterFrameWidth = std::ceil(fFrameWidth/iDimensionMultiple) * iDimensionMultiple;
float fBetterFrameHeight = std::ceil(fFrameHeight/iDimensionMultiple) * iDimensionMultiple;
float fBetterSourceWidth = this->GetFramesWide() * fBetterFrameWidth;
float fBetterSourceHeight = this->GetFramesHigh() * fBetterFrameHeight;
if( fFrameWidth!=fBetterFrameWidth || fFrameHeight!=fBetterFrameHeight )
src/RageDisplay.cpp
+11 -9
View File
@@ -15,6 +15,8 @@
#include "DisplaySpec.h"
#include "arch/ArchHooks/ArchHooks.h"
#include <cmath>
// Statistics stuff
RageTimer g_LastCheckTimer;
int g_iNumVerts;
@@ -116,7 +118,7 @@ RString RageDisplay::SetVideoMode( VideoModeParams p, bool &bNeedReloadTextures
const DisplayMode supported = d.currentMode() != nullptr ? *d.currentMode() : *d.supportedModes().begin();
p.width = supported.width;
p.height = supported.height;
p.rate = static_cast<int> (round(supported.refreshRate));
p.rate = std::round(supported.refreshRate);
if( (err = this->TryVideoMode(p,bNeedReloadTextures)) == "" )
return RString();
vs.push_back( err );
@@ -133,9 +135,9 @@ void RageDisplay::ProcessStatsOnFlip()
{
float fActualTime = g_LastCheckTimer.GetDeltaTime();
g_iNumChecksSinceLastReset++;
g_iFPS = lrintf( g_iFramesRenderedSinceLastCheck / fActualTime );
g_iFPS = std::lrint( g_iFramesRenderedSinceLastCheck / fActualTime );
g_iCFPS = g_iFramesRenderedSinceLastReset / g_iNumChecksSinceLastReset;
g_iCFPS = lrintf( g_iCFPS / fActualTime );
g_iCFPS = std::lrint( g_iCFPS / fActualTime );
g_iVPF = g_iVertsRenderedSinceLastCheck / g_iFramesRenderedSinceLastCheck;
g_iFramesRenderedSinceLastCheck = g_iVertsRenderedSinceLastCheck = 0;
if( LOG_FPS )
@@ -199,7 +201,7 @@ void RageDisplay::DrawPolyLine(const RageSpriteVertex &p1, const RageSpriteVerte
// soh cah toa strikes strikes again!
float opp = p2.p.x - p1.p.x;
float adj = p2.p.y - p1.p.y;
float hyp = powf(opp*opp + adj*adj, 0.5f);
float hyp = std::pow(opp*opp + adj*adj, 0.5f);
float lsin = opp/hyp;
float lcos = adj/hyp;
@@ -578,7 +580,7 @@ void RageDisplay::LoadMenuPerspective( float fovDegrees, float fWidth, float fHe
CLAMP( fovDegrees, 0.1f, 179.9f );
float fovRadians = fovDegrees / 180.f * PI;
float theta = fovRadians/2;
float fDistCameraFromImage = fWidth/2 / tanf( theta );
float fDistCameraFromImage = fWidth/2 / std::tan( theta );
fVanishPointX = SCALE( fVanishPointX, 0, fWidth, fWidth, 0 );
fVanishPointY = SCALE( fVanishPointY, 0, fHeight, fHeight, 0 );
@@ -634,7 +636,7 @@ void RageDisplay::LoadLookAt( float fFOV, const RageVector3 &Eye, const RageVect
RageMatrix RageDisplay::GetPerspectiveMatrix(float fovy, float aspect, float zNear, float zFar)
{
float ymax = zNear * tanf(fovy * PI / 360.0f);
float ymax = zNear * std::tan(fovy * PI / 360.0f);
float ymin = -ymax;
float xmin = ymin * aspect;
float xmax = ymax * aspect;
@@ -781,9 +783,9 @@ bool RageDisplay::SaveScreenshot( RString sPath, GraphicsFileFormat format )
// Maintain the DAR.
ASSERT( GetActualVideoModeParams().fDisplayAspectRatio > 0 );
int iHeight = 480;
// This used to be lrintf. However, lrintf causes odd resolutions like
// 639x480 (4:3) and 853x480 (16:9). ceilf gives correct values. -aj
int iWidth = static_cast<int>(ceilf( iHeight * GetActualVideoModeParams().fDisplayAspectRatio ));
// This used to be lrint. However, lrint causes odd resolutions like
// 639x480 (4:3) and 853x480 (16:9). ceil gives correct values. -aj
int iWidth = std::ceil( iHeight * GetActualVideoModeParams().fDisplayAspectRatio );
timer.Touch();
RageSurfaceUtils::Zoom( surface, iWidth, iHeight );
// LOG->Trace( "%ix%i -> %ix%i (%.3f) in %f seconds", surface->w, surface->h, iWidth, iHeight, GetActualVideoModeParams().fDisplayAspectRatio, timer.GetDeltaTime() );
src/RageDisplay_D3D.cpp
+1 -1
View File
@@ -24,7 +24,7 @@
#pragma comment(lib, "d3d9.lib")
#endif
#include <math.h>
#include <cmath>
#include <list>
// Globals
src/RageDisplay_OGL.cpp
+3 -2
View File
@@ -19,6 +19,7 @@ using namespace RageDisplay_Legacy_Helpers;
#include "arch/LowLevelWindow/LowLevelWindow.h"
#include <cmath>
#include <set>
#if defined(WINDOWS)
@@ -686,10 +687,10 @@ static void CheckReversePackedPixels()
void SetupExtensions()
{
const float fGLVersion = StringToFloat( (const char *) glGetString(GL_VERSION) );
g_glVersion = lrintf( fGLVersion * 10 );
g_glVersion = std::lrint( fGLVersion * 10 );
const float fGLUVersion = StringToFloat( (const char *) gluGetString(GLU_VERSION) );
g_gluVersion = lrintf( fGLUVersion * 10 );
g_gluVersion = std::lrint( fGLUVersion * 10 );
#ifndef HAVE_X11 // LLW_X11 needs to init GLEW early for GLX exts
glewInit();
src/RageMath.cpp
+13 -10
View File
@@ -8,7 +8,10 @@
#include "RageLog.h"
#include "RageMath.h"
#include "RageTypes.h"
#include <float.h>
#include <cfloat>
#include <cmath>
void RageVec3ClearBounds( RageVector3 &mins, RageVector3 &maxs )
{
@@ -28,14 +31,14 @@ void RageVec3AddToBounds( const RageVector3 &p, RageVector3 &mins, RageVector3 &
void RageVec2Normalize( RageVector2* pOut, const RageVector2* pV )
{
float scale = 1.0f / sqrtf( pV->x*pV->x + pV->y*pV->y );
float scale = 1.0f / std::sqrt( pV->x*pV->x + pV->y*pV->y );
pOut->x = pV->x * scale;
pOut->y = pV->y * scale;
}
void RageVec3Normalize( RageVector3* pOut, const RageVector3* pV )
{
float scale = 1.0f / sqrtf( pV->x*pV->x + pV->y*pV->y + pV->z*pV->z );
float scale = 1.0f / std::sqrt( pV->x*pV->x + pV->y*pV->y + pV->z*pV->z );
pOut->x = pV->x * scale;
pOut->y = pV->y * scale;
pOut->z = pV->z * scale;
@@ -44,7 +47,7 @@ void RageVec3Normalize( RageVector3* pOut, const RageVector3* pV )
void VectorFloatNormalize(std::vector<float>& v)
{
ASSERT_M(v.size() == 3, "Can't normalize a non-3D vector.");
float scale = 1.0f / sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
float scale = 1.0f / std::sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
v[0]*= scale;
v[1]*= scale;
v[2]*= scale;
@@ -358,7 +361,7 @@ void RageQuatMultiply( RageVector4* pOut, const RageVector4 &pA, const RageVecto
square = out.x * out.x + out.y * out.y + out.z * out.z + out.w * out.w;
if (square > 0.0)
dist = 1.0f / sqrtf(square);
dist = 1.0f / std::sqrt(square);
else dist = 1;
out.x *= dist;
@@ -505,7 +508,7 @@ void RageQuatSlerp(RageVector4 *pOut, const RageVector4 &from, const RageVector4
if ( cosom < 0.9999f )
{
// standard case (slerp)
float omega = acosf(cosom);
float omega = std::acos(cosom);
float sinom = RageFastSin(omega);
scale0 = RageFastSin((1.0f - t) * omega) / sinom;
scale1 = RageFastSin(t * omega) / sinom;
@@ -606,7 +609,7 @@ struct sine_initter
for(unsigned int i= 0; i < sine_table_size; ++i)
{
float angle= SCALE(i, 0, sine_table_size, 0.0f, PI);
sine_table[i]= sinf(angle);
sine_table[i]= std::sin(angle);
}
}
};
@@ -654,7 +657,7 @@ float RageFastCsc( float x )
float RageSquare( float angle )
{
float fAngle = fmod( angle , (PI * 2) );
float fAngle = std::fmod( angle , (PI * 2) );
//Hack: This ensures the hold notes don't flicker right before they're hit.
if(fAngle < 0.01f)
{
@@ -665,7 +668,7 @@ float RageSquare( float angle )
float RageTriangle( float angle )
{
float fAngle= fmod(angle, PI * 2.0f);
float fAngle= std::fmod(angle, PI * 2.0f);
if(fAngle < 0.0)
{
fAngle+= PI * 2.0;
@@ -742,7 +745,7 @@ float RageBezier2D::EvaluateYFromX( float fX ) const
float fError = fX-fGuessedX;
/* If our guess is good enough, evaluate the result Y and return. */
if( unlikely(fabsf(fError) < 0.0001f) )
if( unlikely(std::abs(fError) < 0.0001f) )
return m_Y.Evaluate( fT );
float fSlope = m_X.GetSlope( fT );
src/RageSound.cpp
+3 -1
View File
@@ -36,6 +36,8 @@
#include "RageSoundReader_FileReader.h"
#include "RageSoundReader_ThreadedBuffer.h"
#include <cmath>
#define samplerate() m_pSource->GetSampleRate()
RageSoundParams::RageSoundParams():
@@ -328,7 +330,7 @@ void RageSound::StartPlaying()
ASSERT( !m_bPlaying );
// Move to the start position.
SetPositionFrames( lrintf(m_Param.m_StartSecond * samplerate()) );
SetPositionFrames( std::lrint(m_Param.m_StartSecond * samplerate()) );
/* If m_StartTime is in the past, then we probably set a start time but took too
* long loading. We don't want that; log it, since it can be unobvious. */
src/RageSoundMixBuffer.cpp
+3 -1
View File
@@ -2,6 +2,8 @@
#include "RageSoundMixBuffer.h"
#include "RageUtil.h"
#include <cmath>
#if defined(MACOSX)
#include "archutils/Darwin/VectorHelper.h"
#ifdef USE_VEC
@@ -79,7 +81,7 @@ void RageSoundMixBuffer::read( int16_t *pBuf )
{
float iOut = m_pMixbuf[iPos];
iOut = clamp( iOut, -1.0f, +1.0f );
pBuf[iPos] = lrintf(iOut * 32767);
pBuf[iPos] = std::lrint(iOut * 32767);
}
m_iBufUsed = 0;
}
src/RageSoundPosMap.cpp
+6 -5
View File
@@ -4,7 +4,8 @@
#include "RageUtil.h"
#include "RageTimer.h"
#include <limits.h>
#include <climits>
#include <cmath>
#include <list>
/* The number of frames we should keep pos_map data for. This being too high
@@ -60,7 +61,7 @@ void pos_map_queue::Insert( int64_t iSourceFrame, int iFrames, int64_t iDestFram
pos_map_t &last = m_pImpl->m_Queue.back();
if( last.m_iSourceFrame + last.m_iFrames == iSourceFrame &&
last.m_fSourceToDestRatio == fSourceToDestRatio &&
llabs(last.m_iDestFrame + lrintf(last.m_iFrames * last.m_fSourceToDestRatio) - iDestFrame) <= 1 )
llabs(last.m_iDestFrame + std::lrint(last.m_iFrames * last.m_fSourceToDestRatio) - iDestFrame) <= 1 )
{
last.m_iFrames += iFrames;
@@ -82,7 +83,7 @@ void pos_map_queue::Insert( int64_t iSourceFrame, int iFrames, int64_t iDestFram
next.m_iSourceFrame += iDeleteFrames;
next.m_iFrames -= iDeleteFrames;
next.m_iDestFrame += lrintf( iDeleteFrames * next.m_fSourceToDestRatio );
next.m_iDestFrame += std::lrint( iDeleteFrames * next.m_fSourceToDestRatio );
m_pImpl->m_Queue.push_back( next );
}
@@ -143,7 +144,7 @@ int64_t pos_map_queue::Search( int64_t iSourceFrame, bool *bApproximate ) const
/* iSourceFrame lies in this block; it's an exact match. Figure
* out the exact position. */
int iDiff = int(iSourceFrame - pm.m_iSourceFrame);
iDiff = lrintf( iDiff * pm.m_fSourceToDestRatio );
iDiff = std::lrint( iDiff * pm.m_fSourceToDestRatio );
return pm.m_iDestFrame + iDiff;
}
@@ -162,7 +163,7 @@ int64_t pos_map_queue::Search( int64_t iSourceFrame, bool *bApproximate ) const
{
iClosestPositionDist = dist;
pClosestBlock = &pm;
iClosestPosition = pm.m_iDestFrame + lrintf( pm.m_iFrames * pm.m_fSourceToDestRatio );
iClosestPosition = pm.m_iDestFrame + std::lrint( pm.m_iFrames * pm.m_fSourceToDestRatio );
}
}
src/RageSoundReader_Chain.cpp
+3 -1
View File
@@ -9,6 +9,8 @@
#include "RageSoundMixBuffer.h"
#include "RageSoundUtil.h"
#include <cmath>
/*
* Keyed sounds should pass this object to SoundReader_Preload, to preprocess it.
@@ -53,7 +55,7 @@ void RageSoundReader_Chain::AddSound( int iIndex, float fOffsetSecs, float fPan
Sound s;
s.iIndex = iIndex;
s.iOffsetMS = lrintf( fOffsetSecs * 1000 );
s.iOffsetMS = std::lrint( fOffsetSecs * 1000 );
s.fPan = fPan;
s.pSound = nullptr;
m_aSounds.push_back( s );
src/RageSoundReader_Extend.cpp
+6 -4
View File
@@ -4,6 +4,8 @@
#include "RageSoundUtil.h"
#include "RageUtil.h"
#include <cmath>
/*
* Add support for negative seeks (adding a delay), extending a sound
* beyond its end (m_LengthSeconds and M_CONTINUE), looping and fading.
@@ -153,7 +155,7 @@ bool RageSoundReader_Extend::SetProperty( const RString &sProperty, float fValue
{
if( sProperty == "StartSecond" )
{
m_iStartFrames = lrintf( fValue * this->GetSampleRate() );
m_iStartFrames = std::lrint( fValue * this->GetSampleRate() );
return true;
}
@@ -162,7 +164,7 @@ bool RageSoundReader_Extend::SetProperty( const RString &sProperty, float fValue
if( fValue == -1 )
m_iLengthFrames = -1;
else
m_iLengthFrames = lrintf( fValue * this->GetSampleRate() );
m_iLengthFrames = std::lrint( fValue * this->GetSampleRate() );
return true;
}
@@ -186,13 +188,13 @@ bool RageSoundReader_Extend::SetProperty( const RString &sProperty, float fValue
if( sProperty == "FadeInSeconds" )
{
m_iFadeInFrames = lrintf( fValue * this->GetSampleRate() );
m_iFadeInFrames = std::lrint( fValue * this->GetSampleRate() );
return true;
}
if( sProperty == "FadeSeconds" || sProperty == "FadeOutSeconds" )
{
m_iFadeOutFrames = lrintf( fValue * this->GetSampleRate() );
m_iFadeOutFrames = std::lrint( fValue * this->GetSampleRate() );
return true;
}
src/RageSoundReader_Merge.cpp
+10 -8
View File
@@ -7,6 +7,8 @@
#include "RageSoundMixBuffer.h"
#include "RageSoundUtil.h"
#include <cmath>
RageSoundReader_Merge::RageSoundReader_Merge()
{
@@ -140,8 +142,8 @@ bool RageSoundReader_Merge::SetProperty( const RString &sProperty, float fValue
return bRet;
}
static float Difference( float a, float b ) { return fabsf( a - b ); }
static int Difference( int a, int b ) { return abs( a - b ); }
static float Difference( float a, float b ) { return std::abs( a - b ); }
static int Difference( int a, int b ) { return std::abs( a - b ); }
/*
* If the audio position drifts apart further than ERROR_CORRECTION_THRESHOLD frames,
@@ -212,7 +214,7 @@ int RageSoundReader_Merge::Read( float *pBuffer, int iFrames )
/* A sound is being delayed to resync it; clamp the number of frames we
* read now, so we don't advance past it. */
int iMaxSourceFramesToRead = aNextSourceFrames[i] - iMinPosition;
int iMaxStreamFramesToRead = lrintf( iMaxSourceFramesToRead / m_fCurrentStreamToSourceRatio );
int iMaxStreamFramesToRead = std::lrint( iMaxSourceFramesToRead / m_fCurrentStreamToSourceRatio );
iFrames = std::min( iFrames, iMaxStreamFramesToRead );
// LOG->Warn( "RageSoundReader_Merge: sound positions moving at different rates" );
}
@@ -224,7 +226,7 @@ int RageSoundReader_Merge::Read( float *pBuffer, int iFrames )
RageSoundReader *pSound = m_aSounds.front();
iFrames = pSound->Read( pBuffer, iFrames );
if( iFrames > 0 )
m_iNextSourceFrame += lrintf( iFrames * m_fCurrentStreamToSourceRatio );
m_iNextSourceFrame += std::lrint( iFrames * m_fCurrentStreamToSourceRatio );
aNextSourceFrames.front() = pSound->GetNextSourceFrame();
aRatios.front() = pSound->GetStreamToSourceRatio();
return iFrames;
@@ -244,11 +246,11 @@ int RageSoundReader_Merge::Read( float *pBuffer, int iFrames )
while( iFramesRead < iFrames )
{
// if( i == 0 )
//LOG->Trace( "*** %i", Difference(aNextSourceFrames[i], m_iNextSourceFrame + lrintf(iFramesRead * aRatios[i])) );
//LOG->Trace( "*** %i", Difference(aNextSourceFrames[i], m_iNextSourceFrame + std::lrint(iFramesRead * aRatios[i])) );
if( Difference(aNextSourceFrames[i], m_iNextSourceFrame + lrintf(iFramesRead * aRatios[i])) > ERROR_CORRECTION_THRESHOLD )
if( Difference(aNextSourceFrames[i], m_iNextSourceFrame + std::lrint(iFramesRead * aRatios[i])) > ERROR_CORRECTION_THRESHOLD )
{
LOG->Trace( "*** hurk %i", Difference(aNextSourceFrames[i], m_iNextSourceFrame + lrintf(iFramesRead * aRatios[i])) );
LOG->Trace( "*** hurk %i", Difference(aNextSourceFrames[i], m_iNextSourceFrame + std::lrint(iFramesRead * aRatios[i])) );
break;
}
@@ -276,7 +278,7 @@ int RageSoundReader_Merge::Read( float *pBuffer, int iFrames )
int iMaxFramesRead = mix.size() / m_iChannels;
mix.read( pBuffer );
m_iNextSourceFrame += lrintf( iMaxFramesRead * m_fCurrentStreamToSourceRatio );
m_iNextSourceFrame += std::lrint( iMaxFramesRead * m_fCurrentStreamToSourceRatio );
return iMaxFramesRead;
}
src/RageSoundReader_Preload.cpp
+5 -3
View File
@@ -7,6 +7,8 @@
#include "RageSoundUtil.h"
#include "Preference.h"
#include <cmath>
/* If true, preloaded sounds are stored in 16-bit instead of floats. Most
* processing happens after preloading, and it's usually a waste to store high-
* resolution data for sound effects. */
@@ -60,7 +62,7 @@ bool RageSoundReader_Preload::Open( RageSoundReader *pSource )
{
float fSecs = iLen / 1000.f;
int iFrames = lrintf( fSecs * m_iSampleRate ); /* seconds -> frames */
int iFrames = std::lrint( fSecs * m_iSampleRate ); /* seconds -> frames */
int iSamples = unsigned( iFrames * m_iChannels ); /* frames -> samples */
if( iSamples > iMaxSamples )
return false; /* Don't bother trying to preload it. */
@@ -123,7 +125,7 @@ int RageSoundReader_Preload::GetLength_Fast() const
int RageSoundReader_Preload::SetPosition( int iFrame )
{
m_iPosition = iFrame;
m_iPosition = lrintf(m_iPosition / m_fRate);
m_iPosition = std::lrint(m_iPosition / m_fRate);
if( m_iPosition >= int(m_Buffer->size() / framesize) )
{
@@ -136,7 +138,7 @@ int RageSoundReader_Preload::SetPosition( int iFrame )
int RageSoundReader_Preload::GetNextSourceFrame() const
{
return lrintf(m_iPosition * m_fRate);
return std::lrint(m_iPosition * m_fRate);
}
int RageSoundReader_Preload::Read( float *pBuffer, int iFrames )
src/RageSoundReader_Resample_Good.cpp
+8 -7
View File
@@ -12,6 +12,7 @@
#include "RageMath.h"
#include "RageThreads.h"
#include <cmath>
#include <numeric>
/* Filter length. This must be a power of 2. */
@@ -23,14 +24,14 @@ namespace
{
if( f == 0 )
return 1;
return sinf(f)/f;
return std::sin(f) / f;
}
/* Modified Bessel function I0. From Abramowitz and Stegun "Handbook of Mathematical
* Functions", "Modified Bessel Functions I and K". */
float BesselI0( float fX )
{
float fAbsX = fabsf( fX );
float fAbsX = std::abs( fX );
if( fAbsX < 3.75f )
{
float y = fX / 3.75f;
@@ -41,7 +42,7 @@ namespace
else
{
float y = 3.75f/fAbsX;
float fRet = (exp(fAbsX)/sqrt(fAbsX)) *
float fRet = (std::exp(fAbsX)/std::sqrt(fAbsX)) *
(+0.39894228f+y*(+0.01328592f+y*(+0.00225319f+y*(-0.00157565f+y*(0.00916281f+
y*(-0.02057706f+y*(+0.02635537f+y*(-0.01647633f+y*+0.00392377f))))))));
return fRet;
@@ -63,8 +64,8 @@ namespace
float p = (iLen-1)/2.0f;
for( int n = 0; n < iLen; ++n )
{
float fN1 = fabsf((n-p)/p);
float fNum = fBeta * sqrtf( std::max(1-fN1*fN1, 0.0f) );
float fN1 = std::abs((n-p)/p);
float fNum = fBeta * std::sqrt( std::max(1.0f - fN1*fN1, 0.0f) );
fNum = BesselI0( fNum );
float fVal = fNum/fDenom;
pBuf[n] *= fVal;
@@ -620,7 +621,7 @@ void RageSoundReader_Resample_Good::ReopenResampler()
}
if( m_fRate != -1 )
iDownFactor = lrintf( m_fRate * iDownFactor );
iDownFactor = std::lrint( m_fRate * iDownFactor );
for( size_t iChannel = 0; iChannel < m_apResamplers.size(); ++iChannel )
m_apResamplers[iChannel]->SetDownFactor( iDownFactor );
@@ -696,7 +697,7 @@ void RageSoundReader_Resample_Good::SetRate( float fRatio )
int iDownFactor, iUpFactor;
GetFactors( iDownFactor, iUpFactor );
if( m_fRate != -1 )
iDownFactor = lrintf( m_fRate * iDownFactor );
iDownFactor = std::lrint( m_fRate * iDownFactor );
/* Set m_fRate to the actual rate, after quantization by iUpFactor. */
m_fRate = float(iDownFactor) / iUpFactor;
src/RageSoundReader_SpeedChange.cpp
+5 -3
View File
@@ -3,6 +3,8 @@
#include "RageUtil.h"
#include "RageLog.h"
#include <cmath>
static const int WINDOW_SIZE_MS = 30;
RageSoundReader_SpeedChange::RageSoundReader_SpeedChange( RageSoundReader *pSource ):
@@ -63,7 +65,7 @@ static int FindClosestMatch( const float *pBuffer, int iBufferSize, const float
for( int j = 0; j < iCorrelateBufferSize; j += iStride )
{
float fDiff = pFrames[j] - pCorrelateBuffer[j];
fScore += fabsf(fDiff);
fScore += std::abs(fDiff);
}
if( i == 0 || fScore < fBestScore )
@@ -163,7 +165,7 @@ int RageSoundReader_SpeedChange::Step()
* by 2.0 frames, and advance by 0.3 more the next time around. */
float fAdvanceFrames = GetWindowSizeFrames() * m_fTrailingSpeedRatio;
fAdvanceFrames += m_fErrorFrames;
int iTrailingDeltaFrames = lrintf( fAdvanceFrames );
int iTrailingDeltaFrames = std::lrint( fAdvanceFrames );
m_fErrorFrames = fAdvanceFrames - iTrailingDeltaFrames;
m_iUncorrelatedPos += iTrailingDeltaFrames;
@@ -312,7 +314,7 @@ int RageSoundReader_SpeedChange::GetNextSourceFrame() const
float fRatio = m_fTrailingSpeedRatio;
int iSourceFrame = RageSoundReader_Filter::GetNextSourceFrame();
int iPos = lrintf(m_iPos * fRatio);
int iPos = std::lrint(m_iPos * fRatio);
iSourceFrame -= m_iDataBufferAvailFrames;
iSourceFrame += m_iUncorrelatedPos + iPos;
src/RageSoundReader_ThreadedBuffer.cpp
+3 -1
View File
@@ -4,6 +4,8 @@
#include "RageTimer.h"
#include "RageLog.h"
#include <cmath>
/* Implement threaded read-ahead buffering.
*
* If a buffer is low on data, keep filling until it has a g_iMinFillFrames.
@@ -235,7 +237,7 @@ void RageSoundReader_ThreadedBuffer::BufferingThread()
else
{
m_Event.Unlock();
usleep( lrintf(fTimeToSleep * 1000000) );
usleep( std::lrint(fTimeToSleep * 1000000) );
m_Event.Lock();
}
}
src/RageSoundUtil.cpp
+3 -1
View File
@@ -2,6 +2,8 @@
#include "RageSoundUtil.h"
#include "RageUtil.h"
#include <cmath>
void RageSoundUtil::Attenuate( float *pBuf, int iSamples, float fVolume )
{
while( iSamples-- )
@@ -91,7 +93,7 @@ void RageSoundUtil::ConvertFloatToNativeInt16( const float *pFrom, int16_t *pTo,
{
for( int i = 0; i < iSamples; ++i )
{
int iOut = lrintf( pFrom[i] * 32768.0f );
int iOut = std::lrint( pFrom[i] * 32768.0f );
pTo[i] = clamp( iOut, -32768, 32767 );
}
}
src/RageSurface.cpp
+6 -5
View File
@@ -2,7 +2,8 @@
#include "RageSurface.h"
#include "RageUtil.h"
#include <limits.h>
#include <climits>
#include <cmath>
int32_t RageSurfacePalette::FindColor( const RageSurfaceColor &color ) const
@@ -23,10 +24,10 @@ int32_t RageSurfacePalette::FindClosestColor( const RageSurfaceColor &color ) co
if( colors[i] == color )
return i;
int iDist = abs( colors[i].r - color.r ) +
abs( colors[i].g - color.g ) +
abs( colors[i].b - color.b ) +
abs( colors[i].a - color.a );
int iDist = std::abs( colors[i].r - color.r ) +
std::abs( colors[i].g - color.g ) +
std::abs( colors[i].b - color.b ) +
std::abs( colors[i].a - color.a );
if( iDist < iBestDist )
{
iBestDist = iDist ;
src/RageSurfaceUtils.cpp
+9 -7
View File
@@ -5,6 +5,8 @@
#include "RageLog.h"
#include "RageFile.h"
#include <cmath>
uint32_t RageSurfaceUtils::decodepixel( const uint8_t *p, int bpp )
{
switch(bpp)
@@ -420,10 +422,10 @@ void RageSurfaceUtils::BlitTransform( const RageSurface *src, RageSurface *dst,
* pixel[1]; 2 indicates 50% pixel[1], 50% pixel[2] (which is clamped
* to pixel[1]). */
int src_x[2], src_y[2];
src_x[0] = (int) truncf(src_xp - 0.5f);
src_x[0] = std::trunc(src_xp - 0.5f);
src_x[1] = src_x[0] + 1;
src_y[0] = (int) truncf(src_yp - 0.5f);
src_y[0] = std::trunc(src_yp - 0.5f);
src_y[1] = src_y[0] + 1;
// Emulate GL_REPEAT.
@@ -452,7 +454,7 @@ void RageSurfaceUtils::BlitTransform( const RageSurface *src, RageSurface *dst,
sum += v[1][i] * (1-weight_x) * (weight_y);
sum += v[2][i] * (weight_x) * (1-weight_y);
sum += v[3][i] * (weight_x) * (weight_y);
out[i] = (uint8_t) clamp( lrintf(sum), 0L, 255L );
out[i] = (uint8_t) clamp( std::lrint(sum), 0L, 255L );
}
// If the source has no alpha, set the destination to opaque.
@@ -547,7 +549,7 @@ static bool blit_rgba_to_rgba( const RageSurface *src_surf, const RageSurface *d
* { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3 }
* SCALE( i, 0, max_src_val, 0, max_dst_val );
* { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3 }
* lrintf( ((float) i / max_src_val) * max_dst_val )
* std::lrint( ((float) i / max_src_val) * max_dst_val )
* { 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3 }
*
* We use the first for increasing resolution, since it gives the most even
@@ -558,7 +560,7 @@ static bool blit_rgba_to_rgba( const RageSurface *src_surf, const RageSurface *d
* { 0, 4, 8, 12 }
* SCALE( i, 0, max_src_val, 0, max_dst_val );
* { 0, 5, 10, 15 }
* lrintf( ((float) i / max_src_val) * max_dst_val )
* std::lrint( ((float) i / max_src_val) * max_dst_val )
* { 0, 5, 10, 15 }
*
* The latter two are equivalent and give an even distribution; we use the
@@ -861,10 +863,10 @@ RageSurface *RageSurfaceUtils::PalettizeToGrayscale( const RageSurface *src_surf
const unsigned int A = (index & Amask) >> Ashift;
// if only one intensity value, always fullbright
const uint8_t ScaledI = Ivalues == 1 ? 255 : clamp( lrintf(I * (255.0f / (Ivalues-1))), 0L, 255L );
const uint8_t ScaledI = Ivalues == 1 ? 255 : clamp( std::lrint(I * (255.0f / (Ivalues-1))), 0L, 255L );
// if only one alpha value, always opaque
const uint8_t ScaledA = Avalues == 1 ? 255 : clamp( lrintf(A * (255.0f / (Avalues-1))), 0L, 255L );
const uint8_t ScaledA = Avalues == 1 ? 255 : clamp( std::lrint(A * (255.0f / (Avalues-1))), 0L, 255L );
RageSurfaceColor c;
c.r = ScaledI;
src/RageSurfaceUtils_Zoom.cpp
+4 -3
View File
@@ -4,6 +4,7 @@
#include "RageSurfaceUtils.h"
#include "RageUtil.h"
#include <cmath>
#include <vector>
/* Coordinate 0x0 represents the exact top-left corner of a bitmap. .5x.5
@@ -72,7 +73,7 @@ static void InitVectors( std::vector<int> &s0, std::vector<int> &s1, std::vector
s0.push_back( clamp(int(sax), 0, src-1));
s1.push_back( clamp(int(sax+1), 0, src-1) );
const float p = (1.0f - (sax - floorf(sax))) * 16777216.0f;
const float p = (1.0f - (sax - std::floor(sax))) * 16777216.0f;
percent.push_back( uint32_t(p) );
}
}
@@ -156,8 +157,8 @@ void RageSurfaceUtils::Zoom( RageSurface *&src, int dstwidth, int dstheight )
xscale = clamp( xscale, .5f, 2.0f );
yscale = clamp( yscale, .5f, 2.0f );
int target_width = lrintf( src->w*xscale );
int target_height = lrintf( src->h*yscale );
int target_width = std::lrint( src->w*xscale );
int target_height = std::lrint( src->h*yscale );
RageSurface *dst =
CreateSurface(target_width, target_height, 32,
src/RageTimer.cpp
+3 -1
View File
@@ -27,6 +27,8 @@
#include "arch/ArchHooks/ArchHooks.h"
#include <cmath>
#define TIMESTAMP_RESOLUTION 1000000
const RageTimer RageZeroTimer(0,0);
@@ -122,7 +124,7 @@ RageTimer RageTimer::Sum(const RageTimer &lhs, float tm)
{
/* tm == 5.25 -> secs = 5, us = 5.25 - ( 5) = .25
* tm == -1.25 -> secs = -2, us = -1.25 - (-2) = .75 */
int seconds = (int) floorf(tm);
int seconds = std::floor(tm);
int us = int( (tm - seconds) * TIMESTAMP_RESOLUTION );
RageTimer ret(0,0); // Prevent unnecessarily checking the time
src/RageTypes.cpp
+6 -4
View File
@@ -2,6 +2,8 @@
#include "RageTypes.h"
#include "LuaManager.h"
#include <cmath>
void RageColor::PushTable( lua_State *L ) const
{
lua_newtable( L );
@@ -53,10 +55,10 @@ void RageColor::FromStackCompat( lua_State *L, int iPos )
RString RageColor::ToString() const
{
int iR = clamp( (int) lrintf(r * 255), 0, 255 );
int iG = clamp( (int) lrintf(g * 255), 0, 255 );
int iB = clamp( (int) lrintf(b * 255), 0, 255 );
int iA = clamp( (int) lrintf(a * 255), 0, 255 );
int iR = clamp( static_cast<int>(std::lrint(r * 255)), 0, 255 );
int iG = clamp( static_cast<int>(std::lrint(g * 255)), 0, 255 );
int iB = clamp( static_cast<int>(std::lrint(b * 255)), 0, 255 );
int iA = clamp( static_cast<int>(std::lrint(a * 255)), 0, 255 );
if( iA == 255 )
return ssprintf( "#%02X%02X%02X", iR, iG, iB );
src/RageUtil.cpp
+14 -14
View File
@@ -8,19 +8,19 @@
#include "LocalizedString.h"
#include "LuaBinding.h"
#include "LuaManager.h"
#include <float.h>
#include <json/json.h>
#include <pcre.h>
#include <numeric>
#include <cfloat>
#include <cmath>
#include <ctime>
#include <sstream>
#include <map>
#include <functional>
#include <map>
#include <numeric>
#include <sstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <math.h>
const RString CUSTOM_SONG_PATH= "/@mem/";
@@ -38,7 +38,7 @@ namespace
MersenneTwister g_LuaPRNG;
/* To map from [0..2^31-1] to [0..1), we divide by 2^31. */
const double DIVISOR = pow( double(2), double(31) );
const double DIVISOR = std::pow( double(2), double(31) );
static int Seed( lua_State *L )
{
@@ -103,9 +103,9 @@ void fapproach( float& val, float other_val, float to_move )
if( val == other_val )
return;
float fDelta = other_val - val;
float fSign = fDelta / fabsf( fDelta );
float fSign = fDelta / std::abs( fDelta );
float fToMove = fSign*to_move;
if( fabsf(fToMove) > fabsf(fDelta) )
if( std::abs(fToMove) > std::abs(fDelta) )
fToMove = fDelta; // snap
val += fToMove;
}
@@ -113,9 +113,9 @@ void fapproach( float& val, float other_val, float to_move )
/* Return a positive x mod y. */
float fmodfp(float x, float y)
{
x = fmodf(x, y); /* x is [-y,y] */
x += y; /* x is [0,y*2] */
x = fmodf(x, y); /* x is [0,y] */
x = std::fmod(x, y); /* x is [-y,y] */
x += y; /* x is [0,y*2] */
x = std::fmod(x, y); /* x is [0,y] */
return x;
}
@@ -1180,7 +1180,7 @@ float calc_stddev( const float *pStart, const float *pEnd, bool bSample )
for( const float *i=pStart; i != pEnd; ++i )
fDev += (*i - fMean) * (*i - fMean);
fDev /= std::distance( pStart, pEnd ) - (bSample ? 1 : 0);
fDev = sqrtf( fDev );
fDev = std::sqrt( fDev );
return fDev;
}
@@ -1209,7 +1209,7 @@ bool CalcLeastSquares( const std::vector<std::pair<float, float>> &vCoordinates,
fError += fOneError * fOneError;
}
fError /= vCoordinates.size();
fError = sqrtf( fError );
fError = std::sqrt( fError );
return true;
}
@@ -1220,7 +1220,7 @@ void FilterHighErrorPoints( std::vector<std::pair<float, float>> &vCoordinates,
for( unsigned int iIn = 0; iIn < vCoordinates.size(); ++iIn )
{
const float fError = fIntercept + fSlope * vCoordinates[iIn].first - vCoordinates[iIn].second;
if( fabsf(fError) < fCutoff )
if( std::abs(fError) < fCutoff )
{
vCoordinates[iOut] = vCoordinates[iIn];
++iOut;
src/RageUtil.h
+7 -6
View File
@@ -4,6 +4,7 @@
#define RAGE_UTIL_H
#include <algorithm>
#include <cmath>
#include <map>
#include <random>
#include <vector>
@@ -73,16 +74,16 @@ inline void wrap( unsigned &x, unsigned n )
inline void wrap( float &x, float n )
{
if (x<0)
x += truncf(((-x/n)+1))*n;
x = fmodf(x,n);
x += std::trunc(((-x/n)+1))*n;
x = std::fmod(x,n);
}
inline float fracf( float f ) { return f - truncf(f); }
inline float fracf( float f ) { return f - std::trunc(f); }
template<class T>
void CircularShift( std::vector<T> &v, int dist )
{
for( int i = abs(dist); i>0; i-- )
for( int i = std::abs(dist); i>0; i-- )
{
if( dist > 0 )
{
@@ -313,7 +314,7 @@ inline int QuantizeUp( int i, int iInterval )
inline float QuantizeUp( float i, float iInterval )
{
return ceilf( i/iInterval ) * iInterval;
return std::ceil( i/iInterval ) * iInterval;
}
/* Return i rounded down to the nearest multiple of iInterval. */
@@ -324,7 +325,7 @@ inline int QuantizeDown( int i, int iInterval )
inline float QuantizeDown( float i, float iInterval )
{
return floorf( i/iInterval ) * iInterval;
return std::floor( i/iInterval ) * iInterval;
}
// Move val toward other_val by to_move.
src/RollingNumbers.cpp
+4 -1
View File
@@ -6,6 +6,9 @@
#include "ActorUtil.h"
#include "LuaManager.h"
#include "ThemeManager.h"
#include <cmath>
REGISTER_ACTOR_CLASS( RollingNumbers );
RollingNumbers::RollingNumbers()
@@ -90,7 +93,7 @@ void RollingNumbers::Update( float fDeltaTime )
{
if(m_fCurrentNumber != m_fTargetNumber)
{
fapproach( m_fCurrentNumber, m_fTargetNumber, fabsf(m_fScoreVelocity) * fDeltaTime );
fapproach( m_fCurrentNumber, m_fTargetNumber, std::abs(m_fScoreVelocity) * fDeltaTime );
UpdateText();
}
src/SampleHistory.cpp
+5 -3
View File
@@ -3,6 +3,8 @@
#include "RageLog.h"
#include "RageUtil.h"
#include <cmath>
inline float sample_step_size(int samples_per_second)
{
@@ -16,7 +18,7 @@ SampleHistory::SampleHistory()
m_fHistorySeconds = 0.0f;
m_fToSample = sample_step_size(m_iHistorySamplesPerSecond);
m_fHistorySeconds = 10.0f;
int iSamples = lrintf( m_iHistorySamplesPerSecond * m_fHistorySeconds );
int iSamples = std::lrint( m_iHistorySamplesPerSecond * m_fHistorySeconds );
m_afHistory.resize( iSamples );
}
@@ -30,8 +32,8 @@ float SampleHistory::GetSampleNum( float fSamplesAgo ) const
float fSample = m_iLastHistory - fSamplesAgo - 1;
float f = floorf( fSample );
int iSample = lrintf(f);
float f = std::floor( fSample );
int iSample = std::lrint(f);
int iNextSample = iSample + 1;
wrap( iSample, m_afHistory.size() );
wrap( iNextSample, m_afHistory.size() );
src/ScreenContinue.cpp
+3 -1
View File
@@ -8,6 +8,8 @@
#include "MenuTimer.h"
#include "MemoryCardManager.h"
#include <cmath>
REGISTER_SCREEN_CLASS( ScreenContinue );
@@ -69,7 +71,7 @@ bool ScreenContinue::Input( const InputEventPlus &input )
case GAME_BUTTON_LEFT:
case GAME_BUTTON_RIGHT:
{
float fSeconds = floorf(m_MenuTimer->GetSeconds()) - 0.0001f;
float fSeconds = std::floor(m_MenuTimer->GetSeconds()) - 0.0001f;
fSeconds = std::max( fSeconds, 0.0001f ); // don't set to 0
m_MenuTimer->SetSeconds( fSeconds );
Message msg("HurryTimer");
src/ScreenDimensions.cpp
+7 -5
View File
@@ -5,6 +5,8 @@
#include "LuaManager.h"
#include "ThemeMetric.h"
#include <cmath>
static ThemeMetric<float> THEME_SCREEN_WIDTH("Common","ScreenWidth");
static ThemeMetric<float> THEME_SCREEN_HEIGHT("Common","ScreenHeight");
@@ -24,8 +26,8 @@ float ScreenDimensions::GetThemeAspectRatio()
return THEME_NATIVE_ASPECT;
}
/* ceilf was originally lrintf. However, lrintf causes odd resolutions like
* 639x480 (4:3) and 853x480 (16:9). ceilf gives the correct values of 640x480
/* ceil was originally lrint. However, lrint causes odd resolutions like
* 639x480 (4:3) and 853x480 (16:9). ceil gives the correct values of 640x480
* and 854x480 (should really be 852 so that SCREEN_CENTER_X == 426 and not 427)
* respectively. -aj */
float ScreenDimensions::GetScreenWidth()
@@ -35,9 +37,9 @@ float ScreenDimensions::GetScreenWidth()
if( fAspect > THEME_NATIVE_ASPECT )
fScale = fAspect / THEME_NATIVE_ASPECT;
ASSERT( fScale >= 1 );
// ceilf causes the width to come out odd when it shouldn't.
// ceil causes the width to come out odd when it shouldn't.
// 576 * 1.7778 = 1024.0128, which is rounded to 1025. -Kyz
int width= (int)ceilf(THEME_SCREEN_WIDTH * fScale);
int width= std::ceil(THEME_SCREEN_WIDTH * fScale);
width-= width % 2;
return (float)width;
}
@@ -49,7 +51,7 @@ float ScreenDimensions::GetScreenHeight()
if( fAspect < THEME_NATIVE_ASPECT )
fScale = THEME_NATIVE_ASPECT / fAspect;
ASSERT( fScale >= 1 );
return (float) ceilf(THEME_SCREEN_HEIGHT * fScale);
return std::ceil(THEME_SCREEN_HEIGHT * fScale);
}
void ScreenDimensions::ReloadScreenDimensions()
src/ScreenEdit.cpp
+9 -7
View File
@@ -1,6 +1,4 @@
#include "global.h"
#include <utility>
#include <float.h>
#include "ScreenEdit.h"
#include "ActorUtil.h"
#include "AdjustSync.h"
@@ -40,6 +38,10 @@
#include "Game.h"
#include "RageSoundReader.h"
#include <cfloat>
#include <cmath>
#include <utility>
static Preference<float> g_iDefaultRecordLength( "DefaultRecordLength", 4 );
static Preference<bool> g_bEditorShowBGChangesPlay( "EditorShowBGChangesPlay", true );
@@ -1769,12 +1771,12 @@ void ScreenEdit::Update( float fDeltaTime )
// Update trailing beat
float fDelta = GetBeat() - m_fTrailingBeat;
if( fabsf(fDelta) < 10 )
if( std::abs(fDelta) < 10 )
fapproach( m_fTrailingBeat, GetBeat(),
fDeltaTime*40 / m_NoteFieldEdit.GetPlayerState()->m_PlayerOptions.GetCurrent().m_fScrollSpeed );
else
fapproach( m_fTrailingBeat, GetBeat(),
fabsf(fDelta) * fDeltaTime*5 );
std::abs(fDelta) * fDeltaTime*5 );
PlayTicks();
}
@@ -1784,7 +1786,7 @@ static std::vector<int> FindAllAttacksAtTime(const AttackArray& attacks, float f
std::vector<int> ret;
for (unsigned i = 0; i < attacks.size(); ++i)
{
if (fabs(attacks[i].fStartSecond - fStartTime) < 0.001f)
if (std::abs(attacks[i].fStartSecond - fStartTime) < 0.001f)
{
ret.push_back(i);
}
@@ -1796,7 +1798,7 @@ static int FindAttackAtTime( const AttackArray& attacks, float fStartTime )
{
for( unsigned i = 0; i < attacks.size(); ++i )
{
if( fabs(attacks[i].fStartSecond - fStartTime) < 0.001f )
if( std::abs(attacks[i].fStartSecond - fStartTime) < 0.001f )
return i;
}
return -1;
@@ -5272,7 +5274,7 @@ void ScreenEdit::HandleAlterMenuChoice(AlterMenuChoice c, const std::vector<int>
int iStartIndex = m_NoteFieldEdit.m_iBeginMarker;
int iEndIndex = m_NoteFieldEdit.m_iEndMarker;
int iNewEndIndex = iEndIndex + lrintf( (iEndIndex - iStartIndex) * (fScale - 1) );
int iNewEndIndex = iEndIndex + std::lrint( (iEndIndex - iStartIndex) * (fScale - 1) );
// scale currently editing notes
NoteDataUtil::ScaleRegion( m_NoteDataEdit, fScale, iStartIndex, iEndIndex );
src/ScreenEnding.cpp
+3 -1
View File
@@ -20,6 +20,8 @@
#include "CommonMetrics.h"
#include "InputEventPlus.h"
#include <cmath>
REGISTER_SCREEN_CLASS( ScreenEnding );
ScreenEnding::ScreenEnding()
@@ -51,7 +53,7 @@ ScreenEnding::ScreenEnding()
for( float f = 0; f < 100.0f; f += 1.0f )
{
float fP1 = fmodf(f/100*4+.3f,1);
float fP1 = std::fmod(f/100*4+.3f,1);
STATSMAN->m_CurStageStats.m_player[PLAYER_1].SetLifeRecordAt( fP1, f );
STATSMAN->m_CurStageStats.m_player[PLAYER_2].SetLifeRecordAt( 1-fP1, f );
}
src/ScreenEvaluation.cpp
+5 -3
View File
@@ -30,6 +30,8 @@
#include "ScoreKeeperNormal.h"
#include "InputEventPlus.h"
#include <cmath>
// metrics that are common to all ScreenEvaluation classes
#define BANNER_WIDTH THEME->GetMetricF(m_sName,"BannerWidth")
#define BANNER_HEIGHT THEME->GetMetricF(m_sName,"BannerHeight")
@@ -143,7 +145,7 @@ void ScreenEvaluation::Init()
for( float f = 0; f < 100.0f; f += 1.0f )
{
float fP1 = fmodf(f/100*4+.3f,1);
float fP1 = std::fmod(f/100*4+.3f,1);
ss.m_player[PLAYER_1].SetLifeRecordAt( fP1, f );
ss.m_player[PLAYER_2].SetLifeRecordAt( 1-fP1, f );
}
@@ -581,8 +583,8 @@ void ScreenEvaluation::Init()
RadarCategory_Hands, RadarCategory_Rolls, RadarCategory_Lifts, RadarCategory_Fakes
};
const int ind = indices[l];
const int iActual = lrintf(m_pStageStats->m_player[p].m_radarActual[ind]);
const int iPossible = lrintf(m_pStageStats->m_player[p].m_radarPossible[ind]);
const int iActual = std::lrint(m_pStageStats->m_player[p].m_radarActual[ind]);
const int iPossible = std::lrint(m_pStageStats->m_player[p].m_radarPossible[ind]);
// todo: check if format string is valid
// (two integer values in DETAILLINE_FORMAT) -aj
src/ScreenGameplay.cpp
+3 -1
View File
@@ -61,6 +61,8 @@
#include "Profile.h" // for replay data stuff
#include "RageDisplay.h"
#include <cmath>
// Defines
#define SHOW_LIFE_METER_FOR_DISABLED_PLAYERS THEME->GetMetricB(m_sName,"ShowLifeMeterForDisabledPlayers")
#define SHOW_SCORE_IN_RAVE THEME->GetMetricB(m_sName,"ShowScoreInRave")
@@ -1701,7 +1703,7 @@ void ScreenGameplay::Update( float fDeltaTime )
fSpeed *= GetHasteRate();
RageSoundParams p = m_pSoundMusic->GetParams();
if( fabsf(p.m_fSpeed - fSpeed) > 0.01f && fSpeed >= 0.0f)
if( std::abs(p.m_fSpeed - fSpeed) > 0.01f && fSpeed >= 0.0f)
{
p.m_fSpeed = fSpeed;
m_pSoundMusic->SetParams( p );
src/ScreenNameEntry.cpp
+6 -4
View File
@@ -25,6 +25,8 @@
#include "Song.h"
#include "StatsManager.h"
#include <cmath>
// Defines specific to ScreenNameEntry
#define CATEGORY_Y THEME->GetMetricF(m_sName,"CategoryY")
#define CATEGORY_ZOOM THEME->GetMetricF(m_sName,"CategoryZoom")
@@ -62,7 +64,7 @@ void ScreenNameEntry::ScrollingText::Init( const RString &sName, const std::vect
void ScreenNameEntry::ScrollingText::DrawPrimitives()
{
const float fFakeBeat = GAMESTATE->m_Position.m_fSongBeat;
const size_t iClosestIndex = lrintf( fFakeBeat ) % CHARS_CHOICES.size();
const size_t iClosestIndex = std::lrint( fFakeBeat ) % CHARS_CHOICES.size();
const float fClosestYOffset = GetClosestCharYOffset( fFakeBeat );
size_t iCharIndex = ( iClosestIndex - NUM_CHARS_TO_DRAW_BEHIND + CHARS_CHOICES.size() ) % CHARS_CHOICES.size();
@@ -75,7 +77,7 @@ void ScreenNameEntry::ScrollingText::DrawPrimitives()
float fAlpha = 1.f;
if( iCharIndex == iClosestIndex )
fZoom = SCALE( fabs(fClosestYOffset), 0, 0.5f, g_fCharsZoomLarge, g_fCharsZoomSmall );
fZoom = SCALE( std::abs(fClosestYOffset), 0, 0.5f, g_fCharsZoomLarge, g_fCharsZoomSmall );
if( i == 0 )
fAlpha *= SCALE( fClosestYOffset, -0.5f, 0.f, 0.f, 1.f );
if( i == g_iNumCharsToDrawTotal-1 )
@@ -98,13 +100,13 @@ void ScreenNameEntry::ScrollingText::DrawPrimitives()
char ScreenNameEntry::ScrollingText::GetClosestChar( float fFakeBeat ) const
{
ASSERT( fFakeBeat >= 0.f );
return CHARS_CHOICES[lrintf(fFakeBeat) % CHARS_CHOICES.size()];
return CHARS_CHOICES[std::lrint(fFakeBeat) % CHARS_CHOICES.size()];
}
// return value is relative to gray arrows
float ScreenNameEntry::ScrollingText::GetClosestCharYOffset( float fFakeBeat ) const
{
float f = fmodf(fFakeBeat, 1.0f);
float f = std::fmod(fFakeBeat, 1.0f);
if( f > 0.5f )
f -= 1;
ASSERT( f>-0.5f && f<=0.5f );
src/ScreenOptions.cpp
+3 -1
View File
@@ -15,6 +15,8 @@
#include "LuaBinding.h"
#include "InputEventPlus.h"
#include <cmath>
/*
* These navigation types are provided:
@@ -1210,7 +1212,7 @@ void ScreenOptions::AfterChangeRow( PlayerNumber pn )
{
int iWidth, iX, iY;
GetWidthXY( pn, m_iCurrentRow[pn], i, iWidth, iX, iY );
const int iDist = abs( iX-m_iFocusX[pn] );
const int iDist = std::abs( iX-m_iFocusX[pn] );
if( iSelectionDist == -1 || iDist < iSelectionDist )
{
iSelectionDist = iDist;
src/ScreenSelectMusic.cpp
+6 -4
View File
@@ -32,6 +32,8 @@
#include "OptionsList.h"
#include "RageFileManager.h"
#include <cmath>
static const char *SelectionStateNames[] = {
"SelectingSong",
"SelectingSteps",
@@ -1644,10 +1646,10 @@ void ScreenSelectMusic::SwitchToPreferredDifficulty()
if( GAMESTATE->m_PreferredDifficulty[pn] != Difficulty_Invalid )
{
int iDifficultyDifference = abs( s->GetDifficulty() - GAMESTATE->m_PreferredDifficulty[pn] );
int iDifficultyDifference = std::abs( s->GetDifficulty() - GAMESTATE->m_PreferredDifficulty[pn] );
int iStepsTypeDifference = 0;
if( GAMESTATE->m_PreferredStepsType != StepsType_Invalid )
iStepsTypeDifference = abs( s->m_StepsType - GAMESTATE->m_PreferredStepsType );
iStepsTypeDifference = std::abs( s->m_StepsType - GAMESTATE->m_PreferredStepsType );
int iTotalDifference = iStepsTypeDifference * NUM_Difficulty + iDifficultyDifference;
if( iCurDifference == -1 || iTotalDifference < iCurDifference )
@@ -1681,8 +1683,8 @@ void ScreenSelectMusic::SwitchToPreferredDifficulty()
if( GAMESTATE->m_PreferredCourseDifficulty[pn] != Difficulty_Invalid && GAMESTATE->m_PreferredStepsType != StepsType_Invalid )
{
int iDifficultyDifference = abs( t->m_CourseDifficulty - GAMESTATE->m_PreferredCourseDifficulty[pn] );
int iStepsTypeDifference = abs( t->m_StepsType - GAMESTATE->m_PreferredStepsType );
int iDifficultyDifference = std::abs( t->m_CourseDifficulty - GAMESTATE->m_PreferredCourseDifficulty[pn] );
int iStepsTypeDifference = std::abs( t->m_StepsType - GAMESTATE->m_PreferredStepsType );
int iTotalDifference = iStepsTypeDifference * NUM_CourseDifficulty + iDifficultyDifference;
if( iCurDifference == -1 || iTotalDifference < iCurDifference )
src/ScreenTextEntry.cpp
+4 -2
View File
@@ -15,6 +15,8 @@
#include "LuaBinding.h"
#include "arch/ArchHooks/ArchHooks.h" // HOOKS->GetClipboard()
#include <cmath>
static const char* g_szKeys[NUM_KeyboardRow][KEYS_PER_ROW] =
{
{"A","B","C","D","E","F","G","H","I","J","K","L","M"},
@@ -684,8 +686,8 @@ void ScreenTextEntryVisual::BeginScreen()
for( int x=0; x<KEYS_PER_ROW; ++x )
{
BitmapText &bt = *m_ptextKeys[r][x];
float fX = roundf( SCALE( x, 0, KEYS_PER_ROW-1, ROW_START_X, ROW_END_X ) );
float fY = roundf( SCALE( r, 0, NUM_KeyboardRow-1, ROW_START_Y, ROW_END_Y ) );
float fX = std::round( SCALE( x, 0, KEYS_PER_ROW-1, ROW_START_X, ROW_END_X ) );
float fY = std::round( SCALE( r, 0, NUM_KeyboardRow-1, ROW_START_Y, ROW_END_Y ) );
bt.SetXY( fX, fY );
}
}
src/ScrollBar.cpp
+5 -3
View File
@@ -3,6 +3,8 @@
#include "ThemeManager.h"
#include "RageUtil.h"
#include <cmath>
ScrollBar::ScrollBar()
{
@@ -52,7 +54,7 @@ void ScrollBar::SetPercentage( float fCenterPercent, float fSizePercent )
/* Set tick thumb */
{
float fY = SCALE( fCenterPercent, 0.0f, 1.0f, -iBarContentHeight/2.0f, iBarContentHeight/2.0f );
fY = roundf( fY );
fY = std::round( fY );
m_sprScrollTickThumb->SetY( fY );
}
@@ -61,8 +63,8 @@ void ScrollBar::SetPercentage( float fCenterPercent, float fSizePercent )
float fEndPercent = fCenterPercent + fSizePercent;
// make sure the percent numbers are between 0 and 1
fStartPercent = fmodf( fStartPercent+1, 1 );
fEndPercent = fmodf( fEndPercent+1, 1 );
fStartPercent = std::fmod( fStartPercent+1, 1 );
fEndPercent = std::fmod( fEndPercent+1, 1 );
CHECKPOINT_M("Percentages set.");
float fPartTopY[2], fPartBottomY[2];
src/Song.cpp
+4 -3
View File
@@ -37,9 +37,10 @@
#include "ActorUtil.h"
#include "CommonMetrics.h"
#include <cfloat>
#include <cmath>
#include <time.h>
#include <set>
#include <float.h>
//-Nick12 Used for song file hashing
#include <CryptManager.h>
@@ -847,7 +848,7 @@ void Song::TidyUpData( bool from_cache, bool /* duringCache */ )
if(m_fMusicSampleStartSeconds+m_fMusicSampleLengthSeconds > this->m_fMusicLengthSeconds)
{
// Attempt to get a reasonable default.
int iBeat = lrintf(this->m_SongTiming.GetBeatFromElapsedTime(this->GetLastSecond())/2);
int iBeat = std::lrint(this->m_SongTiming.GetBeatFromElapsedTime(this->GetLastSecond())/2);
iBeat -= iBeat%4;
m_fMusicSampleStartSeconds = timing.GetElapsedTimeFromBeat((float)iBeat);
}
@@ -1443,7 +1444,7 @@ void Song::AddAutoGenNotes()
// has (non-autogen) Steps of this type
const int iNumTracks = GAMEMAN->GetStepsTypeInfo(st).iNumTracks;
const int iTrackDifference = abs(iNumTracks-iNumTracksOfMissing);
const int iTrackDifference = std::abs(iNumTracks-iNumTracksOfMissing);
if( iTrackDifference < iBestTrackDifference )
{
stBestMatch = st;
src/SongOptions.cpp
+3 -1
View File
@@ -4,6 +4,8 @@
#include "GameState.h"
#include "CommonMetrics.h"
#include <cmath>
static const char *AutosyncTypeNames[] = {
"Off",
"Song",
@@ -49,7 +51,7 @@ static void AddPart( std::vector<RString> &AddTo, float level, RString name )
if( level == 0 )
return;
const RString LevelStr = (level == 1)? RString(""): ssprintf( "%ld%% ", lrintf(level*100) );
const RString LevelStr = (level == 1)? RString(""): ssprintf( "%ld%% ", std::lrint(level*100) );
AddTo.push_back( LevelStr + name );
}
src/SongUtil.cpp
+3 -1
View File
@@ -18,6 +18,8 @@
#include "LuaBinding.h"
#include "EnumHelper.h"
#include <cmath>
ThemeMetric<int> SORT_BPM_DIVISION ( "MusicWheel", "SortBPMDivision" );
ThemeMetric<int> SORT_LENGTH_DIVISION ( "MusicWheel", "SortLengthDivision" );
ThemeMetric<bool> SHOW_SECTIONS_IN_BPM_SORT ( "MusicWheel", "ShowSectionsInBPMSort" );
@@ -235,7 +237,7 @@ Steps* SongUtil::GetClosestNotes( const Song *pSong, StepsType st, Difficulty dc
if( bIgnoreLocked && UNLOCKMAN->StepsIsLocked(pSong,pSteps) )
continue;
int iDistance = abs(dc - pSteps->GetDifficulty());
int iDistance = std::abs(dc - pSteps->GetDifficulty());
if( iDistance < iClosestDistance )
{
pClosest = pSteps;
src/Sprite.cpp
+6 -5
View File
@@ -1,7 +1,4 @@
#include "global.h"
#include <cassert>
#include <float.h>
#include "Sprite.h"
#include "RageTextureManager.h"
#include "XmlFile.h"
@@ -17,6 +14,10 @@
#include "ThemeMetric.h"
#include <numeric>
#include <cassert>
#include <cfloat>
#include <cmath>
REGISTER_ACTOR_CLASS( Sprite );
const float min_state_delay= 0.0001f;
@@ -500,8 +501,8 @@ void Sprite::Update( float fDelta )
* coordinates by the same amount, this won't be visible. */
if( m_bTextureWrapping )
{
const float fXAdjust = floorf( fTexCoords[0] );
const float fYAdjust = floorf( fTexCoords[1] );
const float fXAdjust = std::floor( fTexCoords[0] );
const float fYAdjust = std::floor( fTexCoords[1] );
fTexCoords[0] -= fXAdjust;
fTexCoords[2] -= fXAdjust;
fTexCoords[4] -= fXAdjust;
src/StatsManager.cpp
+4 -2
View File
@@ -1,4 +1,4 @@
#include "global.h"
#include "global.h"
#include "StatsManager.h"
#include "RageFileManager.h"
#include "GameState.h"
@@ -19,6 +19,8 @@
#include "PlayerState.h"
#include "Player.h"
#include <cmath>
StatsManager* STATSMAN = nullptr; // global object accessible from anywhere in the program
void AddPlayerStatsToProfile( Profile *pProfile, const StageStats &ss, PlayerNumber pn );
@@ -209,7 +211,7 @@ void StatsManager::CommitStatsToProfiles( const StageStats *pSS )
// Update profile stats
Profile* pMachineProfile = PROFILEMAN->GetMachineProfile();
int iGameplaySeconds = (int)truncf(pSS->m_fGameplaySeconds);
int iGameplaySeconds = std::trunc(pSS->m_fGameplaySeconds);
pMachineProfile->m_iTotalGameplaySeconds += iGameplaySeconds;
pMachineProfile->m_iNumTotalSongsPlayed += pSS->m_vpPlayedSongs.size();
src/StepMania.cpp
+4 -2
View File
@@ -70,6 +70,8 @@
#include "ActorUtil.h"
#include "ver.h"
#include <cmath>
#if defined(WIN32)
#include <windows.h>
#endif
@@ -88,8 +90,8 @@ void StepMania::GetPreferredVideoModeParams( VideoModeParams &paramsOut )
{
//float fRatio = PREFSMAN->m_iDisplayHeight;
//iWidth = PREFSMAN->m_iDisplayHeight * fRatio;
iWidth = static_cast<int>(ceilf(PREFSMAN->m_iDisplayHeight * PREFSMAN->m_fDisplayAspectRatio));
// ceilf causes the width to come out odd when it shouldn't.
iWidth = std::ceil(PREFSMAN->m_iDisplayHeight * PREFSMAN->m_fDisplayAspectRatio);
// ceil causes the width to come out odd when it shouldn't.
// 576 * 1.7778 = 1024.0128, which is rounded to 1025. -Kyz
iWidth-= iWidth % 2;
}
src/StreamDisplay.cpp
+5 -3
View File
@@ -1,11 +1,13 @@
#include "global.h"
#include "StreamDisplay.h"
#include "GameState.h"
#include <float.h>
#include "RageDisplay.h"
#include "ThemeManager.h"
#include "EnumHelper.h"
#include <cfloat>
#include <cmath>
static const char *StreamTypeNames[] = {
"Normal",
"Passing",
@@ -75,10 +77,10 @@ void StreamDisplay::Update( float fDeltaSecs )
// Just move straight to either full or empty.
if( m_fPercent <= 0 || m_fPercent >= 1 )
{
if( fabsf(fDelta) < 0.00001f )
if( std::abs(fDelta) < 0.00001f )
m_fVelocity = 0; // prevent div/0
else
m_fVelocity = (fDelta / fabsf(fDelta)) * VELOCITY_MULTIPLIER;
m_fVelocity = (fDelta / std::abs(fDelta)) * VELOCITY_MULTIPLIER;
}
else
{
src/Style.cpp
+2 -1
View File
@@ -19,7 +19,8 @@
#include "RageUtil.h"
#include "InputMapper.h"
#include "NoteData.h"
#include <float.h>
#include <cfloat>
bool Style::GetUsesCenteredArrows() const
{
src/Texture Font Generator/Texture Font GeneratorDlg.cpp
+2 -2
View File
@@ -4,10 +4,10 @@
#include "TextureFont.h"
#include "Utils.h"
#include <vector>
#include <cmath>
#include <fstream>
#include <set>
#include <math.h>
#include <vector>
static TextureFont *g_pTextureFont = NULL;
src/Texture Font Generator/TextureFont.cpp
+9 -9
View File
@@ -2,9 +2,9 @@
#include "TextureFont.h"
#include "Utils.h"
#include <fstream>
#include <math.h>
#include <cassert>
#include <cmath>
#include <fstream>
TextureFont::TextureFont()
{
@@ -151,9 +151,9 @@ void TextureFont::FormatCharacter( wchar_t c, HDC hDC )
ABCFLOAT abcf;
GetCharABCWidthsFloatW( hDC, c, c, &abcf );
abc.abcA = lrintf( abcf.abcfA );
abc.abcB = lrintf( abcf.abcfB );
abc.abcC = lrintf( abcf.abcfC );
abc.abcA = std::lrint( abcf.abcfA );
abc.abcB = std::lrint( abcf.abcfB );
abc.abcC = std::lrint( abcf.abcfC );
}
/*
@@ -289,11 +289,11 @@ void TextureFont::FormatFontPage( int iPage, HDC hDC )
pPage->m_iFrameWidth = (m_BoundingRect.right - m_BoundingRect.left) + m_iPadding;
pPage->m_iFrameHeight = (m_BoundingRect.bottom - m_BoundingRect.top) + m_iPadding;
int iDimensionMultiple = 4; // TODO: This only needs to be 4 for doubleres textures. It could be 2 otherwise and use less space
pPage->m_iFrameWidth = (int)ceil( pPage->m_iFrameWidth /(double)iDimensionMultiple ) * iDimensionMultiple;
pPage->m_iFrameHeight = (int)ceil( pPage->m_iFrameHeight /(double)iDimensionMultiple ) * iDimensionMultiple;
pPage->m_iFrameWidth = std::ceil( pPage->m_iFrameWidth /(double)iDimensionMultiple ) * iDimensionMultiple;
pPage->m_iFrameHeight = std::ceil( pPage->m_iFrameHeight /(double)iDimensionMultiple ) * iDimensionMultiple;
pPage->m_iNumFramesX = (int) ceil( powf( (float) Desc.chars.size(), 0.5f ) );
pPage->m_iNumFramesY = (int) ceil( (float) Desc.chars.size() / pPage->m_iNumFramesX );
pPage->m_iNumFramesX = std::ceil( std::pow( (float) Desc.chars.size(), 0.5f ) );
pPage->m_iNumFramesY = std::ceil( (float) Desc.chars.size() / pPage->m_iNumFramesX );
pPage->Create( pPage->m_iNumFramesX*pPage->m_iFrameWidth, pPage->m_iNumFramesY*pPage->m_iFrameHeight );
src/Texture Font Generator/Utils.h
-24
View File
@@ -3,30 +3,6 @@
#include "config.hpp"
#if !defined(HAVE_TRUNCF)
inline float truncf( float f ) { return float(int(f)); };
#endif
#if !defined(HAVE_ROUNDF)
inline float roundf( float f ) { if(f < 0) return truncf(f-0.5f); return truncf(f+0.5f); };
#endif
#if !defined(HAVE_LRINTF)
#if defined(_MSC_VER) && defined(_X86_)
inline long int lrintf( float f )
{
int retval;
_asm fld f;
_asm fistp retval;
return retval;
}
#else
#define lrintf(x) ((int)rint(x))
#endif
#endif
struct Surface
{
Surface() { pRGBA = NULL; }
src/TimingData.cpp
+4 -2
View File
@@ -6,7 +6,9 @@
#include "RageLog.h"
#include "ThemeManager.h"
#include "NoteTypes.h"
#include <float.h>
#include <cfloat>
#include <cmath>
static void EraseSegment(std::vector<TimingSegment*> &vSegs, int index, TimingSegment *cur);
static const int INVALID_INDEX = -1;
@@ -1030,7 +1032,7 @@ void TimingData::ScaleRegion( float fScale, int iStartIndex, int iEndIndex, bool
ASSERT( iStartIndex < iEndIndex );
int length = iEndIndex - iStartIndex;
int newLength = lrintf( fScale * length );
int newLength = std::lrint( fScale * length );
FOREACH_TimingSegmentType( tst )
for (unsigned j = 0; j < m_avpTimingSegments[tst].size(); j++)
src/TimingData.h
+3 -1
View File
@@ -4,8 +4,10 @@
#include "NoteTypes.h"
#include "TimingSegments.h"
#include "PrefsManager.h"
#include <float.h> // max float
#include <cfloat>
#include <array>
struct lua_State;
/** @brief Compare a TimingData segment's properties with one another. */
src/TimingSegments.h
+3 -1
View File
@@ -3,6 +3,8 @@
#include "NoteTypes.h" // Converting rows to beats and vice~versa.
#include <cmath>
enum TimingSegmentType
{
SEGMENT_BPM,
@@ -37,7 +39,7 @@ const RString& TimingSegmentTypeToString( TimingSegmentType tst );
const int ROW_INVALID = -1;
#define COMPARE(x) if( this->x!=other.x ) return false
#define COMPARE_FLOAT(x) if( fabsf(this->x - other.x) > EPSILON ) return false
#define COMPARE_FLOAT(x) if( std::abs(this->x - other.x) > EPSILON ) return false
/**
* @brief The base timing segment for make glorious benefit wolfman
src/Trail.cpp
+3 -1
View File
@@ -7,6 +7,8 @@
#include "NoteData.h"
#include "NoteDataUtil.h"
#include "CommonMetrics.h"
#include <cmath>
#include <numeric>
void TrailEntry::GetAttackArray( AttackArray &out ) const
@@ -154,7 +156,7 @@ int Trail::GetMeter() const
float fMeter = GetTotalMeter() / (float)m_vEntries.size();
return lrintf( fMeter );
return std::lrint( fMeter );
}
int Trail::GetTotalMeter() const
src/UnlockManager.cpp
+2 -1
View File
@@ -12,12 +12,13 @@
#include "Profile.h"
#include "ThemeManager.h"
#include "Steps.h"
#include <float.h>
#include "CommonMetrics.h"
#include "LuaManager.h"
#include "GameManager.h"
#include "Style.h"
#include <cfloat>
UnlockManager* UNLOCKMAN = nullptr; // global and accessible from anywhere in our program
#define UNLOCK_NAMES THEME->GetMetric ("UnlockManager","UnlockNames")
src/WheelBase.cpp
+8 -6
View File
@@ -15,6 +15,8 @@
#include "ThemeMetric.h"
#include "ScreenDimensions.h"
#include <cmath>
const int MAX_WHEEL_SOUND_SPEED = 15;
AutoScreenMessage( SM_SongChanged ); // TODO: Replace this with a Message and MESSAGEMAN
@@ -137,7 +139,7 @@ void WheelBase::SetPositions()
{
WheelItemBase *pDisplay = m_WheelBaseItems[i];
const float fOffsetFromSelection = i - NUM_WHEEL_ITEMS/2 + m_fPositionOffsetFromSelection;
if( fabsf(fOffsetFromSelection) > NUM_WHEEL_ITEMS_TO_DRAW/2 )
if( std::abs(fOffsetFromSelection) > NUM_WHEEL_ITEMS_TO_DRAW/2 )
pDisplay->SetVisible( false );
else
pDisplay->SetVisible( true );
@@ -198,7 +200,7 @@ void WheelBase::Update( float fDeltaTime )
m_fPositionOffsetFromSelection += m_fLockedWheelVelocity*t;
if( fabsf(m_fPositionOffsetFromSelection) < 0.01f && fabsf(m_fLockedWheelVelocity) < 0.01f )
if( std::abs(m_fPositionOffsetFromSelection) < 0.01f && std::abs(m_fLockedWheelVelocity) < 0.01f )
{
m_fPositionOffsetFromSelection = 0;
m_fLockedWheelVelocity = 0;
@@ -236,7 +238,7 @@ void WheelBase::Update( float fDeltaTime )
else
{
// "rotate" wheel toward selected song
float fSpinSpeed = 0.2f + fabsf( m_fPositionOffsetFromSelection ) / SWITCH_SECONDS;
float fSpinSpeed = 0.2f + std::abs( m_fPositionOffsetFromSelection ) / SWITCH_SECONDS;
if( m_fPositionOffsetFromSelection > 0 )
{
@@ -345,7 +347,7 @@ void WheelBase::ChangeMusicUnlessLocked( int n )
{
if(n)
{
int iSign = n/abs(n);
int iSign = n / std::abs(n);
m_fLockedWheelVelocity = iSign*LOCKED_INITIAL_VELOCITY;
m_soundLocked.Play(true);
}
@@ -364,7 +366,7 @@ void WheelBase::Move(int n)
{
if(n)
{
int iSign = n/abs(n);
int iSign = n / std::abs(n);
m_fLockedWheelVelocity = iSign*LOCKED_INITIAL_VELOCITY;
m_soundLocked.Play(true);
}
@@ -407,7 +409,7 @@ bool WheelBase::MoveSpecific( int n )
/* We were moving, and now we're stopping. If we're really close to
* the selection, move to the next one, so we have a chance to spin down
* smoothly. */
if(fabsf(m_fPositionOffsetFromSelection) < 0.25f )
if(std::abs(m_fPositionOffsetFromSelection) < 0.25f )
ChangeMusic(m_Moving);
/* Make sure the user always gets an SM_SongChanged when
src/WheelBase.h
+3 -1
View File
@@ -12,7 +12,9 @@
#include "ThemeMetric.h"
#include "LuaExpressionTransform.h"
#define NUM_WHEEL_ITEMS ((int)ceil(NUM_WHEEL_ITEMS_TO_DRAW+2))
#include <cmath>
#define NUM_WHEEL_ITEMS ((int)std::ceil(NUM_WHEEL_ITEMS_TO_DRAW+2))
enum WheelState {
STATE_SELECTING,
src/WheelNotifyIcon.cpp
+3 -1
View File
@@ -7,6 +7,8 @@
#include "RageTimer.h"
#include "ThemeManager.h"
#include <cmath>
/* todo: replace this entire thing with a set of AutoActors and a Scroller.
* In reality, everything except the Beginner/Training icon can be replicated
* in Lua (in stock StepMania 4), so I'm not sure if we even need this... -aj
@@ -84,7 +86,7 @@ void WheelNotifyIcon::Update( float fDeltaTime )
/* We should probably end up parsing the vector and then dynamically
* insert flag icons based on "priority". Easy to do, hopefully
- Midiman */
const float fSecondFraction = fmodf( RageTimer::GetTimeSinceStartFast(), 1 );
const float fSecondFraction = std::fmod( RageTimer::GetTimeSinceStartFast(), 1 );
const int index = (int)(fSecondFraction*m_vIconsToShow.size());
Sprite::SetState( m_vIconsToShow[index] );
}
src/arch/InputHandler/InputHandler_DirectInput.cpp
+3 -2
View File
@@ -20,6 +20,7 @@
#pragma comment(lib, "xinput.lib")
#endif
#include <cmath>
#include <XInput.h>
#include <WbemIdl.h>
#include <OleAuto.h>
@@ -783,7 +784,7 @@ void InputHandler_DInput::UpdateXInput( XIDevice &device, const RageTimer &tm )
// map joysticks
float lx = 0.f;
float ly = 0.f;
if (sqrt(pow(state.Gamepad.sThumbLX, 2) + pow(state.Gamepad.sThumbLY, 2)) > XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE)
if (std::sqrt(std::pow(state.Gamepad.sThumbLX, 2) + std::pow(state.Gamepad.sThumbLY, 2)) > XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE)
{
lx = SCALE(state.Gamepad.sThumbLX + 0.f, XINPUT_GAMEPAD_THUMB_MIN + 0.f, XINPUT_GAMEPAD_THUMB_MAX + 0.f, -1.0f, 1.0f);
ly = SCALE(state.Gamepad.sThumbLY + 0.f, XINPUT_GAMEPAD_THUMB_MIN + 0.f, XINPUT_GAMEPAD_THUMB_MAX + 0.f, -1.0f, 1.0f);
@@ -795,7 +796,7 @@ void InputHandler_DInput::UpdateXInput( XIDevice &device, const RageTimer &tm )
float rx = 0.f;
float ry = 0.f;
if (sqrt(pow(state.Gamepad.sThumbRX, 2) + pow(state.Gamepad.sThumbRY, 2)) > XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE)
if (std::sqrt(std::pow(state.Gamepad.sThumbRX, 2) + std::pow(state.Gamepad.sThumbRY, 2)) > XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE)
{
rx = SCALE(state.Gamepad.sThumbRX + 0.f, XINPUT_GAMEPAD_THUMB_MIN + 0.f, XINPUT_GAMEPAD_THUMB_MAX + 0.f, -1.0f, 1.0f);
ry = SCALE(state.Gamepad.sThumbRY + 0.f, XINPUT_GAMEPAD_THUMB_MIN + 0.f, XINPUT_GAMEPAD_THUMB_MAX + 0.f, -1.0f, 1.0f);
src/arch/Lights/LightsDriver_LinuxParallel.cpp
+3 -1
View File
@@ -9,6 +9,8 @@
#include "InputMapper.h"
#include "Game.h"
#include <cmath>
// xxx: don't hardcode the port address. -aj
static const int PORT_ADDRESS = 0x378;
static const bool SCREEN_DEBUG = false;
@@ -46,7 +48,7 @@ void LightsDriver_LinuxParallel::Set( const LightsState *ls )
{
s += ls->m_bCabinetLights[cl] ? '1' : '0';
if ( ls->m_bCabinetLights[cl] )
output += (unsigned char)pow((double)2,i);
output += std::pow((double)2,i);
i++;
}
s += "\n";
src/arch/LoadingWindow/LoadingWindow_Win32.cpp
+4 -2
View File
@@ -12,11 +12,13 @@
#include "RageSurface_Load.h"
#include "RageSurface.h"
#include "RageSurfaceUtils.h"
#include "RageSurfaceUtils_Zoom.h"
#include "RageLog.h"
#include "ProductInfo.h"
#include "LocalizedString.h"
#include "RageSurfaceUtils_Zoom.h"
#include <cmath>
static HBITMAP g_hBitmap = nullptr;
/* Load a RageSurface into a GDI surface. */
@@ -34,7 +36,7 @@ static HBITMAP LoadWin32Surface( const RageSurface *pSplash, HWND hWnd )
int iWidth = r.right;
float fRatio = (float) iWidth / s->w;
int iHeight = lrintf( s->h * fRatio );
int iHeight = std::lrint( s->h * fRatio );
RageSurfaceUtils::Zoom( s, iWidth, iHeight );
}
src/arch/LowLevelWindow/LowLevelWindow_X11.cpp
+3 -3
View File
@@ -12,8 +12,8 @@
using namespace RageDisplay_Legacy_Helpers;
using namespace X11Helper;
#include <cmath>
#include <set>
#include <math.h> // ceil()
#include <GL/glxew.h>
#define GLX_GLXEXT_PROTOTYPES
#include <GL/glx.h> // All sorts of stuff...
@@ -410,7 +410,7 @@ RString LowLevelWindow_X11::TryVideoMode( const VideoModeParams &p, bool &bNewDe
}
}
}
rate = roundf(fRefreshRate);
rate = std::round(fRefreshRate);
g_usedCrtc = tgtOutCrtc;
g_originalRandRMode = oldConf->mode;
@@ -559,7 +559,7 @@ RString LowLevelWindow_X11::TryVideoMode( const VideoModeParams &p, bool &bNewDe
CurrentParams.windowHeight = windowHeight;
CurrentParams.renderOffscreen = renderOffscreen;
ASSERT( rate > 0 );
CurrentParams.rate = static_cast<int> (roundf(rate));
CurrentParams.rate = std::round(rate);
if (!p.windowed)
{
src/arch/MemoryCard/MemoryCardDriverThreaded_Windows.cpp
+3 -1
View File
@@ -6,6 +6,8 @@
#include "PlayerNumber.h"
#include "MemoryCardManager.h"
#include <cmath>
MemoryCardDriverThreaded_Windows::MemoryCardDriverThreaded_Windows()
{
m_dwLastLogicalDrives = 0;
@@ -172,7 +174,7 @@ void MemoryCardDriverThreaded_Windows::GetUSBStorageDevices( std::vector<UsbStor
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters ) )
{
usbd.iVolumeSizeMB = (int)roundf( dwTotalNumberOfClusters * (float)dwSectorsPerCluster * dwBytesPerSector / (1024*1024) );
usbd.iVolumeSizeMB = std::round( dwTotalNumberOfClusters * (float)dwSectorsPerCluster * dwBytesPerSector / (1024*1024) );
}
}
}
src/arch/MovieTexture/MovieTexture_DShowHelper.cpp
+3 -1
View File
@@ -4,6 +4,8 @@
#include "RageLog.h"
#include "archutils/Win32/DirectXHelpers.h"
#include <cmath>
//-----------------------------------------------------------------------------
// Define GUID for Texture Renderer
// {71771540-2017-11cf-AE26-0020AFD79767}
@@ -54,7 +56,7 @@ HRESULT CTextureRenderer::SetMediaType(const CMediaType *pmt)
VIDEOINFO *pviBmp; // Bitmap info header
pviBmp = (VIDEOINFO *)pmt->Format();
m_lVidWidth = pviBmp->bmiHeader.biWidth;
m_lVidHeight = abs(pviBmp->bmiHeader.biHeight);
m_lVidHeight = std::abs(pviBmp->bmiHeader.biHeight);
m_lVidPitch = (m_lVidWidth * 3 + 3) + ~3; // We are forcing RGB24
return S_OK;
src/arch/MovieTexture/MovieTexture_Generic.cpp
+4 -2
View File
@@ -9,6 +9,8 @@
#include "RageUtil.h"
#include "Sprite.h"
#include <cmath>
#if defined(WIN32)
#include "archutils/Win32/ErrorStrings.h"
#include <windows.h>
@@ -193,9 +195,9 @@ void MovieTexture_Generic::CreateTexture()
/* Adjust m_iSourceWidth to support different source aspect ratios. */
float fSourceAspectRatio = m_pDecoder->GetSourceAspectRatio();
if( fSourceAspectRatio < 1 )
m_iSourceHeight = lrintf( m_iSourceHeight / fSourceAspectRatio );
m_iSourceHeight = std::lrint( m_iSourceHeight / fSourceAspectRatio );
else if( fSourceAspectRatio > 1 )
m_iSourceWidth = lrintf( m_iSourceWidth * fSourceAspectRatio );
m_iSourceWidth = std::lrint( m_iSourceWidth * fSourceAspectRatio );
/* HACK: Don't cap movie textures to the max texture size, since we
* render them onto the texture at the source dimensions. If we find a
src/arch/Sound/DSoundHelpers.cpp
+4 -2
View File
@@ -5,6 +5,8 @@
#include "archutils/Win32/DirectXHelpers.h"
#include "archutils/Win32/GetFileInformation.h"
#include <cmath>
#if defined(_WINDOWS)
#include <mmsystem.h>
#endif
@@ -282,8 +284,8 @@ void DSoundBuf::SetVolume( float fVolume )
ASSERT_M( fVolume >= 0 && fVolume <= 1, ssprintf("%f",fVolume) );
if( fVolume == 0 )
fVolume = 0.001f; // fix log10f(0) == -INF
float iVolumeLog2 = log10f(fVolume) / log10f(2); /* vol log 2 */
fVolume = 0.001f; // fix log10(0) == -INF
float iVolumeLog2 = std::log10(fVolume) / std::log10(2); /* vol log 2 */
/* Volume is a multiplier; SetVolume wants attenuation in hundredths of a decibel. */
const int iNewVolume = std::max( int(1000 * iVolumeLog2), DSBVOLUME_MIN );

Some files were not shown because too many files have changed in this diff Show More