StereoLayerComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Components/SceneComponent.h"
#include "IStereoLayers.h"
#include "StereoLayerComponent.generated.h"
 
class UTexture;
 
UENUM()
enum EStereoLayerType : int
{
    SLT_WorldLocked     UMETA(DisplayName = "World Locked"),
 
    SLT_TrackerLocked   UMETA(DisplayName = "Tracker Locked"),
 
    SLT_FaceLocked      UMETA(DisplayName = "Face Locked"),
 
    SLT_MAX,
};
 
UENUM()
enum EStereoLayerShape : int
{
    SLSH_QuadLayer      UMETA(DisplayName = "Quad Layer"),
 
    SLSH_CylinderLayer  UMETA(DisplayName = "Cylinder Layer"),
 
    SLSH_CubemapLayer   UMETA(DisplayName = "Cubemap Layer"),
 
    SLSH_EquirectLayer  UMETA(DisplayName = "Equirect Layer"),
 
    SLSH_MAX,
};
 
UCLASS()
class UEditorFlagCollector : public UObject
{
    GENERATED_BODY()
 
public:
    UFUNCTION()
    static TArray<FName> GetFlagNames();
};
 
UCLASS(EditInlineNew, Abstract, BlueprintType, CollapseCategories, MinimalAPI)
class UStereoLayerShape : public UObject
{
    GENERATED_BODY()
 
public:
    ENGINE_API virtual void ApplyShape(IStereoLayers::FLayerDesc& LayerDesc);
#if WITH_EDITOR
    ENGINE_API virtual void DrawShapeVisualization(const class FSceneView* View, class FPrimitiveDrawInterface* PDI);
#endif
 
protected:
    ENGINE_API void MarkStereoLayerDirty();
};
 
UCLASS(meta = (DisplayName = "Quad Layer"), MinimalAPI)
class UStereoLayerShapeQuad : public UStereoLayerShape
{
    GENERATED_BODY()
public:
    ENGINE_API virtual void ApplyShape(IStereoLayers::FLayerDesc& LayerDesc) override;
#if WITH_EDITOR
    ENGINE_API virtual void DrawShapeVisualization(const class FSceneView* View, class FPrimitiveDrawInterface* PDI) override;
#endif
};
 
UCLASS(meta = (DisplayName = "Cylinder Layer"), MinimalAPI)
class UStereoLayerShapeCylinder : public UStereoLayerShape
{
    GENERATED_BODY()
 
public:
    UStereoLayerShapeCylinder()
        : Radius(100)
        , OverlayArc(100)
        , Height(50)
    {}
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "Cylinder Properties")
    float Radius;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "Cylinder Properties")
    float OverlayArc;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "Cylinder Properties")
    int Height;
 
    UFUNCTION(BlueprintCallable, Category = "Components|Stereo Layer")
    ENGINE_API void SetRadius(float InRadius);
    UFUNCTION(BlueprintCallable, Category = "Components|Stereo Layer")
    ENGINE_API void SetOverlayArc(float InOverlayArc);
    UFUNCTION(BlueprintCallable, Category = "Components|Stereo Layer")
    ENGINE_API void SetHeight(int InHeight);
 
    ENGINE_API virtual void ApplyShape(IStereoLayers::FLayerDesc& LayerDesc) override;
#if WITH_EDITOR
    ENGINE_API virtual void DrawShapeVisualization(const class FSceneView* View, class FPrimitiveDrawInterface* PDI) override;
#endif
};
 
UCLASS(meta = (DisplayName = "Cubemap Layer"), MinimalAPI)
class UStereoLayerShapeCubemap : public UStereoLayerShape
{
    GENERATED_BODY()
public:
    ENGINE_API virtual void ApplyShape(IStereoLayers::FLayerDesc& LayerDesc) override;
};
 
USTRUCT(BlueprintType)
struct FEquirectProps
{
    GENERATED_USTRUCT_BODY()
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    FBox2D LeftUVRect;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    FBox2D RightUVRect;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    FVector2D LeftScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    FVector2D RightScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    FVector2D LeftBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    FVector2D RightBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category = "StereoLayer | Equirect Layer Properties")
    float Radius;
 
public:
 
    FEquirectProps()
        : LeftUVRect(FBox2D(FVector2D(0.0f, 0.0f), FVector2D(1.0f, 1.0f)))
        , RightUVRect(FBox2D(FVector2D(0.0f, 0.0f), FVector2D(1.0f, 1.0f)))
        , LeftScale(FVector2D(1.0f, 1.0f))
        , RightScale(FVector2D(1.0f, 1.0f))
        , LeftBias(FVector2D(0.0f, 0.0f))
        , RightBias(FVector2D(0.0f, 0.0f))
        , Radius(0.0f)
    {}
 
    FEquirectProps(FBox2D InLeftUVRect, FBox2D InRightUVRect, FVector2D InLeftScale, FVector2D InRightScale, FVector2D InLeftBias, FVector2D InRightBias, float Radius)
        : LeftUVRect(InLeftUVRect)
        , RightUVRect(InRightUVRect)
        , LeftScale(InLeftScale)
        , RightScale(InRightScale)
        , LeftBias(InLeftBias)
        , RightBias(InRightBias)
        , Radius(Radius)
    { }
 
    bool operator==(const FEquirectProps& Other) const;
 
    bool operator==(const class UStereoLayerShapeEquirect& Other) const;
};
 
