virtual void SwitchToNextElement() override
{
if (RHITexture.IsValid())
{
auto D3D11TS = static_cast<FD3D11Texture2DSet*>(RHITexture->GetTexture2D());
FOvrSessionShared::AutoSession OvrSession(Session);
D3D11TS->SwitchToNextElement(OvrSession);
}
}
virtual void ReleaseResources() override
{
if (RHITexture.IsValid())
{
auto D3D11TS = static_cast<FD3D11Texture2DSet*>(RHITexture->GetTexture2D());
FOvrSessionShared::AutoSession OvrSession(Session);
D3D11TS->ReleaseResources(OvrSession);
RHITexture = nullptr;
}
}
void FOculusInput::SetHapticFeedbackValues(int32 ControllerId, int32 Hand, const FHapticFeedbackValues& Values)
{
for (FOculusTouchControllerPair& ControllerPair : ControllerPairs)
{
if (ControllerPair.UnrealControllerIndex == ControllerId)
{
FOculusTouchControllerState& ControllerState = ControllerPair.ControllerStates[Hand];
if (ControllerState.bIsCurrentlyTracked)
{
if(IOculusRiftPlugin::IsAvailable())
{
FOvrSessionShared::AutoSession OvrSession(IOculusRiftPlugin::Get().GetSession());
if (OvrSession && FApp::HasVRFocus())
{
float FreqMin, FreqMax = 0.f;
GetHapticFrequencyRange(FreqMin, FreqMax);
const float Frequency = FMath::Lerp(FreqMin, FreqMax, FMath::Clamp(Values.Frequency, 0.f, 1.f));
const float Amplitude = Values.Amplitude * GetHapticAmplitudeScale();
if ((ControllerState.HapticAmplitude != Amplitude) || (ControllerState.HapticFrequency != Frequency))
{
ControllerState.HapticAmplitude = Amplitude;
ControllerState.HapticFrequency = Frequency;
const ovrControllerType OvrController = (EControllerHand(Hand) == EControllerHand::Left) ? ovrControllerType_LTouch : ovrControllerType_RTouch;
ovr_SetControllerVibration(OvrSession, OvrController, Frequency, Amplitude);
UE_CLOG(0, LogOcInput, Log, TEXT("SetHapticFeedbackValues: Hand %d, freq %f, amp %f"), int(Hand), Frequency, Amplitude);
ControllerState.bPlayingHapticEffect = (Amplitude != 0.f) && (Frequency != 0.f);
}
}
}
}
break;
}
}
}
void FOculusInput::UpdateForceFeedback( const FOculusTouchControllerPair& ControllerPair, const EControllerHand Hand )
{
const FOculusTouchControllerState& ControllerState = ControllerPair.ControllerStates[ (int32)Hand ];
if(IOculusRiftPlugin::IsAvailable())
{
FOvrSessionShared::AutoSession OvrSession(IOculusRiftPlugin::Get().GetSession());
if( ControllerState.bIsCurrentlyTracked && !ControllerState.bPlayingHapticEffect && OvrSession && FApp::HasVRFocus())
{
float FreqMin, FreqMax = 0.f;
GetHapticFrequencyRange(FreqMin, FreqMax);
// Map the [0.0 - 1.0] range to a useful range of frequencies for the Oculus controllers
const float ActualFrequency = FMath::Lerp(FreqMin, FreqMax, FMath::Clamp(ControllerState.HapticFrequency, 0.0f, 1.0f));
// Oculus SDK wants amplitude values between 0.0 and 1.0
const float ActualAmplitude = ControllerState.HapticAmplitude * GetHapticAmplitudeScale();
const ovrControllerType OvrController = ( Hand == EControllerHand::Left ) ? ovrControllerType_LTouch : ovrControllerType_RTouch;
ovr_SetControllerVibration( OvrSession, OvrController, ActualFrequency, ActualAmplitude );
}
}
}
void FOculusInput::SendControllerEvents()
{
const double CurrentTime = FPlatformTime::Seconds();
// @todo: Should be made configurable and unified with other controllers handling of repeat
const float InitialButtonRepeatDelay = 0.2f;
const float ButtonRepeatDelay = 0.1f;
const float AnalogButtonPressThreshold = TriggerThreshold;
if(IOculusRiftPlugin::IsAvailable())
{
IOculusRiftPlugin& OculusRiftPlugin = IOculusRiftPlugin::Get();
FOvrSessionShared::AutoSession OvrSession(IOculusRiftPlugin::Get().GetSession());
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: OvrSession = %p"), ovrSession(OvrSession));
if (OvrSession && MessageHandler.IsValid() && FApp::HasVRFocus())
{
ovrInputState OvrInput;
ovrTrackingState OvrTrackingState;
ovrResult OvrRes = ovr_GetInputState(OvrSession, ovrControllerType_Remote, &OvrInput);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: ovr_GetInputState(Remote) ret = %d"), int(OvrRes));
if (OVR_SUCCESS(OvrRes) && OvrInput.ControllerType == ovrControllerType_Remote)
{
for (int32 ButtonIndex = 0; ButtonIndex < (int32)EOculusRemoteControllerButton::TotalButtonCount; ++ButtonIndex)
{
FOculusButtonState& ButtonState = Remote.Buttons[ButtonIndex];
check(!ButtonState.Key.IsNone()); // is button's name initialized?
// Determine if the button is pressed down
bool bButtonPressed = false;
switch ((EOculusRemoteControllerButton)ButtonIndex)
{
case EOculusRemoteControllerButton::DPad_Up:
bButtonPressed = (OvrInput.Buttons & ovrButton_Up) != 0;
break;
case EOculusRemoteControllerButton::DPad_Down:
bButtonPressed = (OvrInput.Buttons & ovrButton_Down) != 0;
break;
case EOculusRemoteControllerButton::DPad_Left:
bButtonPressed = (OvrInput.Buttons & ovrButton_Left) != 0;
break;
case EOculusRemoteControllerButton::DPad_Right:
bButtonPressed = (OvrInput.Buttons & ovrButton_Right) != 0;
break;
case EOculusRemoteControllerButton::Enter:
bButtonPressed = (OvrInput.Buttons & ovrButton_Enter) != 0;
break;
case EOculusRemoteControllerButton::Back:
bButtonPressed = (OvrInput.Buttons & ovrButton_Back) != 0;
break;
case EOculusRemoteControllerButton::VolumeUp:
#ifdef SUPPORT_INTERNAL_BUTTONS
bButtonPressed = (OvrInput.Buttons & ovrButton_VolUp) != 0;
#endif
break;
case EOculusRemoteControllerButton::VolumeDown:
#ifdef SUPPORT_INTERNAL_BUTTONS
bButtonPressed = (OvrInput.Buttons & ovrButton_VolDown) != 0;
#endif
break;
case EOculusRemoteControllerButton::Home:
#ifdef SUPPORT_INTERNAL_BUTTONS
bButtonPressed = (OvrInput.Buttons & ovrButton_Home) != 0;
#endif
break;
default:
check(0); // unhandled button, shouldn't happen
break;
}
// Update button state
if (bButtonPressed != ButtonState.bIsPressed)
{
const bool bIsRepeat = false;
ButtonState.bIsPressed = bButtonPressed;
if (ButtonState.bIsPressed)
{
MessageHandler->OnControllerButtonPressed(ButtonState.Key, 0, bIsRepeat);
// Set the timer for the first repeat
ButtonState.NextRepeatTime = CurrentTime + ButtonRepeatDelay;
}
else
{
MessageHandler->OnControllerButtonReleased(ButtonState.Key, 0, bIsRepeat);
}
}
// Apply key repeat, if its time for that
if (ButtonState.bIsPressed && ButtonState.NextRepeatTime <= CurrentTime)
{
const bool bIsRepeat = true;
MessageHandler->OnControllerButtonPressed(ButtonState.Key, 0, bIsRepeat);
// Set the timer for the next repeat
ButtonState.NextRepeatTime = CurrentTime + ButtonRepeatDelay;
}
}
}
OvrRes = ovr_GetInputState(OvrSession, ovrControllerType_Touch, &OvrInput);
const bool bOvrGCTRes = OculusRiftPlugin.GetCurrentTrackingState(&OvrTrackingState);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: ovr_GetInputState(Touch) ret = %d, GetCurrentTrackingState ret = %d"), int(OvrRes), int(bOvrGCTRes));
if (OVR_SUCCESS(OvrRes) && bOvrGCTRes)
{
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: ButtonState = 0x%X"), OvrInput.Buttons);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: Touches = 0x%X"), OvrInput.Touches);
for (FOculusTouchControllerPair& ControllerPair : ControllerPairs)
{
for( int32 HandIndex = 0; HandIndex < ARRAY_COUNT( ControllerPair.ControllerStates ); ++HandIndex )
{
FOculusTouchControllerState& State = ControllerPair.ControllerStates[ HandIndex ];
const bool bIsLeft = (HandIndex == (int32)EControllerHand::Left);
bool bIsCurrentlyTracked = (bIsLeft ? (OvrInput.ControllerType & ovrControllerType_LTouch) != 0 : (OvrInput.ControllerType & ovrControllerType_RTouch) != 0);
#if OVR_TESTING
bIsCurrentlyTracked = true;
static float _angle = 0;
OvrTrackingState.HandPoses[HandIndex].ThePose.Orientation = OVR::Quatf(OVR::Vector3f(0, 0, 1), _angle);
_angle += 0.1f;
OvrTrackingState.HandPoses[HandIndex].ThePose = OvrTrackingState.HeadPose.ThePose;
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Error, TEXT("SendControllerEvents: OVR_TESTING is enabled!"));
#endif
if (bIsCurrentlyTracked)
{
State.bIsCurrentlyTracked = true;
const float OvrTriggerAxis = OvrInput.IndexTrigger[HandIndex];
const float OvrGripAxis = OvrInput.HandTrigger[HandIndex];
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: IndexTrigger[%d] = %f"), int(HandIndex), OvrTriggerAxis);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: HandTrigger[%d] = %f"), int(HandIndex), OvrGripAxis);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: ThumbStick[%d] = { %f, %f }"), int(HandIndex), OvrInput.Thumbstick[HandIndex].x, OvrInput.Thumbstick[HandIndex].y );
if (OvrTriggerAxis != State.TriggerAxis)
{
State.TriggerAxis = OvrTriggerAxis;
MessageHandler->OnControllerAnalog(bIsLeft ? FGamepadKeyNames::MotionController_Left_TriggerAxis : FGamepadKeyNames::MotionController_Right_TriggerAxis, ControllerPair.UnrealControllerIndex, State.TriggerAxis);
}
if (OvrGripAxis != State.GripAxis)
{
State.GripAxis = OvrGripAxis;
MessageHandler->OnControllerAnalog(bIsLeft ? FGamepadKeyNames::MotionController_Left_Grip1Axis : FGamepadKeyNames::MotionController_Right_Grip1Axis, ControllerPair.UnrealControllerIndex, State.GripAxis);
}
if (OvrInput.Thumbstick[HandIndex].x != State.ThumbstickAxes.X)
{
State.ThumbstickAxes.X = OvrInput.Thumbstick[HandIndex].x;
MessageHandler->OnControllerAnalog(bIsLeft ? FGamepadKeyNames::MotionController_Left_Thumbstick_X : FGamepadKeyNames::MotionController_Right_Thumbstick_X, ControllerPair.UnrealControllerIndex, State.ThumbstickAxes.X);
}
if (OvrInput.Thumbstick[HandIndex].y != State.ThumbstickAxes.Y)
{
State.ThumbstickAxes.Y = OvrInput.Thumbstick[HandIndex].y;
// we need to negate Y value to match XBox controllers
MessageHandler->OnControllerAnalog(bIsLeft ? FGamepadKeyNames::MotionController_Left_Thumbstick_Y : FGamepadKeyNames::MotionController_Right_Thumbstick_Y, ControllerPair.UnrealControllerIndex, -State.ThumbstickAxes.Y);
}
for (int32 ButtonIndex = 0; ButtonIndex < (int32)EOculusTouchControllerButton::TotalButtonCount; ++ButtonIndex)
{
FOculusButtonState& ButtonState = State.Buttons[ButtonIndex];
check(!ButtonState.Key.IsNone()); // is button's name initialized?
// Determine if the button is pressed down
bool bButtonPressed = false;
switch ((EOculusTouchControllerButton)ButtonIndex)
{
case EOculusTouchControllerButton::Trigger:
bButtonPressed = State.TriggerAxis >= AnalogButtonPressThreshold;
break;
case EOculusTouchControllerButton::Grip:
bButtonPressed = State.GripAxis >= AnalogButtonPressThreshold;
break;
case EOculusTouchControllerButton::XA:
bButtonPressed = bIsLeft ? (OvrInput.Buttons & ovrButton_X) != 0 : (OvrInput.Buttons & ovrButton_A) != 0;
break;
case EOculusTouchControllerButton::YB:
bButtonPressed = bIsLeft ? (OvrInput.Buttons & ovrButton_Y) != 0 : (OvrInput.Buttons & ovrButton_B) != 0;
break;
case EOculusTouchControllerButton::Thumbstick:
bButtonPressed = bIsLeft ? (OvrInput.Buttons & ovrButton_LThumb) != 0 : (OvrInput.Buttons & ovrButton_RThumb) != 0;
break;
default:
check(0);
break;
}
// Update button state
if (bButtonPressed != ButtonState.bIsPressed)
{
const bool bIsRepeat = false;
ButtonState.bIsPressed = bButtonPressed;
if (ButtonState.bIsPressed)
{
MessageHandler->OnControllerButtonPressed(ButtonState.Key, ControllerPair.UnrealControllerIndex, bIsRepeat);
// Set the timer for the first repeat
ButtonState.NextRepeatTime = CurrentTime + ButtonRepeatDelay;
}
else
{
MessageHandler->OnControllerButtonReleased(ButtonState.Key, ControllerPair.UnrealControllerIndex, bIsRepeat);
}
}
// Apply key repeat, if its time for that
if (ButtonState.bIsPressed && ButtonState.NextRepeatTime <= CurrentTime)
{
const bool bIsRepeat = true;
MessageHandler->OnControllerButtonPressed(ButtonState.Key, ControllerPair.UnrealControllerIndex, bIsRepeat);
// Set the timer for the next repeat
ButtonState.NextRepeatTime = CurrentTime + ButtonRepeatDelay;
}
}
// Handle Capacitive States
for (int32 CapTouchIndex = 0; CapTouchIndex < (int32)EOculusTouchCapacitiveAxes::TotalAxisCount; ++CapTouchIndex)
{
FOculusTouchCapacitiveState& CapState = State.CapacitiveAxes[CapTouchIndex];
float CurrentAxisVal = 0.f;
switch ((EOculusTouchCapacitiveAxes)CapTouchIndex)
{
case EOculusTouchCapacitiveAxes::XA:
{
const uint32 mask = (bIsLeft) ? ovrTouch_X : ovrTouch_A;
CurrentAxisVal = (OvrInput.Touches & mask) != 0 ? 1.f : 0.f;
break;
}
case EOculusTouchCapacitiveAxes::YB:
{
const uint32 mask = (bIsLeft) ? ovrTouch_Y : ovrTouch_B;
CurrentAxisVal = (OvrInput.Touches & mask) != 0 ? 1.f : 0.f;
break;
}
case EOculusTouchCapacitiveAxes::Thumbstick:
{
const uint32 mask = (bIsLeft) ? ovrTouch_LThumb : ovrTouch_RThumb;
CurrentAxisVal = (OvrInput.Touches & mask) != 0 ? 1.f : 0.f;
break;
}
case EOculusTouchCapacitiveAxes::Trigger:
{
const uint32 mask = (bIsLeft) ? ovrTouch_LIndexTrigger : ovrTouch_RIndexTrigger;
CurrentAxisVal = (OvrInput.Touches & mask) != 0 ? 1.f : 0.f;
break;
}
case EOculusTouchCapacitiveAxes::IndexPointing:
{
const uint32 mask = (bIsLeft) ? ovrTouch_LIndexPointing : ovrTouch_RIndexPointing;
CurrentAxisVal = (OvrInput.Touches & mask) != 0 ? 1.f : 0.f;
break;
}
case EOculusTouchCapacitiveAxes::ThumbUp:
{
const uint32 mask = (bIsLeft) ? ovrTouch_LThumbUp : ovrTouch_RThumbUp;
CurrentAxisVal = (OvrInput.Touches & mask) != 0 ? 1.f : 0.f;
break;
}
default:
check(0);
}
if (CurrentAxisVal != CapState.State)
{
MessageHandler->OnControllerAnalog(CapState.Axis, ControllerPair.UnrealControllerIndex, CurrentAxisVal);
CapState.State = CurrentAxisVal;
}
}
const ovrPosef& OvrHandPose = OvrTrackingState.HandPoses[HandIndex].ThePose;
FVector NewLocation;
FQuat NewOrientation;
if (OculusRiftPlugin.PoseToOrientationAndPosition(OvrHandPose, /* Out */ NewOrientation, /* Out */ NewLocation))
{
// OK, we have up to date positional data!
State.Orientation = NewOrientation;
State.Location = NewLocation;
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: HandPOSE[%d]: Pos %.3f %.3f %.3f"), HandIndex, NewLocation.X, NewLocation.Y, NewLocation.Y);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: HandPOSE[%d]: Yaw %.3f Pitch %.3f Roll %.3f"), HandIndex, NewOrientation.Rotator().Yaw, NewOrientation.Rotator().Pitch, NewOrientation.Rotator().Roll);
}
else
{
// HMD wasn't ready. This can currently happen if we try to grab motion data before we've rendered at least one frame
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: PoseToOrientationAndPosition returned false"));
}
}
else
{
// Controller isn't available right now. Zero out input state, so that if it comes back it will send fresh event deltas
State = FOculusTouchControllerState((EControllerHand)HandIndex);
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT("SendControllerEvents: Controller for the hand %d is not tracked"), int(HandIndex));
}
}
}
}
}
}
UE_CLOG(OVR_DEBUG_LOGGING, LogOcInput, Log, TEXT(""));
}
FD3D11Texture2DSet* FD3D11Texture2DSet::D3D11CreateTexture2DSet(
FD3D11DynamicRHI* InD3D11RHI,
const FOvrSessionSharedPtr& InOvrSession,
ovrTextureSwapChain InTextureSet,
const D3D11_TEXTURE2D_DESC& InDsDesc,
EPixelFormat InFormat,
uint32 InFlags
)
{
FOvrSessionShared::AutoSession OvrSession(InOvrSession);
check(InTextureSet);
TArray<TRefCountPtr<ID3D11RenderTargetView> > TextureSetRenderTargetViews;
FD3D11Texture2DSet* NewTextureSet = new FD3D11Texture2DSet(
InD3D11RHI,
nullptr,
nullptr,
false,
1,
TextureSetRenderTargetViews,
/*DepthStencilViews=*/ NULL,
InDsDesc.Width,
InDsDesc.Height,
0,
InDsDesc.MipLevels,
InDsDesc.SampleDesc.Count,
InFormat,
/*bInCubemap=*/ false,
InFlags,
/*bPooledTexture=*/ false
);
int TexCount;
ovr_GetTextureSwapChainLength(OvrSession, InTextureSet, &TexCount);
const bool bSRGB = (InFlags & TexCreate_SRGB) != 0;
const DXGI_FORMAT PlatformResourceFormat = (DXGI_FORMAT)GPixelFormats[InFormat].PlatformFormat;
const DXGI_FORMAT PlatformShaderResourceFormat = FindShaderResourceDXGIFormat(PlatformResourceFormat, bSRGB);
const DXGI_FORMAT PlatformRenderTargetFormat = FindShaderResourceDXGIFormat(PlatformResourceFormat, bSRGB);
D3D11_RTV_DIMENSION RenderTargetViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
if (InDsDesc.SampleDesc.Count > 1)
{
RenderTargetViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
}
for (int32 i = 0; i < TexCount; ++i)
{
TRefCountPtr<ID3D11Texture2D> pD3DTexture;
ovrResult res = ovr_GetTextureSwapChainBufferDX(OvrSession, InTextureSet, i, IID_PPV_ARGS(pD3DTexture.GetInitReference()));
if (!OVR_SUCCESS(res))
{
UE_LOG(LogHMD, Error, TEXT("ovr_GetTextureSwapChainBufferDX failed, error = %d"), int(res));
return nullptr;
}
TArray<TRefCountPtr<ID3D11RenderTargetView> > RenderTargetViews;
if (InFlags & TexCreate_RenderTargetable)
{
// Create a render target view for each mip
for (uint32 MipIndex = 0; MipIndex < InDsDesc.MipLevels; MipIndex++)
{
check(!(InFlags & TexCreate_TargetArraySlicesIndependently)); // not supported
D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;
FMemory::Memzero(&RTVDesc, sizeof(RTVDesc));
RTVDesc.Format = PlatformRenderTargetFormat;
RTVDesc.ViewDimension = RenderTargetViewDimension;
RTVDesc.Texture2D.MipSlice = MipIndex;
TRefCountPtr<ID3D11RenderTargetView> RenderTargetView;
VERIFYD3D11RESULT_EX(InD3D11RHI->GetDevice()->CreateRenderTargetView(pD3DTexture, &RTVDesc, RenderTargetView.GetInitReference()), InD3D11RHI->GetDevice());
RenderTargetViews.Add(RenderTargetView);
}
}
TRefCountPtr<ID3D11ShaderResourceView> ShaderResourceView;
// Create a shader resource view for the texture.
if (InFlags & TexCreate_ShaderResource)
{
D3D11_SRV_DIMENSION ShaderResourceViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
SRVDesc.Format = PlatformShaderResourceFormat;
SRVDesc.ViewDimension = ShaderResourceViewDimension;
SRVDesc.Texture2D.MostDetailedMip = 0;
SRVDesc.Texture2D.MipLevels = InDsDesc.MipLevels;
VERIFYD3D11RESULT_EX(InD3D11RHI->GetDevice()->CreateShaderResourceView(pD3DTexture, &SRVDesc, ShaderResourceView.GetInitReference()), InD3D11RHI->GetDevice());
check(IsValidRef(ShaderResourceView));
}
NewTextureSet->AddTexture(pD3DTexture, ShaderResourceView, &RenderTargetViews);
}
if (InFlags & TexCreate_RenderTargetable)
{
NewTextureSet->SetCurrentGPUAccess(EResourceTransitionAccess::EWritable);
}
NewTextureSet->TextureSet = InTextureSet;
NewTextureSet->InitWithCurrentElement(0);
return NewTextureSet;
}
