time.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2012 Sifteo, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/macros.h>
#include <sifteo/abi.h>

namespace Sifteo {

class SystemTime;


class TimeDelta {
public:

    TimeDelta(float sec) : mMilli(sec * 1e3) {}
    TimeDelta(double sec) : mMilli(sec * 1e3) {}

    static TimeDelta hz(float h) {
        return TimeDelta(1.0f / h);
    }

    static TimeDelta fromMillisec(int32_t m) {
        return TimeDelta(m);
    }

    int32_t milliseconds() const {
        return mMilli;
    }

    int64_t nanoseconds() const {
        return mMilli * (int64_t)1000000;
    }

    float seconds() const {
        return mMilli * 1e-3;
    }
    
    unsigned frames(TimeDelta duration) const {
        ASSERT(!isNegative());
        ASSERT(duration.isPositive());
        return mMilli / duration.mMilli;
    }

    unsigned pullFrames(TimeDelta duration) {
        unsigned f = frames(duration);
        // Could be "*this -= duration * f", but operator* isn't defined yet.
        mMilli -= duration.mMilli * f;
        return f;
    } 
    
    bool isNegative() const {
        return mMilli < 0;
    }
    
    bool isPositive() const {
        return mMilli > 0;
    }

    operator float() const { return seconds(); }
    operator double() const { return seconds(); }
    // Accumulate time from another TimeDelta
    TimeDelta operator+= (TimeDelta b) { mMilli += b.mMilli; return *this; }
    // Accumulate negative time from another TimeDelta
    TimeDelta operator-= (TimeDelta b) { mMilli -= b.mMilli; return *this; }

private:
    friend class SystemTime;

