unreal.LandscapeTexturePatch

class unreal.LandscapeTexturePatch(outer: Object | None = None, name: Name | str = 'None')

Bases: LandscapePatchComponent

Landscape Texture Patch

C++ Source:

  • Plugin: LandscapePatch

  • Module: LandscapePatch

  • File: LandscapeTexturePatch.h

Editor Properties: (see get_editor_property/set_editor_property)

  • absolute_location (bool): [Read-Write] If RelativeLocation should be considered relative to the world, rather than the parent

  • absolute_rotation (bool): [Read-Write] If RelativeRotation should be considered relative to the world, rather than the parent

  • absolute_scale (bool): [Read-Write] If RelativeScale3D should be considered relative to the world, rather than the parent

  • apply_component_z_scale (bool): [Read-Write] Whether to apply the patch Z scale to the height stored in the patch.

  • asset_user_data (Array[AssetUserData]): [Read-Write] Array of user data stored with the component

  • asset_user_data_editor_only (Array[AssetUserData]): [Read-Write] Array of user data stored with the component

  • auto_activate (bool): [Read-Write] Whether the component is activated at creation or must be explicitly activated.

  • base_resolution_off_landscape (bool): [Read-Write] When initializing from landscape, set resolution based off of the landscape (and a multiplier).

  • blend_mode (LandscapeTexturePatchBlendMode): [Read-Write]

  • can_ever_affect_navigation (bool): [Read-Write] Whether this component can potentially influence navigation

  • component_tags (Array[Name]): [Read-Write] Array of tags that can be used for grouping and categorizing. Can also be accessed from scripting.

  • detail_mode (DetailMode): [Read-Write] If detail mode is >= system detail mode, primitive won’t be rendered.

  • detail_panel_height_source_mode (LandscapeTexturePatchSourceMode): [Read-Write] How the heightmap of the patch is stored. Not settable in the detail panel of the blueprint editor- use SetHeightSourceMode in blueprint actors instead.

  • editable_when_inherited (bool): [Read-Write] True if this component can be modified when it was inherited from a parent actor class

  • falloff (float): [Read-Write] Distance (in unscaled world coordinates) across which to smoothly fall off the patch effects.

  • falloff_mode (LandscapeTexturePatchFalloffMode): [Read-Write]

  • height_encoding (LandscapeTextureHeightPatchEncoding): [Read-Write] How the values stored in the patch represent the height. Not customizable for Internal Texture source mode, which always uses native packed height.

  • height_encoding_settings (LandscapeTexturePatchEncodingSettings): [Read-Write] Encoding settings. Not relevant when using native packed height as the encoding.

  • height_internal_data (LandscapeHeightTextureBackedRenderTarget): [Read-Only] Not directly settable via detail panel- for display/debugging purposes only.

  • height_source_mode (LandscapeTexturePatchSourceMode): [Read-Write] How the heightmap of the patch is stored. This is the property that is actually used, and it will agree with DetailPanelHeightSourceMode at all times except when user is changing the latter via the detail panel.

  • height_texture_asset (Texture): [Read-Write] Texture used when source mode is set to a texture asset.

  • hidden_in_game (bool): [Read-Write] Whether to hide the primitive in game, if the primitive is Visible.

  • init_texture_size_x (int32): [Read-Write] Texture width to use when reinitializing, if not basing resolution off landscape.

  • init_texture_size_y (int32): [Read-Write] Texture height to use when reinitializing

  • is_editor_only (bool): [Read-Write] If true, the component will be excluded from non-editor builds

  • is_enabled (bool): [Read-Write] When false, patch does not affect the landscape. Useful for temporarily disabling the patch.

  • landscape (Landscape): [Read-Write]

  • mobility (ComponentMobility): [Read-Write] How often this component is allowed to move, used to make various optimizations. Only safe to set in constructor.

  • on_component_activated (ActorComponentActivatedSignature): [Read-Write] Called when the component has been activated, with parameter indicating if it was from a reset

  • on_component_deactivated (ActorComponentDeactivateSignature): [Read-Write] Called when the component has been deactivated

  • patch_manager (LandscapePatchManager): [Read-Write]

  • physics_volume_changed_delegate (PhysicsVolumeChanged): [Read-Write] Delegate that will be called when PhysicsVolume has been changed *

  • primary_component_tick (ActorComponentTickFunction): [Read-Write] Main tick function for the Component

  • relative_location (Vector): [Read-Write] Location of the component relative to its parent

  • relative_rotation (Rotator): [Read-Write] Rotation of the component relative to its parent

  • relative_scale3d (Vector): [Read-Write] Non-uniform scaling of the component relative to its parent. Note that scaling is always applied in local space (no shearing etc)

  • replicate_using_registered_sub_object_list (bool): [Read-Write] When true the replication system will only replicate the registered subobjects list When false the replication system will instead call the virtual ReplicateSubObjects() function where the subobjects need to be manually replicated.

  • replicates (bool): [Read-Write] Is this component currently replicating? Should the network code consider it for replication? Owning Actor must be replicating first!

  • resolution_multiplier (float): [Read-Write] Multiplier to apply to landscape resolution when initializing patch resolution. A value greater than 1.0 will use higher resolution than the landscape (perhaps useful for slightly more accurate results while not aligned to landscape), and a value less that 1.0 will use lower.

  • should_update_physics_volume (bool): [Read-Write] Whether or not the cached PhysicsVolume this component overlaps should be updated when the component is moved. see: GetPhysicsVolume()

  • unscaled_patch_coverage (Vector2D): [Read-Write] At scale 1.0, the X and Y of the region affected by the height patch. This corresponds to the distance from the center

    of the first pixel to the center of the last pixel in the patch texture in the X and Y directions.

  • use_attach_parent_bound (bool): [Read-Write] If true, this component uses its parents bounds when attached. This can be a significant optimization with many components attached together.

  • use_texture_alpha_for_height (bool): [Read-Write] When true, texture alpha channel will be used when applying the patch. Note that the source data needs to have an alpha channel for this to have an effect.

  • visible (bool): [Read-Write] Whether to completely draw the primitive; if false, the primitive is not drawn, does not cast a shadow.

  • weight_patches (Array[LandscapeWeightPatchTextureInfo]): [Read-Write]

  • zero_height_meaning (LandscapeTextureHeightPatchZeroHeightMeaning): [Read-Write] How 0 height is interpreted.

