275 lines
9.2 KiB
C++
275 lines
9.2 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Modules/ModuleInterface.h"
|
|
#include "HeadMountedDisplayTypes.h"
|
|
#include "StereoRendering.h"
|
|
#include "LateUpdateManager.h"
|
|
#include "SceneInterface.h"
|
|
|
|
class FSceneInterface;
|
|
class UCanvas;
|
|
struct FPostProcessSettings;
|
|
struct FWorldContext;
|
|
class UTexture;
|
|
class FSceneViewFamily;
|
|
class FSceneView;
|
|
class FRHICommandListImmediate;
|
|
class FTexture;
|
|
|
|
struct FHeadMountedDisplayPassContext
|
|
{
|
|
FHeadMountedDisplayPassContext(FRHICommandListImmediate& InRHICmdList, const FSceneView& InView)
|
|
: RHICmdList(InRHICmdList)
|
|
, View(InView)
|
|
{}
|
|
|
|
FRHICommandListImmediate& RHICmdList;
|
|
const FSceneView& View;
|
|
};
|
|
|
|
/**
|
|
* HMD device interface
|
|
*/
|
|
|
|
class IHeadMountedDisplay : public IModuleInterface
|
|
{
|
|
|
|
public:
|
|
HEADMOUNTEDDISPLAY_API IHeadMountedDisplay();
|
|
|
|
/**
|
|
* Returns true if HMD is currently connected. It may or may not be in use.
|
|
*/
|
|
virtual bool IsHMDConnected() = 0;
|
|
|
|
/**
|
|
* Whether or not switching to stereo is enabled; if it is false, then EnableStereo(true) will do nothing.
|
|
*/
|
|
virtual bool IsHMDEnabled() const = 0;
|
|
|
|
/**
|
|
* Returns EHMDWornState::Worn if we detect that the user is wearing the HMD, EHMDWornState::NotWorn if we detect the user is not wearing the HMD, and EHMDWornState::Unknown if we cannot detect the state.
|
|
*/
|
|
virtual EHMDWornState::Type GetHMDWornState() { return EHMDWornState::Unknown; };
|
|
|
|
/**
|
|
* Enables or disables switching to stereo.
|
|
*/
|
|
virtual void EnableHMD(bool bEnable = true) = 0;
|
|
|
|
/**
|
|
* Retrieves the HMD name.
|
|
*/
|
|
virtual FName GetHMDName() const = 0;
|
|
|
|
struct MonitorInfo
|
|
{
|
|
FString MonitorName;
|
|
size_t MonitorId;
|
|
int DesktopX, DesktopY;
|
|
int ResolutionX, ResolutionY;
|
|
int WindowSizeX, WindowSizeY;
|
|
bool bShouldTestResolution;
|
|
|
|
MonitorInfo() : MonitorId(0)
|
|
, DesktopX(0)
|
|
, DesktopY(0)
|
|
, ResolutionX(0)
|
|
, ResolutionY(0)
|
|
, WindowSizeX(0)
|
|
, WindowSizeY(0)
|
|
, bShouldTestResolution(false)
|
|
{
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Get the name or id of the display to output for this HMD.
|
|
*/
|
|
virtual bool GetHMDMonitorInfo(MonitorInfo&) = 0;
|
|
|
|
/**
|
|
* Calculates the FOV, based on the screen dimensions of the device. Original FOV is passed as params.
|
|
*/
|
|
virtual void GetFieldOfView(float& InOutHFOVInDegrees, float& InOutVFOVInDegrees) const = 0;
|
|
|
|
/**
|
|
* Sets near and far clipping planes (NCP and FCP) for the HMD.
|
|
*
|
|
* @param NCP (in) Near clipping plane, in centimeters
|
|
* @param FCP (in) Far clipping plane, in centimeters
|
|
*/
|
|
virtual void SetClippingPlanes(float NCP, float FCP) {}
|
|
|
|
/**
|
|
* Returns eye render params, used from PostProcessHMD, RenderThread.
|
|
*/
|
|
virtual void GetEyeRenderParams_RenderThread(const struct FHeadMountedDisplayPassContext& Context, FVector2D& EyeToSrcUVScaleValue, FVector2D& EyeToSrcUVOffsetValue) const {}
|
|
|
|
/**
|
|
* Accessors to modify the interpupillary distance (meters)
|
|
*/
|
|
virtual void SetInterpupillaryDistance(float NewInterpupillaryDistance) = 0;
|
|
virtual float GetInterpupillaryDistance() const = 0;
|
|
|
|
/**
|
|
* Whether HMDDistortion post processing is enabled or not
|
|
*/
|
|
virtual bool GetHMDDistortionEnabled(EShadingPath ShadingPath) const = 0;
|
|
|
|
// Are we outputting so a Spectator Screen now.
|
|
virtual bool IsSpectatorScreenActive() const { return false; }
|
|
|
|
/**
|
|
* Return a pointer to the SpectatorScreenController for the HMD if supported, else null.
|
|
* The controller is owned by the HMD, and will be destroyed when the HMD is destroyed.
|
|
*/
|
|
virtual class ISpectatorScreenController* GetSpectatorScreenController() { return nullptr; }
|
|
virtual class ISpectatorScreenController const* GetSpectatorScreenController() const { return nullptr; }
|
|
|
|
/**
|
|
* When implemented, creates a new post process node to provide platform-specific HMD distortion.
|
|
*/
|
|
virtual void CreateHMDPostProcessPass_RenderThread(FRDGBuilder& GraphBuilder, const FSceneView& View, const struct FHMDDistortionInputs& Inputs, struct FScreenPassTexture& OutPass) const {}
|
|
|
|
public:
|
|
|
|
/**
|
|
* Gets the current pixel density setting.
|
|
*/
|
|
virtual float GetPixelDenity() const { check(IsInGameThread() || IsInRenderingThread()); return 1.0f; }
|
|
|
|
/**
|
|
* Sets the pixel density. This may cause render target resizing.
|
|
*/
|
|
virtual void SetPixelDensity(const float NewDensity) { };
|
|
|
|
/**
|
|
* Gets the ideal render target size for the device. See xr.SecondaryScreenPercentage.HMDRenderTarget description.
|
|
*/
|
|
virtual FIntPoint GetIdealRenderTargetSize() const { check(IsInGameThread() || IsInRenderingThread()); return FIntPoint(); }
|
|
|
|
/**
|
|
* Gets the ideal render target size for the debug canvas on the device.
|
|
*/
|
|
virtual FIntPoint GetIdealDebugCanvasRenderTargetSize() const { return FIntPoint(1024, 1024); }
|
|
|
|
/**
|
|
* Gets the scaling factor, applied to the post process warping effect
|
|
*/
|
|
virtual float GetDistortionScalingFactor() const { return 0; }
|
|
|
|
/**
|
|
* Gets the offset (in clip coordinates) from the center of the screen for the lens position
|
|
*/
|
|
virtual float GetLensCenterOffset() const { return 0; }
|
|
|
|
/**
|
|
* Gets the barrel distortion shader warp values for the device
|
|
*/
|
|
virtual void GetDistortionWarpValues(FVector4& K) const { }
|
|
|
|
/**
|
|
* Returns 'false' if chromatic aberration correction is off.
|
|
*/
|
|
virtual bool IsChromaAbCorrectionEnabled() const = 0;
|
|
|
|
/**
|
|
* Gets the chromatic aberration correction shader values for the device.
|
|
* Returns 'false' if chromatic aberration correction is off.
|
|
*/
|
|
virtual bool GetChromaAbCorrectionValues(FVector4& K) const { return false; }
|
|
|
|
/**
|
|
* @return true if a hidden area mesh is available for the device.
|
|
*/
|
|
virtual bool HasHiddenAreaMesh() const { return false; }
|
|
|
|
/**
|
|
* @return true if a visible area mesh is available for the device.
|
|
*/
|
|
virtual bool HasVisibleAreaMesh() const { return false; }
|
|
|
|
/**
|
|
* Optional method to draw a view's hidden area mesh where supported.
|
|
* This can be used to avoid rendering pixels which are not included as input into the final distortion pass.
|
|
*/
|
|
virtual void DrawHiddenAreaMesh(class FRHICommandList& RHICmdList, int32 ViewIndex) const {};
|
|
|
|
/**
|
|
* Optional method to draw a view's hidden area mesh where supported.
|
|
* This can be used to avoid rendering pixels which are not included as input into the final distortion pass.
|
|
* Supports instanced rendering.
|
|
*/
|
|
virtual void DrawHiddenAreaMesh(class FRHICommandList& RHICmdList, int32 ViewIndex, int32 InstanceCount) const {};
|
|
|
|
/**
|
|
* Optional method to draw a view's visible area mesh where supported.
|
|
* This can be used instead of a full screen quad to avoid rendering pixels which are not included as input into the final distortion pass.
|
|
*/
|
|
virtual void DrawVisibleAreaMesh(class FRHICommandList& RHICmdList, int32 ViewIndex) const {};
|
|
|
|
/**
|
|
* Optional method to draw a view's visible area mesh where supported.
|
|
* This can be used instead of a full screen quad to avoid rendering pixels which are not included as input into the final distortion pass.
|
|
* Supports instanced rendering.
|
|
*/
|
|
virtual void DrawVisibleAreaMesh(class FRHICommandList& RHICmdList, int32 ViewIndex, int32 InstanceCount) const {};
|
|
|
|
virtual void DrawDistortionMesh_RenderThread(struct FHeadMountedDisplayPassContext& Context, const FIntPoint& TextureSize) {}
|
|
|
|
/**
|
|
* This method is able to change screen settings right before any drawing occurs.
|
|
* It is called at the beginning of UGameViewportClient::Draw() method.
|
|
* We might remove this one as UpdatePostProcessSettings should be able to capture all needed cases
|
|
*/
|
|
virtual void UpdateScreenSettings(const class FViewport* InViewport) {}
|
|
|
|
/**
|
|
* Additional optional distortion rendering parameters
|
|
* @todo: Once we can move shaders into plugins, remove these!
|
|
*/
|
|
virtual FTexture* GetDistortionTextureLeft() const {return NULL;}
|
|
virtual FTexture* GetDistortionTextureRight() const {return NULL;}
|
|
virtual FVector2D GetTextureOffsetLeft() const {return FVector2D::ZeroVector;}
|
|
virtual FVector2D GetTextureOffsetRight() const {return FVector2D::ZeroVector;}
|
|
virtual FVector2D GetTextureScaleLeft() const {return FVector2D::ZeroVector;}
|
|
virtual FVector2D GetTextureScaleRight() const {return FVector2D::ZeroVector;}
|
|
virtual const float* GetRedDistortionParameters() const { return nullptr; }
|
|
virtual const float* GetGreenDistortionParameters() const { return nullptr; }
|
|
virtual const float* GetBlueDistortionParameters() const { return nullptr; }
|
|
|
|
virtual bool NeedsUpscalePostProcessPass() { return false; }
|
|
|
|
/**
|
|
* Record analytics
|
|
*/
|
|
virtual void RecordAnalytics() {}
|
|
|
|
/**
|
|
* Returns true, if the App is using VR focus. This means that the app may handle lifecycle events differently from
|
|
* the regular desktop apps. In this case, FCoreDelegates::ApplicationWillEnterBackgroundDelegate and FCoreDelegates::ApplicationHasEnteredForegroundDelegate
|
|
* reflect the state of VR focus (either the app should be rendered in HMD or not).
|
|
*/
|
|
HEADMOUNTEDDISPLAY_API virtual bool DoesAppUseVRFocus() const;
|
|
|
|
/**
|
|
* Returns true, if the app has VR focus, meaning if it is rendered in the HMD.
|
|
*/
|
|
HEADMOUNTEDDISPLAY_API virtual bool DoesAppHaveVRFocus() const;
|
|
|
|
/**
|
|
* If true, scene rendering should be skipped.
|
|
*/
|
|
virtual bool IsRenderingPaused() const { return false; }
|
|
|
|
/**
|
|
* Set the multiply and offset colors for composited images in the HMD
|
|
*/
|
|
virtual bool SetColorScaleAndBias(FLinearColor ColorScale, FLinearColor ColorBias) { return false; };
|
|
};
|