void OsuManiaRenderer::RenderHitTimings(Window& _win)
{
const int KEYS = play->beatmap->getMods().getCS();
Analyzer* analyzer = AnalysisStruct::beatmapAnalysis.getAnalyzer("Tap Deviation (ms)");
if (analyzer == nullptr) return;
for (osu::TIMING timing : *(analyzer->getData()))
{
if (BTWN(getStartTime(), timing.time + timing.data, getEndTime())) // hits
{
int hitXpos = timing.key * (this->width / KEYS) + (this->absXpos - this->width / 2);
int width = ((this->width) / KEYS) - (2 * KEYS);
int hitPos = (*viewTime) - timing.time - timing.data;
int hitYpos = hitPos*zoom + height;
_win.driver->draw2DRectangle(SColor(255, 255, 0, 255), rect<s32>(absXpos + hitXpos, absYpos + hitYpos, absXpos + hitXpos + width, absYpos + hitYpos + 2));
}
else if (BTWN(getStartTime(), timing.time, getEndTime())) // misses
{
if (timing.data == INT_MAX)
{
int hitXpos = timing.key * (this->width / KEYS) + (this->absXpos - this->width / 2);
int width = ((this->width) / KEYS) - (2 * KEYS);
int hitPos = (*viewTime) - timing.time;
int hitYpos = hitPos*zoom + height;
_win.driver->draw2DRectangle(SColor(255, 200, 0, 0), rect<s32>(absXpos + hitXpos, absYpos + hitYpos, absXpos + hitXpos + width, absYpos + hitYpos + 3));
}
}
}
}
uint32
UserRight::getRightTimeLength() const {
if ( getEndTime() == 0 ) {
return MAX_UINT32;
} else {
if ( getEndTime() >= getStartTime() ) {
return getEndTime() - getStartTime();
} else {
return 0;
}
}
}
H5::DataSet CompartmentReportHDF5::_createDataset( const uint32_t gid,
const size_t compCount )
{
LBASSERT( compCount > 0 );
LBASSERT( !_reportName.empty( ));
std::ostringstream neuronName;
neuronName << "a" << gid;
H5::Group neuronGroup = _file.createGroup( neuronName.str().c_str( ));
H5::Group reportGroup = neuronGroup.createGroup( _reportName );
const int dims = 2;
const size_t numSteps = (getEndTime() - getStartTime()) / getTimestep();
const hsize_t mappingDim[dims] = { 1, compCount };
const hsize_t dataDim[dims] = { numSteps, compCount };
LBASSERT( numSteps > 0 );
H5::DataSpace mappingDataspace( dims, mappingDim );
H5::DataSpace dataDataspace( dims, dataDim );
H5::DataSet mappingDataset = reportGroup.createDataSet(
mappingDatasetName, H5::PredType::NATIVE_FLOAT, mappingDataspace );
H5::DataSet dataDataset = reportGroup.createDataSet( dataDatasetName,
H5::PredType::NATIVE_FLOAT, dataDataspace );
_datas[gid] = dataDataset;
_createMappingAttributes( mappingDataset );
_createDataAttributes( dataDataset );
return mappingDataset;
}
/// \brief get interpolated value at time t and derivative
///
void getValueAndDerivative(T_time t, T_value & value, T_value & derivative) const {
assert(t >= getStartTime());
assert(t < getEndTime());
// find i
int i=2;
while (this->_times[i] <= t) i++;
// compute points and tangents
const T_time G = (1+sqrt(5))/2;
T_value P1 = this->_values[i-1];
T_value P4 = this->_values[i];
T_value R1 = G / (this->_times[i]-this->_times[i-2])*(this->_values[i]-this->_values[i-2]);
T_value R4 = G / (this->_times[i+1]-this->_times[i-1])*(this->_values[i+1]-this->_values[i-1]);
// compute hermite interpolation
T_time tu = (t-this->_times[i-1]) / (this->_times[i]-this->_times[i-1]);
T_time tu2 = tu*tu;
T_time tu3 = tu2*tu;
value = (2*tu3 - 3*tu2 + 1) * P1
+ (-2*tu3 + 3*tu2) * P4
+ (tu3 - 2*tu2 + tu) * R1
+ (tu3 - tu2) * R4;
derivative = (6*tu2 - 6*tu) * P1
+ (-6*tu2 + 6*tu) * P4
+ (3*tu2 - 4*tu) * R1
+ (3*tu2 - 2*tu) * R4;
}
/// \brief get interpolated value at time t and derivative
///
void getValueAndDerivative(T_time t, T_value & value, T_value & derivative) const {
assert(t >= getStartTime());
assert(t < getEndTime());
int size = this->_times.size();
int iLater = 0;
while (iLater < size and this->_times[iLater] <= t) iLater++;
if (iLater == 0) {
value = this->_values.front();
T_time dt = (this->_times[1] - this->_times[0]);
T_value dP = this->_values[1] - this->_values[0];
derivative = dP / dt;
}
else if (iLater == size) {
value = this->_values.back();
T_time dt = this->_times[size-1] - this->_times[size-2];
T_value dP = this->_values[size-1] - this->_values[size-2];
derivative = dP / dt;
} else {
T_time dt = (this->_times[iLater] - this->_times[iLater-1]);
T_time tu = (t - this->_times[iLater-1]) / dt;
value = (1-tu)*this->_values[iLater-1] + tu*this->_values[iLater];
T_value dP = this->_values[iLater] - this->_values[iLater-1];
derivative = dP / dt;
}
}
void QAniCameraInstance::generateInterpolatedFrame(QAniKeyframe * frame) {
float itp = (frame->getTime() - getStartTime()) / getDuration();
CameraOptions co1 = ((QAniCameraKeyframe*)m_start)->getOptions();
CameraOptions co2 = ((QAniCameraKeyframe*)m_end)->getOptions();
CameraOptions & co = ((QAniCameraKeyframe*)frame)->getOptions();
co.l = co1.l + m_lookTrans * itp;
if (m_trackballRadians != 0.0) co.c = Matrix4x4::fromRotation(m_trackballAxis, m_trackballRadians * itp) * co1.c;
else co.c = co1.c;
if (m_tiltRadians != 0.0) {
co.u = Matrix4x4::fromRotation(m_tiltAxis, m_tiltRadians * itp) * co1.u;
co.o = Matrix4x4::fromRotation(m_tiltAxis, m_tiltRadians * itp) * co1.o;
}
else {
co.u = co1.u;
co.o = co1.o;
}
co.dist = co1.dist + m_zoom * itp;
co.nearclip = co1.nearclip;
co.farclip = co1.farclip;
co.fov = co1.fov;
co.maxDist = co1.maxDist;
}
// root search
void SimplePVSearch::search(Board board) {
prepareToSearch();
setStartTime(getTickCount());
setTimeToStop();
searchScore = idSearch(board);
time = getTickCount()-getStartTime();
}
void QAniSliceInstance::generateInterpolatedFrame(QAniKeyframe * frame) {
float itp = (frame->getTime() - getStartTime()) / getDuration();
Slicer s1 = ((QAniSliceKeyframe*)m_start)->getSlicer();
Slicer s2 = ((QAniSliceKeyframe*)m_end)->getSlicer();
Slicer& s = ((QAniSliceKeyframe*)frame)->getSlicer();
if (m_vecRadians) {
s.setVec(Matrix4x4::fromRotation(m_vecAxis, m_vecRadians * itp) * s1.getVec());
}
s.setDist(s1.getDist() + m_distChange * itp);
switch (m_maskingChange) {
case 2:
s.setMaskingColor(QColor(255*0.75,255*0.75,255*0.75,255*0.25));
s.setMasking(true);
break;
case 1:
s.setMaskingColor(QColor(255*0.75,255*0.75,255*0.75,255*0.25*itp));
s.setMasking(true);
break;
case 0:
s.setMaskingColor(QColor(255*0.75,255*0.75,255*0.75,255*0.25));
s.setMasking(false);
break;
case -1:
s.setMaskingColor(QColor(255*0.75,255*0.75,255*0.75,255*0.25*(1-itp)));
s.setMasking(true);
break;
}
}
void OsuManiaRenderer::RenderVisible(Window& _win)
{
Beatmap* beatmap = play->beatmap;
std::vector<Hitobject*>& hitobjects = beatmap->getHitobjects();
/// \TODO: Faster object search
for (int i = 0; i < hitobjects.size(); i++)
{
bool HoldStart = BTWN(hitobjects[i]->getTime(), getStartTime(), hitobjects[i]->getEndTime());
bool HoldEnd = BTWN(hitobjects[i]->getTime(), getEndTime(), hitobjects[i]->getEndTime());
bool circle = BTWN(getStartTime(), hitobjects[i]->getTime(), getEndTime());
if (HoldStart || HoldEnd || circle)
hitNotes[i]->Update(_win);
}
}
Frames CompartmentReportCommon::loadFrames(double start, double end) const
{
const auto startTime = getStartTime();
if (start >= getEndTime() || end < startTime || end <= start)
return Frames();
const double timestep = getTimestep();
const size_t startFrame = _getFrameNumber(start);
end = std::nextafter(end, -INFINITY);
const size_t count = _getFrameNumber(end) - startFrame + 1;
Frames frames;
frames.timeStamps.reset(new std::vector<double>);
for (size_t i = 0; i < count; ++i)
frames.timeStamps->push_back(startTime + (i + startFrame) * timestep);
const auto frameSize = getFrameSize();
frames.data.reset(new floats(frameSize * count));
if (frameSize == 0)
return frames;
if (!_loadFrames(startFrame, count, frames.data->data()))
return Frames();
return frames;
}
bool FareTicket::isAvailable(const graph::ServicePointer* newService, const graph::ServicePointer* lastService)
{
if((newService == NULL) || (_fare == NULL) || (!_available))
return false;
// test continuity
if(_fare->isRequiredContinuity()
&& lastService != NULL
&& lastService != getLastService())
{
return false;
}
// test the number of permitted connections
if(_fare->getPermittedConnectionsNumber()
&& _fare->getPermittedConnectionsNumber() <= getNumberOfConnections())
{
return false;
}
// test validity period of the ticket
boost::posix_time::time_duration period = newService->getArrivalDateTime() - getStartTime();
if(_fare->getValidityPeriod() < period.minutes())
return false;
return true;
}
//------------------------------------------------------------------------------
void WESplClient::printStats()
{
if(fOwner.getDebugLvl())
{
cout <<"\tPMid \t"<<getPmId()<<endl;
cout <<"\tTx Rows \t"<<getRowTx()<<endl;
//if(fOwner.getDebugLvl())
cout <<"\tTx Bytes \t"<<getBytesTx()<<endl;
//if(fOwner.getDebugLvl())
cout <<"\tRcv Bytes \t"<<getBytesRcv()<<endl;
cout <<"\tInserted/Read Rows "<<fRowsUploadInfo.fRowsInserted<<"/"
<<fRowsUploadInfo.fRowsRead<< endl;
if(fColOorVec.size()>0)
cout <<"\tCol Id\tColName\t\t\tout-of-range count" <<endl;
WEColOorVec::iterator aIt = fColOorVec.begin();
while(aIt != fColOorVec.end())
{
cout <<"\t"<<(*aIt).fColNum <<"\t"<<(*aIt).fColName <<"\t\t" << (*aIt).fNoOfOORs <<endl;
aIt++;
}
if(!fBadDataFile.empty())cout<<"\tBad Data Filename "<<fBadDataFile<<endl;
if(!fErrInfoFile.empty())cout<<"\tError Filename "<<fErrInfoFile<<endl;
cout <<"\t("<<getLastInTime()-getStartTime()<<"sec)"<<endl;
cout <<"\t"<<endl;
}
}
string Event::getEventDetails ()
{
stringstream output;
if (getEventType()!="d")
output << getStartTime().formatCompleteTime(getEndTime()) << " - ";
output << formatDisplay(getName()) ;
if (getLocation()!="")
output << " at "<< formatDisplay(getLocation());
if (getEventType()=="d")
output << " (by " << getStartTime().formatCompleteTime(getEndTime()) << ")";
output<<" " << getEventStatus();
output << endl;
return output.str();
}
void TimeMap::initFirstTimestepsYears() {
m_first_timestep_years.clear();
const boost::posix_time::ptime& ptime_prev = getStartTime(0);
boost::gregorian::date prev_date = ptime_prev.date();
for (size_t rstep = 0; rstep < m_timeList.size(); ++rstep) {
const boost::posix_time::ptime& ptime_cur = getStartTime(rstep);
boost::gregorian::date cur_date = ptime_cur.date();
if (cur_date.year() != prev_date.year()) {
m_first_timestep_years.push_back(rstep);
prev_date = cur_date;
}
}
}
void MxmlMeasure::addDummyRest(void) {
HumNum measuredur = getTimeSigDur();
HumNum starttime = getStartTime();
MxmlEvent* event = new MxmlEvent(this);
m_events.push_back(event);
MxmlMeasure* measure = this;
event->makeDummyRest(measure, starttime, measuredur);
}
Datum StandardDynamicStimulus::getCurrentAnnounceDrawData() {
Datum announceData(M_DICTIONARY, 5);
announceData.addElement(STIM_NAME, tag);
announceData.addElement(STIM_ACTION, STIM_ACTION_DRAW);
announceData.addElement(STIM_TYPE, "standard_dynamic_stimulus");
announceData.addElement("start_time", getStartTime());
return announceData;
}
bool
UserRight::checkAccessAt( uint32 t ) const {
if ( getStartTime() <= t && (getEndTime() >= t || getEndTime() == 0) ) {
return true;
} else {
return false;
}
}
// @ctor SelectAddEvenNotesCommand
// @author Tom Breton (Tehom)
SelectAddEvenNotesCommand::
SelectAddEvenNotesCommand(BeatEventVector beatEventVector, Segment *segment) :
BasicCommand(getGlobalName(),
*segment,
getStartTime(beatEventVector),
getEndTime(beatEventVector), true),
m_beatEventVector(beatEventVector)
{
}
void
MakeNotesViableCommand::modifySegment()
{
Segment &segment(getSegment());
SegmentNotationHelper helper(segment);
if (m_selection) {
EventSelection::RangeTimeList ranges(m_selection->getRangeTimes());
for (EventSelection::RangeTimeList::iterator i = ranges.begin();
i != ranges.end(); ++i) {
helper.makeNotesViable(i->first, i->second, true);
segment.normalizeRests(i->first, i->second);
}
} else {
helper.makeNotesViable(getStartTime(), getEndTime(), true);
segment.normalizeRests(getStartTime(), getEndTime());
}
}
void TimeMap::initFirstTimestepsMonths() {
m_first_timestep_months.clear();
const boost::posix_time::ptime& ptime_prev = getStartTime(0);
boost::gregorian::date prev_date = ptime_prev.date();
for (size_t rstep = 0; rstep < m_timeList.size(); ++rstep) {
const boost::posix_time::ptime& ptime_cur = getStartTime(rstep);
boost::gregorian::date cur_date = ptime_cur.date();
if (cur_date.month() != prev_date.month()) {
m_first_timestep_months.push_back(rstep);
prev_date = cur_date;
} else if (cur_date.year() != prev_date.year()) { //Same month but different year
m_first_timestep_months.push_back(rstep);
prev_date = cur_date;
}
}
}
void MorpherCtrl::getAnimDataTimeRange(REAL& start, REAL& end) const
{
start = INFINITY;
end = -INFINITY;
for(size_t i = 0; i < _channels.size(); ++i)
{
start = min(getStartTime(_channels[i].eval_weight, start), start);
end = max(getEndTime(_channels[i].eval_weight, end), end);
}
}
/// \brief get interpolated value at time t
///
T_value getValue(T_time t) const {
assert(t >= getStartTime());
assert(t < getEndTime());
int iLater = 0;
while (iLater < this->_times.size() and this->_times[iLater] <= t) iLater++;
if (iLater == 0) return this->_values.front();
if (iLater == this->_times.size()) return this->_values.back();
T_time dt = (this->_times[iLater] - this->_times[iLater-1]);
T_time tu = (t - this->_times[iLater-1]) / dt;
return (1-tu)*this->_values[iLater-1] + tu*this->_values[iLater];
}
void
AddIndicationCommand::modifySegment()
{
SegmentNotationHelper helper(getSegment());
Segment::iterator i, j;
int actualSubordering = Indication::EventSubOrdering;
helper.segment().getTimeSlice(getStartTime(), i, j);
for (Segment::iterator k = i; k != j; ++k) {
if ((*k)->has(BaseProperties::IS_GRACE_NOTE)) {
// If a grace note is inserted before an indication, the
// subordering is minor than Indication::EventSubOrdering,
// therefore we have to decrement the subordering to insert
// the new indication before the grace note.
if ((*k)->getSubOrdering() <= actualSubordering) {
actualSubordering = (*k)->getSubOrdering() - 1;
}
}
}
Indication indication(m_indicationType, m_indicationDuration);
Event *e;
e = new Event(Indication::EventType, m_indicationStart, m_indicationDuration,
actualSubordering);
e->set<String>(Indication::IndicationTypePropertyName, m_indicationType);
e->set<Int>("indicationduration", m_indicationDuration);
helper.segment().insert(e);
m_lastInsertedEvent = e;
if (indication.isOttavaType()) {
for (Segment::iterator i = getSegment().findTime(getStartTime());
i != getSegment().findTime(getStartTime() + m_indicationDuration);
++i) {
if ((*i)->isa(Note::EventType)) {
(*i)->setMaybe<Int>(NotationProperties::OTTAVA_SHIFT,
indication.getOttavaShift());
}
}
}
}
void MxmlMeasure::calculateDuration(void) {
HumNum maxdur = 0;
HumNum sum = 0;
for (int i=0; i<(int)m_events.size(); i++) {
m_events[i]->setStartTime(sum + getStartTime());
sum += m_events[i]->getDuration();
if (maxdur < sum) {
maxdur = sum;
}
}
setDuration(maxdur);
}
size_t CompartmentReportCommon::_getFrameNumber(double timestamp) const
{
const auto startTime = getStartTime();
const auto endTime = getEndTime();
assert(endTime > startTime);
const auto step = getTimestep();
timestamp =
std::max(std::min(timestamp, std::nextafter(endTime, -INFINITY)),
startTime) -
startTime;
return size_t(timestamp / step);
}
const float* MovedSound::readSample()
{
bool playhead_was_negative = playhead < getStartTime();
cursor_position_in_buffer ++;
updatePlayhead();
if (playhead >= getStartTime() && playhead_was_negative)
{
fillBuffer();
}
int channels = (sound != NULL ? sound->getChannels() : MAX_CHANNELS);
if (buffer_actual_size > 0)
{
if (cursor_position_in_buffer >= buffer_allocated_size)
{
fillBuffer();
}
for (int i = 0; i < channels; i++)
{
read_buffer[i] = buffer[i][cursor_position_in_buffer];
}
}
else
{
for (int i = 0; i < channels; i++)
{
read_buffer[i] = 0.f;
}
}
return read_buffer;
}
void
EventUnquantizeCommand::modifySegment()
{
Segment &segment = getSegment();
if (m_selection) {
m_quantizer->unquantize(m_selection);
} else {
m_quantizer->unquantize(&segment,
segment.findTime(getStartTime()),
segment.findTime(getEndTime()));
}
}
void CConfigInfo::processorCfgValue()
{
getHistoryDataDirectory();
getSaveDataDirectoryBAR();
getSaveDataDirectoryTIK();
getDbType();
getStartTime();
getLoadMaxFilesSize();
getAutoRunType();
getAutoRunTime();
//logInfo();
}
uint32
UserRight::printValue( char* target,
UserConstants::UserRightField field ) const
{
switch ( field ) {
case UserConstants::USER_RIGHT_ID :
case UserConstants::USER_RIGHT_USERUIN :
mc2log << error << "UserRight::printValue asked to print "
<< "ID or userUIN, not supported." << endl;
MC2_ASSERT( false );
break;
case UserConstants::USER_RIGHT_ADD_TIME :
sprintf( target, "%u", getAddTime() );
break;
case UserConstants::USER_RIGHT_TYPE :
// Needs to be signed for MySQL to keep all bits.
sprintf( target, "%lld",
static_cast<int64> ( getUserRightType().getAsInt() ) );
break;
case UserConstants::USER_RIGHT_REGION_ID :
sprintf( target, "%u", getRegionID() );
break;
case UserConstants::USER_RIGHT_START_TIME :
sprintf( target, "%u", getStartTime() );
break;
case UserConstants::USER_RIGHT_END_TIME :
sprintf( target, "%u", getEndTime() );
break;
case UserConstants::USER_RIGHT_DELETED :
sprintf( target, "%hu", isDeleted() );
break;
case UserConstants::USER_RIGHT_ORIGIN :
strcat( target, "'" );
sqlString( target + 1, getOrigin() );
strcat( target, "'" );
break;
default:
mc2log << error << "UserRight::printValue unknown "
<< "fieldType: " << (int)field << endl;
break;
}
return strlen( target );
}
//-----------------------------------------------------------------------------
//
// VFadeEvent::onTrigger( pTime, pDelta );
//
// Start the fade sequence if a valid fade control can be found.
//
//-----------------------------------------------------------------------------
void VFadeEvent::onTrigger( const S32 &pTime, const S32 &pDelta )
{
Parent::onTrigger( pTime, pDelta );
// Fetch GUI Control.
VFadeControl *fadeControl;
if ( !Sim::findObject( "VFadeControlGUI", fadeControl ) )
{
// Invalid.
return;
}
// Start Fade.
fadeControl->start( getFadeType(), mDuration );
// Set Elapsed Time.
fadeControl->mElapsedTime = mAbs( pTime - getStartTime() );
}