add_weight_patch(weightmap_layer_name, source_mode, use_alpha_channel) → None

By default, the layer is added with source mode set to be a texture-backed render target.

Parameters:
clear_weight_patch_blend_mode_override(weightmap_layer_name) → None

Clear Weight Patch Blend Mode Override

Parameters:

weightmap_layer_name (Name) –

disable_all_weight_patches() → None

Sets the soure mode of all weight patches to “None”.

get_all_weight_patch_layer_names() → Array[Name]

Get All Weight Patch Layer Names

Return type:

Array[Name]

get_full_unscaled_world_size() → Vector2D

Gives size in unscaled world coordinates of the patch in the world, based off of UnscaledCoverage and texture resolution (i.e., adds a half-pixel around UnscaledCoverage).

Return type:

Vector2D

get_height_render_target(mark_dirty=True) → TextureRenderTarget2D

Gets the internal height render target, if source mode is set to Texture Backed Render Target.

Things that should be set up if using the internal render target: - SetHeightSourceMode should have been called with TextureBackedRenderTarget. - An appropriate texture size should have been set with SetResolution. If the patch extent has already

been set, you can base your resolution on the extent and the resolution of the landscape by using GetInitResolutionFromLandscape().

  • SetHeightRenderTargetFormat should have been called with a desired format. In particular, if using

an alpha channel, the format should have an alpha channel (and SetUseAlphaChannelForHeight should have been called with “true”).

In addition, you may need to call SetHeightEncodingMode, SetHeightEncodingSettings, and SetZeroHeightMeaning based on how you want the data you write to be interpreted. This part is not specific to using an internal render target, since you are likely to need to do that with a TextureAsset source mode as well.

Parameters:

mark_dirty (bool) – If true, marks the containing package as dirty, since the render target is presumably being written to. Can be set to false if the render target is not being written to.

Return type:

TextureRenderTarget2D

get_height_source_mode() → LandscapeTexturePatchSourceMode

Height related functions:

Return type:

LandscapeTexturePatchSourceMode

get_init_resolution_from_landscape(resolution_multiplier=1.000000) → Vector2D or None

Given the landscape resolution, current patch coverage, and a landscape resolution multiplier, gives the needed resolution of the landscape patch. I.e., figures out the number of pixels in the landcape that would be in a region of such size, and then uses the resolution multiplier to give a result.

Parameters:

resolution_multiplier (float) –

Returns:

true if successful (may fail if landscape is not set, for instance)

resolution_out (Vector2D):

Return type:

Vector2D or None

get_patch_to_world_transform() → Transform

Gets the transform from patch to world. The transform is based off of the component transform, but with rotation changed to align to the landscape, only using the yaw to rotate it relative to the landscape.

Return type:

Transform

get_resolution() → Vector2D

Gets the size (in pixels) of the internal textures used by the patch. Does not reflect the resolution of any used texture assets (if the source mode is texture asset).

Return type:

Vector2D

get_unscaled_coverage() → Vector2D