UCLASS(meta = (DisplayName = "Equirect Layer"), MinimalAPI)
class UStereoLayerShapeEquirect : public UStereoLayerShape
{
    GENERATED_BODY()
 
public:
    UStereoLayerShapeEquirect()
        : LeftUVRect(FBox2D(FVector2D(0.0f, 0.0f), FVector2D(1.0f, 1.0f)))
        , RightUVRect(FBox2D(FVector2D(0.0f, 0.0f), FVector2D(1.0f, 1.0f)))
        , LeftScale(FVector2D(1.0f, 1.0f))
        , RightScale(FVector2D(1.0f, 1.0f))
        , LeftBias(FVector2D(0.0f, 0.0f))
        , RightBias(FVector2D(0.0f, 0.0f))
        , Radius(0.0)
    {}
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    FBox2D LeftUVRect;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    FBox2D RightUVRect;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    FVector2D LeftScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    FVector2D RightScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    FVector2D LeftBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    FVector2D RightBias;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Equirect Properties")
    float Radius;
 
    UFUNCTION(BlueprintCallable, Category = "Components|Stereo Layer")
    ENGINE_API void SetEquirectProps(FEquirectProps InScaleBiases);
 
    ENGINE_API virtual void ApplyShape(IStereoLayers::FLayerDesc& LayerDesc) override;
#if WITH_EDITOR
    ENGINE_API virtual void DrawShapeVisualization(const class FSceneView* View, class FPrimitiveDrawInterface* PDI) override;
#endif
};
 
UCLASS(ClassGroup="HeadMountedDisplay", hidecategories=(Object,LOD,Lighting,TextureStreaming), editinlinenew, meta=(DisplayName="Stereo Layer", BlueprintSpawnableComponent), MinimalAPI)
class UStereoLayerComponent : public USceneComponent
{
    GENERATED_UCLASS_BODY()
    friend class FStereoLayerComponentVisualizer;
    
public:
 
    //~ Begin UObject Interface
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void PostLoad() override;
    //~ End UObject Interface
 
    //~ Begin UActorComponent Interface
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    //~ End UActorComponent Interface
 
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    ENGINE_API void SetTexture(UTexture* InTexture);
 
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    ENGINE_API void SetLeftTexture(UTexture* InTexture);
 
    // @return the texture mapped to the stereo layer.
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    UTexture* GetTexture() const { return Texture; }
 
    // @return the texture mapped to the stereo layer for left eye, if stereoscopic layer textures are supported on the platform.
    UFUNCTION(BlueprintCallable, Category = "Components|Stereo Layer")
    UTexture* GetLeftTexture() const { return LeftTexture; }
 
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    ENGINE_API void SetQuadSize(FVector2D InQuadSize);
 
    // @return the height and width of the rendered quad
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    FVector2D GetQuadSize() const { return QuadSize; }
 
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    ENGINE_API void SetUVRect(FBox2D InUVRect);
 
    // @return the UV coordinates mapped to the quad face
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    FBox2D GetUVRect() const { return UVRect; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|Stereo Layer", meta = (DeprecatedFunction, DeprecationMessage = "Use UStereoLayerShapeEquirect::SetEquirectProps() instead."))
    ENGINE_API void SetEquirectProps(FEquirectProps InEquirectProps);
 
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    ENGINE_API void SetPriority(int32 InPriority);
 
    // @return the render priority
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    int32 GetPriority() const { return Priority; }
 
    // Manually mark the stereo layer texture for updating
    UFUNCTION(BlueprintCallable, Category="Components|Stereo Layer")
    ENGINE_API void MarkTextureForUpdate();
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "StereoLayer")
    uint32 bLiveTexture:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "StereoLayer")
    uint32 bSupportsDepth : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category= "StereoLayer")
    uint32 bNoAlphaChannel:1;
 
    ENGINE_API void MarkStereoLayerDirty();
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category= "StereoLayer")
    TObjectPtr<class UTexture> Texture;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Stereoscopic Properties")
    TObjectPtr<class UTexture> LeftTexture;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "StereoLayer")
    uint32 bQuadPreserveTextureRatio : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "StereoLayer", Meta=(GetOptions= "EditorFlagCollector.GetFlagNames"))
    TArray<FName> AdditionalFlags;
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category="StereoLayer")
    FVector2D QuadSize;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category="StereoLayer")
    FBox2D UVRect;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category="StereoLayer")
    TEnumAsByte<enum EStereoLayerType> StereoLayerType;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, NoClear, Instanced, Category = "StereoLayer", DisplayName="Stereo Layer Shape")
    TObjectPtr<UStereoLayerShape> Shape;
 
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, export, Category= "StereoLayer")
    int32 Priority;
 
    uint32 LayerId;
 
private:
    bool bIsDirty;
 
    bool bTextureNeedsUpdate;
 
    FTransform LastTransform;
 
    bool bLastVisible;
};