1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/************************************************************************************
PublicHeader: OVR
Filename : OVR_Timer.h
Content : Provides static functions for precise timing
Created : September 19, 2012
Notes :
Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
Licensed under the Oculus Master SDK License Version 1.0 (the "License");
you may not use the Oculus VR Rift SDK except in compliance with the License,
which is provided at the time of installation or download, or which
otherwise accompanies this software in either electronic or hard copy form.
You may obtain a copy of the License at
https://developer.oculus.com/licenses/oculusmastersdk-1.0
Unless required by applicable law or agreed to in writing, the Oculus VR SDK
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
************************************************************************************/
#ifndef OVR_Timer_h
#define OVR_Timer_h
#include <chrono>
#include "OVR_Types.h"
namespace OVR {
//-----------------------------------------------------------------------------------
// ***** Timer
// Timer class defines a family of static functions used for application
// timing and profiling.
class Timer {
public:
enum {
MsPerSecond = 1000, // Milliseconds in one second.
MksPerSecond = 1000 * 1000, // Microseconds in one second.
NanosPerSecond = 1000 * 1000 * 1000, // Nanoseconds in one second.
};
// ***** Timing APIs for Application
// These APIs should be used to guide animation and other program functions
// that require precision.
// Returns global high-resolution application timer in seconds.
static double OVR_STDCALL GetSeconds();
// This may return a recorded time if Replaying a recording
static double OVR_STDCALL GetVirtualSeconds();
// Returns time in Nanoseconds, using highest possible system resolution.
static uint64_t OVR_STDCALL GetTicksNanos();
// This may return a recorded time if Replaying a recording
static uint64_t OVR_STDCALL GetVirtualTicksNanos();
#ifdef OVR_OS_MS
static double OVR_STDCALL GetPerfFrequencyInverse();
static double OVR_STDCALL GetPerfFrequency();
#endif
// Kept for compatibility.
// Returns ticks in milliseconds, as a 32-bit number. May wrap around every 49.2 days.
// Use either time difference of two values of GetTicks to avoid wrap-around.
static uint32_t OVR_STDCALL GetTicksMs() {
return uint32_t(GetTicksNanos() / 1000000);
}
// This may return a recorded time if Replaying a recording
static uint32_t OVR_STDCALL GetVirtualTicksMs() {
return uint32_t(GetVirtualTicksNanos() / 1000000);
}
// for recorded data playback
static void SetVirtualSeconds(double virtualSeconds, bool enable = true) {
VirtualSeconds = virtualSeconds;
useVirtualSeconds = enable;
}
private:
friend class System;
// System called during program startup/shutdown.
static void initializeTimerSystem();
static void shutdownTimerSystem();
// for recorded data playback.
static double VirtualSeconds;
static bool useVirtualSeconds;
#if defined(OVR_OS_ANDROID)
// Android-specific data
#elif defined(OVR_OS_MS)
// Microsoft-specific data
#endif
}; // class Timer
//-----------------------------------------------------------------------------
// CountdownTimer
//
// Acts like a kitchen timer. Implemented using std::chrono::steady_clock.
// Input resolution is in milliseconds.
// Under the hood, it uses the native resolution of a std::chrono::steady_clock.
//
// Exmample usage:
// CountdownTimer timer(5000, true);
//
// if(timer.IsTimeUp())
// {
// DoSomething();
// timer.Restart();
// }
//
struct CountdownTimer {
std::chrono::steady_clock::time_point DoneTime;
std::chrono::steady_clock::duration CountdownTime;
CountdownTimer(size_t countdownTimeMs = 0, bool start = false);
std::chrono::steady_clock::time_point CurrentTime() const;
bool IsTimeUp() const;
void Restart();
void Restart(size_t countdownTimeMs);
};
} // namespace OVR
// This version of ovr_GetTimeInSeconds should be called internally with Oculus service,
// as public APIs are not available.
inline double ovr_GetTimeInSeconds_Internal() {
return OVR::Timer::GetSeconds();
}
#endif
|