    TimeDelta(int32_t m) : mMilli(m) {}
    int32_t mMilli;
};

inline bool operator== (TimeDelta a, TimeDelta b) { return a.milliseconds() == b.milliseconds(); }
inline bool operator!= (TimeDelta a, TimeDelta b) { return a.milliseconds() != b.milliseconds(); }
inline bool operator<  (TimeDelta a, TimeDelta b) { return a.milliseconds() <  b.milliseconds(); }
inline bool operator>  (TimeDelta a, TimeDelta b) { return a.milliseconds() >  b.milliseconds(); }
inline bool operator<= (TimeDelta a, TimeDelta b) { return a.milliseconds() <= b.milliseconds(); }
inline bool operator>= (TimeDelta a, TimeDelta b) { return a.milliseconds() >= b.milliseconds(); }

inline bool operator== (TimeDelta a, float b) { return a.milliseconds() == TimeDelta(b).milliseconds(); }
inline bool operator!= (TimeDelta a, float b) { return a.milliseconds() != TimeDelta(b).milliseconds(); }
inline bool operator<  (TimeDelta a, float b) { return a.milliseconds() <  TimeDelta(b).milliseconds(); }
inline bool operator>  (TimeDelta a, float b) { return a.milliseconds() >  TimeDelta(b).milliseconds(); }
inline bool operator<= (TimeDelta a, float b) { return a.milliseconds() <= TimeDelta(b).milliseconds(); }
inline bool operator>= (TimeDelta a, float b) { return a.milliseconds() >= TimeDelta(b).milliseconds(); }

inline bool operator== (float a, TimeDelta b) { return TimeDelta(a).milliseconds() == b.milliseconds(); }
inline bool operator!= (float a, TimeDelta b) { return TimeDelta(a).milliseconds() != b.milliseconds(); }
inline bool operator<  (float a, TimeDelta b) { return TimeDelta(a).milliseconds() <  b.milliseconds(); }
inline bool operator>  (float a, TimeDelta b) { return TimeDelta(a).milliseconds() >  b.milliseconds(); }
inline bool operator<= (float a, TimeDelta b) { return TimeDelta(a).milliseconds() <= b.milliseconds(); }
inline bool operator>= (float a, TimeDelta b) { return TimeDelta(a).milliseconds() >= b.milliseconds(); }

inline bool operator== (TimeDelta a, double b) { return a.milliseconds() == TimeDelta(b).milliseconds(); }
inline bool operator!= (TimeDelta a, double b) { return a.milliseconds() != TimeDelta(b).milliseconds(); }
inline bool operator<  (TimeDelta a, double b) { return a.milliseconds() <  TimeDelta(b).milliseconds(); }
inline bool operator>  (TimeDelta a, double b) { return a.milliseconds() >  TimeDelta(b).milliseconds(); }
inline bool operator<= (TimeDelta a, double b) { return a.milliseconds() <= TimeDelta(b).milliseconds(); }
inline bool operator>= (TimeDelta a, double b) { return a.milliseconds() >= TimeDelta(b).milliseconds(); }

inline bool operator== (double a, TimeDelta b) { return TimeDelta(a).milliseconds() == b.milliseconds(); }
inline bool operator!= (double a, TimeDelta b) { return TimeDelta(a).milliseconds() != b.milliseconds(); }
inline bool operator<  (double a, TimeDelta b) { return TimeDelta(a).milliseconds() <  b.milliseconds(); }
inline bool operator>  (double a, TimeDelta b) { return TimeDelta(a).milliseconds() >  b.milliseconds(); }
inline bool operator<= (double a, TimeDelta b) { return TimeDelta(a).milliseconds() <= b.milliseconds(); }
inline bool operator>= (double a, TimeDelta b) { return TimeDelta(a).milliseconds() >= b.milliseconds(); }

inline TimeDelta operator+ (TimeDelta a, TimeDelta b) { return TimeDelta::fromMillisec(a.milliseconds() + b.milliseconds()); }
inline TimeDelta operator- (TimeDelta a, TimeDelta b) { return TimeDelta::fromMillisec(a.milliseconds() - b.milliseconds()); }

inline TimeDelta operator* (TimeDelta a, float b)    { return TimeDelta::fromMillisec(a.milliseconds() * b); }
inline TimeDelta operator* (TimeDelta a, double b)   { return TimeDelta::fromMillisec(a.milliseconds() * b); }
inline TimeDelta operator* (TimeDelta a, int b)      { return TimeDelta::fromMillisec(a.milliseconds() * b); }
inline TimeDelta operator* (TimeDelta a, unsigned b) { return TimeDelta::fromMillisec(a.milliseconds() * b); }

inline TimeDelta operator* (float a,    TimeDelta b) { return TimeDelta::fromMillisec(b.milliseconds() * a); }
inline TimeDelta operator* (double a,   TimeDelta b) { return TimeDelta::fromMillisec(b.milliseconds() * a); }
inline TimeDelta operator* (int a,      TimeDelta b) { return TimeDelta::fromMillisec(b.milliseconds() * a); }
inline TimeDelta operator* (unsigned a, TimeDelta b) { return TimeDelta::fromMillisec(b.milliseconds() * a); }

inline float operator+= (float &a, TimeDelta b) { return a += b.seconds(); }
inline float operator-= (float &a, TimeDelta b) { return a -= b.seconds(); }


class SystemTime {
public:
    SystemTime() : mTicks(0) {}

    static SystemTime now() {
        return SystemTime(_SYS_ticks_ns());
    }
    
    bool isValid() const {
        return mTicks != 0;
    }

    bool inFuture() const {
        return mTicks > now().mTicks;
    }

    bool inPast() const {
        return mTicks < now().mTicks;
    }

    uint64_t uptimeNS() const {
        ASSERT(isValid());
        return mTicks;
    }

    uint64_t uptimeUS() const {
        ASSERT(isValid());
        return mTicks / (uint64_t)1000;
    }

    uint64_t uptimeMS() const {
        ASSERT(isValid());
        return mTicks / (uint64_t)1000000;
    }

    double uptime() const {
        ASSERT(isValid());
        return mTicks * 1e-9;
    }

