Skip to content

GitLab

T
tangled
Commit 129ebfdf authored by bsheedy's avatar bsheedy Committed by Commit Bot
Browse files
Options

Rename fake_openvr_impl_api variables 

Renames the variables in fake_openvr_impl_api.cc to be consistent with
Chromium style guidelines instead of using the original names from
openvr.h.

Also drive-by fixes a timeout that was flakily getting hit.

Bug: 892717
Change-Id: Id6f25826df26212be5e0fae659cc4715c459f093
Reviewed-on: https://chromium-review.googlesource.com/c/1312195Reviewed-by: default avatarBill Orr <billorr@chromium.org>
Commit-Queue: Brian Sheedy <bsheedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#604677}
parent 92d5660c
Hide whitespace changes
Inline Side-by-side
Showing with 194 additions and 194 deletions
chrome/browser/vr/webxr_vr_pixel_browser_test.cc
View file @ 129ebfdf
......@@ -64,7 +64,7 @@ void TestPresentationPixelsImpl(WebXrVrBrowserTestBase* t,
// Wait for JavaScript to submit at least one frame.
EXPECT_TRUE(
t->PollJavaScriptBoolean("hasPresentedFrame", t->kPollTimeoutShort))
t->PollJavaScriptBoolean("hasPresentedFrame", t->kPollTimeoutMedium))
<< "No frame submitted";
// Tell JavaScript that it is done with the test.
......
device/vr/openvr/test/fake_openvr_impl_api.cc
View file @ 129ebfdf
......@@ -20,30 +20,30 @@ namespace vr {
class TestVRSystem : public IVRSystem {
public:
void GetRecommendedRenderTargetSize(uint32_t* pnWidth,
uint32_t* pnHeight) override;
HmdMatrix44_t GetProjectionMatrix(EVREye eEye,
float fNearZ,
float fFarZ) override {
void GetRecommendedRenderTargetSize(uint32_t* width,
uint32_t* height) override;
HmdMatrix44_t GetProjectionMatrix(EVREye eye,
float near_z,
float far_z) override {
NOTIMPLEMENTED();
return {};
};
void GetProjectionRaw(EVREye eEye,
float* pfLeft,
float* pfRight,
float* pfTop,
float* pfBottom) override;
void GetProjectionRaw(EVREye eye,
float* left,
float* right,
float* top,
float* bottom) override;
bool ComputeDistortion(
EVREye eEye,
float fU,
float fV,
DistortionCoordinates_t* pDistortionCoordinates) override {
EVREye eye,
float u,
float v,
DistortionCoordinates_t* distortion_coordinates) override {
NOTIMPLEMENTED();
return false;
}
HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) override;
bool GetTimeSinceLastVsync(float* pfSecondsSinceLastVsync,
uint64_t* pulFrameCounter) override {
HmdMatrix34_t GetEyeToHeadTransform(EVREye eye) override;
bool GetTimeSinceLastVsync(float* seconds_since_last_vsync,
uint64_t* frame_counter) override {
NOTIMPLEMENTED();
return false;
}
......@@ -51,21 +51,21 @@ class TestVRSystem : public IVRSystem {
NOTIMPLEMENTED();
return 0;
}
void GetDXGIOutputInfo(int32_t* pnAdapterIndex) override;
void GetDXGIOutputInfo(int32_t* adapter_index) override;
bool IsDisplayOnDesktop() override {
NOTIMPLEMENTED();
return false;
}
bool SetDisplayVisibility(bool bIsVisibleOnDesktop) override {
bool SetDisplayVisibility(bool is_visible_on_desktop) override {
NOTIMPLEMENTED();
return false;
}
void GetDeviceToAbsoluteTrackingPose(
ETrackingUniverseOrigin eOrigin,
float fPredictedSecondsToPhotonsFromNow,
VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount)
TrackedDevicePose_t* pTrackedDevicePoseArray,
uint32_t unTrackedDevicePoseArrayCount) override;
ETrackingUniverseOrigin origin,
float predicted_seconds_to_photons_from_now,
VR_ARRAY_COUNT(tracked_device_pose_array_count)
TrackedDevicePose_t* tracked_device_pose_array,
uint32_t tracked_device_pose_array_count) override;
void ResetSeatedZeroPose() override { NOTIMPLEMENTED(); }
HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() override;
HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() override {
......@@ -73,88 +73,89 @@ class TestVRSystem : public IVRSystem {
return {};
}
uint32_t GetSortedTrackedDeviceIndicesOfClass(
ETrackedDeviceClass eTrackedDeviceClass,
VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount)
TrackedDeviceIndex_t* punTrackedDeviceIndexArray,
uint32_t unTrackedDeviceIndexArrayCount,
ETrackedDeviceClass tracked_device_class,
VR_ARRAY_COUNT(tracked_device_index_array_count)
TrackedDeviceIndex_t* tracked_device_index_array,
uint32_t tracked_device_index_array_count,
TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex =
k_unTrackedDeviceIndex_Hmd) override {
NOTIMPLEMENTED();
return 0;
}
EDeviceActivityLevel GetTrackedDeviceActivityLevel(
TrackedDeviceIndex_t unDeviceId) override {
TrackedDeviceIndex_t device_id) override {
NOTIMPLEMENTED();
return k_EDeviceActivityLevel_Unknown;
}
void ApplyTransform(TrackedDevicePose_t* pOutputPose,
const TrackedDevicePose_t* pTrackedDevicePose,
const HmdMatrix34_t* pTransform) override {
void ApplyTransform(TrackedDevicePose_t* output_pose,
const TrackedDevicePose_t* tracked_device_pose,
const HmdMatrix34_t* transform) override {
NOTIMPLEMENTED();
}
TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole(
ETrackedControllerRole unDeviceType) override {
ETrackedControllerRole device_type) override {
NOTIMPLEMENTED();
return 0;
}
ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(
TrackedDeviceIndex_t unDeviceIndex) override;
TrackedDeviceIndex_t device_index) override;
ETrackedDeviceClass GetTrackedDeviceClass(
TrackedDeviceIndex_t unDeviceIndex) override;
bool IsTrackedDeviceConnected(TrackedDeviceIndex_t unDeviceIndex) override {
TrackedDeviceIndex_t device_index) override;
bool IsTrackedDeviceConnected(TrackedDeviceIndex_t device_index) override {
NOTIMPLEMENTED();
return false;
}
bool GetBoolTrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError = 0L) override {
ETrackedPropertyError* error = 0L) override {
NOTIMPLEMENTED();
return false;
}
float GetFloatTrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError = 0L) override;
ETrackedPropertyError* error = 0L) override;
int32_t GetInt32TrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError = 0L) override;
ETrackedPropertyError* error = 0L) override;
uint64_t GetUint64TrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError = 0L) override;
ETrackedPropertyError* error = 0L) override;
HmdMatrix34_t GetMatrix34TrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError = 0L) override {
ETrackedPropertyError* error = 0L) override {
NOTIMPLEMENTED();
return {};
}
uint32_t GetStringTrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
VR_OUT_STRING() char* pchValue,
uint32_t unBufferSize,
ETrackedPropertyError* pError = 0L) override;
VR_OUT_STRING() char* value,
uint32_t buffer_size,
ETrackedPropertyError* error = 0L) override;
const char* GetPropErrorNameFromEnum(ETrackedPropertyError error) override {
NOTIMPLEMENTED();
return nullptr;
}
bool PollNextEvent(VREvent_t* pEvent, uint32_t uncbVREvent) override;
bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,
VREvent_t* pEvent,
uint32_t uncbVREvent,
TrackedDevicePose_t* pTrackedDevicePose) override {
bool PollNextEvent(VREvent_t* event, uint32_t vr_event) override;
bool PollNextEventWithPose(
ETrackingUniverseOrigin origin,
VREvent_t* event,
uint32_t vr_event,
TrackedDevicePose_t* tracked_device_pose) override {
NOTIMPLEMENTED();
return false;
}
const char* GetEventTypeNameFromEnum(EVREventType eType) override {
const char* GetEventTypeNameFromEnum(EVREventType type) override {
NOTIMPLEMENTED();
return nullptr;
}
HiddenAreaMesh_t GetHiddenAreaMesh(
EVREye eEye,
EVREye eye,
EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard) override {
NOTIMPLEMENTED();
return {};
......@@ -168,17 +169,17 @@ class TestVRSystem : public IVRSystem {
VRControllerState_t* controller_state,
uint32_t controller_state_size,
TrackedDevicePose_t* tracked_device_pose) override;
void TriggerHapticPulse(TrackedDeviceIndex_t unControllerDeviceIndex,
uint32_t unAxisId,
unsigned short usDurationMicroSec) override {
void TriggerHapticPulse(TrackedDeviceIndex_t device_index,
uint32_t axis_id,
unsigned short duration_micro_sec) override {
NOTIMPLEMENTED();
}
const char* GetButtonIdNameFromEnum(EVRButtonId eButtonId) override {
const char* GetButtonIdNameFromEnum(EVRButtonId button_id) override {
NOTIMPLEMENTED();
return nullptr;
};
const char* GetControllerAxisTypeNameFromEnum(
EVRControllerAxisType eAxisType) override {
EVRControllerAxisType axis_type) override {
NOTIMPLEMENTED();
return nullptr;
}
......@@ -191,15 +192,15 @@ class TestVRSystem : public IVRSystem {
NOTIMPLEMENTED();
return false;
}
uint32_t DriverDebugRequest(TrackedDeviceIndex_t unDeviceIndex,
const char* pchRequest,
char* pchResponseBuffer,
uint32_t unResponseBufferSize) override {
uint32_t DriverDebugRequest(TrackedDeviceIndex_t device_index,
const char* request,
char* response_buffer,
uint32_t response_buffer_size) override {
NOTIMPLEMENTED();
return 0;
}
EVRFirmwareError PerformFirmwareUpdate(
TrackedDeviceIndex_t unDeviceIndex) override {
TrackedDeviceIndex_t device_index) override {
NOTIMPLEMENTED();
return VRFirmwareError_None;
}
......@@ -209,44 +210,44 @@ class TestVRSystem : public IVRSystem {
class TestVRCompositor : public IVRCompositor {
public:
void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) override;
void SetTrackingSpace(ETrackingUniverseOrigin origin) override;
ETrackingUniverseOrigin GetTrackingSpace() override {
NOTIMPLEMENTED();
return TrackingUniverseSeated;
}
EVRCompositorError WaitGetPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount)
TrackedDevicePose_t* pRenderPoseArray,
uint32_t unRenderPoseArrayCount,
VR_ARRAY_COUNT(unGamePoseArrayCount)
TrackedDevicePose_t* pGamePoseArray,
uint32_t unGamePoseArrayCount) override;
EVRCompositorError GetLastPoses(VR_ARRAY_COUNT(unRenderPoseArrayCount)
TrackedDevicePose_t* pRenderPoseArray,
uint32_t unRenderPoseArrayCount,
VR_ARRAY_COUNT(unGamePoseArrayCount)
TrackedDevicePose_t* pGamePoseArray,
uint32_t unGamePoseArrayCount) override {
EVRCompositorError WaitGetPoses(VR_ARRAY_COUNT(render_pose_array_count)
TrackedDevicePose_t* render_pose_array,
uint32_t render_pose_array_count,
VR_ARRAY_COUNT(game_pose_array_count)
TrackedDevicePose_t* game_pose_array,
uint32_t game_pose_array_count) override;
EVRCompositorError GetLastPoses(VR_ARRAY_COUNT(render_pose_array_count)
TrackedDevicePose_t* render_pose_array,
uint32_t render_pose_array_count,
VR_ARRAY_COUNT(game_pose_array_count)
TrackedDevicePose_t* game_pose_array,
uint32_t game_pose_array_count) override {
NOTIMPLEMENTED();
return VRCompositorError_None;
}
EVRCompositorError GetLastPoseForTrackedDeviceIndex(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDevicePose_t* pOutputPose,
TrackedDevicePose_t* pOutputGamePose) override {
TrackedDeviceIndex_t device_index,
TrackedDevicePose_t* output_pose,
TrackedDevicePose_t* output_game_pose) override {
NOTIMPLEMENTED();
return VRCompositorError_None;
}
EVRCompositorError Submit(
EVREye eEye,
const Texture_t* pTexture,
const VRTextureBounds_t* pBounds = 0,
EVRSubmitFlags nSubmitFlags = Submit_Default) override;
EVREye eye,
const Texture_t* texture,
const VRTextureBounds_t* bounds = 0,
EVRSubmitFlags submit_flags = Submit_Default) override;
void ClearLastSubmittedFrame() override { NOTIMPLEMENTED(); }
void PostPresentHandoff() override;
bool GetFrameTiming(Compositor_FrameTiming* pTiming,
uint32_t unFramesAgo = 0) override;
uint32_t GetFrameTimings(Compositor_FrameTiming* pTiming,
uint32_t nFrames) override {
bool GetFrameTiming(Compositor_FrameTiming* timing,
uint32_t frames_ago = 0) override;
uint32_t GetFrameTimings(Compositor_FrameTiming* timing,
uint32_t frames) override {
NOTIMPLEMENTED();
return 0;
}
......@@ -254,30 +255,30 @@ class TestVRCompositor : public IVRCompositor {
NOTIMPLEMENTED();
return 0;
}
void GetCumulativeStats(Compositor_CumulativeStats* pStats,
uint32_t nStatsSizeInBytes) override {
void GetCumulativeStats(Compositor_CumulativeStats* stats,
uint32_t stats_size_in_bytes) override {
NOTIMPLEMENTED();
}
void FadeToColor(float fSeconds,
float fRed,
float fGreen,
float fBlue,
float fAlpha,
bool bBackground = false) override {
void FadeToColor(float seconds,
float red,
float green,
float blue,
float alpha,
bool background = false) override {
NOTIMPLEMENTED();
}
HmdColor_t GetCurrentFadeColor(bool bBackground = false) override {
HmdColor_t GetCurrentFadeColor(bool background = false) override {
NOTIMPLEMENTED();
return {};
}
void FadeGrid(float fSeconds, bool bFadeIn) override { NOTIMPLEMENTED(); }
void FadeGrid(float seconds, bool fade_in) override { NOTIMPLEMENTED(); }
float GetCurrentGridAlpha() override {
NOTIMPLEMENTED();
return 0;
}
EVRCompositorError SetSkyboxOverride(VR_ARRAY_COUNT(unTextureCount)
const Texture_t* pTextures,
uint32_t unTextureCount) override {
EVRCompositorError SetSkyboxOverride(VR_ARRAY_COUNT(texture_count)
const Texture_t* textures,
uint32_t texture_count) override {
NOTIMPLEMENTED();
return VRCompositorError_None;
}
......@@ -312,51 +313,51 @@ class TestVRCompositor : public IVRCompositor {
NOTIMPLEMENTED();
return false;
}
void ForceInterleavedReprojectionOn(bool bOverride) override {
void ForceInterleavedReprojectionOn(bool override) override {
NOTIMPLEMENTED();
}
void ForceReconnectProcess() override { NOTIMPLEMENTED(); }
void SuspendRendering(bool bSuspend) override;
void SuspendRendering(bool suspend) override;
EVRCompositorError GetMirrorTextureD3D11(
EVREye eEye,
void* pD3D11DeviceOrResource,
void** ppD3D11ShaderResourceView) override {
EVREye eye,
void* d3d11_device_or_resource,
void** d3d11_shader_resource_view) override {
NOTIMPLEMENTED();
return VRCompositorError_None;
}
void ReleaseMirrorTextureD3D11(void* pD3D11ShaderResourceView) override {
void ReleaseMirrorTextureD3D11(void* d3d11_shader_resource_view) override {
NOTIMPLEMENTED();
}
EVRCompositorError GetMirrorTextureGL(
EVREye eEye,
glUInt_t* pglTextureId,
glSharedTextureHandle_t* pglSharedTextureHandle) override {
EVREye eye,
glUInt_t* texture_id,
glSharedTextureHandle_t* shared_texture_handle) override {
NOTIMPLEMENTED();
return VRCompositorError_None;
}
bool ReleaseSharedGLTexture(
glUInt_t glTextureId,
glSharedTextureHandle_t glSharedTextureHandle) override {
glUInt_t texture_id,
glSharedTextureHandle_t shared_texture_handle) override {
NOTIMPLEMENTED();
return false;
}
void LockGLSharedTextureForAccess(
glSharedTextureHandle_t glSharedTextureHandle) override {
glSharedTextureHandle_t shared_texture_handle) override {
NOTIMPLEMENTED();
}
void UnlockGLSharedTextureForAccess(
glSharedTextureHandle_t glSharedTextureHandle) override {
glSharedTextureHandle_t shared_texture_handle) override {
NOTIMPLEMENTED();
}
uint32_t GetVulkanInstanceExtensionsRequired(VR_OUT_STRING() char* pchValue,
uint32_t unBufferSize) override {
uint32_t GetVulkanInstanceExtensionsRequired(VR_OUT_STRING() char* value,
uint32_t buffer_size) override {
NOTIMPLEMENTED();
return 0;
}
uint32_t GetVulkanDeviceExtensionsRequired(
VkPhysicalDevice_T* pPhysicalDevice,
VR_OUT_STRING() char* pchValue,
uint32_t unBufferSize) override {
VkPhysicalDevice_T* physical_device,
VR_OUT_STRING() char* value,
uint32_t buffer_size) override {
NOTIMPLEMENTED();
return 0;
}
......@@ -364,18 +365,17 @@ class TestVRCompositor : public IVRCompositor {
class TestVRClientCore : public IVRClientCore {
public:
EVRInitError Init(EVRApplicationType eApplicationType) override;
EVRInitError Init(EVRApplicationType application_type) override;
void Cleanup() override;
EVRInitError IsInterfaceVersionValid(
const char* pchInterfaceVersion) override;
void* GetGenericInterface(const char* pchNameAndVersion,
EVRInitError* peError) override;
EVRInitError IsInterfaceVersionValid(const char* interface_version) override;
void* GetGenericInterface(const char* name_and_version,
EVRInitError* error) override;
bool BIsHmdPresent() override;
const char* GetEnglishStringForHmdError(EVRInitError eError) override {
const char* GetEnglishStringForHmdError(EVRInitError error) override {
NOTIMPLEMENTED();
return nullptr;
}
const char* GetIDForVRInitError(EVRInitError eError) override {
const char* GetIDForVRInitError(EVRInitError error) override {
NOTIMPLEMENTED();
return nullptr;
}
......@@ -386,7 +386,7 @@ TestVRSystem g_system;
TestVRCompositor g_compositor;
TestVRClientCore g_loader;
EVRInitError TestVRClientCore::Init(EVRApplicationType eApplicationType) {
EVRInitError TestVRClientCore::Init(EVRApplicationType application_type) {
return VRInitError_None;
}
......@@ -394,21 +394,21 @@ void TestVRClientCore::Cleanup() {
}
EVRInitError TestVRClientCore::IsInterfaceVersionValid(
const char* pchInterfaceVersion) {
const char* interface_version) {
return VRInitError_None;
}
void* TestVRClientCore::GetGenericInterface(const char* pchNameAndVersion,
EVRInitError* peError) {
*peError = VRInitError_None;
if (strcmp(pchNameAndVersion, IVRSystem_Version) == 0)
void* TestVRClientCore::GetGenericInterface(const char* name_and_version,
EVRInitError* error) {
*error = VRInitError_None;
if (strcmp(name_and_version, IVRSystem_Version) == 0)
return static_cast<IVRSystem*>(&g_system);
if (strcmp(pchNameAndVersion, IVRCompositor_Version) == 0)
if (strcmp(name_and_version, IVRCompositor_Version) == 0)
return static_cast<IVRCompositor*>(&g_compositor);
if (strcmp(pchNameAndVersion, device::kChromeOpenVRTestHookAPI) == 0)
if (strcmp(name_and_version, device::kChromeOpenVRTestHookAPI) == 0)
return static_cast<device::TestHookRegistration*>(&g_test_helper);
*peError = VRInitError_Init_InvalidInterface;
*error = VRInitError_Init_InvalidInterface;
return nullptr;
}
......@@ -416,15 +416,15 @@ bool TestVRClientCore::BIsHmdPresent() {
return true;
}
void TestVRSystem::GetRecommendedRenderTargetSize(uint32_t* pnWidth,
uint32_t* pnHeight) {
*pnWidth = 1024;
*pnHeight = 768;
void TestVRSystem::GetRecommendedRenderTargetSize(uint32_t* width,
uint32_t* height) {
*width = 1024;
*height = 768;
}
void TestVRSystem::GetDXGIOutputInfo(int32_t* pnAdapterIndex) {
void TestVRSystem::GetDXGIOutputInfo(int32_t* adapter_index) {
// Enumerate devices until we find one that supports 11.1.
*pnAdapterIndex = -1;
*adapter_index = -1;
Microsoft::WRL::ComPtr<IDXGIFactory1> dxgi_factory;
Microsoft::WRL::ComPtr<IDXGIAdapter> adapter;
DCHECK(
......@@ -443,44 +443,44 @@ void TestVRSystem::GetDXGIOutputInfo(int32_t* pnAdapterIndex) {
arraysize(feature_levels), D3D11_SDK_VERSION,
d3d11_device.GetAddressOf(), &feature_level_out,
d3d11_device_context.GetAddressOf()))) {
*pnAdapterIndex = i;
*adapter_index = i;
return;
}
}
}
void TestVRSystem::GetProjectionRaw(EVREye eEye,
float* pfLeft,
float* pfRight,
float* pfTop,
float* pfBottom) {
auto proj = g_test_helper.GetProjectionRaw(eEye == EVREye::Eye_Left);
*pfLeft = proj.projection[0];
*pfRight = proj.projection[1];
*pfTop = proj.projection[2];
*pfBottom = proj.projection[3];
void TestVRSystem::GetProjectionRaw(EVREye eye,
float* left,
float* right,
float* top,
float* bottom) {
auto proj = g_test_helper.GetProjectionRaw(eye == EVREye::Eye_Left);
*left = proj.projection[0];
*right = proj.projection[1];
*top = proj.projection[2];
*bottom = proj.projection[3];
}
HmdMatrix34_t TestVRSystem::GetEyeToHeadTransform(EVREye eEye) {
HmdMatrix34_t TestVRSystem::GetEyeToHeadTransform(EVREye eye) {
HmdMatrix34_t ret = {};
ret.m[0][0] = 1;
ret.m[1][1] = 1;
ret.m[2][2] = 1;
ret.m[0][3] = (eEye == Eye_Left) ? 0.1f : -0.1f;
ret.m[0][3] = (eye == Eye_Left) ? 0.1f : -0.1f;
return ret;
}
void TestVRSystem::GetDeviceToAbsoluteTrackingPose(
ETrackingUniverseOrigin eOrigin,
float fPredictedSecondsToPhotonsFromNow,
VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount)
TrackedDevicePose_t* pTrackedDevicePoseArray,
uint32_t unTrackedDevicePoseArrayCount) {
ETrackingUniverseOrigin origin,
float predicted_seconds_to_photons_from_now,
VR_ARRAY_COUNT(tracked_device_pose_array_count)
TrackedDevicePose_t* tracked_device_pose_array,
uint32_t tracked_device_pose_array_count) {
TrackedDevicePose_t pose = g_test_helper.GetPose(false /* presenting pose */);
pTrackedDevicePoseArray[0] = pose;
for (unsigned int i = 1; i < unTrackedDevicePoseArrayCount; ++i) {
tracked_device_pose_array[0] = pose;
for (unsigned int i = 1; i < tracked_device_pose_array_count; ++i) {
TrackedDevicePose_t pose = {};
pTrackedDevicePoseArray[i] = pose;
tracked_device_pose_array[i] = pose;
}
}
......@@ -508,24 +508,24 @@ bool TestVRSystem::GetControllerStateWithPose(
}
uint32_t TestVRSystem::GetStringTrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
VR_OUT_STRING() char* pchValue,
uint32_t unBufferSize,
ETrackedPropertyError* pError) {
if (pError) {
*pError = TrackedProp_Success;
VR_OUT_STRING() char* value,
uint32_t buffer_size,
ETrackedPropertyError* error) {
if (error) {
*error = TrackedProp_Success;
}
sprintf_s(pchValue, unBufferSize, "test-value");
sprintf_s(value, buffer_size, "test-value");
return 11;
}
float TestVRSystem::GetFloatTrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError) {
if (pError) {
*pError = TrackedProp_Success;
ETrackedPropertyError* error) {
if (error) {
*error = TrackedProp_Success;
}
switch (prop) {
case Prop_UserIpdMeters_Float:
......@@ -537,33 +537,33 @@ float TestVRSystem::GetFloatTrackedDeviceProperty(
}
int32_t TestVRSystem::GetInt32TrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError) {
ETrackedPropertyError* error) {
int32_t ret;
ETrackedPropertyError err =
g_test_helper.GetInt32TrackedDeviceProperty(unDeviceIndex, prop, ret);
g_test_helper.GetInt32TrackedDeviceProperty(device_index, prop, ret);
if (err != TrackedProp_Success) {
NOTIMPLEMENTED();
}
if (pError) {
*pError = err;
if (error) {
*error = err;
}
return ret;
}
uint64_t TestVRSystem::GetUint64TrackedDeviceProperty(
TrackedDeviceIndex_t unDeviceIndex,
TrackedDeviceIndex_t device_index,
ETrackedDeviceProperty prop,
ETrackedPropertyError* pError) {
ETrackedPropertyError* error) {
uint64_t ret;
ETrackedPropertyError err =
g_test_helper.GetUint64TrackedDeviceProperty(unDeviceIndex, prop, ret);
g_test_helper.GetUint64TrackedDeviceProperty(device_index, prop, ret);
if (err != TrackedProp_Success) {
NOTIMPLEMENTED();
}
if (pError) {
*pError = err;
if (error) {
*error = err;
}
return ret;
}
......@@ -578,16 +578,16 @@ HmdMatrix34_t TestVRSystem::GetSeatedZeroPoseToStandingAbsoluteTrackingPose() {
}
ETrackedControllerRole TestVRSystem::GetControllerRoleForTrackedDeviceIndex(
TrackedDeviceIndex_t unDeviceIndex) {
return g_test_helper.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex);
TrackedDeviceIndex_t device_index) {
return g_test_helper.GetControllerRoleForTrackedDeviceIndex(device_index);
}
ETrackedDeviceClass TestVRSystem::GetTrackedDeviceClass(
TrackedDeviceIndex_t unDeviceIndex) {
return g_test_helper.GetTrackedDeviceClass(unDeviceIndex);
TrackedDeviceIndex_t device_index) {
return g_test_helper.GetTrackedDeviceClass(device_index);
}
void TestVRCompositor::SuspendRendering(bool bSuspend) {}
void TestVRCompositor::SuspendRendering(bool suspend) {}
void TestVRCompositor::SetTrackingSpace(ETrackingUniverseOrigin) {}
......@@ -625,8 +625,8 @@ bool TestVRCompositor::GetFrameTiming(Compositor_FrameTiming*, unsigned int) {
} // namespace vr
extern "C" {
__declspec(dllexport) void* VRClientCoreFactory(const char* pInterfaceName,
int* pReturnCode) {
__declspec(dllexport) void* VRClientCoreFactory(const char* interface_name,
int* return_code) {
return &vr::g_loader;
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment