1008 lines
31 KiB
Ucode
1008 lines
31 KiB
Ucode
/**
|
|
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
|
|
*/
|
|
class Terrain extends Info
|
|
dependson(LightComponent)
|
|
native(Terrain)
|
|
showcategories(Movement,Collision)
|
|
`if(`__TW_)
|
|
notplaceable; // use landscape!
|
|
`else
|
|
placeable;
|
|
`endif
|
|
|
|
// Structs that are mirrored properly in C++.
|
|
|
|
/**
|
|
* A height data entry that is stored in an array for the terrain.
|
|
* Full structure can be found in UnTerrain.h, FTerrainHeight.
|
|
*/
|
|
struct TerrainHeight
|
|
{
|
|
// No UObject reference.
|
|
};
|
|
|
|
/**
|
|
* InfoData entries for each patch in the terrain.
|
|
* This includes information such as whether the patch is visible or not (holes).
|
|
* Full structure can be found in UnTerrain.h, FTerrainInfoData.
|
|
*/
|
|
struct TerrainInfoData
|
|
{
|
|
// No UObject reference.
|
|
};
|
|
|
|
/**
|
|
* A weighted material used on the terrain.
|
|
* Full structure can be found in UnTerrain.h, FTerrainWeightedMaterial.
|
|
*/
|
|
struct TerrainWeightedMaterial
|
|
{
|
|
// UObject references.
|
|
};
|
|
|
|
/**
|
|
* A layer that can be painted onto the terrain.
|
|
*/
|
|
struct TerrainLayer
|
|
{
|
|
/** The name of the layer, for UI display purposes. */
|
|
var() string Name;
|
|
/** The TerrainLayerSetup, which declares the material(s) used in the layer. */
|
|
var() TerrainLayerSetup Setup;
|
|
/** INTERNAL: The index of the alpha map that represents the application of this layer. */
|
|
var int AlphaMapIndex;
|
|
/** Whether the layer should be highlighted when rendered. */
|
|
var() bool Highlighted;
|
|
/** Whether the layer should be wireframe highlighted when rendered.
|
|
* CURRENTLY NOT IMPLEMENTED
|
|
*/
|
|
var() bool WireframeHighlighted;
|
|
/** Whether the layer is hidden (not rendered). */
|
|
var() bool Hidden;
|
|
/** The color to highlight the layer with. */
|
|
var() color HighlightColor;
|
|
/** The color to wireframe highlight the layer with. */
|
|
var() color WireframeColor;
|
|
/**
|
|
* Rectangle encompassing all the vertices this layer affects.
|
|
* TerrainLayerSetup::SetMaterial() uses this to avoid rebuilding
|
|
* terrain that has not changed
|
|
*/
|
|
var int MinX, MinY, MaxX, MaxY;
|
|
|
|
structdefaultproperties
|
|
{
|
|
AlphaMapIndex=-1
|
|
HighlightColor=(R=255,G=255,B=255)
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A mapping used to apply a layer to the terrain.
|
|
* Full structure can be found in UnTerrain.h, FAlphaMap.
|
|
*/
|
|
struct AlphaMap
|
|
{
|
|
// No UObject references.
|
|
};
|
|
|
|
/**
|
|
* A decoration instance applied to the terrain.
|
|
* Used internally to apply DecoLayers.
|
|
*/
|
|
struct TerrainDecorationInstance
|
|
{
|
|
var PrimitiveComponent Component;
|
|
var float X,
|
|
Y,
|
|
Scale;
|
|
var int Yaw;
|
|
};
|
|
|
|
/**
|
|
* A decoration source for terrain DecoLayers.
|
|
*/
|
|
struct TerrainDecoration
|
|
{
|
|
/** The factory used to generate the decoration mesh. */
|
|
var() editinline PrimitiveComponentFactory Factory;
|
|
/** The min scale to apply to the source mesh. */
|
|
var() float MinScale;
|
|
/** The max scale to apply to the source mesh. */
|
|
var() float MaxScale;
|
|
/** The density to use when applying the mesh to the terrain. */
|
|
var() float Density;
|
|
/**
|
|
* The amount to rotate the mesh to match the slope of the terrain
|
|
* where it is being placed. If 1.0, the mesh will match the slope
|
|
* exactly.
|
|
*/
|
|
var() float SlopeRotationBlend;
|
|
/** The value to use to seed the random number generator. */
|
|
var() int RandSeed;
|
|
|
|
/**
|
|
* INTERNAL: An array of instances of the decoration applied to the
|
|
* terrain.
|
|
*/
|
|
var array<TerrainDecorationInstance> Instances;
|
|
|
|
structdefaultproperties
|
|
{
|
|
Density=0.01
|
|
MinScale=1.0
|
|
MaxScale=1.0
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A decoration layer - used to easily apply static meshes to the terrain
|
|
*/
|
|
struct TerrainDecoLayer
|
|
{
|
|
/** The name of the DecoLayer, for UI display purposes. */
|
|
var() string Name;
|
|
/** The decoration(s) to apply for this layer. */
|
|
var() array<TerrainDecoration> Decorations;
|
|
/** INTERNAL: The index of the alpha map that represents the application of this layer. */
|
|
var int AlphaMapIndex;
|
|
|
|
structdefaultproperties
|
|
{
|
|
AlphaMapIndex=-1
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Terrain material resource - compiled terrain material used to render the terrain.
|
|
* Full structure can be found in UnTerrain.h, FTerrainMaterialResource.
|
|
*/
|
|
struct TerrainMaterialResource
|
|
{
|
|
// UObject references.
|
|
};
|
|
|
|
/** Array of the terrain heights */
|
|
var private const native array<TerrainHeight> Heights;
|
|
/** Array of the terrain information data (visible, etc.) */
|
|
var private const native array<TerrainInfoData> InfoData;
|
|
/** Array of the terrain layers applied to the terrain */
|
|
var() const array<TerrainLayer> Layers;
|
|
/**
|
|
* The index of the layer that supplies the normal map for the whole terrain.
|
|
* If this is -1, the terrain will compile the normal property the old way
|
|
* (all normal maps blended together).
|
|
* If this is a valid index into the layer array, it will compile the normal
|
|
* property only for the material(s) contained in said layer.
|
|
*/
|
|
var() int NormalMapLayer;
|
|
/** Array of the decoration layers applied */
|
|
var() const array<TerrainDecoLayer> DecoLayers;
|
|
/** Array of the alpha maps between layers */
|
|
var native const array<AlphaMap> AlphaMaps;
|
|
|
|
/** The array of terrain components that are used by the terrain */
|
|
var const NonTransactional array<TerrainComponent> TerrainComponents;
|
|
|
|
/**
|
|
* Internal values used to setup components
|
|
*
|
|
* The number of sections is the number of terrain components along the
|
|
* X and Y of the 'grid'.
|
|
*/
|
|
var const int NumSectionsX;
|
|
var const int NumSectionsY;
|
|
|
|
/** INTERNAL - The weighted materials and blend maps */
|
|
var private native const array<TerrainWeightedMaterial> WeightedMaterials;
|
|
var private const native array<TerrainWeightMapTexture> WeightedTextureMaps;
|
|
|
|
/**
|
|
* The maximum number of quads in a single row/column of a tessellated patch.
|
|
* Must be a power of two, 1 <= MaxTesselationLevel <= 16
|
|
*/
|
|
var() int MaxTesselationLevel;
|
|
|
|
/**
|
|
* The minimum number of quads in a tessellated patch.
|
|
* Must be a power of two, 1 <= MaxTesselationLevel
|
|
*/
|
|
var() int MinTessellationLevel;
|
|
|
|
/**
|
|
* The scale factor to apply to the distance used in determining the tessellation
|
|
* level to utilize when rendering a patch.
|
|
* TessellationLevel = SomeFunction((Patch distance to camera) * TesselationDistanceScale)
|
|
*/
|
|
var() float TesselationDistanceScale;
|
|
|
|
/**
|
|
* The radius from the view origin that terrain tessellation checks should be performed.
|
|
* If less than 0, the general setting from the engine configuration will be used.
|
|
* If 0.0, every component will be checked for tessellation changes each frame.
|
|
*/
|
|
var() float TessellationCheckDistance;
|
|
|
|
/**
|
|
* The tessellation level to utilize when performing collision checks with non-zero extents.
|
|
*/
|
|
var(Collision) int CollisionTesselationLevel;
|
|
|
|
struct native CachedTerrainMaterialArray
|
|
{
|
|
var native const array<pointer> CachedMaterials{FTerrainMaterialResource};
|
|
};
|
|
/**
|
|
* array of cached terrain materials
|
|
* Only the first entry is ever used now that SM2 is no longer supported,
|
|
* But the member is kept as an array to make adding future material platforms easier.
|
|
* The second entry is to work around the script compile error from having an array with one element.
|
|
*/
|
|
var native const CachedTerrainMaterialArray CachedTerrainMaterials[2];
|
|
|
|
/**
|
|
* The number of vertices currently stored in a single row of height and alpha data.
|
|
* Updated from NumPatchesX when Allocate is called(usually from PostEditChange).
|
|
*/
|
|
var const int NumVerticesX;
|
|
|
|
/**
|
|
* The number of vertices currently stored in a single column of height and alpha data.
|
|
* Updated from NumPatchesY when Allocate is called(usually from PostEditChange).
|
|
*/
|
|
var const int NumVerticesY;
|
|
|
|
/**
|
|
* The number of patches in a single row of the terrain's patch grid.
|
|
* PostEditChange clamps this to be >= 1.
|
|
* Note that if you make this and/or NumPatchesY smaller, it will destroy the height-map/alpha-map
|
|
* data which is no longer used by the patches.If you make the dimensions larger, it simply fills
|
|
* in the new height-map/alpha-map data with zero.
|
|
*/
|
|
var() int NumPatchesX;
|
|
|
|
/**
|
|
* The number of patches in a single column of the terrain's patch grid.
|
|
* PostEditChange clamps this to be >= 1.
|
|
*/
|
|
var() int NumPatchesY;
|
|
|
|
/**
|
|
* For rendering and collision, split the terrain into components with a maximum size of
|
|
* (MaxComponentSize,MaxComponentSize) patches.
|
|
* The terrain is split up into rectangular groups of patches called terrain components for rendering.
|
|
* MaxComponentSize is the maximum number of patches in a single row/column of a terrain component.
|
|
* Generally, all components will be MaxComponentSize patches square, but on terrains with a patch
|
|
* resolution which isn't a multiple of MaxComponentSize, there will be some components along the edges
|
|
* which are smaller.
|
|
*
|
|
* This is limited by the MaxTesselationLevel, to prevent the vertex buffer for a fully tessellated
|
|
* component from being > 65536 vertices.
|
|
* For a MaxTesselationLevel of 16, MaxComponentSize is limited to <= 15.
|
|
* For a MaxTesselationLevel of 8, MaxComponentSize is limited to <= 31.
|
|
*
|
|
* PostEditChange clamps this to be >= 1.
|
|
*/
|
|
var() int MaxComponentSize;
|
|
|
|
/**
|
|
* The resolution to cache lighting at, in texels/patch.
|
|
* A separate shadow-map is used for each terrain component, which is up to
|
|
* (MaxComponentSize * StaticLightingResolution + 1) pixels on a side.
|
|
* Must be a power of two, 1 <= StaticLightingResolution <= MaxTesselationLevel.
|
|
*/
|
|
var(Lighting) int StaticLightingResolution;
|
|
|
|
/**
|
|
* If true, the light/shadow map size is no longer restricted...
|
|
* The size of the light map will be (per component):
|
|
* INT LightMapSizeX = Component->SectionSizeX * StaticLightingResolution + 1;
|
|
* INT LightMapSizeY = Component->SectionSizeY * StaticLightingResolution + 1;
|
|
*
|
|
* So, the maximum size of a light/shadow map for a component will be:
|
|
* MaxMapSizeX = MaxComponentSize * StaticLightingResolution + 1
|
|
* MaxMapSizeY = MaxComponentSize * StaticLightingResolution + 1
|
|
*
|
|
* Be careful with the setting of StaticLightingResolution when this mode is enabled.
|
|
* It will be quite easy to run up a massive texture requirement on terrain!
|
|
*/
|
|
var(Lighting) bool bIsOverridingLightResolution;
|
|
|
|
/**
|
|
* If true, the lightmap generation will be performed using the bilinear filtering
|
|
* that all other lightmap generation in the engine uses.
|
|
*
|
|
*/
|
|
var(Lighting) bool bBilinearFilterLightmapGeneration;
|
|
|
|
/**
|
|
* Whether terrain should cast shadows.
|
|
*
|
|
* Property is propagated to terrain components
|
|
*/
|
|
var(Lighting) bool bCastShadow;
|
|
|
|
/**
|
|
* If true, forces all static lights to use light-maps for direct lighting on the terrain, regardless of
|
|
* the light's UseDirectLightMap property.
|
|
*
|
|
* Property is propagated to terrain components .
|
|
*/
|
|
var(Lighting) const bool bForceDirectLightMap;
|
|
|
|
/**
|
|
* If false, primitive does not cast dynamic shadows.
|
|
*
|
|
* Property is propagated to terrain components .
|
|
*/
|
|
var(Lighting) const bool bCastDynamicShadow;
|
|
|
|
/**
|
|
* If TRUE, enable specular on this terrain.
|
|
*/
|
|
var(Lighting) bool bEnableSpecular;
|
|
|
|
/**
|
|
* If false, primitive does not block rigid body physics.
|
|
*
|
|
* Property is propagated to terrain components.
|
|
*/
|
|
var(Collision) const bool bBlockRigidBody;
|
|
|
|
/** If true, this allows rigid bodies to go underneath visible areas of the terrain. This adds some physics cost. */
|
|
var(Collision) const bool bAllowRigidBodyUnderneath;
|
|
|
|
/** PhysicalMaterial to use for entire terrain */
|
|
var(Physics) const PhysicalMaterial TerrainPhysMaterialOverride;
|
|
|
|
/**
|
|
* If false, primitive does not accept dynamic lights, aka lights with HasStaticShadowing() == FALSE
|
|
*
|
|
* Property is propagated to terrain components.
|
|
*/
|
|
var(Lighting) const bool bAcceptsDynamicLights;
|
|
|
|
/**
|
|
* Lighting channels controlling light/ primitive interaction. Only allows interaction if at least one channel is shared */
|
|
var(Lighting) const LightingChannelContainer LightingChannels;
|
|
|
|
/**
|
|
* Lightmass settings for the terrain
|
|
*/
|
|
var(Lightmass) LightmassPrimitiveSettings LightmassSettings <ScriptOrder=true>;
|
|
|
|
/**
|
|
* Whether to utilize morping terrain or not
|
|
*/
|
|
var() bool bMorphingEnabled;
|
|
/**
|
|
* Whether to utilize morping gradients or not (bMorphingEnabled must be true for this to matter)
|
|
*/
|
|
var() bool bMorphingGradientsEnabled;
|
|
|
|
/** The terrain is locked - no editing can take place on it */
|
|
var bool bLocked;
|
|
|
|
/** The terrain heightmap is locked - no editing can take place on it */
|
|
var bool bHeightmapLocked;
|
|
|
|
/** Command fence used to shut down properly */
|
|
var native const pointer ReleaseResourcesFence{FRenderCommandFence};
|
|
|
|
/** Editor-viewing tessellation level */
|
|
var() transient int EditorTessellationLevel;
|
|
|
|
/** Viewing collision tessellation level */
|
|
var bool bShowingCollision;
|
|
|
|
/** Base UVs from world origin, to avoid layering seams in adjacent terrains */
|
|
var() bool bUseWorldOriginTextureUVs;
|
|
|
|
/** Selected vertex structure - used for vertex editing */
|
|
struct SelectedTerrainVertex
|
|
{
|
|
/** The position of the vertex. */
|
|
var int X, Y;
|
|
/** The weight of the selection. */
|
|
var int Weight;
|
|
};
|
|
|
|
var transient array<SelectedTerrainVertex> SelectedVertices;
|
|
|
|
/** Tells the terrain to render in wireframe. */
|
|
var() bool bShowWireframe;
|
|
/** The color to use when rendering the wireframe of the terrain. */
|
|
var() color WireframeColor;
|
|
|
|
/** Unique ID for this terrain, used for caching during distributed lighting */
|
|
var private const editoronly Guid LightingGuid;
|
|
|
|
cpptext
|
|
{
|
|
// UObject interface
|
|
|
|
virtual void Serialize(FArchive& Ar);
|
|
virtual void PreEditChange(UProperty* PropertyThatChanged);
|
|
virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent);
|
|
virtual void PostEditMove(UBOOL bFinished);
|
|
|
|
protected:
|
|
void HandleLegacyTextureReferences();
|
|
public:
|
|
|
|
virtual void PostLoad();
|
|
|
|
/**
|
|
* @return Sum of the size of textures referenced by this material.
|
|
*/
|
|
virtual INT GetResourceSize();
|
|
|
|
/**
|
|
* Called before the Actor is saved.
|
|
*/
|
|
virtual void PreSave();
|
|
virtual void BeginDestroy();
|
|
virtual UBOOL IsReadyForFinishDestroy();
|
|
virtual void FinishDestroy();
|
|
|
|
virtual void ClearWeightMaps();
|
|
virtual void TouchWeightMapResources();
|
|
|
|
/**
|
|
* Callback used to allow object register its direct object references that are not already covered by
|
|
* the token stream.
|
|
*
|
|
* @param ObjectArray array to add referenced objects to via AddReferencedObject
|
|
*/
|
|
void AddReferencedObjects( TArray<UObject*>& ObjectArray );
|
|
|
|
// AActor interface
|
|
|
|
virtual void Spawned();
|
|
virtual UBOOL ShouldTrace(UPrimitiveComponent* Primitive,AActor *SourceActor, DWORD TraceFlags);
|
|
|
|
virtual void InitRBPhys();
|
|
virtual void TermRBPhys(FRBPhysScene* Scene);
|
|
|
|
virtual 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
|
|
}
|
|
|
|
virtual void SetLightingGuid()
|
|
{
|
|
#if WITH_EDITORONLY_DATA
|
|
LightingGuid = appCreateGuid();
|
|
#endif // WITH_EDITORONLY_DATA
|
|
}
|
|
|
|
/**
|
|
* Function that gets called from within Map_Check to allow this actor to check itself
|
|
* for any potential errors and register them with map check dialog.
|
|
*/
|
|
#if WITH_EDITOR
|
|
virtual void CheckForErrors();
|
|
|
|
/**
|
|
* Function that is called from CheckForErrors - specifically checks for material errors.
|
|
*/
|
|
void CheckForMaterialErrors();
|
|
#endif
|
|
virtual void ClearComponents();
|
|
|
|
/** Called by the lighting system to allow actors to order their components for deterministic lighting */
|
|
virtual void OrderComponentsForDeterministicLighting();
|
|
|
|
protected:
|
|
virtual void UpdateComponentsInternal(UBOOL bCollisionUpdate = FALSE);
|
|
public:
|
|
virtual void UpdatePatchBounds(INT MinX,INT MinY,INT MaxX,INT MaxY);
|
|
|
|
void WeldEdgesToOtherTerrains();
|
|
|
|
virtual UBOOL ActorLineCheck(FCheckResult& Result,const FVector& End,const FVector& Start,const FVector& Extent,DWORD TraceFlags);
|
|
|
|
// CompactAlphaMaps - Cleans up alpha maps that are no longer used.
|
|
|
|
void CompactAlphaMaps();
|
|
|
|
// CacheWeightMaps - Generates the weightmaps from the layer stack and filtered materials.
|
|
|
|
void CacheWeightMaps(INT MinX,INT MinY,INT MaxX,INT MaxY);
|
|
|
|
// CacheDecorations - Generates a set of decoration components for an area of the terrain.
|
|
void CacheDecorations(INT MinX,INT MinY,INT MaxX,INT MaxY);
|
|
|
|
// UpdateRenderData - Updates the weightmaps, displacements, decorations, vertex buffers and bounds when the heightmap, an alphamap or a terrain property changes.
|
|
void UpdateRenderData(INT MinX,INT MinY,INT MaxX,INT MaxY);
|
|
|
|
/** updates decoration components to account for terrain/layer property changes */
|
|
void UpdateDecorationComponents();
|
|
|
|
/** Clamps the vertex index to a valid vertex index (0 to NumVerticesX - 1, 0 to NumVerticesY - 1) that can be used to address the vertex collection.
|
|
* An invalid vertex index is something like (-1,-1) which would cause an array out of bounds exception.
|
|
*
|
|
* @param OutX The clamped X coordinate.
|
|
* @param OutY The clamped Y coordinate.
|
|
*/
|
|
void ClampVertexIndex(INT& OutX, INT& OutY) const;
|
|
|
|
/**
|
|
* Allocates and initializes resolution dependent persistent data. (height-map, alpha-map, components)
|
|
* Keeps the old height-map and alpha-map data, cropping and extending as necessary.
|
|
* Uses DesiredSizeX, DesiredSizeY to determine the desired resolution.
|
|
* DesiredSectionSize determines the size of the components the terrain is split into.
|
|
*/
|
|
void Allocate();
|
|
|
|
/**
|
|
* Recreates all the components
|
|
*/
|
|
void RecreateComponents();
|
|
|
|
/**
|
|
* Split a terrain along the X or Y axis
|
|
* Returns the new terrain if successful
|
|
*/
|
|
ATerrain* SplitTerrain( UBOOL SplitOnXAxis, INT RemainingPatches );
|
|
void SplitTerrainPreview( class FPrimitiveDrawInterface* PDI, UBOOL SplitOnXAxis, INT RemainingPatches );
|
|
|
|
/**
|
|
* Merges this terrain with another specified terrain if possible
|
|
* Returns success TRUE/FALSE
|
|
*/
|
|
UBOOL MergeTerrain( ATerrain* Other );
|
|
UBOOL MergeTerrainPreview( class FPrimitiveDrawInterface* PDI, ATerrain* Other );
|
|
|
|
/**
|
|
* Add or remove sectors to the terrain
|
|
*
|
|
* @param CountX The number of sectors in the X-direction. If negative,
|
|
* they will go to the left, otherwise to the right.
|
|
* @param CountY The number of sectors in the Y-direction. If negative,
|
|
* they will go to the bottom, otherwise to the top.
|
|
* @param bRemove If TRUE, remove the sectors, otherwise add them.
|
|
*
|
|
* @return UBOOL TRUE if successful.
|
|
*/
|
|
UBOOL AddRemoveSectors(INT CountX, INT CountY, UBOOL bRemove);
|
|
|
|
// Internal functions for adding/removing sectos
|
|
void StoreOldData(TArray<FTerrainHeight>& OldHeights, TArray<FTerrainInfoData>& OldInfoData, TArray<FAlphaMap>& OldAlphaMaps);
|
|
void SetupSizeData();
|
|
UBOOL AddSectors_X(INT Count);
|
|
UBOOL AddSectors_Y(INT Count);
|
|
UBOOL RemoveSectors_X(INT Count);
|
|
UBOOL RemoveSectors_Y(INT Count);
|
|
|
|
// Data access.
|
|
|
|
//
|
|
// ATerrain::Height
|
|
//
|
|
inline const WORD& Height(INT X,INT Y) const
|
|
{
|
|
X = Clamp(X,0,NumVerticesX - 1);
|
|
Y = Clamp(Y,0,NumVerticesY - 1);
|
|
return Heights(Y * NumVerticesX + X).Value;
|
|
}
|
|
|
|
//
|
|
// ATerrain::Height
|
|
//
|
|
inline WORD& Height(INT X,INT Y)
|
|
{
|
|
X = Clamp(X,0,NumVerticesX - 1);
|
|
Y = Clamp(Y,0,NumVerticesY - 1);
|
|
return Heights(Y * NumVerticesX + X).Value;
|
|
}
|
|
|
|
inline WORD BilinearHeight(FLOAT fX,FLOAT fY)
|
|
{
|
|
INT X = appFloor(fX);
|
|
INT Y = appFloor(fY);
|
|
FLOAT tx = fX - (FLOAT)X;
|
|
FLOAT ty = fY - (FLOAT)Y;
|
|
|
|
return appRound(
|
|
Lerp(
|
|
Lerp( (FLOAT)Height(X,Y), (FLOAT)Height(X+1,Y), tx),
|
|
Lerp( (FLOAT)Height(X,Y+1), (FLOAT)Height(X+1,Y+1), tx),
|
|
ty) );
|
|
}
|
|
|
|
inline FTerrainInfoData* GetInfoData(INT X, INT Y)
|
|
{
|
|
X = Clamp(X, 0, NumVerticesX - 1);
|
|
Y = Clamp(Y, 0, NumVerticesY - 1);
|
|
|
|
return &(InfoData(Y * NumVerticesX + X));
|
|
}
|
|
|
|
inline const FTerrainInfoData* GetInfoData(INT X, INT Y) const
|
|
{
|
|
X = Clamp(X, 0, NumVerticesX - 1);
|
|
Y = Clamp(Y, 0, NumVerticesY - 1);
|
|
|
|
return &(InfoData(Y * NumVerticesX + X));
|
|
}
|
|
|
|
inline UBOOL IsTerrainQuadVisible(INT X, INT Y) const
|
|
{
|
|
const FTerrainInfoData* TheInfoData = GetInfoData(X, Y);
|
|
checkSlow(TheInfoData);
|
|
return TheInfoData->IsVisible();
|
|
}
|
|
|
|
inline UBOOL IsTerrainQuadFlipped(INT X, INT Y) const
|
|
{
|
|
const FTerrainInfoData* TheInfoData = GetInfoData(X, Y);
|
|
checkSlow(TheInfoData);
|
|
return TheInfoData->IsOrientationFlipped();
|
|
}
|
|
|
|
/**
|
|
* Returns TRUE is the component at the given X,Y has ANY patches contained in are visible.
|
|
*/
|
|
UBOOL IsTerrainComponentVisible(INT InBaseX, INT InBaseY, INT InSizeX, INT InSizeY);
|
|
UBOOL IsTerrainComponentVisible(UTerrainComponent* InComponent);
|
|
|
|
FVector GetLocalVertex(INT X,INT Y) const; // Returns a vertex in actor-local space.
|
|
FVector GetWorldVertex(INT X,INT Y) const; // Returns a vertex in world space.
|
|
|
|
FTerrainPatch GetPatch(INT X,INT Y) const;
|
|
FVector GetCollisionVertex(const FTerrainPatch& Patch,UINT PatchX,UINT PatchY,UINT SubX,UINT SubY,UINT TesselationLevel) const;
|
|
|
|
BYTE Alpha(INT AlphaMapIndex,INT X,INT Y) const; // If AlphaMapIndex == INDEX_NONE, returns 0.
|
|
BYTE& Alpha(INT& AlphaMapIndex,INT X,INT Y); // If AlphaMapIndex == INDEX_NONE, creates a new alphamap and places the index in AlphaMapIndex.
|
|
|
|
/**
|
|
* Returns a cached terrain material containing a given set of weighted materials.
|
|
* Generates a new entry if not found
|
|
*
|
|
* @param Mask - bitmask combination of weight materials to be used
|
|
* @param bIsTerrainResource - [out] TRUE if the material resource returned is a terrain material, FALSE if fallback
|
|
* @return terrain material resource render proxy or error material render proxy
|
|
*/
|
|
FMaterialRenderProxy* GetCachedMaterial(const FTerrainMaterialMask& Mask, UBOOL& bIsTerrainResource);
|
|
|
|
/**
|
|
* Creates new cached terrain material entry if it doesn't exist for the given mask
|
|
*
|
|
* @param Mask - bitmask combination of weight materials to be used
|
|
* @return new terrain material resource
|
|
*/
|
|
FTerrainMaterialResource* GenerateCachedMaterial(const FTerrainMaterialMask& Mask);
|
|
|
|
/**
|
|
* RetrieveReleaseResourcesFence
|
|
*
|
|
* This function will grab the ReleaseResourcesFence.
|
|
* If it is NULL, it will create one.
|
|
* Should be used when a fence is required.
|
|
*
|
|
* @return FRenderCommandFence The ReleaseResourcesFence returned.
|
|
*/
|
|
FRenderCommandFence* RetrieveReleaseResourcesFence()
|
|
{
|
|
if (ReleaseResourcesFence == NULL)
|
|
{
|
|
ReleaseResourcesFence = ::new FRenderCommandFence();
|
|
check(ReleaseResourcesFence);
|
|
}
|
|
return ReleaseResourcesFence;
|
|
}
|
|
|
|
/**
|
|
* GetReleaseResourcesFence
|
|
*
|
|
* This function will grab the current ReleaseResourcesFence.
|
|
* Should be used when a fence should be checked if it has been created previously.
|
|
*
|
|
* @return FRenderCommandFence The ReleaseResourcesFence returned.
|
|
*/
|
|
FRenderCommandFence* GetReleaseResourcesFence()
|
|
{
|
|
return ReleaseResourcesFence;
|
|
}
|
|
|
|
/**
|
|
* FreeReleaseResourcesFence
|
|
*
|
|
* This function will free the current ReleaseResourcesFence.
|
|
* Should be used when a fence should be checked if it has been created previously.
|
|
*
|
|
* @return FRenderCommandFence The ReleaseResourcesFence returned.
|
|
*/
|
|
void FreeReleaseResourcesFence()
|
|
{
|
|
if (ReleaseResourcesFence != NULL)
|
|
{
|
|
delete ReleaseResourcesFence;
|
|
ReleaseResourcesFence = NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* MaterialUpdateCallback
|
|
*
|
|
* Called when materials are edited to propagate the change to terrain materials.
|
|
*
|
|
* @param InMaterial The material that was edited.
|
|
*
|
|
*/
|
|
static void MaterialUpdateCallback(UMaterial* InMaterial);
|
|
|
|
/**
|
|
* BuildCollisionData
|
|
*
|
|
* Helper function to force the re-building of the collision date.
|
|
*/
|
|
void BuildCollisionData();
|
|
|
|
/**
|
|
* RecacheMaterials
|
|
*
|
|
* Helper function that tosses the cached materials and regenerates them.
|
|
*/
|
|
void RecacheMaterials();
|
|
|
|
/**
|
|
* UpdateLayerSetup
|
|
*
|
|
* Editor function for updating altered materials/layers
|
|
*
|
|
* @param InSetup The layer setup to update.
|
|
*/
|
|
void UpdateLayerSetup(UTerrainLayerSetup* InSetup);
|
|
|
|
/**
|
|
* RemoveLayerSetup
|
|
*
|
|
* Editor function for removing altered materials/layers
|
|
*
|
|
* @param InSetup The layer setup to remove.
|
|
*/
|
|
void RemoveLayerSetup(UTerrainLayerSetup* InSetup);
|
|
|
|
/**
|
|
* UpdateTerrainMaterial
|
|
*
|
|
* Editor function for updating altered materials/layers
|
|
*
|
|
* @param InTMat The terrain material to update.
|
|
*/
|
|
void UpdateTerrainMaterial(UTerrainMaterial* InTMat);
|
|
|
|
/**
|
|
* RemoveTerrainMaterial
|
|
*
|
|
* Editor function for removing altered materials/layers
|
|
*
|
|
* @param InTMat The terrain material to Remove.
|
|
*/
|
|
void RemoveTerrainMaterial(UTerrainMaterial* InTMat);
|
|
|
|
/**
|
|
* UpdateMaterialInstance
|
|
*
|
|
* Editor function for updating altered materials/layers
|
|
*
|
|
* @param InMatInst The material instance to update.
|
|
*/
|
|
void UpdateMaterialInstance(UMaterialInterface* InMatInst);
|
|
|
|
/**
|
|
* UpdateCachedMaterial
|
|
*
|
|
* Editor function for updating altered materials/layers
|
|
*
|
|
* @param InMat The material instance to update.
|
|
*/
|
|
void UpdateCachedMaterial(UMaterial* InMat);
|
|
|
|
/**
|
|
* RemoveCachedMaterial
|
|
*
|
|
* Editor function for removing altered materials/layers
|
|
*
|
|
* @param InMat The material instance to remove.
|
|
*/
|
|
void RemoveCachedMaterial(UMaterial* InMat);
|
|
|
|
/**
|
|
* Tessellate the terrain up in detail
|
|
* Also used for converting old terrain to the new hi-res model
|
|
*
|
|
* REQUIRES UPDATING TERRAIN MATERIAL MAPPING SCALES BY HAND!
|
|
*
|
|
* @param InTessellationlevel The tessellation level to increase it to
|
|
*
|
|
* @return UBOOL TRUE if successful
|
|
*/
|
|
UBOOL TessellateTerrainUp(INT InTessellationlevel = 2, UBOOL bRegenerateComponents = TRUE);
|
|
|
|
/**
|
|
* Tessellate the terrain down in detail.
|
|
* Will remove patches while retaining the 'shape' of the terrain.
|
|
*
|
|
* REQUIRES UPDATING TERRAIN MATERIAL MAPPING SCALES BY HAND!
|
|
*/
|
|
UBOOL TessellateTerrainDown();
|
|
|
|
/**
|
|
* GetClosestVertex
|
|
*
|
|
* Determine the vertex that is closest to the given location.
|
|
* Used for drawing tool items.
|
|
*
|
|
* @param InLocation FVector representing the location caller is interested in
|
|
* @param OutVertex FVector the function will fill in
|
|
* @param bConstrained If TRUE, then select the closest according to editor tessellation level
|
|
*
|
|
* @return UBOOL TRUE indicates the point was found and OutVertex is valid.
|
|
* FALSE indicates the point was not contained within the terrain.
|
|
*/
|
|
UBOOL GetClosestVertex(const FVector& InLocation, FVector& OutVertex, UBOOL bConstrained = FALSE);
|
|
|
|
/**
|
|
* GetClosestLocalSpaceVertex
|
|
*
|
|
* Determine the vertex that is closest to the given location in local space.
|
|
* The returned position is also in local space.
|
|
* Used for drawing tool items.
|
|
*
|
|
* @param InLocation FVector representing the location caller is interested in
|
|
* @param OutVertex FVector the function will fill in
|
|
* @param bConstrained If TRUE, then select the closest according to editor tessellation level
|
|
*
|
|
* @return UBOOL TRUE indicates the point was found and OutVertex is valid.
|
|
* FALSE indicates the point was not contained within the terrain.
|
|
*/
|
|
UBOOL GetClosestLocalSpaceVertex(const FVector& InLocation, FVector& OutVertex, UBOOL bConstrained = FALSE);
|
|
|
|
/**
|
|
* ShowCollisionCallback
|
|
*
|
|
* Called when SHOW terrain collision is toggled.
|
|
*
|
|
* @param bShow Whether to show it or not.
|
|
*
|
|
*/
|
|
static void ShowCollisionCallback(UBOOL bShow);
|
|
|
|
/**
|
|
* Show/Hide terrain collision overlay
|
|
*
|
|
* @param bShow Show or hide
|
|
*/
|
|
void ShowCollisionOverlay(UBOOL bShow);
|
|
|
|
/**
|
|
* Update the given selected vertex in the list.
|
|
* If the vertex is not present, then add it to the list (provided Weight > 0)
|
|
*
|
|
* @param X
|
|
* @param Y
|
|
* @param Weight
|
|
*
|
|
*/
|
|
void UpdateSelectedVertex(INT X, INT Y, FLOAT Weight);
|
|
|
|
/**
|
|
* Internal function for getting a selected vertex from the list
|
|
*/
|
|
INT FindSelectedVertexInList(INT X, INT Y, FSelectedTerrainVertex*& SelectedVert);
|
|
|
|
/**
|
|
* Clear all selected vertices
|
|
*/
|
|
void ClearSelectedVertexList();
|
|
|
|
/**
|
|
* Retrieve the component(s) that contain the given vertex point
|
|
* The components will be added (using AddUniqueItem) to the supplied array.
|
|
*
|
|
* @param X The X position of interest
|
|
* @param Y The Y position of interest
|
|
* @param ComponentList The array to add found components to
|
|
*
|
|
* @return UBOOL TRUE if any components were found.
|
|
* FALSE if none were found
|
|
*/
|
|
UBOOL GetComponentsAtXY(INT X, INT Y, TArray<UTerrainComponent*>& ComponentList);
|
|
|
|
/**
|
|
* Recache the visibility flags - used when changing tessellation levels.
|
|
*/
|
|
void RecacheVisibilityFlags();
|
|
|
|
/**
|
|
* Get the array of cached terrain material resource
|
|
*/
|
|
FORCEINLINE TArrayNoInit<FTerrainMaterialResource*>& GetCachedTerrainMaterials()
|
|
{
|
|
return CachedTerrainMaterials[MSQ_TERRAIN].CachedMaterials;
|
|
}
|
|
|
|
/**
|
|
* Delete the entries in the cached terrain materials
|
|
*/
|
|
void ClearCachedTerrainMaterials();
|
|
|
|
/**
|
|
* Compiles material resources for the current platform if the shader map for that resource didn't already exist.
|
|
*
|
|
* @param ShaderPlatform - platform to compile for
|
|
* @param bFlushExistingShaderMaps - forces a compile, removes existing shader maps from shader cache.
|
|
*/
|
|
void CacheResourceShaders(EShaderPlatform ShaderPlatform, UBOOL bFlushExistingShaderMaps=FALSE);
|
|
}
|
|
|
|
/** for each layer, calculate the rectangle encompassing all the vertices affected by it and store the result in
|
|
* the layer's MinX, MinY, MaxX, and MaxY properties
|
|
*/
|
|
native final function CalcLayerBounds();
|
|
|
|
simulated event PostBeginPlay()
|
|
{
|
|
local int i;
|
|
|
|
CalcLayerBounds();
|
|
|
|
// allow any layers to run startup actions
|
|
for (i = 0; i < Layers.length; i++)
|
|
{
|
|
if (Layers[i].Setup != None)
|
|
{
|
|
Layers[i].Setup.PostBeginPlay();
|
|
}
|
|
}
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
Begin Object Name=Sprite
|
|
Sprite=Texture2D'EditorResources.S_Terrain'
|
|
End Object
|
|
|
|
NormalMapLayer=-1
|
|
NumPatchesX=1
|
|
NumPatchesY=1
|
|
MaxComponentSize=16
|
|
|
|
DrawScale3D=(X=256.0,Y=256.0,Z=256.0)
|
|
bEdShouldSnap=True
|
|
bCollideActors=True
|
|
bBlockActors=True
|
|
bWorldGeometry=True
|
|
bStatic=True
|
|
bNoDelete=True
|
|
bHidden=False
|
|
MaxTesselationLevel=4
|
|
MinTessellationLevel=1
|
|
CollisionTesselationLevel=1
|
|
TessellationCheckDistance=-1.0
|
|
TesselationDistanceScale=1.0
|
|
StaticLightingResolution=4
|
|
bIsOverridingLightResolution=false
|
|
bBilinearFilterLightmapGeneration=true
|
|
bCastShadow=True
|
|
bCastDynamicShadow=True
|
|
bBlockRigidBody=True
|
|
bAcceptsDynamicLights=True
|
|
`if(`__TW_LIGHTING_MODIFICATIONS_) // Custom lighting channel implementation
|
|
LightingChannels=(Outdoor=TRUE,bInitialized=TRUE)
|
|
`else
|
|
LightingChannels=(Static=TRUE,bInitialized=TRUE)
|
|
`endif
|
|
bForceDirectLightMap=TRUE
|
|
WireframeColor=(R=0,G=255,B=255)
|
|
}
|