generated from krampus/template-godot4
464 lines
18 KiB
GDScript
464 lines
18 KiB
GDScript
extends RefCounted
|
|
|
|
const WINDOW_SCENE: String = "res://addons/terrain_3d/src/channel_packer.tscn"
|
|
const TEMPLATE_PATH: String = "res://addons/terrain_3d/src/channel_packer_import_template.txt"
|
|
const DRAG_DROP_SCRIPT: String = "res://addons/terrain_3d/src/channel_packer_dragdrop.gd"
|
|
enum {
|
|
INFO,
|
|
WARN,
|
|
ERROR,
|
|
}
|
|
|
|
enum {
|
|
IMAGE_ALBEDO,
|
|
IMAGE_HEIGHT,
|
|
IMAGE_NORMAL,
|
|
IMAGE_ROUGHNESS
|
|
}
|
|
|
|
var plugin: EditorPlugin
|
|
var window: Window
|
|
var save_file_dialog: EditorFileDialog
|
|
var open_file_dialog: EditorFileDialog
|
|
var invert_green_checkbox: CheckBox
|
|
var invert_smooth_checkbox: CheckBox
|
|
var invert_height_checkbox: CheckBox
|
|
var lumin_height_button: Button
|
|
var generate_mipmaps_checkbox: CheckBox
|
|
var high_quality_checkbox: CheckBox
|
|
var align_normals_checkbox: CheckBox
|
|
var resize_toggle_checkbox: CheckBox
|
|
var resize_option_box: SpinBox
|
|
var height_channel: Array[Button]
|
|
var height_channel_selected: int = 0
|
|
var roughness_channel: Array[Button]
|
|
var roughness_channel_selected: int = 0
|
|
var last_opened_directory: String
|
|
var last_saved_directory: String
|
|
var packing_albedo: bool = false
|
|
var queue_pack_normal_roughness: bool = false
|
|
var images: Array[Image] = [null, null, null, null]
|
|
var status_label: Label
|
|
var no_op: Callable = func(): pass
|
|
var last_file_selected_fn: Callable = no_op
|
|
var normal_vector: Vector3
|
|
|
|
|
|
func pack_textures_popup() -> void:
|
|
if window != null:
|
|
window.show()
|
|
window.move_to_foreground()
|
|
window.move_to_center()
|
|
return
|
|
window = (load(WINDOW_SCENE) as PackedScene).instantiate()
|
|
window.close_requested.connect(_on_close_requested)
|
|
window.window_input.connect(func(event:InputEvent):
|
|
if event is InputEventKey:
|
|
if event.pressed and event.keycode == KEY_ESCAPE:
|
|
_on_close_requested()
|
|
)
|
|
window.find_child("CloseButton").pressed.connect(_on_close_requested)
|
|
|
|
status_label = window.find_child("StatusLabel") as Label
|
|
invert_green_checkbox = window.find_child("InvertGreenChannelCheckBox") as CheckBox
|
|
invert_smooth_checkbox = window.find_child("InvertSmoothCheckBox") as CheckBox
|
|
invert_height_checkbox = window.find_child("ConvertDepthToHeight") as CheckBox
|
|
lumin_height_button = window.find_child("LuminanceAsHeightButton") as Button
|
|
generate_mipmaps_checkbox = window.find_child("GenerateMipmapsCheckBox") as CheckBox
|
|
high_quality_checkbox = window.find_child("HighQualityCheckBox") as CheckBox
|
|
align_normals_checkbox = window.find_child("AlignNormalsCheckBox") as CheckBox
|
|
resize_toggle_checkbox = window.find_child("ResizeToggle") as CheckBox
|
|
resize_option_box = window.find_child("ResizeOptionButton") as SpinBox
|
|
height_channel = [
|
|
window.find_child("HeightChannelR") as Button,
|
|
window.find_child("HeightChannelG") as Button,
|
|
window.find_child("HeightChannelB") as Button,
|
|
window.find_child("HeightChannelA") as Button
|
|
]
|
|
roughness_channel = [
|
|
window.find_child("RoughnessChannelR") as Button,
|
|
window.find_child("RoughnessChannelG") as Button,
|
|
window.find_child("RoughnessChannelB") as Button,
|
|
window.find_child("RoughnessChannelA") as Button
|
|
]
|
|
|
|
height_channel[0].pressed.connect(func() -> void: height_channel_selected = 0)
|
|
height_channel[1].pressed.connect(func() -> void: height_channel_selected = 1)
|
|
height_channel[2].pressed.connect(func() -> void: height_channel_selected = 2)
|
|
height_channel[3].pressed.connect(func() -> void: height_channel_selected = 3)
|
|
|
|
roughness_channel[0].pressed.connect(func() -> void: roughness_channel_selected = 0)
|
|
roughness_channel[1].pressed.connect(func() -> void: roughness_channel_selected = 1)
|
|
roughness_channel[2].pressed.connect(func() -> void: roughness_channel_selected = 2)
|
|
roughness_channel[3].pressed.connect(func() -> void: roughness_channel_selected = 3)
|
|
|
|
plugin.add_child(window)
|
|
_init_file_dialogs()
|
|
|
|
# the dialog disables the parent window "on top" so, restore it after 1 frame to alow the dialog to clear.
|
|
var set_on_top_fn: Callable = func(_file: String = "") -> void:
|
|
await RenderingServer.frame_post_draw
|
|
window.always_on_top = true
|
|
save_file_dialog.file_selected.connect(set_on_top_fn)
|
|
save_file_dialog.canceled.connect(set_on_top_fn)
|
|
open_file_dialog.file_selected.connect(set_on_top_fn)
|
|
open_file_dialog.canceled.connect(set_on_top_fn)
|
|
|
|
_init_texture_picker(window.find_child("AlbedoVBox"), IMAGE_ALBEDO)
|
|
_init_texture_picker(window.find_child("HeightVBox"), IMAGE_HEIGHT)
|
|
_init_texture_picker(window.find_child("NormalVBox"), IMAGE_NORMAL)
|
|
_init_texture_picker(window.find_child("RoughnessVBox"), IMAGE_ROUGHNESS)
|
|
|
|
var pack_button_path: String = "Panel/MarginContainer/VBoxContainer/PackButton"
|
|
(window.get_node(pack_button_path) as Button).pressed.connect(_on_pack_button_pressed)
|
|
|
|
|
|
func _on_close_requested() -> void:
|
|
last_file_selected_fn = no_op
|
|
images = [null, null, null, null]
|
|
window.queue_free()
|
|
window = null
|
|
|
|
|
|
func _init_file_dialogs() -> void:
|
|
save_file_dialog = EditorFileDialog.new()
|
|
save_file_dialog.set_filters(PackedStringArray(["*.png"]))
|
|
save_file_dialog.set_file_mode(EditorFileDialog.FILE_MODE_SAVE_FILE)
|
|
save_file_dialog.access = EditorFileDialog.ACCESS_FILESYSTEM
|
|
save_file_dialog.file_selected.connect(_on_save_file_selected)
|
|
save_file_dialog.ok_button_text = "Save"
|
|
save_file_dialog.size = Vector2i(550, 550)
|
|
#save_file_dialog.transient = false
|
|
#save_file_dialog.exclusive = false
|
|
#save_file_dialog.popup_window = true
|
|
|
|
open_file_dialog = EditorFileDialog.new()
|
|
open_file_dialog.set_filters(PackedStringArray(
|
|
["*.png", "*.bmp", "*.exr", "*.hdr", "*.jpg", "*.jpeg", "*.tga", "*.svg", "*.webp", "*.ktx", "*.dds"]))
|
|
open_file_dialog.set_file_mode(EditorFileDialog.FILE_MODE_OPEN_FILE)
|
|
open_file_dialog.access = EditorFileDialog.ACCESS_FILESYSTEM
|
|
open_file_dialog.ok_button_text = "Open"
|
|
open_file_dialog.size = Vector2i(550, 550)
|
|
#open_file_dialog.transient = false
|
|
#open_file_dialog.exclusive = false
|
|
#open_file_dialog.popup_window = true
|
|
|
|
window.add_child(save_file_dialog)
|
|
window.add_child(open_file_dialog)
|
|
|
|
|
|
func _init_texture_picker(p_parent: Node, p_image_index: int) -> void:
|
|
var line_edit: LineEdit = p_parent.find_child("LineEdit") as LineEdit
|
|
var file_pick_button: Button = p_parent.find_child("PickButton") as Button
|
|
var clear_button: Button = p_parent.find_child("ClearButton") as Button
|
|
var texture_rect: TextureRect = p_parent.find_child("TextureRect") as TextureRect
|
|
var texture_button: Button = p_parent.find_child("TextureButton") as Button
|
|
texture_button.set_script(load(DRAG_DROP_SCRIPT) as GDScript)
|
|
|
|
var set_channel_fn: Callable = func(used_channels: int) -> void:
|
|
var channel_count: int = 4
|
|
# enum Image.UsedChannels
|
|
match used_channels:
|
|
Image.USED_CHANNELS_L, Image.USED_CHANNELS_R: channel_count = 1
|
|
Image.USED_CHANNELS_LA, Image.USED_CHANNELS_RG: channel_count = 2
|
|
Image.USED_CHANNELS_RGB: channel_count = 3
|
|
Image.USED_CHANNELS_RGBA: channel_count = 4
|
|
if p_image_index == IMAGE_HEIGHT:
|
|
for i in 4:
|
|
height_channel[i].visible = i < channel_count
|
|
height_channel[0].button_pressed = true
|
|
height_channel[0].pressed.emit()
|
|
elif p_image_index == IMAGE_ROUGHNESS:
|
|
for i in 4:
|
|
roughness_channel[i].visible = i < channel_count
|
|
roughness_channel[0].button_pressed = true
|
|
roughness_channel[0].pressed.emit()
|
|
|
|
var load_image_fn: Callable = func(path: String):
|
|
var image: Image = Image.new()
|
|
var error: int = OK
|
|
# Special case for dds files
|
|
if path.get_extension() == "dds":
|
|
image = ResourceLoader.load(path).get_image()
|
|
if not image.is_empty():
|
|
# if the dds file is loaded, we must clear any mipmaps and
|
|
# decompress if needed in order to do per pixel operations.
|
|
image.clear_mipmaps()
|
|
image.decompress()
|
|
else:
|
|
error = FAILED
|
|
else:
|
|
error = image.load(path)
|
|
if error != OK:
|
|
_show_message(ERROR, "Failed to load texture '" + path + "'")
|
|
texture_rect.texture = null
|
|
images[p_image_index] = null
|
|
else:
|
|
_show_message(INFO, "Loaded texture '" + path + "'")
|
|
texture_rect.texture = ImageTexture.create_from_image(image)
|
|
images[p_image_index] = image
|
|
_set_wh_labels(p_image_index, image.get_width(), image.get_height())
|
|
if p_image_index == IMAGE_NORMAL:
|
|
_set_normal_vector(image)
|
|
if p_image_index == IMAGE_HEIGHT or p_image_index == IMAGE_ROUGHNESS:
|
|
set_channel_fn.call(image.detect_used_channels())
|
|
|
|
var os_drop_fn: Callable = func(files: PackedStringArray) -> void:
|
|
# OS drag drop holds mouse focus until released,
|
|
# Get mouse pos and check directly if inside texture_rect
|
|
var rect = texture_button.get_global_rect()
|
|
var mouse_position = texture_button.get_global_mouse_position()
|
|
if rect.has_point(mouse_position):
|
|
if files.size() != 1:
|
|
_show_message(ERROR, "Cannot load multiple files")
|
|
else:
|
|
line_edit.text = files[0]
|
|
load_image_fn.call(files[0])
|
|
|
|
var godot_drop_fn: Callable = func(path: String) -> void:
|
|
path = ProjectSettings.globalize_path(path)
|
|
line_edit.text = path
|
|
load_image_fn.call(path)
|
|
|
|
var open_fn: Callable = func() -> void:
|
|
open_file_dialog.current_path = last_opened_directory
|
|
if last_file_selected_fn != no_op:
|
|
open_file_dialog.file_selected.disconnect(last_file_selected_fn)
|
|
last_file_selected_fn = func(path: String) -> void:
|
|
line_edit.text = path
|
|
load_image_fn.call(path)
|
|
open_file_dialog.file_selected.connect(last_file_selected_fn)
|
|
open_file_dialog.popup_centered_ratio()
|
|
|
|
var line_edit_submit_fn: Callable = func(path: String) -> void:
|
|
line_edit.text = path
|
|
load_image_fn.call(path)
|
|
|
|
var clear_fn: Callable = func() -> void:
|
|
line_edit.text = ""
|
|
texture_rect.texture = null
|
|
images[p_image_index] = null
|
|
_set_wh_labels(p_image_index, -1, -1)
|
|
|
|
line_edit.text_submitted.connect(line_edit_submit_fn)
|
|
file_pick_button.pressed.connect(open_fn)
|
|
texture_button.pressed.connect(open_fn)
|
|
clear_button.pressed.connect(clear_fn)
|
|
texture_button.dropped.connect(godot_drop_fn)
|
|
window.files_dropped.connect(os_drop_fn)
|
|
|
|
if p_image_index == IMAGE_HEIGHT:
|
|
var lumin_fn: Callable = func() -> void:
|
|
if !images[IMAGE_ALBEDO]:
|
|
_show_message(ERROR, "Albedo Image Required for Operation")
|
|
else:
|
|
line_edit.text = "Generated Height"
|
|
var height_texture: Image = Terrain3DUtil.luminance_to_height(images[IMAGE_ALBEDO])
|
|
if height_texture.is_empty():
|
|
_show_message(ERROR, "Height Texture Generation error")
|
|
# blur the image by resizing down and back..
|
|
var w: int = height_texture.get_width()
|
|
var h: int = height_texture.get_height()
|
|
height_texture.resize(w / 4, h / 4)
|
|
height_texture.resize(w, h, Image.INTERPOLATE_CUBIC)
|
|
# "Load" the height texture
|
|
images[IMAGE_HEIGHT] = height_texture
|
|
texture_rect.texture = ImageTexture.create_from_image(images[IMAGE_HEIGHT])
|
|
_set_wh_labels(IMAGE_HEIGHT, height_texture.get_width(), height_texture.get_height())
|
|
set_channel_fn.call(Image.USED_CHANNELS_R)
|
|
_show_message(INFO, "Height Texture generated sucsessfully")
|
|
lumin_height_button.pressed.connect(lumin_fn)
|
|
plugin.ui.set_button_editor_icon(file_pick_button, "Folder")
|
|
plugin.ui.set_button_editor_icon(clear_button, "Remove")
|
|
|
|
|
|
func _set_wh_labels(p_image_index: int, width: int, height: int) -> void:
|
|
var w: String = ""
|
|
var h: String = ""
|
|
if width > 0 and height > 0:
|
|
w = "w: " + str(width)
|
|
h = "h: " + str(height)
|
|
match p_image_index:
|
|
0:
|
|
window.find_child("AlbedoW").text = w
|
|
window.find_child("AlbedoH").text = h
|
|
1:
|
|
window.find_child("HeightW").text = w
|
|
window.find_child("HeightH").text = h
|
|
2:
|
|
window.find_child("NormalW").text = w
|
|
window.find_child("NormalH").text = h
|
|
3:
|
|
window.find_child("RoughnessW").text = w
|
|
window.find_child("RoughnessH").text = h
|
|
|
|
|
|
func _show_message(p_level: int, p_text: String) -> void:
|
|
status_label.text = p_text
|
|
match p_level:
|
|
INFO:
|
|
print("Terrain3DChannelPacker: " + p_text)
|
|
status_label.add_theme_color_override("font_color", Color(0, 0.82, 0.14))
|
|
WARN:
|
|
push_warning("Terrain3DChannelPacker: " + p_text)
|
|
status_label.add_theme_color_override("font_color", Color(0.9, 0.9, 0))
|
|
ERROR,_:
|
|
push_error("Terrain3DChannelPacker: " + p_text)
|
|
status_label.add_theme_color_override("font_color", Color(0.9, 0, 0))
|
|
|
|
|
|
func _create_import_file(png_path: String) -> void:
|
|
var dst_import_path: String = png_path + ".import"
|
|
var file: FileAccess = FileAccess.open(TEMPLATE_PATH, FileAccess.READ)
|
|
var template_content: String = file.get_as_text()
|
|
file.close()
|
|
template_content = template_content.replace(
|
|
"$SOURCE_FILE", png_path).replace(
|
|
"$HIGH_QUALITY", str(high_quality_checkbox.button_pressed)).replace(
|
|
"$GENERATE_MIPMAPS", str(generate_mipmaps_checkbox.button_pressed)
|
|
)
|
|
var import_content: String = template_content
|
|
file = FileAccess.open(dst_import_path, FileAccess.WRITE)
|
|
file.store_string(import_content)
|
|
file.close()
|
|
|
|
|
|
func _on_pack_button_pressed() -> void:
|
|
packing_albedo = images[IMAGE_ALBEDO] != null and images[IMAGE_HEIGHT] != null
|
|
var packing_normal_roughness: bool = images[IMAGE_NORMAL] != null and images[IMAGE_ROUGHNESS] != null
|
|
|
|
if not packing_albedo and not packing_normal_roughness:
|
|
_show_message(WARN, "Please select an albedo and height texture or a normal and roughness texture")
|
|
return
|
|
if packing_albedo:
|
|
save_file_dialog.current_path = last_saved_directory + "packed_albedo_height"
|
|
save_file_dialog.title = "Save Packed Albedo/Height Texture"
|
|
save_file_dialog.popup_centered_ratio()
|
|
if packing_normal_roughness:
|
|
queue_pack_normal_roughness = true
|
|
return
|
|
if packing_normal_roughness:
|
|
save_file_dialog.current_path = last_saved_directory + "packed_normal_roughness"
|
|
save_file_dialog.title = "Save Packed Normal/Roughness Texture"
|
|
save_file_dialog.popup_centered_ratio()
|
|
|
|
|
|
func _on_save_file_selected(p_dst_path) -> void:
|
|
last_saved_directory = p_dst_path.get_base_dir() + "/"
|
|
var error: int
|
|
if packing_albedo:
|
|
error = _pack_textures(images[IMAGE_ALBEDO], images[IMAGE_HEIGHT], p_dst_path, false,
|
|
invert_height_checkbox.button_pressed, false, height_channel_selected)
|
|
else:
|
|
error = _pack_textures(images[IMAGE_NORMAL], images[IMAGE_ROUGHNESS], p_dst_path,
|
|
invert_green_checkbox.button_pressed, invert_smooth_checkbox.button_pressed,
|
|
align_normals_checkbox.button_pressed, roughness_channel_selected)
|
|
|
|
if error == OK:
|
|
EditorInterface.get_resource_filesystem().scan()
|
|
if window.visible:
|
|
window.hide()
|
|
await EditorInterface.get_resource_filesystem().resources_reimported
|
|
# wait 1 extra frame, to ensure the UI is responsive.
|
|
await RenderingServer.frame_post_draw
|
|
window.show()
|
|
|
|
if queue_pack_normal_roughness:
|
|
queue_pack_normal_roughness = false
|
|
packing_albedo = false
|
|
save_file_dialog.current_path = last_saved_directory + "packed_normal_roughness"
|
|
save_file_dialog.title = "Save Packed Normal/Roughness Texture"
|
|
|
|
save_file_dialog.call_deferred("popup_centered_ratio")
|
|
save_file_dialog.call_deferred("move_to_foreground")
|
|
|
|
|
|
func _alignment_basis(normal: Vector3) -> Basis:
|
|
var up: Vector3 = Vector3(0, 0, 1)
|
|
var v: Vector3 = normal.cross(up)
|
|
var c: float = normal.dot(up)
|
|
var k: float = 1.0 / (1.0 + c)
|
|
|
|
var vxy: float = v.x * v.y * k
|
|
var vxz: float = v.x * v.z * k
|
|
var vyz: float = v.y * v.z * k
|
|
|
|
return Basis(Vector3(v.x * v.x * k + c, vxy - v.z, vxz + v.y),
|
|
Vector3(vxy + v.z, v.y * v.y * k + c, vyz - v.x),
|
|
Vector3(vxz - v.y, vyz + v.x, v.z * v.z * k + c)
|
|
)
|
|
|
|
|
|
func _set_normal_vector(source: Image, quiet: bool = false) -> void:
|
|
# Calculate texture normal sum direction
|
|
var normal: Image = source
|
|
var sum: Color = Color(0.0, 0.0, 0.0, 0.0)
|
|
for x in normal.get_height():
|
|
for y in normal.get_width():
|
|
sum += normal.get_pixel(x, y)
|
|
var div: float = normal.get_height() * normal.get_width()
|
|
sum /= Color(div, div, div)
|
|
sum *= 2.0
|
|
sum -= Color(1.0, 1.0, 1.0)
|
|
normal_vector = Vector3(sum.r, sum.g, sum.b).normalized()
|
|
if normal_vector.dot(Vector3(0.0, 0.0, 1.0)) < 0.999 && !quiet:
|
|
_show_message(WARN, "Normal Texture Not Orthoganol to UV plane.\nFor Compatability with Detiling and Rotation, Select Orthoganolize Normals")
|
|
|
|
|
|
func _align_normals(source: Image, iteration: int = 0) -> void:
|
|
# generate matrix to re-align the normalmap
|
|
var mat3: Basis = _alignment_basis(normal_vector)
|
|
# re-align the normal map pixels
|
|
for x in source.get_height():
|
|
for y in source.get_width():
|
|
var old_pixel: Color = source.get_pixel(x, y)
|
|
var vector_pixel: Vector3 = Vector3(old_pixel.r, old_pixel.g, old_pixel.b)
|
|
vector_pixel *= 2.0
|
|
vector_pixel -= Vector3.ONE
|
|
vector_pixel = vector_pixel.normalized()
|
|
vector_pixel = vector_pixel * mat3
|
|
vector_pixel += Vector3.ONE
|
|
vector_pixel *= 0.5
|
|
var new_pixel: Color = Color(vector_pixel.x, vector_pixel.y, vector_pixel.z, old_pixel.a)
|
|
source.set_pixel(x, y, new_pixel)
|
|
_set_normal_vector(source, true)
|
|
if normal_vector.dot(Vector3(0.0, 0.0, 1.0)) < 0.999 && iteration < 3:
|
|
++iteration
|
|
_align_normals(source, iteration)
|
|
|
|
|
|
func _pack_textures(p_rgb_image: Image, p_a_image: Image, p_dst_path: String, p_invert_green: bool,
|
|
p_invert_smooth: bool, p_align_normals : bool, p_alpha_channel: int) -> Error:
|
|
if p_rgb_image and p_a_image:
|
|
if p_rgb_image.get_size() != p_a_image.get_size() and !resize_toggle_checkbox.button_pressed:
|
|
_show_message(ERROR, "Textures must be the same size.\nEnable resize to override image dimensions")
|
|
return FAILED
|
|
|
|
if resize_toggle_checkbox.button_pressed:
|
|
var size: int = max(128, resize_option_box.value)
|
|
p_rgb_image.resize(size, size, Image.INTERPOLATE_CUBIC)
|
|
p_a_image.resize(size, size, Image.INTERPOLATE_CUBIC)
|
|
|
|
if p_align_normals and normal_vector.dot(Vector3(0.0, 0.0, 1.0)) < 0.999:
|
|
_align_normals(p_rgb_image)
|
|
elif p_align_normals:
|
|
_show_message(INFO, "Alignment OK, skipping Normal Orthogonalization")
|
|
|
|
var output_image: Image = Terrain3DUtil.pack_image(p_rgb_image, p_a_image,
|
|
p_invert_green, p_invert_smooth, p_alpha_channel)
|
|
|
|
if not output_image:
|
|
_show_message(ERROR, "Failed to pack textures")
|
|
return FAILED
|
|
if output_image.detect_used_channels() != 5:
|
|
_show_message(ERROR, "Packing Error, Alpha Channel empty")
|
|
return FAILED
|
|
|
|
output_image.save_png(p_dst_path)
|
|
_create_import_file(p_dst_path)
|
|
_show_message(INFO, "Packed to " + p_dst_path + ".")
|
|
return OK
|
|
else:
|
|
_show_message(ERROR, "Failed to load one or more textures")
|
|
return FAILED
|