1301 lines
56 KiB
C++
1301 lines
56 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "Containers/StaticArray.h"
|
|
#include "CoreMinimal.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
#include "Misc/Guid.h"
|
|
#include "Engine/TextureStreamingTypes.h"
|
|
#include "Components/PrimitiveComponent.h"
|
|
#include "UObject/PerPlatformProperties.h"
|
|
#include "LandscapePhysicalMaterial.h"
|
|
#include "LandscapeInfo.h"
|
|
#include "LandscapeWeightmapUsage.h"
|
|
#include "Containers/ArrayView.h"
|
|
#include "Engine/StreamableRenderAsset.h"
|
|
#include "Engine/Texture2DArray.h"
|
|
|
|
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
|
|
#include "Serialization/BulkData.h"
|
|
#endif
|
|
|
|
#include "LandscapeComponent.generated.h"
|
|
|
|
class ALandscape;
|
|
class ALandscapeProxy;
|
|
class FLightingBuildOptions;
|
|
class FMaterialUpdateContext;
|
|
class FMeshMapBuildData;
|
|
class FPrimitiveSceneProxy;
|
|
class ITargetPlatform;
|
|
class ULandscapeComponent;
|
|
class ULandscapeGrassType;
|
|
class ULandscapeHeightfieldCollisionComponent;
|
|
class ULandscapeInfo;
|
|
class ULandscapeLayerInfoObject;
|
|
class ULightComponent;
|
|
class UMaterialInstanceConstant;
|
|
class UMaterialInterface;
|
|
class UTexture2D;
|
|
struct FConvexVolume;
|
|
struct FEngineShowFlags;
|
|
struct FLandscapeTextureDataInfo;
|
|
struct FStaticLightingPrimitiveInfo;
|
|
struct FLandscapeEditDataInterface;
|
|
struct FLandscapeMobileRenderData;
|
|
class ULandscapeHeightmapTextureEdgeFixup;
|
|
struct FLandscapeGroup;
|
|
enum class ELandscapeTextureUsage : uint8;
|
|
enum class ELandscapeTextureType : uint8;
|
|
|
|
//
|
|
// FLandscapeEditToolRenderData
|
|
//
|
|
USTRUCT()
|
|
struct FLandscapeEditToolRenderData
|
|
{
|
|
public:
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
enum SelectionType
|
|
{
|
|
ST_NONE = 0,
|
|
ST_COMPONENT = 1,
|
|
ST_REGION = 2,
|
|
// = 4...
|
|
};
|
|
|
|
FLandscapeEditToolRenderData()
|
|
: ToolMaterial(NULL),
|
|
GizmoMaterial(NULL),
|
|
SelectedType(ST_NONE),
|
|
DebugChannelR(INDEX_NONE),
|
|
DebugChannelG(INDEX_NONE),
|
|
DebugChannelB(INDEX_NONE),
|
|
DataTexture(NULL),
|
|
LayerContributionTexture(NULL),
|
|
DirtyTexture(NULL)
|
|
{}
|
|
|
|
// Material used to render the tool.
|
|
UPROPERTY(NonTransactional)
|
|
TObjectPtr<UMaterialInterface> ToolMaterial;
|
|
|
|
// Material used to render the gizmo selection region...
|
|
UPROPERTY(NonTransactional)
|
|
TObjectPtr<UMaterialInterface> GizmoMaterial;
|
|
|
|
// Component is selected
|
|
UPROPERTY(NonTransactional)
|
|
int32 SelectedType;
|
|
|
|
UPROPERTY(NonTransactional)
|
|
int32 DebugChannelR;
|
|
|
|
UPROPERTY(NonTransactional)
|
|
int32 DebugChannelG;
|
|
|
|
UPROPERTY(NonTransactional)
|
|
int32 DebugChannelB;
|
|
|
|
UPROPERTY(NonTransactional)
|
|
TObjectPtr<UTexture2D> DataTexture; // Data texture other than height/weight
|
|
|
|
UPROPERTY(NonTransactional)
|
|
TObjectPtr<UTexture2D> LayerContributionTexture; // Data texture used to represent layer contribution
|
|
|
|
UPROPERTY(NonTransactional)
|
|
TObjectPtr<UTexture2D> DirtyTexture; // Data texture used to represent layer blend dirtied area
|
|
|
|
#if WITH_EDITOR
|
|
void UpdateDebugColorMaterial(const ULandscapeComponent* const Component);
|
|
void UpdateSelectionMaterial(int32 InSelectedType, const ULandscapeComponent* const Component);
|
|
#endif
|
|
};
|
|
|
|
/* Used to uniquely reference a landscape vertex in a component. */
|
|
struct FLandscapeVertexRef
|
|
{
|
|
FLandscapeVertexRef(int16 InX, int16 InY, int8 InSubX, int8 InSubY)
|
|
: X(InX)
|
|
, Y(InY)
|
|
, SubX(InSubX)
|
|
, SubY(InSubY)
|
|
{}
|
|
|
|
uint32 X : 8;
|
|
uint32 Y : 8;
|
|
uint32 SubX : 8;
|
|
uint32 SubY : 8;
|
|
|
|
/** Helper to provide a standard ordering for vertex arrays. */
|
|
static int32 GetVertexIndex(FLandscapeVertexRef Vert, int32 SubsectionCount, int32 SubsectionVerts)
|
|
{
|
|
return (Vert.SubY * SubsectionVerts + Vert.Y) * SubsectionVerts * SubsectionCount + Vert.SubX * SubsectionVerts + Vert.X;
|
|
}
|
|
};
|
|
|
|
/** Stores information about which weightmap texture and channel each layer is stored */
|
|
USTRUCT()
|
|
struct FWeightmapLayerAllocationInfo
|
|
{
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
UPROPERTY()
|
|
TObjectPtr<ULandscapeLayerInfoObject> LayerInfo;
|
|
|
|
UPROPERTY()
|
|
uint8 WeightmapTextureIndex;
|
|
|
|
UPROPERTY()
|
|
uint8 WeightmapTextureChannel;
|
|
|
|
FWeightmapLayerAllocationInfo()
|
|
: LayerInfo(nullptr)
|
|
, WeightmapTextureIndex(0)
|
|
, WeightmapTextureChannel(0)
|
|
{
|
|
}
|
|
|
|
|
|
FWeightmapLayerAllocationInfo(ULandscapeLayerInfoObject* InLayerInfo)
|
|
: LayerInfo(InLayerInfo)
|
|
, WeightmapTextureIndex(255) // Indicates an invalid allocation
|
|
, WeightmapTextureChannel(255)
|
|
{
|
|
}
|
|
|
|
bool operator == (const FWeightmapLayerAllocationInfo& RHS) const
|
|
{
|
|
return (LayerInfo == RHS.LayerInfo)
|
|
&& (WeightmapTextureIndex == RHS.WeightmapTextureIndex)
|
|
&& (WeightmapTextureChannel == RHS.WeightmapTextureChannel);
|
|
}
|
|
|
|
FName GetLayerName() const;
|
|
|
|
uint32 GetHash() const;
|
|
|
|
void Free()
|
|
{
|
|
WeightmapTextureChannel = 255;
|
|
WeightmapTextureIndex = 255;
|
|
}
|
|
|
|
bool IsAllocated() const { return (WeightmapTextureChannel != 255 && WeightmapTextureIndex != 255); }
|
|
};
|
|
|
|
inline uint32 GetTypeHash(const FWeightmapLayerAllocationInfo& InAllocInfo)
|
|
{
|
|
return InAllocInfo.GetHash();
|
|
}
|
|
|
|
template<typename T>
|
|
struct IBuffer2DView
|
|
{
|
|
// copy up to Count elements to Dest, in X then Y order (standard image order)
|
|
virtual void CopyTo(T* Dest, int32 Count) const = 0;
|
|
|
|
// copy up to Count elements to Dest, in X then Y order (standard image order)
|
|
virtual bool CopyToAndCalcIsAllZero(T* Dest, int32 Count) const = 0;
|
|
|
|
// return the total number of elements
|
|
virtual int32 Num() const = 0;
|
|
};
|
|
|
|
struct FLandscapeComponentGrassData
|
|
{
|
|
#if WITH_EDITORONLY_DATA
|
|
// Variables used to detect when grass data needs to be regenerated:
|
|
|
|
// Guid per material instance in the hierarchy between the assigned landscape material (instance) and the root UMaterial
|
|
// used to detect changes to material instance parameters or the root material that could affect the grass maps
|
|
UE_DEPRECATED(5.5, "GenerationHash is now used")
|
|
TArray<FGuid, TInlineAllocator<2>> MaterialStateIds_DEPRECATED;
|
|
// cached component rotation when material world-position-offset is used,
|
|
// as this will affect the direction of world-position-offset deformation (included in the HeightData below)
|
|
UE_DEPRECATED(5.5, "GenerationHash is now used")
|
|
FQuat RotationForWPO_DEPRECATED;
|
|
|
|
// Variable used to detect when grass data needs to be regenerated:
|
|
uint32 GenerationHash = 0;
|
|
#endif
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
// Height data for LODs 1+, keyed on LOD index
|
|
TMap<int32, TArray<uint16>> HeightMipData;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
static constexpr int32 UnknownNumElements = -1;
|
|
// Elements per contiguous array: for validation and also to indicate whether the grass data is valid (NumElements >= 0, meaning 0 elements is valid but the grass data is all zero and
|
|
// therefore empty) or not known yet (== UnknownNumElements)
|
|
int32 NumElements = UnknownNumElements;
|
|
// Serialized in one block to prevent Slack waste
|
|
TMap<TObjectPtr<ULandscapeGrassType>, int32> WeightOffsets;
|
|
TArray<uint8> HeightWeightData;
|
|
|
|
// Note: We need to explicitly disable warnings on these constructors/operators for clang to be happy with deprecated variables
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
FLandscapeComponentGrassData() = default;
|
|
FLandscapeComponentGrassData(ULandscapeComponent* Component);
|
|
~FLandscapeComponentGrassData() = default;
|
|
FLandscapeComponentGrassData(const FLandscapeComponentGrassData&) = default;
|
|
FLandscapeComponentGrassData(FLandscapeComponentGrassData&&) = default;
|
|
FLandscapeComponentGrassData& operator=(const FLandscapeComponentGrassData&) = default;
|
|
FLandscapeComponentGrassData& operator=(FLandscapeComponentGrassData&&) = default;
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
|
|
// Returns whether grass data has been computed (or serialized) yet. Returns true even if the data is completely empty (e.g. all-zero weightmap data)
|
|
bool HasValidData() const;
|
|
|
|
// Returns whether the data is completely empty (e.g. all-zero weightmap data). Returns false if the data just wasn't computed yet :
|
|
bool HasData() const;
|
|
|
|
void InitializeFrom(const TArray<uint16>& HeightData, const TMap<ULandscapeGrassType*, TArray<uint8>>& WeightData);
|
|
void InitializeFrom(IBuffer2DView<uint16>* HeightData, TMap<ULandscapeGrassType*, IBuffer2DView<uint8>*>& WeightData, bool bStripEmptyWeights);
|
|
|
|
bool HasWeightData() const;
|
|
TArrayView<uint8> GetWeightData(const ULandscapeGrassType* GrassType);
|
|
bool Contains(ULandscapeGrassType* GrassType) const;
|
|
TArrayView<uint16> GetHeightData();
|
|
|
|
SIZE_T GetAllocatedSize() const;
|
|
|
|
// Check whether we can discard any data not needed with current scalability settings
|
|
void ConditionalDiscardDataOnLoad();
|
|
|
|
friend FArchive& operator<<(FArchive& Ar, FLandscapeComponentGrassData& Data);
|
|
};
|
|
|
|
USTRUCT(NotBlueprintable, meta = (Deprecated = "5.1"))
|
|
struct UE_DEPRECATED(all, "FLandscapeComponentMaterialOverride is deprecated; please use FLandscapePerLODMaterialOverride instead") FLandscapeComponentMaterialOverride
|
|
{
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
UPROPERTY(EditAnywhere, Category = LandscapeComponent, meta=(UIMin=0, UIMax=8, ClampMin=0, ClampMax=8))
|
|
FPerPlatformInt LODIndex;
|
|
|
|
UPROPERTY(EditAnywhere, Category = LandscapeComponent)
|
|
TObjectPtr<UMaterialInterface> Material = nullptr;
|
|
};
|
|
|
|
USTRUCT(NotBlueprintable)
|
|
struct FLandscapePerLODMaterialOverride
|
|
{
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
UPROPERTY(EditAnywhere, Category = Material, meta = (UIMin = 0, UIMax = 8, ClampMin = 0, ClampMax = 8))
|
|
int32 LODIndex = 0;
|
|
|
|
UPROPERTY(EditAnywhere, Category = Material)
|
|
TObjectPtr<UMaterialInterface> Material = nullptr;
|
|
|
|
bool operator == (const FLandscapePerLODMaterialOverride & InOther) const
|
|
{
|
|
return (LODIndex == InOther.LODIndex)
|
|
&& (Material == InOther.Material);
|
|
}
|
|
};
|
|
|
|
USTRUCT(NotBlueprintable)
|
|
struct FWeightmapData
|
|
{
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
UPROPERTY()
|
|
TArray<TObjectPtr<UTexture2D>> Textures;
|
|
|
|
UPROPERTY()
|
|
TArray<FWeightmapLayerAllocationInfo> LayerAllocations;
|
|
|
|
UPROPERTY(Transient, NonTransactional)
|
|
TArray<TObjectPtr<ULandscapeWeightmapUsage>> TextureUsages;
|
|
};
|
|
|
|
USTRUCT(NotBlueprintable)
|
|
struct FHeightmapData
|
|
{
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
UPROPERTY()
|
|
TObjectPtr<UTexture2D> Texture = nullptr;
|
|
};
|
|
|
|
USTRUCT(NotBlueprintable)
|
|
struct FLandscapeLayerComponentData
|
|
{
|
|
GENERATED_USTRUCT_BODY()
|
|
|
|
FLandscapeLayerComponentData() = default;
|
|
|
|
#if WITH_EDITOR
|
|
FLandscapeLayerComponentData(const FName& InDebugName)
|
|
: DebugName(InDebugName)
|
|
{}
|
|
|
|
#endif // WITH_EDITOR
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
// Edit layers are referenced by Guid, this name is just there to provide some insights as to what edit layer name this layer data corresponded to in case of a missing edit layer guid
|
|
UPROPERTY()
|
|
FName DebugName;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
UPROPERTY()
|
|
FHeightmapData HeightmapData;
|
|
|
|
UPROPERTY()
|
|
FWeightmapData WeightmapData;
|
|
|
|
bool IsInitialized() const { return HeightmapData.Texture != nullptr || WeightmapData.Textures.Num() > 0; }
|
|
};
|
|
|
|
#if WITH_EDITOR
|
|
enum ELandscapeComponentUpdateFlag : uint32
|
|
{
|
|
// Will call UpdateCollisionHeightData, UpdateCacheBounds, UpdateComponentToWorld on Component
|
|
Component_Update_Heightmap_Collision = 1 << 0,
|
|
// Will call UdateCollisionLayerData on Component
|
|
Component_Update_Weightmap_Collision = 1 << 1,
|
|
// Will call RecreateCollision on Component
|
|
Component_Update_Recreate_Collision = 1 << 2,
|
|
// Will update Component clients: Navigation data, Foliage, Grass, etc.
|
|
Component_Update_Client = 1 << 3,
|
|
// Will update Component clients while editing
|
|
Component_Update_Client_Editing = 1 << 4,
|
|
// Will compute component approximated bounds
|
|
Component_Update_Approximated_Bounds = 1 << 5
|
|
};
|
|
|
|
enum ELandscapeLayerUpdateMode : uint32
|
|
{
|
|
// No Update
|
|
Update_None = 0,
|
|
// Update types
|
|
Update_Heightmap_All = 1 << 0,
|
|
Update_Heightmap_Editing = 1 << 1,
|
|
Update_Heightmap_Editing_NoCollision = 1 << 2,
|
|
Update_Weightmap_All = 1 << 3,
|
|
Update_Weightmap_Editing = 1 << 4,
|
|
Update_Weightmap_Editing_NoCollision = 1 << 5,
|
|
// Combinations
|
|
Update_All = Update_Weightmap_All | Update_Heightmap_All,
|
|
Update_All_Editing = Update_Weightmap_Editing | Update_Heightmap_Editing,
|
|
Update_All_Editing_NoCollision = Update_Weightmap_Editing_NoCollision | Update_Heightmap_Editing_NoCollision,
|
|
Update_Heightmap_Types = Update_Heightmap_All | Update_Heightmap_Editing | Update_Heightmap_Editing_NoCollision,
|
|
Update_Weightmap_Types = Update_Weightmap_All | Update_Weightmap_Editing | Update_Weightmap_Editing_NoCollision,
|
|
// In cases where we couldn't update the clients right away this flag will be set in RegenerateLayersContent
|
|
Update_Client_Deferred = 1 << 6,
|
|
// Update landscape component clients while editing
|
|
Update_Client_Editing = 1 << 7
|
|
};
|
|
|
|
static const uint32 DefaultSplineHash = 0xFFFFFFFF;
|
|
|
|
#endif
|
|
|
|
// TODO [jonathan.bard] : Deprecate : this is now kinda redundant with ELandscapeToolTargetType
|
|
UENUM()
|
|
enum ELandscapeClearMode : int
|
|
{
|
|
Clear_Weightmap = 1 << 0 UMETA(DisplayName = "Paint"),
|
|
Clear_Heightmap = 1 << 1 UMETA(DisplayName = "Sculpt"),
|
|
Clear_All = Clear_Weightmap | Clear_Heightmap UMETA(DisplayName = "All")
|
|
};
|
|
|
|
UCLASS(MinimalAPI)
|
|
class ULandscapeLODStreamingProxy_DEPRECATED : public UStreamableRenderAsset
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
};
|
|
|
|
UCLASS(hidecategories=(Display, Attachment, Physics, Debug, Collision, Movement, Rendering, PrimitiveComponent, Object, Transform, Mobility, VirtualTexture), showcategories=("Rendering|Material"), MinimalAPI, Within=LandscapeProxy)
|
|
class ULandscapeComponent : public UPrimitiveComponent
|
|
{
|
|
GENERATED_UCLASS_BODY()
|
|
|
|
/** X offset from global components grid origin (in quads) */
|
|
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
|
|
int32 SectionBaseX;
|
|
|
|
/** Y offset from global components grid origin (in quads) */
|
|
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
|
|
int32 SectionBaseY;
|
|
|
|
/** Total number of quads for this component, has to be >0 */
|
|
UPROPERTY()
|
|
int32 ComponentSizeQuads;
|
|
|
|
/** Number of quads for a subsection of the component. SubsectionSizeQuads+1 must be a power of two. */
|
|
UPROPERTY()
|
|
int32 SubsectionSizeQuads;
|
|
|
|
/** Number of subsections in X or Y axis */
|
|
UPROPERTY()
|
|
int32 NumSubsections;
|
|
|
|
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LandscapeComponent)
|
|
TObjectPtr<UMaterialInterface> OverrideMaterial;
|
|
|
|
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LandscapeComponent, AdvancedDisplay)
|
|
TObjectPtr<UMaterialInterface> OverrideHoleMaterial;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
PRAGMA_DISABLE_DEPRECATION_WARNINGS
|
|
UE_DEPRECATED(all, "OverrideMaterials has been deprecated, use PerLODOverrideMaterials instead.")
|
|
UPROPERTY()
|
|
TArray<FLandscapeComponentMaterialOverride> OverrideMaterials_DEPRECATED;
|
|
PRAGMA_ENABLE_DEPRECATION_WARNINGS
|
|
|
|
UE_DEPRECATED(5.5, "MaterialInstance has been deprecated, use MaterialInstances instead.")
|
|
UPROPERTY()
|
|
TObjectPtr<UMaterialInstanceConstant> MaterialInstance_DEPRECATED;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
UPROPERTY(TextExportTransient)
|
|
TArray<TObjectPtr<UMaterialInstanceConstant>> MaterialInstances;
|
|
|
|
UPROPERTY(Transient, TextExportTransient)
|
|
TArray<TObjectPtr<UMaterialInstanceDynamic>> MaterialInstancesDynamic;
|
|
|
|
/** Mapping between LOD and Material Index*/
|
|
UPROPERTY(TextExportTransient)
|
|
TArray<int8> LODIndexToMaterialIndex;
|
|
|
|
/** XYOffsetmap texture reference */
|
|
UPROPERTY()
|
|
TObjectPtr<UTexture2D> XYOffsetmapTexture;
|
|
|
|
/** UV offset to component's weightmap data from component local coordinates*/
|
|
UPROPERTY()
|
|
FVector4 WeightmapScaleBias;
|
|
|
|
/** U or V offset into the weightmap for the first subsection, in texture UV space */
|
|
UPROPERTY()
|
|
float WeightmapSubsectionOffset;
|
|
|
|
/** UV offset to Heightmap data from component local coordinates */
|
|
UPROPERTY()
|
|
FVector4 HeightmapScaleBias;
|
|
|
|
/** Cached local-space bounding box, created at heightmap update time */
|
|
UPROPERTY()
|
|
FBox CachedLocalBox;
|
|
|
|
/** Maximum deltas between vertices and their counterparts from other mips. This mip-to-mip data is laid out in a contiguous array following the following pattern :
|
|
* Say, we have 5 "relevant" mips and [N -> M] is the delta from mip N to M (where M > N and M < (NumRelevantMips - 1)) then the array will contain :
|
|
* [0 -> 1], [0 -> 2], [0 -> 3], [1 -> 2], [1 -> 3], [2 -> 3]
|
|
* i.e. for mip 0 : (NumRelevantMips - 1) deltas, then for mip 1 : (NumRelevantMips - 2) deltas, until mip == (NumRelevantMips - 2) : 1 delta
|
|
* Note: a "relevant" mip is one with more than 1 vertex. i.e.:
|
|
* - In the case of a 1x1 subsection, the last mip index (NumMips - 1) has a single pixel and is therefore not relevant (we cannot draw a landscape component with a single vertex!), hence the last relevant mip index will be NumMips - 2
|
|
* - In the case of 2x2 subsections, the penultimate mip index (NumMips - 2) has 4 pixels, which means 4 subsections, each with a single pixel, and is therefore not relevant either, hence the last relevant mip index will be NumMips - 3
|
|
*/
|
|
UPROPERTY()
|
|
TArray<double> MipToMipMaxDeltas;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
UE_DEPRECATED(5.5, "CollisionComponent has been deprecated and will be removed in a future version")
|
|
UPROPERTY()
|
|
TLazyObjectPtr<ULandscapeHeightfieldCollisionComponent> CollisionComponent_DEPRECATED;
|
|
#endif // !WITH_EDITORONLY_DATA
|
|
|
|
private:
|
|
/** Reference to associated collision component */
|
|
UPROPERTY()
|
|
TObjectPtr<ULandscapeHeightfieldCollisionComponent> CollisionComponentRef;
|
|
|
|
/** Store */
|
|
UPROPERTY(Transient)
|
|
bool bUserTriggeredChangeRequested = false;
|
|
|
|
UPROPERTY(Transient)
|
|
bool bNaniteActive;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Unique ID for this component, used for caching during distributed lighting */
|
|
UPROPERTY()
|
|
FGuid LightingGuid;
|
|
|
|
/** Edit Layers that have data for this component store it here */
|
|
UPROPERTY()
|
|
TMap<FGuid, FLandscapeLayerComponentData> LayersData;
|
|
|
|
// Final layer data
|
|
UPROPERTY(Transient)
|
|
TArray<TObjectPtr<ULandscapeWeightmapUsage>> WeightmapTexturesUsage;
|
|
|
|
UPROPERTY(Transient)
|
|
uint32 LayerUpdateFlagPerMode;
|
|
|
|
UPROPERTY(Transient)
|
|
bool bPendingCollisionDataUpdate;
|
|
|
|
UPROPERTY(Transient)
|
|
bool bPendingLayerCollisionDataUpdate;
|
|
|
|
bool bUndoChangedWeightmapAllocs = false;
|
|
|
|
/** Dirtied collision height region when painting (only used by Landscape Layer System) */
|
|
FIntRect LayerDirtyCollisionHeightData;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
/** Heightmap texture reference */
|
|
UPROPERTY()
|
|
TObjectPtr<UTexture2D> HeightmapTexture;
|
|
|
|
/** List of layers, and the weightmap and channel they are stored */
|
|
UPROPERTY()
|
|
TArray<FWeightmapLayerAllocationInfo> WeightmapLayerAllocations;
|
|
|
|
/** Weightmap texture reference */
|
|
UPROPERTY()
|
|
TArray<TObjectPtr<UTexture2D>> WeightmapTextures;
|
|
|
|
UPROPERTY(EditAnywhere, Category = LandscapeComponent)
|
|
TArray<FLandscapePerLODMaterialOverride> PerLODOverrideMaterials;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** The value of the landscape material AllStateCRC the last time the GrassTypes array was updated from it */
|
|
uint32 LastLandscapeMaterialAllStateCRCWhenGrassTypesBuilt = 0;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
/** Cached list of grass types supported by the component's material.
|
|
* This is needed in a cooked build, as the grass types list is not available
|
|
* on the cooked material.
|
|
* Call UpdateGrassTypes() to ensure this array is up to date */
|
|
UPROPERTY()
|
|
TArray<TObjectPtr<ULandscapeGrassType>> GrassTypes;
|
|
|
|
public:
|
|
// Non-serialized runtime cache of values derived from the assigned grass types.
|
|
// Call ALandscapeProxy::UpdateGrassTypeSummary() to update.
|
|
struct FGrassTypeSummary
|
|
{
|
|
bool bInvalid = true;
|
|
bool bHasAnyGrass = true;
|
|
double MaxInstanceDiscardDistance = DBL_MAX;
|
|
};
|
|
FGrassTypeSummary GrassTypeSummary;
|
|
inline bool IsGrassTypeSummaryValid() { return GrassTypeSummary.bInvalid; }
|
|
|
|
/** Invalidate the grass type summary. Call whenever grass types are changed to indicate that the summary values are out of date. */
|
|
LANDSCAPE_API void InvalidateGrassTypeSummary();
|
|
|
|
/** Uniquely identifies this component's built map data. */
|
|
UPROPERTY()
|
|
FGuid MapBuildDataId;
|
|
|
|
/** Heightfield mipmap used to generate collision */
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent)
|
|
int32 CollisionMipLevel;
|
|
|
|
/** Heightfield mipmap used to generate simple collision */
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent)
|
|
int32 SimpleCollisionMipLevel;
|
|
|
|
/** Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
|
|
* Extension value in the negative Z axis, positive value increases bound size */
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent)
|
|
float NegativeZBoundsExtension;
|
|
|
|
/** Allows overriding the landscape bounds. This is useful if you distort the landscape with world-position-offset, for example
|
|
* Extension value in the positive Z axis, positive value increases bound size */
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent)
|
|
float PositiveZBoundsExtension;
|
|
|
|
/** StaticLightingResolution overriding per component, default value 0 means no overriding */
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent, meta=(ClampMax = 4096))
|
|
float StaticLightingResolution;
|
|
|
|
/** Forced LOD level to use when rendering */
|
|
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
|
|
int32 ForcedLOD;
|
|
|
|
/** LOD level Bias to use when rendering */
|
|
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=LandscapeComponent)
|
|
int32 LODBias;
|
|
|
|
UE_DEPRECATED(5.5, "StateId is unused and will be removed in a future version")
|
|
UPROPERTY()
|
|
FGuid StateId;
|
|
|
|
/** When the component has registered a heightmap texture edge fixup,
|
|
* a reference to the edge fixup and the group are stored here for easy access
|
|
* (the fixup is also referenced via the heightmap AssetUserDatas,
|
|
* and the group can be accessed via the ULandcapeSubsystem)
|
|
*/
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
TObjectPtr<ULandscapeHeightmapTextureEdgeFixup> RegisteredEdgeFixup;
|
|
FLandscapeGroup* RegisteredLandscapeGroup;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** Legacy irrelevant lights */
|
|
UE_DEPRECATED(5.5, "IrrelevantLights is officially deprecated now and will be removed in a future version")
|
|
UPROPERTY()
|
|
TArray<FGuid> IrrelevantLights_DEPRECATED;
|
|
|
|
/** LOD level Bias to use when lighting building via lightmass, -1 Means automatic LOD calculation based on ForcedLOD + LODBias */
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent)
|
|
int32 LightingLODBias;
|
|
|
|
// List of layers allowed to be painted on this component
|
|
UPROPERTY(EditAnywhere, Category=LandscapeComponent)
|
|
TArray<TObjectPtr<ULandscapeLayerInfoObject>> LayerAllowList;
|
|
|
|
/** Pointer to data shared with the render thread, used by the editor tools */
|
|
UPROPERTY(Transient, DuplicateTransient, NonTransactional)
|
|
FLandscapeEditToolRenderData EditToolRenderData;
|
|
|
|
/** Hash of source for mobile generated data. Used determine if we need to re-generate mobile pixel data. */
|
|
UPROPERTY(DuplicateTransient)
|
|
FGuid MobileDataSourceHash;
|
|
|
|
/** Represent the chosen material for each LOD */
|
|
UPROPERTY(DuplicateTransient)
|
|
TMap<TObjectPtr<UMaterialInterface>, int8> MaterialPerLOD;
|
|
|
|
/** Represents hash of last weightmap usage update */
|
|
uint32 WeightmapsHash;
|
|
|
|
UPROPERTY()
|
|
uint32 SplineHash;
|
|
|
|
/** Represents hash for last PhysicalMaterialTask */
|
|
UPROPERTY()
|
|
uint32 PhysicalMaterialHash;
|
|
|
|
/** Represents last saved hash for PhysicalMaterialTask */
|
|
UPROPERTY(Transient)
|
|
uint32 LastSavedPhysicalMaterialHash;
|
|
|
|
UE_DEPRECATED(5.5, "MobileMaterialInterface has been deprecated and will be removed in a future version")
|
|
UPROPERTY(NonPIEDuplicateTransient)
|
|
TObjectPtr<UMaterialInterface> MobileMaterialInterface_DEPRECATED;
|
|
|
|
UE_DEPRECATED(5.5, "MobileCombinationMaterialInstance has been deprecated and will be removed in a future version")
|
|
UPROPERTY(NonPIEDuplicateTransient)
|
|
TObjectPtr<UMaterialInstanceConstant> MobileCombinationMaterialInstance_DEPRECATED;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
/** Material interfaces used for mobile */
|
|
UPROPERTY(NonPIEDuplicateTransient)
|
|
TArray<TObjectPtr<UMaterialInterface>> MobileMaterialInterfaces;
|
|
|
|
/** Generated weightmap textures used for mobile. The first entry is also used for the normal map.
|
|
* Serialized only when cooking or loading cooked builds. */
|
|
UPROPERTY(NonPIEDuplicateTransient)
|
|
TArray<TObjectPtr<UTexture2D>> MobileWeightmapTextures;
|
|
|
|
UPROPERTY(NonPIEDuplicateTransient)
|
|
TObjectPtr<UTexture2DArray> MobileWeightmapTextureArray;
|
|
|
|
/** Layer allocations used by mobile.*/
|
|
UPROPERTY()
|
|
TArray<FWeightmapLayerAllocationInfo> MobileWeightmapLayerAllocations;
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
/** The editor needs to save out the combination MIC we'll use for mobile,
|
|
because we cannot generate it at runtime for standalone PIE games */
|
|
UPROPERTY(NonPIEDuplicateTransient)
|
|
TArray<TObjectPtr<UMaterialInstanceConstant>> MobileCombinationMaterialInstances;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
|
|
public:
|
|
/** Grass data for generation **/
|
|
TSharedRef<FLandscapeComponentGrassData, ESPMode::ThreadSafe> GrassData;
|
|
|
|
// This wrapper is needed to filter out exclude boxes that are completely inside of another exclude box
|
|
struct FExcludeBox
|
|
{
|
|
FBox Box;
|
|
|
|
FExcludeBox() = default;
|
|
FExcludeBox(const FBox& InBox) : Box(InBox) {}
|
|
|
|
bool operator==(const FExcludeBox& Other) const
|
|
{
|
|
return Box.IsInsideOrOn(Other.Box);
|
|
}
|
|
};
|
|
TArray<FExcludeBox> ActiveExcludedBoxes;
|
|
uint32 ChangeTag;
|
|
|
|
#if WITH_EDITOR
|
|
/** Physical material update task */
|
|
FLandscapePhysicalMaterialRenderTask PhysicalMaterialTask;
|
|
uint32 CalculatePhysicalMaterialTaskHash() const;
|
|
|
|
/**
|
|
* Get the physical materials that are configured by the landscape component graphical material.
|
|
* Returns false if there are no non-null physical materials. (We probably don't want to use if no physical material connections are bound.)
|
|
*/
|
|
bool GetRenderPhysicalMaterials(TArray<UPhysicalMaterial*>& OutPhysicalMaterials) const;
|
|
#endif // WITH_EDITOR
|
|
|
|
//~ Begin UObject Interface.
|
|
virtual void PostInitProperties() override;
|
|
virtual void Serialize(FArchive& Ar) override;
|
|
virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
|
|
virtual void BeginDestroy() override;
|
|
virtual void PostLoad() override;
|
|
#if WITH_EDITORONLY_DATA
|
|
static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
|
|
#endif
|
|
|
|
static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
|
|
|
|
#if WITH_EDITOR
|
|
virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
|
|
virtual void PreEditUndo() override;
|
|
virtual void PostEditUndo() override;
|
|
virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
|
|
virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
|
|
//~ End UObject Interface
|
|
|
|
LANDSCAPE_API void UpdateEditToolRenderData();
|
|
|
|
/** Fix up component layers, weightmaps */
|
|
LANDSCAPE_API void FixupWeightmaps();
|
|
LANDSCAPE_API void FixupWeightmaps(const FGuid& InEditLayerGuid);
|
|
|
|
/** Repair invalid texture data that might have been introduced by a faulty version. Returns the list of repaired textures */
|
|
TArray<UTexture*> RepairInvalidTextures();
|
|
|
|
// Update layer allow list to include the currently painted layers
|
|
LANDSCAPE_API void UpdateLayerAllowListFromPaintedLayers();
|
|
|
|
//~ Begin UPrimitiveComponent Interface.
|
|
virtual bool GetLightMapResolution( int32& Width, int32& Height ) const override;
|
|
virtual int32 GetStaticLightMapResolution() const override;
|
|
virtual void GetLightAndShadowMapMemoryUsage( int32& LightMapMemoryUsage, int32& ShadowMapMemoryUsage ) const override;
|
|
virtual void GetStaticLightingInfo(FStaticLightingPrimitiveInfo& OutPrimitiveInfo,const TArray<ULightComponent*>& InRelevantLights,const FLightingBuildOptions& Options) override;
|
|
virtual void AddMapBuildDataGUIDs(TSet<FGuid>& InGUIDs) const override;
|
|
#endif
|
|
virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;
|
|
virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
|
|
virtual ELightMapInteractionType GetStaticLightingType() const override;
|
|
virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
|
|
virtual bool IsPrecomputedLightingValid() const override;
|
|
|
|
virtual TArray<URuntimeVirtualTexture*> const& GetRuntimeVirtualTextures() const override;
|
|
virtual ERuntimeVirtualTextureMainPassType GetVirtualTextureRenderPassType() const override;
|
|
|
|
// Returns the heightmap for this component. If InReturnEditingHeightmap is passed, returns the currently active edit layer's heightmap :
|
|
LANDSCAPE_API UTexture2D* GetHeightmap(bool InReturnEditingHeightmap = false) const;
|
|
// Returns the heightmap for this component and the edit layer specified by InLayerGuid. If InLayerGuid is invalid, returns the final (base) heightmap :
|
|
LANDSCAPE_API UTexture2D* GetHeightmap(const FGuid& InLayerGuid) const;
|
|
LANDSCAPE_API TArray<TObjectPtr<UTexture2D>>& GetWeightmapTextures(bool InReturnEditingWeightmap = false);
|
|
LANDSCAPE_API const TArray<UTexture2D*>& GetWeightmapTextures(bool InReturnEditingWeightmap = false) const;
|
|
LANDSCAPE_API TArray<TObjectPtr<UTexture2D>>& GetWeightmapTextures(const FGuid& InLayerGuid);
|
|
LANDSCAPE_API const TArray<UTexture2D*>& GetWeightmapTextures(const FGuid& InLayerGuid) const;
|
|
LANDSCAPE_API const TArray<UTexture2D*>& GetRenderedWeightmapTexturesForFeatureLevel(ERHIFeatureLevel::Type FeatureLevel) const;
|
|
|
|
LANDSCAPE_API TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(bool InReturnEditingWeightmap = false);
|
|
LANDSCAPE_API const TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(bool InReturnEditingWeightmap = false) const;
|
|
LANDSCAPE_API TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(const FGuid& InLayerGuid);
|
|
LANDSCAPE_API const TArray<FWeightmapLayerAllocationInfo>& GetWeightmapLayerAllocations(const FGuid& InLayerGuid) const;
|
|
|
|
LANDSCAPE_API TArray<FWeightmapLayerAllocationInfo>& GetCurrentRuntimeWeightmapLayerAllocations();
|
|
LANDSCAPE_API const TArray<FWeightmapLayerAllocationInfo>& GetCurrentRuntimeWeightmapLayerAllocations() const;
|
|
|
|
const TArray<FLandscapePerLODMaterialOverride>& GetPerLODOverrideMaterials() const { return PerLODOverrideMaterials; }
|
|
void SetPerLODOverrideMaterials(const TArray<FLandscapePerLODMaterialOverride>& InValue) { PerLODOverrideMaterials = InValue; }
|
|
|
|
LANDSCAPE_API void SetHeightmap(UTexture2D* NewHeightmap);
|
|
LANDSCAPE_API void SetWeightmapTextures(const TArray<UTexture2D*>& InNewWeightmapTextures, bool InApplyToEditingWeightmap = false);
|
|
void SetWeightmapTexturesInternal(const TArray<UTexture2D*>& InNewWeightmapTextures, const FGuid& InEditLayerGuid);
|
|
|
|
#if WITH_EDITOR
|
|
LANDSCAPE_API void SetWeightmapLayerAllocations(const TArray<FWeightmapLayerAllocationInfo>& InNewWeightmapLayerAllocations);
|
|
LANDSCAPE_API uint32 ComputeLayerHash(bool InReturnEditingHash = true) const;
|
|
|
|
LANDSCAPE_API void SetWeightmapTexturesUsage(const TArray<ULandscapeWeightmapUsage*>& InNewWeightmapTexturesUsage, bool InApplyToEditingWeightmap = false);
|
|
void SetWeightmapTexturesUsageInternal(const TArray<ULandscapeWeightmapUsage*>& InNewWeightmapTexturesUsage, const FGuid& InEditLayerGuid);
|
|
|
|
LANDSCAPE_API TArray<TObjectPtr<ULandscapeWeightmapUsage>>& GetWeightmapTexturesUsage(bool InReturnEditingWeightmap = false);
|
|
LANDSCAPE_API const TArray<ULandscapeWeightmapUsage*>& GetWeightmapTexturesUsage(bool InReturnEditingWeightmap = false) const;
|
|
LANDSCAPE_API TArray<TObjectPtr<ULandscapeWeightmapUsage>>& GetWeightmapTexturesUsage(const FGuid& InLayerGuid);
|
|
LANDSCAPE_API const TArray<ULandscapeWeightmapUsage*>& GetWeightmapTexturesUsage(const FGuid& InLayerGuid) const;
|
|
LANDSCAPE_API void InitializeLayersWeightmapUsage(const FGuid& InLayerGuid);
|
|
|
|
LANDSCAPE_API bool HasLayersData() const;
|
|
LANDSCAPE_API const FLandscapeLayerComponentData* GetLayerData(const FGuid& InLayerGuid) const;
|
|
LANDSCAPE_API FLandscapeLayerComponentData* GetLayerData(const FGuid& InLayerGuid);
|
|
LANDSCAPE_API void AddLayerData(const FGuid& InLayerGuid, const FLandscapeLayerComponentData& InData);
|
|
LANDSCAPE_API void AddDefaultLayerData(const FGuid& InLayerGuid, const TArray<ULandscapeComponent*>& InComponentsUsingHeightmap, TMap<UTexture2D*, UTexture2D*>& InOutCreatedHeightmapTextures);
|
|
LANDSCAPE_API void RemoveLayerData(const FGuid& InLayerGuid);
|
|
LANDSCAPE_API void ForEachLayer(TFunctionRef<void(const FGuid&, struct FLandscapeLayerComponentData&)> Fn);
|
|
|
|
/** Get the Landscape Actor's editing layer data */
|
|
FLandscapeLayerComponentData* GetEditingLayer();
|
|
const FLandscapeLayerComponentData* GetEditingLayer() const;
|
|
|
|
/** Get the Landscape Actor's editing layer GUID */
|
|
FGuid GetEditingLayerGUID() const;
|
|
|
|
void CopyFinalLayerIntoEditingLayer(FLandscapeEditDataInterface& DataInterface, TSet<UTexture2D*>& ProcessedHeightmaps);
|
|
|
|
void SetPendingCollisionDataUpdate(bool bInPendingCollisionDataUpdate) { bPendingCollisionDataUpdate = bInPendingCollisionDataUpdate; }
|
|
bool GetPendingCollisionDataUpdate() const { return bPendingCollisionDataUpdate; }
|
|
void SetPendingLayerCollisionDataUpdate(bool bInPendingLayerCollisionDataUpdate) { bPendingLayerCollisionDataUpdate = bInPendingLayerCollisionDataUpdate; }
|
|
bool GetPendingLayerCollisionDataUpdate() const { return bPendingLayerCollisionDataUpdate; }
|
|
|
|
void SetUndoChangedWeightmapAllocs(bool bInVal) { bUndoChangedWeightmapAllocs = bInVal; }
|
|
bool GetUndoChangedWeightmapAllocs() const { return bUndoChangedWeightmapAllocs; }
|
|
#endif // WITH_EDITOR
|
|
|
|
virtual bool IsShown(const FEngineShowFlags& ShowFlags) const override;
|
|
|
|
#if WITH_EDITOR
|
|
virtual int32 GetNumMaterials() const override;
|
|
virtual UMaterialInterface* GetMaterial(int32 ElementIndex) const override;
|
|
virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* Material) override;
|
|
virtual void PreFeatureLevelChange(ERHIFeatureLevel::Type PendingFeatureLevel) override;
|
|
#endif
|
|
//~ End UPrimitiveComponent Interface.
|
|
|
|
//~ Begin USceneComponent Interface.
|
|
#if WITH_EDITOR
|
|
virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty) override;
|
|
#endif // WITH_EDITOR
|
|
virtual void DestroyComponent(bool bPromoteChildren = false) override;
|
|
virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
|
|
//~ End USceneComponent Interface.
|
|
|
|
//~ Begin UActorComponent Interface.
|
|
virtual void OnRegister() override;
|
|
virtual void OnUnregister() override;
|
|
#if WITH_EDITOR
|
|
virtual void InvalidateLightingCacheDetailed(bool bInvalidateBuildEnqueuedLighting, bool bTranslationOnly) override;
|
|
#endif
|
|
virtual void PropagateLightingScenarioChange() override;
|
|
virtual bool IsHLODRelevant() const override;
|
|
//~ End UActorComponent Interface.
|
|
|
|
/** Gets the landscape info object for this landscape */
|
|
LANDSCAPE_API ULandscapeInfo* GetLandscapeInfo() const;
|
|
|
|
/** Returns the array of grass types used by the landscape material. Call UpdateGrassTypes first to ensure this array is up to date. */
|
|
const TArray<TObjectPtr<ULandscapeGrassType>>& GetGrassTypes() const { return GrassTypes; }
|
|
|
|
/** Temporarily sets the grass type for this component. Any call to UpdateGrassTypes may override what has been set using this method. */
|
|
void SetGrassTypes(const TArray<TObjectPtr<ULandscapeGrassType>>& InGrassTypes)
|
|
{
|
|
GrassTypes = InGrassTypes;
|
|
InvalidateGrassTypeSummary();
|
|
}
|
|
|
|
bool MaterialHasGrass() const { return !GetGrassTypes().IsEmpty(); }
|
|
|
|
double GetGrassTypesMaxDiscardDistance() const { return GrassTypeSummary.MaxInstanceDiscardDistance; }
|
|
void SetGrassTypesMaxDiscardDistance(const float InGrassTypesMaxDiscardDistance) { GrassTypeSummary.MaxInstanceDiscardDistance = InGrassTypesMaxDiscardDistance; GrassTypeSummary.bInvalid = false; }
|
|
|
|
/** If the LandscapeMaterial has changed, updates the GrassTypes array. Returns true if the GrassTypes array was updated. */
|
|
LANDSCAPE_API bool UpdateGrassTypes(bool bForceUpdate = false);
|
|
|
|
/** Installs new or updates existing TextureUserDatas for this component: up to one ULandscapeHeightmapTextureEdgeFixup and
|
|
* up to one UTextureMipDataProviderFactory (either ULandscapeTextureStorageProviderFactory or ULandscapeTextureMipEdgeOverrideFactory).
|
|
*
|
|
* The edge fixup class ULandscapeHeightmapTextureEdgeFixup is used to store edge snapshots and manage edge blending with neighboring heightmap textures.
|
|
*
|
|
* ULandscapeTextureStorageProviderFactory is used to stream custom-compressed heightmap texture mip data,
|
|
* and it supports also applying edge blending from the edge fixup class while streaming its mips.
|
|
*
|
|
* If bUseEdgeFixup is enabled, but bUseCompression is not, the ULandscapeTextureMipEdgeOverrideFactory is used to apply the edge blending
|
|
* on top of the standard built-in texture mip streaming.
|
|
*
|
|
* This function will ensure an edge fixup class exists if bUseEdgeFixup is true, or it will remove any existing ones otherwise.
|
|
*
|
|
* [EDITOR ONLY] It will capture a new snapshot for the edge fixup, when bUpdateSnapshotNow is true. Ignored in non-editor builds.
|
|
*
|
|
* [EDITOR ONLY] It will compress heightmaps to a ULandscapeTextureStorageProviderFactory when bUseCompression is true. Ignored in non-editor builds.
|
|
* NOTE: It will NOT remove an existing one if false -- applying compression is a one-way street, and should only be used in cooked content.
|
|
*/
|
|
ULandscapeHeightmapTextureEdgeFixup* InstallOrUpdateTextureUserDatas(bool bUseEdgeFixup, bool bUseCompression = false, bool bUpdateSnapshotNow = true, int32 HeightmapCompressionMipThreshold = 32);
|
|
|
|
#if WITH_EDITOR
|
|
/** Deletes a layer from this component if it does not contain data, calling DeleteLayerAllocation. */
|
|
bool DeleteLayerIfAllZero(const FGuid& InEditLayerGuid, const uint8* const TexDataPtr, int32 TexSize, int32 LayerIdx, bool bShouldDirtyPackage);
|
|
|
|
/** Deletes a material layer from the current edit layer on this component, removing all its data, adjusting other layer's weightmaps if necessary, etc. */
|
|
LANDSCAPE_API void DeleteLayer(ULandscapeLayerInfoObject* LayerInfo, FLandscapeEditDataInterface& LandscapeEdit);
|
|
|
|
/** Deletes a material layer from the specified edit layer on this component, removing all its data, adjusting other layer's weightmaps if necessary, etc. */
|
|
void DeleteLayerInternal(ULandscapeLayerInfoObject* LayerInfo, FLandscapeEditDataInterface& LandscapeEdit, const FGuid& InEditLayerGuid);
|
|
|
|
/** Deletes a layer from this component, but doesn't do anything else (assumes the user knows what he's doing, use DeleteLayer otherwise) */
|
|
void DeleteLayerAllocation(const FGuid& InEditLayerGuid, int32 InLayerAllocationIdx, bool bInShouldDirtyPackage);
|
|
|
|
/** Fills a layer to 100% on this component, adding it if needed and removing other layers that get painted away. Uses the edit layer specified by LandscapeEdit. */
|
|
LANDSCAPE_API void FillLayer(ULandscapeLayerInfoObject* LayerInfo, FLandscapeEditDataInterface& LandscapeEdit);
|
|
|
|
/** Replaces one layerinfo on this component with another */
|
|
LANDSCAPE_API void ReplaceLayer(ULandscapeLayerInfoObject* FromLayerInfo, ULandscapeLayerInfoObject* ToLayerInfo, FLandscapeEditDataInterface& LandscapeEdit);
|
|
void ReplaceLayerInternal(ULandscapeLayerInfoObject* FromLayerInfo, ULandscapeLayerInfoObject* ToLayerInfo, FLandscapeEditDataInterface& LandscapeEdit, const FGuid& InEditLayerGUID);
|
|
|
|
#endif // WITH_EDITOR
|
|
|
|
/** Destroys grass map data stored on the component */
|
|
void RemoveGrassMap();
|
|
|
|
/* Could a grassmap currently be generated, disregarding whether our textures are streamed in? */
|
|
LANDSCAPE_API bool CanRenderGrassMap() const;
|
|
|
|
#if WITH_EDITOR
|
|
/** Computes a hash representing the state of the material and grasstypes used by this component. */
|
|
LANDSCAPE_API uint32 ComputeGrassMapGenerationHash() const;
|
|
|
|
/* Returns true if the component HAS grass data, but it is not up to date */
|
|
bool IsGrassMapOutdated() const;
|
|
|
|
/** Renders the heightmap of this component (including material world-position-offset) at the specified LOD */
|
|
TArray<uint16> RenderWPOHeightmap(int32 LOD);
|
|
|
|
/* Serialize all hashes/guids that record the current state of this component */
|
|
void SerializeStateHashes(FArchive& Ar);
|
|
|
|
// Generates mobile platform data for this component
|
|
void GenerateMobileWeightmapLayerAllocations();
|
|
void GenerateMobilePlatformPixelData(bool bIsCooking, const ITargetPlatform* TargetPlatform);
|
|
|
|
/** Generate mobile data if it's missing or outdated */
|
|
void CheckGenerateMobilePlatformData(bool bIsCooking, const ITargetPlatform* TargetPlatform);
|
|
|
|
virtual TSubclassOf<class UHLODBuilder> GetCustomHLODBuilderClass() const override;
|
|
#endif
|
|
|
|
int32 GetCurrentRuntimeMaterialInstanceCount() const;
|
|
class UMaterialInterface* GetCurrentRuntimeMaterialInterface(int32 InIndex);
|
|
|
|
LANDSCAPE_API int32 GetMaterialInstanceCount(bool InDynamic = true) const;
|
|
LANDSCAPE_API class UMaterialInstance* GetMaterialInstance(int32 InIndex, bool InDynamic = true) const;
|
|
|
|
/** Gets the landscape material instance dynamic for this component */
|
|
UFUNCTION(BlueprintCallable, Category = "Landscape|Runtime|Material")
|
|
class UMaterialInstanceDynamic* GetMaterialInstanceDynamic(int32 InIndex) const;
|
|
|
|
/** Gets the landscape paint layer weight value at the given position using LandscapeLayerInfo . Returns 0 in case it fails. */
|
|
UFUNCTION(BlueprintCallable, Category = "Landscape|Editor")
|
|
LANDSCAPE_API float EditorGetPaintLayerWeightAtLocation(const FVector& InLocation, ULandscapeLayerInfoObject* PaintLayer);
|
|
|
|
/** Gets the landscape paint layer weight value at the given position using layer name. Returns 0 in case it fails. */
|
|
UFUNCTION(BlueprintCallable, Category = "Landscape|Editor")
|
|
LANDSCAPE_API float EditorGetPaintLayerWeightByNameAtLocation(const FVector& InLocation, const FName InPaintLayerName);
|
|
|
|
/** Get the landscape actor associated with this component. */
|
|
LANDSCAPE_API ALandscape* GetLandscapeActor() const;
|
|
|
|
/** Get the level in which the owning actor resides */
|
|
ULevel* GetLevel() const;
|
|
|
|
#if WITH_EDITOR
|
|
/** Returns all generated textures and material instances used by this component. */
|
|
LANDSCAPE_API void GetGeneratedTexturesAndMaterialInstances(TArray<UObject*>& OutTexturesAndMaterials) const;
|
|
LANDSCAPE_API TArray<UTexture*> GetGeneratedTextures() const;
|
|
LANDSCAPE_API TArray<UMaterialInstance*> GetGeneratedMaterialInstances() const;
|
|
#endif // WITH_EDITOR
|
|
|
|
/** Gets the landscape proxy actor which owns this component */
|
|
LANDSCAPE_API ALandscapeProxy* GetLandscapeProxy() const;
|
|
|
|
/** @return Component section base as FIntPoint */
|
|
FIntPoint GetSectionBase() const
|
|
{
|
|
return FIntPoint(SectionBaseX, SectionBaseY);
|
|
}
|
|
|
|
/** @return the component's coordinates (aka index, aka component key) in the entire landscape */
|
|
FIntPoint GetComponentKey() const
|
|
{
|
|
return GetSectionBase() / ComponentSizeQuads;
|
|
}
|
|
|
|
/** @param InSectionBase new section base for a component */
|
|
void SetSectionBase(FIntPoint InSectionBase)
|
|
{
|
|
SectionBaseX = InSectionBase.X;
|
|
SectionBaseY = InSectionBase.Y;
|
|
}
|
|
|
|
/**
|
|
* Computes the number of mips that are actually usable, i.e.:
|
|
* - For 1x1 subsection, the last mip is not usable (it has a single vertex)
|
|
* - For 2x2 subsections, the last 2 mips are not usable (a single vertex per subsection)
|
|
*/
|
|
int32 GetNumRelevantMips() const;
|
|
|
|
/** @todo document */
|
|
const FGuid& GetLightingGuid() const
|
|
{
|
|
#if WITH_EDITORONLY_DATA
|
|
return LightingGuid;
|
|
#else
|
|
static const FGuid NullGuid( 0, 0, 0, 0 );
|
|
return NullGuid;
|
|
#endif // WITH_EDITORONLY_DATA
|
|
}
|
|
|
|
/** @todo document */
|
|
void SetLightingGuid()
|
|
{
|
|
#if WITH_EDITORONLY_DATA
|
|
LightingGuid = FGuid::NewGuid();
|
|
#endif // WITH_EDITORONLY_DATA
|
|
}
|
|
|
|
FGuid GetMapBuildDataId() const
|
|
{
|
|
return MapBuildDataId;
|
|
}
|
|
|
|
LANDSCAPE_API const FMeshMapBuildData* GetMeshMapBuildData() const;
|
|
|
|
/** Initialize the landscape component */
|
|
LANDSCAPE_API void Init(int32 InBaseX, int32 InBaseY, int32 InComponentSizeQuads, int32 InNumSubsections, int32 InSubsectionSizeQuads);
|
|
|
|
/** Returns the component's LandscapeMaterial, or the Component's OverrideLandscapeMaterial if set */
|
|
LANDSCAPE_API UMaterialInterface* GetLandscapeMaterial(int8 InLODIndex = INDEX_NONE) const;
|
|
|
|
/** Returns the components's LandscapeHoleMaterial, or the Component's OverrideLandscapeHoleMaterial if set */
|
|
LANDSCAPE_API UMaterialInterface* GetLandscapeHoleMaterial() const;
|
|
|
|
#if WITH_EDITOR
|
|
/**
|
|
* Recalculate cached bounds using height values. Returns true when the bounds were changed.
|
|
*/
|
|
LANDSCAPE_API bool UpdateCachedBounds(bool bInApproximateBounds = false);
|
|
|
|
/**
|
|
* Update the MaterialInstance parameters to match the layer and weightmaps for this component
|
|
* Creates the MaterialInstance if it doesn't exist.
|
|
*/
|
|
LANDSCAPE_API void UpdateMaterialInstances();
|
|
LANDSCAPE_API void UpdateMaterialInstances(FMaterialUpdateContext& InOutMaterialContext, TArray<class FComponentRecreateRenderStateContext>& InOutRecreateRenderStateContext);
|
|
|
|
// Internal implementation of UpdateMaterialInstances, not safe to call directly
|
|
void UpdateMaterialInstances_Internal(FMaterialUpdateContext& Context);
|
|
|
|
/** Helper function for UpdateMaterialInstance to get Material without set parameters */
|
|
UMaterialInstanceConstant* GetCombinationMaterial(FMaterialUpdateContext* InMaterialUpdateContext, const TArray<FWeightmapLayerAllocationInfo>& Allocations, int8 InLODIndex, bool bMobile = false) const;
|
|
/**
|
|
* Generate mipmaps for height and tangent data.
|
|
* @param HeightmapTextureMipData - array of pointers to the locked mip data.
|
|
* This should only include the mips that are generated directly from this component's data
|
|
* ie where each subsection has at least 2 vertices.
|
|
* @param ComponentX1 - region of texture to update in component space, MAX_int32 meant end of X component in ALandscape::Import()
|
|
* @param ComponentY1 - region of texture to update in component space, MAX_int32 meant end of Y component in ALandscape::Import()
|
|
* @param ComponentX2 (optional) - region of texture to update in component space
|
|
* @param ComponentY2 (optional) - region of texture to update in component space
|
|
* @param TextureDataInfo - FLandscapeTextureDataInfo pointer, to notify of the mip data region updated.
|
|
*/
|
|
void GenerateHeightmapMips(TArray<FColor*>& HeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
|
|
|
|
/**
|
|
* if bClear is true, clears all mips on the specified texture to zero
|
|
* if bClear is false, clears all mips EXCEPT MIP 0 to zero
|
|
* Updates the texture hash appropriately for the given usage and texture type
|
|
*/
|
|
LANDSCAPE_API static void CreateEmptyTextureMips(UTexture2D* Texture, ELandscapeTextureUsage TextureUsage, ELandscapeTextureType TextureType, bool bClear = false);
|
|
|
|
/**
|
|
* Generate mipmaps for weightmap
|
|
* Assumes all weightmaps are unique to this component.
|
|
* @param WeightmapTextureBaseMipData: array of pointers to each of the weightmaps' base locked mip data.
|
|
*/
|
|
template<typename DataType>
|
|
|
|
/** @todo document */
|
|
static void GenerateMipsTempl(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, DataType* BaseMipData);
|
|
|
|
/** @todo document */
|
|
static void GenerateWeightmapMips(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, FColor* BaseMipData);
|
|
|
|
/**
|
|
* Update mipmaps for existing weightmap texture
|
|
*/
|
|
template<typename DataType>
|
|
|
|
/** @todo document */
|
|
static void UpdateMipsTempl(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, TArray<DataType*>& WeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
|
|
|
|
/** @todo document */
|
|
LANDSCAPE_API static void UpdateWeightmapMips(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* WeightmapTexture, TArray<FColor*>& WeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
|
|
|
|
/** @todo document */
|
|
static void UpdateDataMips(int32 InNumSubsections, int32 InSubsectionSizeQuads, UTexture2D* Texture, TArray<uint8*>& TextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, FLandscapeTextureDataInfo* TextureDataInfo=nullptr);
|
|
|
|
/**
|
|
* Create or updates collision component height data
|
|
* @param HeightmapTextureMipData: heightmap data
|
|
* @param ComponentX1, ComponentY1, ComponentX2, ComponentY2: region to update
|
|
* @param bUpdateBounds: Whether to update bounds from render component.
|
|
* @param XYOffsetTextureMipData: xy-offset map data
|
|
* @returns True if CollisionComponent was created in this update.
|
|
*/
|
|
void UpdateCollisionHeightData(const FColor* HeightmapTextureMipData, const FColor* SimpleCollisionHeightmapTextureData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32, bool bUpdateBounds=false, const FColor* XYOffsetTextureMipData=nullptr, bool bInUpdateHeightfieldRegion=true);
|
|
|
|
/**
|
|
* Deletes Collision Component
|
|
*/
|
|
void DestroyCollisionData();
|
|
|
|
/** Updates collision component height data for the entire component, locking and unlocking heightmap textures
|
|
*/
|
|
void UpdateCollisionData(bool bInUpdateHeightfieldRegion = true);
|
|
|
|
/** Cumulates component's dirtied collision region that will need to be updated (used by Layer System)*/
|
|
void UpdateDirtyCollisionHeightData(FIntRect Region);
|
|
|
|
/** Clears component's dirtied collision region (used by Layer System)*/
|
|
void ClearDirtyCollisionHeightData();
|
|
|
|
/**
|
|
* Update collision component dominant layer data
|
|
* @param WeightmapTextureMipData: weightmap data
|
|
* @param ComponentX1, ComponentY1, ComponentX2, ComponentY2: region to update
|
|
* @param Whether to update bounds from render component.
|
|
*/
|
|
void UpdateCollisionLayerData(const FColor* const* WeightmapTextureMipData, const FColor* const* const SimpleCollisionWeightmapTextureMipData, int32 ComponentX1=0, int32 ComponentY1=0, int32 ComponentX2=MAX_int32, int32 ComponentY2=MAX_int32);
|
|
|
|
/**
|
|
* Update collision component dominant layer data for the whole component, locking and unlocking the weightmap textures.
|
|
*/
|
|
LANDSCAPE_API void UpdateCollisionLayerData();
|
|
|
|
/** Returns true if we can currently update physical materials. */
|
|
bool CanUpdatePhysicalMaterial();
|
|
/** Update physical material render tasks. */
|
|
void UpdatePhysicalMaterialTasks();
|
|
/** Write the physical materials into the LandscapeComponent from the Render & Immediately Rebuild physics if requested */
|
|
void FinalizePhysicalMaterial(bool bInImmediatePhysicsRebuild);
|
|
/** Update collision component physical materials from render task results. */
|
|
void UpdateCollisionPhysicalMaterialData(TArray<UPhysicalMaterial*> const& InPhysicalMaterials, TArray<uint8> const& InMaterialIds);
|
|
|
|
/**
|
|
* Create weightmaps for this component for the layers specified in the WeightmapLayerAllocations array, works in the landscape current edit layer when InCanUseEditingWeightmap is true
|
|
*/
|
|
UE_DEPRECATED(5.5, "Use the new prototype of ReallocateWeightmaps : note : this is very internal stuff, normally, you shouldn't have to use this function at all")
|
|
LANDSCAPE_API void ReallocateWeightmaps(FLandscapeEditDataInterface* DataInterface = nullptr, bool InCanUseEditingWeightmap = true, bool InSaveToTransactionBuffer = true, bool InForceReallocate = false, ALandscapeProxy* InTargetProxy = nullptr, TArray<UTexture*>* OutNewCreatedTextures = nullptr);
|
|
|
|
/**
|
|
* Create weightmaps for this component for the layers specified in the WeightmapLayerAllocations array, works in the specified edit layer
|
|
*/
|
|
LANDSCAPE_API TArray<UTexture*> ReallocateWeightmaps(FLandscapeEditDataInterface* DataInterface, const FGuid& InEditLayerGuid, bool bInSaveToTransactionBuffer, bool bInForceReallocate, ALandscapeProxy* InTargetProxy, TSet<ULandscapeComponent*>* InRestrictSharingToComponents);
|
|
|
|
/** Returns true if the component has a valid LandscapeHoleMaterial */
|
|
LANDSCAPE_API bool IsLandscapeHoleMaterialValid() const;
|
|
|
|
/** Returns true if this component has visibility painted */
|
|
LANDSCAPE_API bool ComponentHasVisibilityPainted() const;
|
|
|
|
LANDSCAPE_API ULandscapeLayerInfoObject* GetVisibilityLayer() const;
|
|
|
|
/**
|
|
* Generate a key for a component's layer allocations to use with MaterialInstanceConstantMap.
|
|
*/
|
|
static FString GetLayerAllocationKey(const TArray<FWeightmapLayerAllocationInfo>& Allocations, UMaterialInterface* LandscapeMaterial, bool bMobile = false);
|
|
|
|
bool ValidateCombinationMaterial(UMaterialInstanceConstant* InCombinationMaterial) const;
|
|
|
|
/** @todo document */
|
|
void GetLayerDebugColorKey(int32& R, int32& G, int32& B) const;
|
|
|
|
/** @todo document */
|
|
void RemoveInvalidWeightmaps();
|
|
void RemoveInvalidWeightmaps(const FGuid& InEditLayerGuid);
|
|
|
|
/** @todo document */
|
|
LANDSCAPE_API void InitHeightmapData(TArray<FColor>& Heights, bool bUpdateCollision);
|
|
|
|
/** @todo document */
|
|
LANDSCAPE_API void InitWeightmapData(TArray<ULandscapeLayerInfoObject*>& LayerInfos, TArray<TArray<uint8> >& Weights);
|
|
|
|
/** @todo document */
|
|
LANDSCAPE_API float GetLayerWeightAtLocation( const FVector& InLocation, ULandscapeLayerInfoObject* LayerInfo, TArray<uint8>* LayerCache = NULL, bool bUseEditingWeightmap = false);
|
|
|
|
/** Extends passed region with this component's 2D bounds (values are in landscape quads) */
|
|
LANDSCAPE_API void GetComponentExtent(int32& MinX, int32& MinY, int32& MaxX, int32& MaxY) const;
|
|
|
|
/** returns the 2D bounds of this component (in landscape quads) */
|
|
LANDSCAPE_API FIntRect GetComponentExtent() const;
|
|
|
|
LANDSCAPE_API void ClearUpdateFlagsForModes(uint32 InModeMask);
|
|
LANDSCAPE_API void RequestWeightmapUpdate(bool bUpdateAll = false, bool bUpdateCollision = true, bool bInUserTriggered = false);
|
|
LANDSCAPE_API void RequestHeightmapUpdate(bool bUpdateAll = false, bool bUpdateCollision = true, bool bInUserTriggered = false);
|
|
LANDSCAPE_API void RequestEditingClientUpdate(bool bInUserTriggered = false);
|
|
LANDSCAPE_API void RequestDeferredClientUpdate();
|
|
uint32 GetLayerUpdateFlagPerMode() const { return LayerUpdateFlagPerMode; }
|
|
LANDSCAPE_API uint32 ComputeWeightmapsHash();
|
|
|
|
void GetUsedPaintLayers(const FGuid& InLayerGuid, TArray<ULandscapeLayerInfoObject*>& OutUsedLayerInfos) const;
|
|
|
|
void GetLandscapeComponentNeighborsToRender(TSet<ULandscapeComponent*>& NeighborComponents) const;
|
|
void GetLandscapeComponentWeightmapsToRender(TSet<ULandscapeComponent*>& WeightmapComponents) const;
|
|
void GetLandscapeComponentNeighbors3x3(TStaticArray<ULandscapeComponent*, 9>& OutNeighborComponents) const;
|
|
#endif
|
|
|
|
/** Updates navigation properties to match landscape actor's */
|
|
void UpdateNavigationRelevance();
|
|
|
|
/** Updates the reject navmesh underneath flag in the collision component */
|
|
void UpdateRejectNavmeshUnderneath();
|
|
|
|
/** Updates the values of component-level properties exposed by the Landscape Actor */
|
|
LANDSCAPE_API void UpdatedSharedPropertiesFromActor();
|
|
|
|
friend class FLandscapeComponentSceneProxy;
|
|
friend struct FLandscapeComponentDataInterface;
|
|
|
|
LANDSCAPE_API void SetLOD(bool bForced, int32 InLODValue);
|
|
|
|
UFUNCTION(BlueprintCallable, Category = "LandscapeComponent")
|
|
LANDSCAPE_API void SetForcedLOD(int32 InForcedLOD);
|
|
|
|
UFUNCTION(BlueprintCallable, Category = "LandscapeComponent")
|
|
LANDSCAPE_API void SetLODBias(int32 InLODBias);
|
|
|
|
void SetNaniteActive(bool bValue);
|
|
|
|
inline bool IsNaniteActive() const
|
|
{
|
|
return bNaniteActive;
|
|
}
|
|
|
|
ULandscapeHeightfieldCollisionComponent* GetCollisionComponent() const { return CollisionComponentRef.Get(); }
|
|
void SetCollisionComponent(ULandscapeHeightfieldCollisionComponent* InCollisionComponent) { CollisionComponentRef = InCollisionComponent; }
|
|
|
|
void SetUserTriggeredChangeRequested(bool bInUserTriggeredChangeRequested)
|
|
{
|
|
bUserTriggeredChangeRequested = bInUserTriggeredChangeRequested;
|
|
}
|
|
|
|
bool GetUserTriggeredChangeRequested() const
|
|
{
|
|
return bUserTriggeredChangeRequested;
|
|
}
|
|
|
|
protected:
|
|
|
|
#if WITH_EDITOR
|
|
void RecreateCollisionComponent(bool bUseSimpleCollision);
|
|
void UpdateCollisionHeightBuffer(int32 InComponentX1, int32 InComponentY1, int32 InComponentX2, int32 InComponentY2, int32 InCollisionMipLevel, int32 InHeightmapSizeU, int32 InHeightmapSizeV,
|
|
const FColor* const InHeightmapTextureMipData, uint16* CollisionHeightData, uint16* GrassHeightData,
|
|
const FColor* const InXYOffsetTextureMipData, uint16* CollisionXYOffsetData);
|
|
void UpdateDominantLayerBuffer(int32 InComponentX1, int32 InComponentY1, int32 InComponentX2, int32 InComponentY2, int32 InCollisionMipLevel, int32 InWeightmapSizeU, int32 InDataLayerIdx, const TArray<uint8*>& InCollisionDataPtrs, const TArray<ULandscapeLayerInfoObject*>& InLayerInfos, uint8* DominantLayerData);
|
|
#endif
|
|
|
|
/** Whether the component type supports static lighting. */
|
|
virtual bool SupportsStaticLighting() const override
|
|
{
|
|
return true;
|
|
}
|
|
|
|
#if WITH_EDITOR
|
|
public:
|
|
/** Records the ULandscapeComponents that are modified in any undo/redo operation that is being applied currently */
|
|
static uint32 UndoRedoModifiedComponentCount;
|
|
static TMap<ULandscapeComponent*, uint32> UndoRedoModifiedComponents;
|
|
#endif // WITH_EDITOR
|
|
};
|