LandscapeUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "UObject/NameTypes.h"
#include "AssetRegistry/AssetData.h"
#include "LandscapeTextureHash.h"
#include "Materials/Material.h"
#include "RenderGraphDefinitions.h"
#include "RenderGraphEvent.h"
#include "RenderGraphBuilder.h"
 
enum EShaderPlatform : uint16;
class AActor;
class ALandscapeProxy;
class FRDGBuilder;
class FRDGEventName;
class ULandscapeComponent;
class ULandscapeLayerInfoObject;
class ULandscapeMaterialInstanceConstant;
class ULevel;
class UTexture;
class UTexture2D;
class UWorld;
class FTextureResource;
class FMaterialUpdateContext;
enum class ELandscapeToolTargetType : uint8;
enum class ELandscapeToolTargetTypeFlags : uint8;
struct FShaderCompilerEnvironment;
 
namespace UE::Landscape
{
enum class EBuildFlags : uint8;
 
LANDSCAPE_API bool DoesPlatformSupportEditLayers(EShaderPlatform InShaderPlatform);
 
LANDSCAPE_API void ModifyShaderCompilerEnvironmentForDebug(FShaderCompilerEnvironment& OutEnvironment);
 
LANDSCAPE_API ELandscapeToolTargetTypeFlags GetLandscapeToolTargetTypeAsFlags(ELandscapeToolTargetType InTargetType);
LANDSCAPE_API ELandscapeToolTargetType GetLandscapeToolTargetTypeSingleFlagAsType(ELandscapeToolTargetTypeFlags InSingleFlag);
LANDSCAPE_API FString GetLandscapeToolTargetTypeFlagsAsString(ELandscapeToolTargetTypeFlags InTargetTypeFlags);
 
// ----------------------------------------------------------------------------------
 
class FRDGBuilderRecorder final
{
public:
    using FRDGRecorderRDGCommand = TFunction<void(FRDGBuilder& /*GraphBuilder*/)>;
    using FRDGRecorderRenderCommand = TFunction<void(FRHICommandListImmediate& /*InRHICmdList*/)>;
    struct FRDGExternalTextureAccessFinal
    {
        FTextureResource* TextureResource = nullptr;
        ERHIAccess Access = ERHIAccess::None;
    };
 
    FRDGBuilderRecorder() = default;
    LANDSCAPE_API ~FRDGBuilderRecorder();
 
    enum class EState
    {
        Immediate, // In immediate mode, any command that is enqueued will be pushed to the render thread immediately (effectively acting like a ENQUEUE_RENDER_COMMAND) 
        Recording, // In recording mode, any command that is enqueued will be deferred to the render thread (effectively acting like a ENQUEUE_RENDER_COMMAND) 
    };
 
    inline EState GetState() const { return State; }
    inline bool IsRecording() const { return State == EState::Recording; }
 
    LANDSCAPE_API void StartRecording();
 
    LANDSCAPE_API void StopRecording();
 
    LANDSCAPE_API void StopRecordingAndFlush(FRDGEventName&& EventName);
 
    LANDSCAPE_API void Flush(FRDGEventName&& EventName);
 
    LANDSCAPE_API void EnqueueRDGCommand(FRDGRecorderRDGCommand InRDGCommand, TConstArrayView<FRDGExternalTextureAccessFinal> InRDGExternalTextureAccessFinalList = {});
 
    LANDSCAPE_API void EnqueueRenderCommand(FRDGRecorderRenderCommand InRenderCommand);
 
    LANDSCAPE_API bool IsEmpty() const;
 
    LANDSCAPE_API void Clear();
 
private:
    EState State = EState::Immediate;
 
    // List of callbacks to call on the render thread after the render command was initiated
    TArray<FRDGRecorderRDGCommand> RDGCommands;
 
    // Map of textures and the RHI access they should have when leaving the FRDGBuilder :
    TMap<FTextureResource*, ERHIAccess> RDGExternalTextureAccessFinal;
 
#if RDG_EVENTS
public:
    class FScopedBreadcrumbEvent final
    {
    public:
        FScopedBreadcrumbEvent(FRDGBuilderRecorder& InRecorder, TCHAR const* StaticName, FRDGEventName&& EventName)
            : Recorder(&InRecorder)
            , RDGEvent(MakeShared<TOptional<TRDGEventScopeGuard<FRDGScope_RHI>>>())
        {
            //  We use a shared ptr to create a TOptional<TRDGEventScopeGuard> immediately, then capture this shared ptr in these additional operations' lambdas (so that the object
            //  continues to live until the closing tag operation)
            Recorder->EnqueueRDGCommand(
            [
                RDGEvent = RDGEvent, 
                StaticName = StaticName,
                EventName = MoveTemp(EventName)
            ](FRDGBuilder& GraphBuilder) mutable
            {
                // Allocate the TOptional<TRDGEventScopeGuard> now in order to insert the tag : 
                RDG_EVENT_SCOPE_CONSTRUCT(*RDGEvent, GraphBuilder, true, ERDGScopeFlags::None, RHI_GPU_STAT_ARGS_NONE, StaticName, MoveTemp(EventName));
            });
        }
 
