MediaTexture.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/EnumAsByte.h"
#include "Engine/Texture.h"
#include "Math/Color.h"
#include "Math/IntPoint.h"
#include "MediaSampleQueue.h"
#include "Misc/Timespan.h"
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
 
#include "MediaTexture.generated.h"
 
class FMediaPlayerFacade;
class FMediaTextureClockSink;
class IMediaTextureSample;
class UMediaPlayer;
 
UENUM()
enum MediaTextureOrientation : int
{
    MTORI_Original                  UMETA(DisplayName = "Original (as decoded)"),
    MTORI_CW90                      UMETA(DisplayName = "Clockwise 90deg"),
    MTORI_CW180                     UMETA(DisplayName = "Clockwise 180deg"),
    MTORI_CW270                     UMETA(DisplayName = "Clockwise 270deg"),
};
 
UCLASS(hidecategories=(Adjustments, Compositing, LevelOfDetail, ImportSettings, Object), MinimalAPI)
class UMediaTexture
    : public UTexture
{
    GENERATED_UCLASS_BODY()
 
public:
 
    enum class ERenderMode
    {
        Default = 0,
        JustInTime, // Will defer rendering this media texture until its consumer calls its JustInTimeRender function.
    };
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="MediaTexture", meta=(DisplayName="X-axis Tiling Method"), AssetRegistrySearchable, AdvancedDisplay)
    TEnumAsByte<TextureAddress> AddressX;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="MediaTexture", meta=(DisplayName="Y-axis Tiling Method"), AssetRegistrySearchable, AdvancedDisplay)
    TEnumAsByte<TextureAddress> AddressY;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="MediaTexture")
    bool AutoClear;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="MediaTexture")
    FLinearColor ClearColor;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "MediaTexture", meta = (DisplayName = "Enable Mipmap generation"))
    bool EnableGenMips;
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.6, "Only 'Enable Mipmap Generation' is needed now. When true, the full mip chain will be generated.")
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Only 'Enable Mipmap Generation' is needed now. When true, the full mip chain will be generated."))
    uint8 NumMips_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "MediaTexture", meta = (DisplayName = "Enable New Style Output"))
    bool NewStyleOutput;
 
    UPROPERTY(Transient, TextExportTransient, SkipSerialization, BlueprintReadOnly, Category = "MediaTexture", meta = (DisplayName = "Current frame's aspect ratio"))
    float CurrentAspectRatio;
 
    UPROPERTY(Transient, TextExportTransient, SkipSerialization, BlueprintReadOnly, Category = "MediaTexture", meta = (DisplayName = "Current frame's orientation"))
    TEnumAsByte<enum MediaTextureOrientation> CurrentOrientation;
 
public:
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaTexture")
    MEDIAASSETS_API float GetAspectRatio() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaTexture")
    MEDIAASSETS_API int32 GetHeight() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaTexture")
    MEDIAASSETS_API int32 GetWidth() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaTexture")
    MEDIAASSETS_API int32 GetTextureNumMips() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaTexture")
    MEDIAASSETS_API UMediaPlayer* GetMediaPlayer() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaTexture")
    MEDIAASSETS_API void SetMediaPlayer(UMediaPlayer* NewMediaPlayer);
 
    MEDIAASSETS_API void SetMediaPlayer(UMediaPlayer* NewMediaPlayer, TSharedPtr<FMediaTextureSampleQueue> InSampleQueue);
    
    UFUNCTION(BlueprintCallable, Category = "Media|MediaTexture")
    void UpdateResource() { UpdateResourceWithParams(EUpdateResourceFlags::None); }
 
    MEDIAASSETS_API void CacheNextAvailableSampleTime(FTimespan InNextSampleTime);
 
    MEDIAASSETS_API FTimespan GetNextSampleTime() const;
 
    MEDIAASSETS_API int32 GetAvailableSampleCount() const;
 