    TimeDelta cycleDelta(TimeDelta period) const {
        ASSERT(period.milliseconds() > 0);
        return TimeDelta((int32_t)(uptimeMS() % (uint64_t)period.milliseconds()));
    }

    float cyclePhase(TimeDelta period) const {
        return cycleDelta(period).milliseconds() / (float) period.milliseconds();
    }

    unsigned cycleFrame(TimeDelta period, unsigned frames) const {
        return cycleDelta(period).milliseconds() * frames / period.milliseconds();
    }

    TimeDelta operator- (SystemTime b) const {
        int64_t diff = uptimeNS() - b.uptimeNS();
        return TimeDelta((int32_t)(diff / 1000000));
    }

    SystemTime &operator+= (const TimeDelta &rhs) { mTicks += rhs.nanoseconds(); return *this; }
    SystemTime &operator-= (const TimeDelta &rhs) { mTicks -= rhs.nanoseconds(); return *this; }

    SystemTime operator+ (TimeDelta b) const { return SystemTime(mTicks + b.nanoseconds()); }
    SystemTime operator- (TimeDelta b) const { return SystemTime(mTicks - b.nanoseconds()); }

private:
    SystemTime(uint64_t t) : mTicks(t) {}
    uint64_t mTicks;
};

inline bool operator== (SystemTime a, SystemTime b) { return a.uptimeNS() == b.uptimeNS(); }
inline bool operator!= (SystemTime a, SystemTime b) { return a.uptimeNS() != b.uptimeNS(); }
inline bool operator<  (SystemTime a, SystemTime b) { return a.uptimeNS() <  b.uptimeNS(); }
inline bool operator>  (SystemTime a, SystemTime b) { return a.uptimeNS() >  b.uptimeNS(); }
inline bool operator<= (SystemTime a, SystemTime b) { return a.uptimeNS() <= b.uptimeNS(); }
inline bool operator>= (SystemTime a, SystemTime b) { return a.uptimeNS() >= b.uptimeNS(); }

inline SystemTime operator+ (TimeDelta a, SystemTime b) { return b + a; }
inline SystemTime operator- (TimeDelta a, SystemTime b) { return b - a; }


class TimeStep {
public:
    TimeStep() : mPrevTime(), mDelta(0.0) {}

    TimeDelta delta() const {
        return mDelta;
    }

    SystemTime end() const {
        ASSERT(mPrevTime.isValid());
        return mPrevTime;
    }

    SystemTime begin() const {
        ASSERT(mDelta != TimeDelta(0.0));
        ASSERT(mPrevTime.isValid());
        return mPrevTime - mDelta;
    }

    void next() {
        SystemTime now = SystemTime::now();

        if (mPrevTime.isValid()) {
            // This subtraction loses sub-millisecond precision.
            // We feed that error back into mPrevTime, so that it will
            // be corrected instead of amplified.

            mDelta = now - mPrevTime;
            mPrevTime += mDelta;
            
        } else {
            // Beginning of the very first timestep
            mPrevTime = now;
        }
    }

private:
    SystemTime mPrevTime;
    TimeDelta mDelta;
};


class TimeTicker {
public:
    TimeTicker() : mRemainder(0.0f), mPeriod(0.0) {}
    TimeTicker(float hz) : mRemainder(0.0f), mPeriod(TimeDelta::hz(hz)) {}

    void setPeriod(TimeDelta period) {
        mPeriod = period;
    }

    void setRate(float hz) {
        mPeriod = TimeDelta::hz(hz);
    }

    unsigned tick(TimeDelta dt) {
        ASSERT(!dt.isNegative());
        mRemainder += dt;
        return mRemainder.pullFrames(mPeriod);
    }
    
    TimeDelta getPeriod() const {
        return mPeriod;
    }
    
private:
    TimeDelta mRemainder;
    TimeDelta mPeriod;
};

}   // namespace Sifteo