        ~FScopedBreadcrumbEvent()
        {
            Recorder->EnqueueRDGCommand([RDGEvent = RDGEvent](FRDGBuilder& GraphBuilder)
            {
                // Reset the TOptional in order to delete the TRDGEventScopeGuard, which will remove the tag : 
                RDGEvent->Reset();
            });
        }
 
    private:
        FRDGBuilderRecorder* Recorder = nullptr;
        TSharedPtr<TOptional<TRDGEventScopeGuard<FRDGScope_RHI>>> RDGEvent;
    };
#endif // RDG_EVENTS
};
 
#if RDG_EVENTS
#define RDG_RENDER_COMMAND_RECORDER_BREADCRUMB_EVENT(Recorder, Format, ...) FRDGBuilderRecorder::FScopedBreadcrumbEvent ANONYMOUS_VARIABLE(BreadcrumbEvent)(Recorder, TEXT(Format), RDG_EVENT_NAME(Format, ##__VA_ARGS__))
#else // RDG_EVENTS
#define RDG_RENDER_COMMAND_RECORDER_BREADCRUMB_EVENT(Recorder, Format, ...) do { } while(0)
#endif // !RDG_EVENTS
 
 
#if WITH_EDITOR
 
// ----------------------------------------------------------------------------------
 
struct FTextureCopyRequest
{
    UTexture2D* Source = nullptr;
    UTexture* Destination = nullptr;
    int8 DestinationSlice = 0;
    ELandscapeTextureUsage TextureUsage = ELandscapeTextureUsage::Unknown;
    ELandscapeTextureType TextureType = ELandscapeTextureType::Unknown;
};
 
uint32 GetTypeHash(const FTextureCopyRequest& InKey);
bool operator==(const FTextureCopyRequest& InEntryA, const FTextureCopyRequest& InEntryB);
 
struct FTextureCopyChannelMapping
{
    FTextureCopyChannelMapping()
        : Mappings{ INDEX_NONE, INDEX_NONE, INDEX_NONE, INDEX_NONE }
    {}
 
    int8& operator[](int32 Index) { return Mappings[Index]; }
    const int8 operator[](int32 Index) const { return Mappings[Index]; }
 
    int8 Mappings[4];
};
 
class FBatchTextureCopy
{
public:
    LANDSCAPE_API bool AddWeightmapCopy(UTexture* InDestination, int8 InDestinationSlice, int8 InDestinationChannel, const ULandscapeComponent* InComponent, ULandscapeLayerInfoObject* InLayerInfo);
 
    LANDSCAPE_API bool ProcessTextureCopies();
 
private:
    using FTextureCopyChannelMappingMap = TMap<FTextureCopyRequest, FTextureCopyChannelMapping>;
 
    FTextureCopyChannelMappingMap CopyRequests;
};
 
LANDSCAPE_API FString GetSharedAssetsPath(const FString& InPath);
 
LANDSCAPE_API FString GetSharedAssetsPath(const ULevel* InLevel);
 
LANDSCAPE_API FString GetLayerInfoObjectPackageName(const FName& InLayerName, const FString& InPackagePath, FName& OutLayerObjectName);
 
UE_DEPRECATED(5.6, "This Get function is deprecated. Please use new GetLayerInfo and pass in a full asset package path.")
LANDSCAPE_API FString GetLayerInfoObjectPackageName(const ULevel* InLevel, const FName& InLayerName, FName& OutLayerObjectName);
 
LANDSCAPE_API ULandscapeLayerInfoObject* CreateTargetLayerInfo(const FName& InLayerName, const FString& InFilePath);
 
LANDSCAPE_API ULandscapeLayerInfoObject* CreateTargetLayerInfo(const FName& InLayerName, const FString& InFilePath, const FString& InFileName);
 
LANDSCAPE_API bool IsVisibilityLayer(const ULandscapeLayerInfoObject* InLayerInfoObject);
 
struct UE_DEPRECATED(5.6, "This helper struct is deprecated. Please use utility methods in LandscapeEditorUtils.") FLayerInfoFinder
{
    LANDSCAPE_API FLayerInfoFinder();
    LANDSCAPE_API ~FLayerInfoFinder() = default;
    LANDSCAPE_API ULandscapeLayerInfoObject* Find(const FName& LayerName) const;
    TArray<FAssetData> LayerInfoAssets;
};
 
LANDSCAPE_API UMaterialInstance* CreateToolLandscapeMaterialInstanceConstant(UMaterialInterface* BaseMaterial);
 
 
LANDSCAPE_API ULandscapeMaterialInstanceConstant* CreateLandscapeLayerThumbnailMIC(FMaterialUpdateContext& MaterialUpdateContext, UMaterialInterface* LandscapeMaterial, FName LayerName);
 
LANDSCAPE_API FString ConvertTargetLayerNamesToString(const TArrayView<const FName>& InTargetLayerNames);
 
LANDSCAPE_API bool DeleteActors(const TArray<AActor*>& InActorsToDelete, UWorld* InWorld, bool bInAllowUI);
 
#endif // WITH_EDITOR
 
LANDSCAPE_API bool LandscapeProxySortPredicate(const TWeakObjectPtr<ALandscapeProxy> APtr, const TWeakObjectPtr<ALandscapeProxy> BPtr);
 
} // end namespace UE::Landscape