Gives size in unscaled world coordinates (ie before applying patch transform) of the patch as measured between the centers of the outermost pixels. Measuring the coverage this way means that a patch can affect the same region of the landscape regardless of patch resolution. This is also the range across which bilinear interpolation always has correct values, so the area outside this center portion is usually set as a “dead” border that doesn’t affect the landscape.

Return type:

Vector2D

get_weight_patch_render_target(weightmap_layer_name) → TextureRenderTarget2D

Get Weight Patch Render Target

Parameters:

weightmap_layer_name (Name) –

Return type:

TextureRenderTarget2D

get_weight_patch_source_mode(weightmap_layer_name) → LandscapeTexturePatchSourceMode

Get Weight Patch Source Mode

Parameters:

weightmap_layer_name (Name) –

Return type:

LandscapeTexturePatchSourceMode

remove_all_weight_patches() → None

Remove All Weight Patches

remove_weight_patch(weightmap_layer_name) → None

Remove Weight Patch

Parameters:

weightmap_layer_name (Name) –

reset_height_encoding_mode(encoding_mode) → None

Just like SetSourceEncodingMode, but resets ZeroInEncoding, WorldSpaceEncodingScale, and height render target format to mode-specific defaults.

Parameters:

encoding_mode (LandscapeTextureHeightPatchEncoding) –

set_blend_mode(blend_mode_in) → None

Determines how the height patch is blended into the existing terrain.

Parameters:

blend_mode_in (LandscapeTexturePatchBlendMode) –

set_edit_visibility_layer(weightmap_layer_name, edit_visibility_layer) → None

Set Edit Visibility Layer

Parameters:

  • weightmap_layer_name (Name) –

  • edit_visibility_layer (bool) –

set_falloff(falloff_in) → None

Set Falloff

Parameters:

falloff_in (float) –

set_height_encoding_mode(encoding_mode) → None

Set the height encoding mode for the patch, which determines how stored values in the patch are translated into heights when applying to landscape.

Parameters:

encoding_mode (LandscapeTextureHeightPatchEncoding) –

set_height_encoding_settings(settings) → None

Set settings that determine how values in the patch are translated into heights. This is only used if the encoding mode is not NativePackedHeight, where values are expected to be already in the same space as the landscape heightmap.

Parameters:

settings (LandscapeTexturePatchEncodingSettings) –

set_height_render_target_format(format) → None

Set Height Render Target Format

Parameters:

format (TextureRenderTargetFormat) –

set_height_source_mode(new_mode) → None

Changes source mode. When changing between sources, existing data is copied from one to the other when possible.

Parameters:

new_mode (LandscapeTexturePatchSourceMode) –

set_height_texture_asset(texture_in) → None

Sets the texture used for height when the height source mode is set to texture asset. Note that virtual textures are not supported.

Parameters:

texture_in (Texture) –

set_resolution(resolution_in) → None

Sets the resolution of the currently used internal texture or render target. Has no effect if the source mode is set to an external texture asset.

Parameters:

resolution_in (Vector2D) –

set_unscaled_coverage(coverage) → None

Set the patch coverage (see GetUnscaledCoverage for description).

Parameters:

coverage (Vector2D) –

set_use_alpha_channel_for_height(use) → None

Determines whether the height patch alpha channel is used for blending into the existing values. Note that the source data needs to have an alpha channel in this case. How the alpha channel is used depends on the patch blend mode (see SetBlendMode).

Parameters:

use (bool) –

set_use_alpha_channel_for_weight_patch(weightmap_layer_name, use_alpha_channel) → None

Set Use Alpha Channel for Weight Patch

Parameters:

  • weightmap_layer_name (Name) –

  • use_alpha_channel (bool) –

set_weight_patch_blend_mode_override(weightmap_layer_name, blend_mode) → None

Set Weight Patch Blend Mode Override

Parameters:
set_weight_patch_source_mode(weightmap_layer_name, new_mode) → None

Set Weight Patch Source Mode

Parameters:
set_weight_patch_texture_asset(weightmap_layer_name, texture_in) → None

Set Weight Patch Texture Asset

Parameters:

  • weightmap_layer_name (Name) –

  • texture_in (Texture) –

set_zero_height_meaning(zero_height_meaning_in) → None

Set how zero height is interpreted, see comments in ELandscapeTextureHeightPatchZeroHeightMeaning.

Parameters:

zero_height_meaning_in (LandscapeTextureHeightPatchZeroHeightMeaning) –

snap_to_landscape() → None

Adjusts patch rotation to be aligned to a 90 degree increment relative to the landscape, adjusts UnscaledPatchCoverage such that it becomes a multiple of landscape quad size, and adjusts patch location so that the boundaries of the covered area lie on the nearest landscape vertices. Note that this doesn’t adjust the resolution of the texture that the patch uses, so landscape vertices within the inside of the patch may still not always align with texture patch pixel centers (if the resolutions aren’t multiples of each other).