mirror/openmw-tes3mp
1
0
Fork 1
mirror of https://github.com/TES3MP/openmw-tes3mp.git synced 2025-02-15 16:09:40 +00:00
Code Issues Releases Wiki Activity

some cleanup

Browse source
This commit is contained in:
Mads Buvik Sandvei 2020-02-02 17:37:43 +01:00
parent 14039e5e25
commit e948b686e8
6 changed files with 12 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
apps/openmw/mwinput/inputmanagerimp.cpp
View file

@ -752,6 +752,8 @@ namespace MWInput
}
}
}
#ifndef USE_OPENXR
if (actionIsActive(A_MoveForward) ||
actionIsActive(A_MoveBackward) ||
actionIsActive(A_MoveLeft) ||
@ -766,6 +768,7 @@ namespace MWInput
} else {
updateIdleTime(dt);
}
#endif
}
else
mGamepadZoom = 0;

77
apps/openmw/mwvr/openxrsession.cpp
View file

@ -26,15 +26,11 @@ namespace MWVR
OpenXRSession::OpenXRSession(
osg::ref_ptr<OpenXRManager> XR)
: mXR(XR)
, mFrameEndTimePoint(clock::now())
, mFrameBeginTimePoint(mFrameEndTimePoint)
{
mXRThread = std::thread([this] {run(); });
}
OpenXRSession::~OpenXRSession()
{
mShouldQuit = true;
}
void OpenXRSession::setLayer(
@ -51,55 +47,15 @@ namespace MWVR
static int wat = 0;
if (!mXR->sessionRunning())
return;
if (!mShouldRenderLayers)
{
if (!mPredictionsReady)
return;
}
//if (wat++ % 100 != 0)
// return;
//std::unique_lock<std::mutex> renderLock(mRenderMutex);
//timer.checkpoint("Mutex");
for (auto layer : mLayerStack.layerObjects())
layer->swapBuffers(gc);
mFrameEndTimePoint = clock::now();
auto nanoseconds_elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(mFrameEndTimePoint - mFrameBeginTimePoint);
auto milliseconds_elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(nanoseconds_elapsed);
mRenderTimes.push_back(nanoseconds_elapsed.count());
Log(Debug::Verbose) << "Render time: " << milliseconds_elapsed.count() << "ms";
//mShouldRenderLayers = true;
timer.checkpoint("Rendered");
mXR->endFrame(predictedDisplayTime(), &mLayerStack);
Log(Debug::Verbose) << "mFrameEndTimePoint: " << mFrameEndTimePoint.time_since_epoch().count() / 1000000;
Log(Debug::Verbose) << "mFrameBeginTimePoint: " << mFrameBeginTimePoint.time_since_epoch().count() / 1000000;
Log(Debug::Verbose) << "mPredictedDisplayTimeRealTime: " << mPredictedDisplayTimeRealTime.time_since_epoch().count() / 1000000;
Log(Debug::Verbose) << "mPredictedTime: " << predictedDisplayTime() / 1000000;
Log(Debug::Verbose) << "mXrDisplayTime: " << mXR->impl().frameState().predictedDisplayTime / 1000000;
//mShouldRenderLayers = false;
mFrameBeginTimePoint = clock::now();
//mRenderTimes.push_front(std::chrono::duration_cast<std::chrono::nanoseconds>(mFrameEndTimePoint - mFrameBeginTimePoint).count());
//if(mRenderTimes.size() > 33) mRenderTimes.pop_back();
//if (mPredictedPeriod == 0)
//{
// mPredictedPeriod = milliseconds_elapsed;
// mPredictedPeriods = 1;
//}
//else
//{
// double periodDevianceMagnitude = static_cast<double>(std::max(milliseconds_elapsed, mPredictedPeriod)) / static_cast<double>(std::min(milliseconds_elapsed, mPredictedPeriod));
// double periodStability = std::pow(periodDevianceMagnitude, -2.);
// mPredictedPeriod = (1. - periodStability) * mPredictedPeriod + (periodStability)*milliseconds_elapsed;
//}
}
void OpenXRSession::run()
{
mXR->endFrame(mXR->impl().frameState().predictedDisplayTime, &mLayerStack);
}
void OpenXRSession::waitFrame()
@ -107,35 +63,17 @@ namespace MWVR
// For now it seems we must just accept crap performance from the rendering loop
// Since Oculus' implementation of waitFrame() does not even attempt to reflect real
// render time and just incurs a huge useless delay.
Log(Debug::Verbose) << "OpenXRSesssion::beginframe";
Timer timer("OpenXRSession::beginFrame");
Timer timer("OpenXRSession::waitFrame");
mXR->waitFrame();
timer.checkpoint("waitFrame");
predictNext(0);
mShouldRenderLayers = true;
mPredictionsReady = true;
}
void OpenXRSession::predictNext(int extraPeriods)
{
int64_t sum = 0;
while (mRenderTimes.size() > 10)
mRenderTimes.pop_front();
for (unsigned i = 0; i < mRenderTimes.size(); i++)
{
sum += mRenderTimes[i] / mXR->impl().frameState().predictedDisplayPeriod;
}
int64_t average = sum / std::max((int64_t)mRenderTimes.size(), (int64_t)1);
mPredictedPeriods = std::max(average, (int64_t)0) + extraPeriods;
Log(Debug::Verbose) << "Periods: " << mPredictedPeriods;
int64_t future = (mPredictedPeriods)*mXR->impl().frameState().predictedDisplayPeriod;
mPredictedDisplayTime = mXR->impl().frameState().predictedDisplayTime + future;
mPredictedDisplayTimeRealTime = mFrameBeginTimePoint + nanoseconds(future + mXR->impl().frameState().predictedDisplayPeriod);
auto mPredictedDisplayTime = mXR->impl().frameState().predictedDisplayTime;
// Update pose predictions
mPredictedPoses.head[(int)TrackedSpace::STAGE] = mXR->impl().getPredictedLimbPose(mPredictedDisplayTime, TrackedLimb::HEAD, TrackedSpace::STAGE);
@ -150,9 +88,6 @@ namespace MWVR
mPredictedPoses.eye[(int)Chirality::LEFT_HAND][(int)TrackedSpace::VIEW] = fromXR(hmdViews[(int)Chirality::LEFT_HAND].pose);
mPredictedPoses.eye[(int)Chirality::RIGHT_HAND][(int)TrackedSpace::STAGE] = fromXR(stageViews[(int)Chirality::RIGHT_HAND].pose);
mPredictedPoses.eye[(int)Chirality::RIGHT_HAND][(int)TrackedSpace::VIEW] = fromXR(hmdViews[(int)Chirality::RIGHT_HAND].pose);
//std::unique_lock<std::mutex> lock(mSyncMutex);
//mSync.notify_all();
}
}

