ile-de-test/addons/zylann.hterrain/tools/generator/generator_dialog.gd

563 lines
17 KiB
GDScript3
Raw Normal View History

2023-10-05 18:02:23 +00:00
@tool
extends AcceptDialog
const HTerrain = preload("../../hterrain.gd")
const HTerrainData = preload("../../hterrain_data.gd")
const HTerrainMesher = preload("../../hterrain_mesher.gd")
const HT_Util = preload("../../util/util.gd")
const HT_TextureGenerator = preload("./texture_generator.gd")
const HT_TextureGeneratorPass = preload("./texture_generator_pass.gd")
const HT_Logger = preload("../../util/logger.gd")
const HT_ImageFileCache = preload("../../util/image_file_cache.gd")
const HT_Inspector = preload("../inspector/inspector.gd")
const HT_TerrainPreview = preload("../terrain_preview.gd")
const HT_ProgressWindow = preload("../progress_window.gd")
const HT_ProgressWindowScene = preload("../progress_window.tscn")
# TODO Power of two is assumed here.
# I wonder why it doesn't have the off by one terrain textures usually have
const MAX_VIEWPORT_RESOLUTION = 512
#signal progress_notified(info) # { "progress": real, "message": string, "finished": bool }
@onready var _inspector_container : Control = $VBoxContainer/Editor/Settings
@onready var _inspector : HT_Inspector = $VBoxContainer/Editor/Settings/Inspector
@onready var _preview : HT_TerrainPreview = $VBoxContainer/Editor/Preview/TerrainPreview
@onready var _progress_bar : ProgressBar = $VBoxContainer/Editor/Preview/ProgressBar
var _dummy_texture = load("res://addons/zylann.hterrain/tools/icons/empty.png")
var _terrain : HTerrain = null
var _applying := false
var _generator : HT_TextureGenerator
var _generated_textures := [null, null]
var _dialog_visible := false
var _undo_map_ids := {}
var _image_cache : HT_ImageFileCache = null
var _undo_redo_manager : EditorUndoRedoManager
var _logger := HT_Logger.get_for(self)
var _viewport_resolution := MAX_VIEWPORT_RESOLUTION
var _progress_window : HT_ProgressWindow
static func get_shader(shader_name: String) -> Shader:
var path := "res://addons/zylann.hterrain/tools/generator/shaders"\
.path_join(str(shader_name, ".gdshader"))
return load(path) as Shader
func _init():
# Godot 4 does not have a plain WindowDialog class... there is Window but it's too unfriendly...
get_ok_button().hide()
_progress_window = HT_ProgressWindowScene.instantiate()
add_child(_progress_window)
func _ready():
_inspector.set_prototype({
"seed": {
"type": TYPE_INT,
"randomizable": true,
"range": { "min": -100, "max": 100 },
"slidable": false
},
"offset": {
"type": TYPE_VECTOR2
},
"base_height": {
"type": TYPE_FLOAT,
"range": {"min": -500.0, "max": 500.0, "step": 0.1 },
"default_value": -50.0
},
"height_range": {
"type": TYPE_FLOAT,
"range": {"min": 0.0, "max": 2000.0, "step": 0.1 },
"default_value": 150.0
},
"scale": {
"type": TYPE_FLOAT,
"range": {"min": 1.0, "max": 1000.0, "step": 1.0},
"default_value": 100.0
},
"roughness": {
"type": TYPE_FLOAT,
"range": {"min": 0.0, "max": 1.0, "step": 0.01},
"default_value": 0.4
},
"curve": {
"type": TYPE_FLOAT,
"range": {"min": 1.0, "max": 10.0, "step": 0.1},
"default_value": 1.0
},
"octaves": {
"type": TYPE_INT,
"range": {"min": 1, "max": 10, "step": 1},
"default_value": 6
},
"erosion_steps": {
"type": TYPE_INT,
"range": {"min": 0, "max": 100, "step": 1},
"default_value": 0
},
"erosion_weight": {
"type": TYPE_FLOAT,
"range": { "min": 0.0, "max": 1.0 },
"default_value": 0.5
},
"erosion_slope_factor": {
"type": TYPE_FLOAT,
"range": { "min": 0.0, "max": 1.0 },
"default_value": 0.0
},
"erosion_slope_direction": {
"type": TYPE_VECTOR2,
"default_value": Vector2(0, 0)
},
"erosion_slope_invert": {
"type": TYPE_BOOL,
"default_value": false
},
"dilation": {
"type": TYPE_FLOAT,
"range": { "min": 0.0, "max": 1.0 },
"default_value": 0.0
},
"island_weight": {
"type": TYPE_FLOAT,
"range": { "min": 0.0, "max": 1.0, "step": 0.01 },
"default_value": 0.0
},
"island_sharpness": {
"type": TYPE_FLOAT,
"range": { "min": 0.0, "max": 1.0, "step": 0.01 },
"default_value": 0.0
},
"island_height_ratio": {
"type": TYPE_FLOAT,
"range": { "min": -1.0, "max": 1.0, "step": 0.01 },
"default_value": -1.0
},
"island_shape": {
"type": TYPE_FLOAT,
"range": { "min": 0.0, "max": 1.0, "step": 0.01 },
"default_value": 0.0
},
"additive_heightmap": {
"type": TYPE_BOOL,
"default_value": false
},
"show_sea": {
"type": TYPE_BOOL,
"default_value": true
},
"shadows": {
"type": TYPE_BOOL,
"default_value": true
}
})
_generator = HT_TextureGenerator.new()
_generator.set_resolution(Vector2i(_viewport_resolution, _viewport_resolution))
# Setup the extra pixels we want on max edges for terrain
# TODO I wonder if it's not better to let the generator shaders work in pixels
# instead of NDC, rather than putting a padding system there
_generator.set_output_padding([0, 1, 0, 1])
_generator.output_generated.connect(_on_TextureGenerator_output_generated)
_generator.completed.connect(_on_TextureGenerator_completed)
_generator.progress_reported.connect(_on_TextureGenerator_progress_reported)
add_child(_generator)
# TEST
if not Engine.is_editor_hint():
call_deferred("popup_centered")
func apply_dpi_scale(dpi_scale: float):
min_size *= dpi_scale
_inspector_container.custom_minimum_size *= dpi_scale
func set_terrain(terrain: HTerrain):
_terrain = terrain
_adjust_viewport_resolution()
func _adjust_viewport_resolution():
if _terrain == null:
return
var data = _terrain.get_data()
if data == null:
return
var terrain_resolution := data.get_resolution()
# By default we want to work with a large enough viewport to generate tiles,
# but we should pick a smaller size if the terrain is smaller than that...
var vp_res := MAX_VIEWPORT_RESOLUTION
while vp_res > terrain_resolution:
vp_res /= 2
_generator.set_resolution(Vector2(vp_res, vp_res))
_viewport_resolution = vp_res
func set_image_cache(image_cache: HT_ImageFileCache):
_image_cache = image_cache
func set_undo_redo(ur: EditorUndoRedoManager):
_undo_redo_manager = ur
func _notification(what: int):
match what:
NOTIFICATION_VISIBILITY_CHANGED:
# We don't want any of this to run in an edited scene
if HT_Util.is_in_edited_scene(self):
return
# Since Godot 4 visibility can be changed even between _enter_tree and _ready
if _preview == null:
return
if visible:
# TODO https://github.com/godotengine/godot/issues/18160
if _dialog_visible:
return
_dialog_visible = true
_adjust_viewport_resolution()
_preview.set_sea_visible(_inspector.get_value("show_sea"))
_preview.set_shadows_enabled(_inspector.get_value("shadows"))
_update_generator(true)
else:
# if not _applying:
# _destroy_viewport()
_preview.cleanup()
for i in len(_generated_textures):
_generated_textures[i] = null
_dialog_visible = false
func _update_generator(preview: bool):
var scale : float = _inspector.get_value("scale")
# Scale is inverted in the shader
if absf(scale) < 0.01:
scale = 0.0
else:
scale = 1.0 / scale
scale *= _viewport_resolution
var preview_scale := 4.0 # As if 2049x2049
var sectors := []
var terrain_size := 513
var additive_heightmap : Texture2D = null
# For testing
if not Engine.is_editor_hint() and _terrain == null:
sectors.append(Vector2(0, 0))
# Get preview scale and sectors to generate.
# Allowing null terrain to make it testable.
if _terrain != null and _terrain.get_data() != null:
var terrain_data := _terrain.get_data()
terrain_size = terrain_data.get_resolution()
if _inspector.get_value("additive_heightmap"):
additive_heightmap = terrain_data.get_texture(HTerrainData.CHANNEL_HEIGHT)
if preview:
# When previewing the resolution does not span the entire terrain,
# so we apply a scale to some of the passes to make it cover it all.
preview_scale = float(terrain_size) / float(_viewport_resolution)
sectors.append(Vector2(0, 0))
else:
if additive_heightmap != null:
# We have to duplicate the heightmap because we are going to write
# into it during the generation process.
# It would be fine when we don't read outside of a generated tile,
# but we actually do that for erosion: neighboring pixels are read
# again, and if they were modified by a previous tile it will
# disrupt generation, so we need to use a copy of the original.
additive_heightmap = additive_heightmap.duplicate()
# When we get to generate it fully, sectors are used,
# so the size or shape of the terrain doesn't matter
preview_scale = 1.0
var cw := terrain_size / _viewport_resolution
var ch := terrain_size / _viewport_resolution
for y in ch:
for x in cw:
sectors.append(Vector2(x, y))
var erosion_iterations := int(_inspector.get_value("erosion_steps"))
erosion_iterations /= int(preview_scale)
_generator.clear_passes()
# Terrain textures need to have an off-by-one on their max edge,
# which is shared with the other sectors.
var base_offset_ndc = _inspector.get_value("offset")
#var sector_size_offby1_ndc = float(VIEWPORT_RESOLUTION - 1) / padded_viewport_resolution
for i in len(sectors):
var sector = sectors[i]
#var offset = sector * sector_size_offby1_ndc - Vector2(pad_offset_ndc, pad_offset_ndc)
# var offset_px = sector * (VIEWPORT_RESOLUTION - 1) - Vector2(pad_offset_px, pad_offset_px)
# var offset_ndc = offset_px / padded_viewport_resolution
var progress := float(i) / len(sectors)
var p := HT_TextureGeneratorPass.new()
p.clear = true
p.shader = get_shader("perlin_noise")
# This pass generates the shapes of the terrain so will have to account for offset
p.tile_pos = sector
p.params = {
"u_octaves": _inspector.get_value("octaves"),
"u_seed": _inspector.get_value("seed"),
"u_scale": scale,
"u_offset": base_offset_ndc,
"u_base_height": _inspector.get_value("base_height") / preview_scale,
"u_height_range": _inspector.get_value("height_range") / preview_scale,
"u_roughness": _inspector.get_value("roughness"),
"u_curve": _inspector.get_value("curve"),
"u_island_weight": _inspector.get_value("island_weight"),
"u_island_sharpness": _inspector.get_value("island_sharpness"),
"u_island_height_ratio": _inspector.get_value("island_height_ratio"),
"u_island_shape": _inspector.get_value("island_shape"),
"u_additive_heightmap": additive_heightmap,
"u_additive_heightmap_factor": \
(1.0 if additive_heightmap != null else 0.0) / preview_scale,
"u_terrain_size": terrain_size / preview_scale,
"u_tile_size": _viewport_resolution
}
_generator.add_pass(p)
if erosion_iterations > 0:
p = HT_TextureGeneratorPass.new()
p.shader = get_shader("erode")
# TODO More erosion config
p.params = {
"u_slope_factor": _inspector.get_value("erosion_slope_factor"),
"u_slope_invert": _inspector.get_value("erosion_slope_invert"),
"u_slope_up": _inspector.get_value("erosion_slope_direction"),
"u_weight": _inspector.get_value("erosion_weight"),
"u_dilation": _inspector.get_value("dilation")
}
p.iterations = erosion_iterations
p.padding = p.iterations
_generator.add_pass(p)
_generator.add_output({
"maptype": HTerrainData.CHANNEL_HEIGHT,
"sector": sector,
"progress": progress
})
p = HT_TextureGeneratorPass.new()
p.shader = get_shader("bump2normal")
p.padding = 1
_generator.add_pass(p)
_generator.add_output({
"maptype": HTerrainData.CHANNEL_NORMAL,
"sector": sector,
"progress": progress
})
# TODO AO generation
# TODO Splat generation
_generator.run()
func _on_CancelButton_pressed():
hide()
func _on_ApplyButton_pressed():
# We used to hide the dialog when the Apply button is clicked, and then texture generation took
# place in an offscreen viewport in multiple tiled stages, with a progress window being shown.
# But in Godot 4, it turns out SubViewports never update if they are child of a hidden Window,
# even if they are set to UPDATE_ALWAYS...
#hide()
_apply()
func _on_Inspector_property_changed(key, value):
match key:
"show_sea":
_preview.set_sea_visible(value)
"shadows":
_preview.set_shadows_enabled(value)
_:
_update_generator(true)
func _on_TerrainPreview_dragged(relative: Vector2, button_mask: int):
if button_mask & MOUSE_BUTTON_MASK_LEFT:
var offset : Vector2 = _inspector.get_value("offset")
offset += relative
_inspector.set_value("offset", offset)
func _apply():
if _terrain == null:
_logger.error("cannot apply, terrain is null")
return
var data := _terrain.get_data()
if data == null:
_logger.error("cannot apply, terrain data is null")
return
var dst_heights := data.get_image(HTerrainData.CHANNEL_HEIGHT)
if dst_heights == null:
_logger.error("terrain heightmap image isn't loaded")
return
var dst_normals := data.get_image(HTerrainData.CHANNEL_NORMAL)
if dst_normals == null:
_logger.error("terrain normal image isn't loaded")
return
_applying = true
_undo_map_ids[HTerrainData.CHANNEL_HEIGHT] = _image_cache.save_image(dst_heights)
_undo_map_ids[HTerrainData.CHANNEL_NORMAL] = _image_cache.save_image(dst_normals)
_update_generator(false)
func _on_TextureGenerator_progress_reported(info: Dictionary):
if _applying:
return
var p := 0.0
if info.pass_index == 1:
p = float(info.iteration) / float(info.iteration_count)
_progress_bar.show()
_progress_bar.ratio = p
func _on_TextureGenerator_output_generated(image: Image, info: Dictionary):
# TODO We should check the terrain's image format,
# but that would prevent from testing in isolation...
if info.maptype == HTerrainData.CHANNEL_HEIGHT:
# Hack to workaround Godot 4.0 not supporting RF viewports. Heights are packed as floats
# into RGBA8 components.
assert(image.get_format() == Image.FORMAT_RGBA8)
image = Image.create_from_data(image.get_width(), image.get_height(), false,
Image.FORMAT_RF, image.get_data())
if not _applying:
# Update preview
# TODO Improve TextureGenerator so we can get a ViewportTexture per output?
var tex = _generated_textures[info.maptype]
if tex == null:
tex = ImageTexture.create_from_image(image)
_generated_textures[info.maptype] = tex
else:
tex.update(image)
var num_set := 0
for v in _generated_textures:
if v != null:
num_set += 1
if num_set == len(_generated_textures):
_preview.setup( \
_generated_textures[HTerrainData.CHANNEL_HEIGHT],
_generated_textures[HTerrainData.CHANNEL_NORMAL])
else:
assert(_terrain != null)
var data := _terrain.get_data()
assert(data != null)
var dst := data.get_image(info.maptype)
assert(dst != null)
# print("Tile ", info.sector)
# image.save_png(str("debug_generator_tile_",
# info.sector.x, "_", info.sector.y, "_map", info.maptype, ".png"))
# Converting in case Viewport texture isn't the format we expect for this map.
# Note, in Godot 4 it seems the chosen renderer also influences what you get.
# Forward+ non-transparent viewport gives RGB8, but Compatibility gives RGBA8.
# I don't know if it's expected or is a bug...
# Also, since RF heightmaps we use RGBA8 so we can pack floats in pixels, because
# Godot 4.0 does not support RF viewports. But that also means the same viewport may be
# re-used for other maps that don't need to be RGBA8.
if image.get_format() != dst.get_format():
image.convert(dst.get_format())
dst.blit_rect(image, \
Rect2i(0, 0, image.get_width(), image.get_height()), \
info.sector * _viewport_resolution)
_notify_progress({
"progress": info.progress,
"message": "Calculating sector ("
+ str(info.sector.x) + ", " + str(info.sector.y) + ")"
})
# if info.maptype == HTerrainData.CHANNEL_NORMAL:
# image.save_png(str("normal_sector_", info.sector.x, "_", info.sector.y, ".png"))
func _on_TextureGenerator_completed():
_progress_bar.hide()
if not _applying:
return
_applying = false
assert(_terrain != null)
var data : HTerrainData = _terrain.get_data()
var resolution := data.get_resolution()
data.notify_region_change(Rect2(0, 0, resolution, resolution), HTerrainData.CHANNEL_HEIGHT)
var redo_map_ids := {}
for map_type in _undo_map_ids:
redo_map_ids[map_type] = _image_cache.save_image(data.get_image(map_type))
var undo_redo := _undo_redo_manager.get_history_undo_redo(
_undo_redo_manager.get_object_history_id(data))
data._edit_set_disable_apply_undo(true)
undo_redo.create_action("Generate terrain")
undo_redo.add_do_method(data._edit_apply_maps_from_file_cache.bind(_image_cache, redo_map_ids))
undo_redo.add_undo_method(
data._edit_apply_maps_from_file_cache.bind(_image_cache, _undo_map_ids))
undo_redo.commit_action()
data._edit_set_disable_apply_undo(false)
_notify_progress({ "finished": true })
_logger.debug("Done")
hide()
func _notify_progress(info: Dictionary):
_progress_window.handle_progress(info)
func _process(delta):
if _applying:
# HACK to workaround a peculiar behavior of Viewports in Godot 4.
# Apparently Godot 4 will not update Viewports set to UPDATE_ALWAYS when the editor decides
# it doesn't need to redraw ("low processor mode", what makes the editor redraw only with
# changes). That wasn't the case in Godot 3, but I guess it is now.
# That means when we click Apply, the viewport will not update in particular when doing
# erosion passes, because the action of clicking Apply doesn't lead to as many redraws as
# changing preview parameters in the UI (those cause redraws for different reasons).
# So let's poke the renderer by redrawing something...
#
# This also piles on top of the workaround in which we keep the window visible when
# applying! So the window has one more reason to stay visible...
#
_preview.queue_redraw()