#if WITH_EDITOR
 
    MEDIAASSETS_API void SetDefaultMediaPlayer(UMediaPlayer* NewMediaPlayer);
 
#endif
 
    MEDIAASSETS_API float GetCurrentAspectRatio() const;
 
    MEDIAASSETS_API MediaTextureOrientation GetCurrentOrientation() const;
 
    MEDIAASSETS_API float GetMipMapBias() const;
 
    MEDIAASSETS_API void SetMipMapBias(float InMipMapBias);
 
    void SetColorSpaceOverride(UE::Color::EColorSpace InColorspaceOverride)
    {
        ColorspaceOverride = InColorspaceOverride;
    }
 
    MEDIAASSETS_API virtual void JustInTimeRender();
 
    void SetRenderMode(ERenderMode InRenderMode)
    {
        RenderMode = InRenderMode;
    }
 
    ERenderMode GetRenderMode()
    {
        return RenderMode;
    }
 
public:
 
    //~ UTexture interface.
 
    MEDIAASSETS_API virtual void BeginDestroy() override;
    MEDIAASSETS_API virtual FTextureResource* CreateResource() override;
    MEDIAASSETS_API virtual EMaterialValueType GetMaterialType() const override;
    MEDIAASSETS_API virtual float GetSurfaceWidth() const override;
    MEDIAASSETS_API virtual float GetSurfaceHeight() const override;
    virtual float GetSurfaceDepth() const override { return 0; }
    virtual uint32 GetSurfaceArraySize() const override { return 0; }
    MEDIAASSETS_API virtual FGuid GetExternalTextureGuid() const override;
    MEDIAASSETS_API void SetRenderedExternalTextureGuid(const FGuid& InNewGuid);
    virtual ETextureClass GetTextureClass() const override { return ETextureClass::Other2DNoSource; }
    MEDIAASSETS_API virtual uint32 CalcTextureMemorySizeEnum(ETextureMipCount Enum) const override;
 
public:
 
    //~ UObject interface.
 
    MEDIAASSETS_API virtual FString GetDesc() override;
    MEDIAASSETS_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    MEDIAASSETS_API virtual void PostInitProperties() override;
    MEDIAASSETS_API virtual void PostLoad() override;
    MEDIAASSETS_API virtual bool IsPostLoadThreadSafe() const override;
 
#if WITH_EDITOR
    MEDIAASSETS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
protected:
 
    MEDIAASSETS_API void TickResource(FTimespan Timecode);
 
    MEDIAASSETS_API void UpdatePlayerAndQueue(TSharedPtr<FMediaTextureSampleQueue> InSampleQueue = nullptr);
 
    MEDIAASSETS_API void UpdateSampleInfo(const TSharedPtr<IMediaTextureSample, ESPMode::ThreadSafe>& Sample);
 
protected:
 
    UPROPERTY(EditAnywhere, Category="Media")
    TObjectPtr<UMediaPlayer> MediaPlayer;
 
private:
 
    friend class FMediaTextureClockSink;
 
    TSharedPtr<FMediaTextureClockSink, ESPMode::ThreadSafe> ClockSink;
 
    FGuid CurrentGuid;
 
    FGuid CurrentRenderedGuid;
 
    TWeakObjectPtr<UMediaPlayer> CurrentPlayer;
 
    const FGuid DefaultGuid;
 
    FIntPoint Dimensions;
 
    FLinearColor LastClearColor;
 
    bool LastSrgb;
 
    bool bIsCleared;
 
    TSharedPtr<FMediaTextureSampleQueue, ESPMode::ThreadSafe> SampleQueue;
 
    SIZE_T Size;
 
    mutable FCriticalSection CriticalSection;
 
    TAtomic<FTimespan> CachedNextSampleTime;
 
    int32 TextureNumMips;
 
    float MipMapBias;
 
    ERenderMode RenderMode = ERenderMode::Default;
 
    UE::Color::EColorSpace ColorspaceOverride;
};