24
apps/openmw/mwvr/openxrsession.hpp
View file

@ -37,41 +37,21 @@ namespace MWVR
void setLayer(OpenXRLayerStack::Layer layerType, OpenXRLayer* layer);
void swapBuffers(osg::GraphicsContext* gc);
void run();
PoseSets& predictedPoses() { return mPredictedPoses; };
//! Call before rendering to update predictions
//! Call before updating poses
void waitFrame();
//! Most recent prediction for display time of next frame.
int64_t predictedDisplayTime() { return mPredictedDisplayTime; };
//! Update predictions
void predictNext(int extraPeriods);
OpenXRLayerStack mLayerStack{};
osg::ref_ptr<OpenXRManager> mXR;
std::thread mXRThread;
bool mShouldQuit = false;
PoseSets mPredictedPoses{};
int64_t mPredictedDisplayTime{ 0 };
time_point mPredictedDisplayTimeRealTime{ nanoseconds(0) };
std::deque<int64_t> mRenderTimes;
int64_t mPredictedPeriods{ 0 };
double mFps{ 0. };
time_point mFrameEndTimePoint;
time_point mFrameBeginTimePoint;
bool mNeedSync = true;
std::condition_variable mSync{};
std::mutex mSyncMutex{};
bool mShouldRenderLayers = false;
std::condition_variable mRenderSignal{};
std::mutex mRenderMutex{};
bool mPredictionsReady;
};
}

12
apps/openmw/mwvr/openxrswapchain.cpp
View file

@ -137,20 +137,8 @@ namespace MWVR {
waitInfo.timeout = XR_INFINITE_DURATION;
CHECK_XRCMD(xrWaitSwapchainImage(mSwapchain, &waitInfo));
// Oculus bug: Either the swapchain image index is off by 1 or xrEndFrame() choses the wrong swapchain image.
//mRenderBuffer->endFrame(gc, mSwapchainImageBuffers[0].image);
//mRenderBuffer->endFrame(gc, mSwapchainImageBuffers[1].image);
//mRenderBuffer->endFrame(gc, mSwapchainImageBuffers[2].image);
// mRenderBuffer->endFrame(gc, mSwapchainImageBuffers[(swapchainImageIndex + 1) % 3].image);
mRenderBuffer->endFrame(gc, mSwapchainImageBuffers[swapchainImageIndex].image);
//Log(Debug::Verbose) << "swapchainImageIndex: " << swapchainImageIndex;
//Log(Debug::Verbose) << "swapchainImage: " << mSwapchainImageBuffers[swapchainImageIndex].image;
static int asdf = 0;
//Log(Debug::Verbose) << "OpenXRSwapchainImpl ENDFRAME[ " << (asdf++ / 3) << "]";
swapCount = asdf / 3;
XrSwapchainImageReleaseInfo releaseInfo{ XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
CHECK_XRCMD(xrReleaseSwapchainImage(mSwapchain, &releaseInfo));
return swapchainImageIndex;

2
apps/openmw/mwvr/openxrswapchain.hpp
View file

@ -10,8 +10,6 @@ namespace MWVR
{
class OpenXRSwapchainImpl;
extern int swapCount;
class OpenXRSwapchain
{
public:

2
apps/openmw/mwvr/openxrviewer.cpp
View file

@ -199,7 +199,7 @@ namespace MWVR
timer.checkpoint("Poses");
// TODO: Keep track of these in the session too.
auto stageViews = mXR->impl().getPredictedViews(mXRSession->predictedDisplayTime(), TrackedSpace::STAGE);
auto stageViews = mXR->impl().getPredictedViews(mXR->impl().frameState().predictedDisplayTime, TrackedSpace::STAGE);
mCompositionLayerProjectionViews[0].fov = stageViews[0].fov;
mCompositionLayerProjectionViews[1].fov = stageViews[1].fov;
timer.checkpoint("Fovs");