114 lines
4.1 KiB
JavaScript
114 lines
4.1 KiB
JavaScript
'use strict';
|
|
|
|
const TestStates = Object.freeze({
|
|
"ShouldSucceedPauseScheduleRAF": 1,
|
|
"ShouldFailResumeScheduleRAF": 2,
|
|
"ShouldSucceedTestDone": 3,
|
|
});
|
|
|
|
const framesToWait = 10;
|
|
const pauseResumeTestFunction = function(session, controller, t, sessionObjects) {
|
|
const isCpuOptimized = session.depthUsage === 'cpu-optimized';
|
|
let state = TestStates.ShouldSucceedPauseScheduleRAF;
|
|
|
|
return session.requestReferenceSpace('viewer').then((viewerSpace) => {
|
|
let done = false;
|
|
|
|
const glBinding = new XRWebGLBinding(session, sessionObjects.gl);
|
|
|
|
let stepFrameCount = 0;
|
|
let advanceState = false;
|
|
|
|
const rafCb = function(time, frame) {
|
|
const pose = frame.getViewerPose(viewerSpace);
|
|
stepFrameCount++;
|
|
for(const view of pose.views) {
|
|
const depthInformation = isCpuOptimized ? frame.getDepthInformation(view)
|
|
: glBinding.getDepthInformation(view);
|
|
|
|
if (state == TestStates.ShouldSucceedPauseScheduleRAF
|
|
|| state == TestStates.ShouldSucceedTestDone) {
|
|
t.step(() => {
|
|
assert_true(session.depthActive);
|
|
});
|
|
// We have no guarantees about when data should start returning,
|
|
// so we need to potentially wait a few frames.
|
|
|
|
// Final chance. If we haven't advanced the state by now, fail the
|
|
// test if it doesn't pass this time.
|
|
if (stepFrameCount >= framesToWait) {
|
|
t.step(() => {
|
|
assert_not_equals(depthInformation, null);
|
|
});
|
|
}
|
|
|
|
// Either we have data, or we've waited long enough to keep moving.
|
|
if (depthInformation != null || stepFrameCount >= framesToWait) {
|
|
advanceState = true;
|
|
}
|
|
} else {
|
|
// Depth should stop being available immediately.
|
|
t.step(() => {
|
|
assert_false(session.depthActive);
|
|
assert_equals(depthInformation, null);
|
|
});
|
|
advanceState = true;
|
|
}
|
|
}
|
|
|
|
switch(state) {
|
|
case TestStates.ShouldSucceedPauseScheduleRAF:
|
|
if (advanceState) {
|
|
session.pauseDepthSensing();
|
|
for(const view of pose.views) {
|
|
const newDepthInformation = isCpuOptimized ? frame.getDepthInformation(view)
|
|
: glBinding.getDepthInformation(view);
|
|
t.step(()=> {
|
|
// depthActive state should update and stop returning depth info
|
|
// immediately.
|
|
assert_false(session.depthActive);
|
|
assert_equals(newDepthInformation, null);
|
|
});
|
|
}
|
|
state = TestStates.ShouldFailResumeScheduleRAF;
|
|
stepFrameCount = 0;
|
|
advanceState = false;
|
|
}
|
|
session.requestAnimationFrame(rafCb);
|
|
break;
|
|
case TestStates.ShouldFailResumeScheduleRAF:
|
|
if (advanceState) {
|
|
session.resumeDepthSensing();
|
|
// In pausing depth sensing, any controller data may have been
|
|
// thrown away since the UA can "tear down" any depth controller.
|
|
// So attempt to repopulate the data once we've resumed it.
|
|
controller.setDepthSensingData(DEPTH_SENSING_DATA);
|
|
t.step(()=> {
|
|
// While depth data may not return for a few frames, depthActive
|
|
// should be updated immediately.
|
|
assert_true(session.depthActive);
|
|
});
|
|
state = TestStates.ShouldSucceedTestDone;
|
|
stepFrameCount = 0;
|
|
advanceState = false;
|
|
}
|
|
session.requestAnimationFrame(rafCb);
|
|
break;
|
|
case TestStates.ShouldSucceedTestDone:
|
|
// If we are advancing the state, we can stop pumping the rAF, but
|
|
// if we're still waiting for data to come back we need to keep it
|
|
// going.
|
|
if (advanceState) {
|
|
done = true;
|
|
} else {
|
|
session.requestAnimationFrame(rafCb);
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
session.requestAnimationFrame(rafCb);
|
|
|
|
return t.step_wait(() => done);
|
|
});
|
|
};
|