path: root/game/addons/zylann.hterrain/hterrain_data.gd

# Holds data of the terrain.
# This is mostly a set of textures using specific formats, some precalculated, and metadata.

@tool
extends Resource

const HT_Grid = preload("./util/grid.gd")
const HT_Util = preload("./util/util.gd")
const HT_Errors = preload("./util/errors.gd")
const HT_Logger = preload("./util/logger.gd")
const HT_ImageFileCache = preload("./util/image_file_cache.gd")
const HT_XYZFormat = preload("./util/xyz_format.gd")

# Note: indexes matters for saving, don't re-order
# TODO Rename "CHANNEL" to "MAP", makes more sense and less confusing with RGBA channels
const CHANNEL_HEIGHT = 0
const CHANNEL_NORMAL = 1
const CHANNEL_SPLAT = 2
const CHANNEL_COLOR = 3
const CHANNEL_DETAIL = 4
const CHANNEL_GLOBAL_ALBEDO = 5
const CHANNEL_SPLAT_INDEX = 6
const CHANNEL_SPLAT_WEIGHT = 7
const CHANNEL_COUNT = 8

const _map_types = {
   CHANNEL_HEIGHT: {
      name = "height",
      shader_param_name = "u_terrain_heightmap",
      filter = true,
      mipmaps = false,
      texture_format = Image.FORMAT_RF,
      default_fill = Color(0, 0, 0, 1),
      default_count = 1,
      can_be_saved_as_png = false,
      authored = true,
      srgb = false
   },
   CHANNEL_NORMAL: {
      name = "normal",
      shader_param_name = "u_terrain_normalmap",
      filter = true,
      mipmaps = false,
      # TODO RGB8 is a lie, we should use RGBA8 and pack something in A I guess
      texture_format = Image.FORMAT_RGB8,
      default_fill = Color(0.5, 0.5, 1.0),
      default_count = 1,
      can_be_saved_as_png = true,
      authored = false,
      srgb = false
   },
   CHANNEL_SPLAT: {
      name = "splat",
      shader_param_name = [
         "u_terrain_splatmap", # not _0 for compatibility
         "u_terrain_splatmap_1",
         "u_terrain_splatmap_2",
         "u_terrain_splatmap_3"
      ],
      filter = true,
      mipmaps = false,
      texture_format = Image.FORMAT_RGBA8,
      default_fill = [Color(1, 0, 0, 0), Color(0, 0, 0, 0)],
      default_count = 1,
      can_be_saved_as_png = true,
      authored = true,
      srgb = false
   },
   CHANNEL_COLOR: {
      name = "color",
      shader_param_name = "u_terrain_colormap",
      filter = true,
      mipmaps = false,
      texture_format = Image.FORMAT_RGBA8,
      default_fill = Color(1, 1, 1, 1),
      default_count = 1,
      can_be_saved_as_png = true,
      authored = true,
      srgb = true
   },
   CHANNEL_DETAIL: {
      name = "detail",
      shader_param_name = "u_terrain_detailmap",
      filter = true,
      mipmaps = false,
      texture_format = Image.FORMAT_R8,
      default_fill = Color(0, 0, 0),
      default_count = 0,
      can_be_saved_as_png = true,
      authored = true,
      srgb = false
   },
   CHANNEL_GLOBAL_ALBEDO: {
      name = "global_albedo",
      shader_param_name = "u_terrain_globalmap",
      filter = true,
      mipmaps = true,
      texture_format = Image.FORMAT_RGB8,
      default_fill = null,
      default_count = 0,
      can_be_saved_as_png = true,
      authored = false,
      srgb = true
   },
   CHANNEL_SPLAT_INDEX: {
      name = "splat_index",
      shader_param_name = "u_terrain_splat_index_map",
      filter = false,
      mipmaps = false,
      texture_format = Image.FORMAT_RGB8,
      default_fill = Color(0, 0, 0),
      default_count = 0,
      can_be_saved_as_png = true,
      authored = true,
      srgb = false
   },
   CHANNEL_SPLAT_WEIGHT: {
      name = "splat_weight",
      shader_param_name = "u_terrain_splat_weight_map",
      filter = true,
      mipmaps = false,
      texture_format = Image.FORMAT_RG8,
      default_fill = Color(1, 0, 0),
      default_count = 0,
      can_be_saved_as_png = true,
      authored = true,
      srgb = false
   }
}

# Resolution is a power of two + 1
const MAX_RESOLUTION = 4097
const MIN_RESOLUTION = 65 # must be higher than largest chunk size
const DEFAULT_RESOLUTION = 513
const SUPPORTED_RESOLUTIONS = [65, 129, 257, 513, 1025, 2049, 4097]

const VERTICAL_BOUNDS_CHUNK_SIZE = 16
# TODO Have undo chunk size to emphasise the fact it's independent

const META_EXTENSION = "hterrain"
const META_FILENAME = "data.hterrain"
const META_VERSION = "0.11"

signal resolution_changed
signal region_changed(x, y, w, h, channel)
signal map_added(type, index)
signal map_removed(type, index)
signal map_changed(type, index)


# A map is a texture covering the terrain.
# The usage of a map depends on its type (heightmap, normalmap, splatmap...).
class HT_Map:
   var texture: Texture2D
   # Reference used in case we need the data CPU-side
   var image: Image
   # ID used for saving, because when adding/removing maps,
   # we shouldn't rename texture files just because the indexes change.
   # This is mostly for internal keeping.
   # The API still uses indexes that may shift if your remove a map.
   var id := -1
   # Should be set to true if the map has unsaved modifications.
   var modified := true

   func _init(p_id: int):
      id = p_id


var _resolution := 0

# There can be multiple maps of the same type, though most of them are single
# [map_type][instance_index] => map
var _maps := [[]]

# RGF image where R is min height and G is max height
var _chunked_vertical_bounds := Image.new()

var _locked := false

var _edit_disable_apply_undo := false
var _logger := HT_Logger.get_for(self)


func _init():
   # Initialize default maps
   _set_default_maps()


func _set_default_maps():
   _maps.resize(CHANNEL_COUNT)
   for c in CHANNEL_COUNT:
      var maps := []
      var n : int = _map_types[c].default_count
      for i in n:
         maps.append(HT_Map.new(i))
      _maps[c] = maps


func _edit_load_default():
   _logger.debug("Loading default data")
   _set_default_maps()
   resize(DEFAULT_RESOLUTION)


# Don't use the data if this getter returns false
func is_locked() -> bool:
   return _locked


func get_resolution() -> int:
   return _resolution


# @obsolete
func set_resolution(p_res):
   _logger.error("`HTerrainData.set_resolution()` is obsolete, use `resize()` instead")
   resize(p_res)


# @obsolete
func set_resolution2(p_res, update_normals):
   _logger.error("`HTerrainData.set_resolution2()` is obsolete, use `resize()` instead")
   resize(p_res, true, Vector2(-1, -1))


# Resizes all maps of the terrain. This may take some time to complete.
# Note that no upload to GPU is done, you have to do it once you're done with all changes,
# by calling `notify_region_change` or `notify_full_change`.
# p_res: new resolution. Must be a power of two + 1.
# stretch: if true, the terrain will be stretched in X and Z axes.
#          If false, it will be cropped or expanded.
# anchor: if stretch is false, decides which side or corner to crop/expand the terrain from.
#
# There is an off-by-one in the data,
# so for example a map of 512x512 will actually have 513x513 cells.
# Here is why:
# If we had an even amount of cells, it would produce this situation when making LOD chunks:
#
#   x---x---x---x      x---x---x---x
#   |   |   |   |      |       |
#   x---x---x---x      x   x   x   x
#   |   |   |   |      |       |
#   x---x---x---x      x---x---x---x
#   |   |   |   |      |       |
#   x---x---x---x      x   x   x   x
#
#       LOD 0              LOD 1
#
# We would be forced to ignore the last cells because they would produce an irregular chunk.
# We need an off-by-one because quads making up chunks SHARE their consecutive vertices.
# One quad needs at least 2x2 cells to exist.
# Two quads of the heightmap share an edge, which needs a total of 3x3 cells, not 4x4.
# One chunk has 16x16 quads, so it needs 17x17 cells,
# not 16, where the last cell is shared with the next chunk.
# As a result, a map of 4x4 chunks needs 65x65 cells, not 64x64.
func resize(p_res: int, stretch := true, anchor := Vector2(-1, -1)):
   assert(typeof(p_res) == TYPE_INT)
   assert(typeof(stretch) == TYPE_BOOL)
   assert(typeof(anchor) == TYPE_VECTOR2)

   _logger.debug(str("set_resolution ", p_res))

   if p_res == get_resolution():
      return

   p_res = clampi(p_res, MIN_RESOLUTION, MAX_RESOLUTION)

   # Power of two is important for LOD.
   # Also, grid data is off by one,
   # because for an even number of quads you need an odd number of vertices.
   # To prevent size from increasing at every deserialization,
   # remove 1 before applying power of two.
   p_res = HT_Util.next_power_of_two(p_res - 1) + 1

   _resolution = p_res;

   for channel in CHANNEL_COUNT:
      var maps : Array = _maps[channel]

      for index in len(maps):
         _logger.debug(str("Resizing ", get_map_debug_name(channel, index), "..."))

         var map : HT_Map = maps[index]
         var im := map.image

         if im == null:
            _logger.debug("Image not in memory, creating it")
            im = Image.create(_resolution, _resolution, false, get_channel_format(channel))

            var fill_color = _get_map_default_fill_color(channel, index)
            if fill_color != null:
               _logger.debug(str("Fill with ", fill_color))
               im.fill(fill_color)

         else:
            if stretch and not _map_types[channel].authored:
               # Create a blank new image, it will be automatically computed later
               im = Image.create(_resolution, _resolution, false, get_channel_format(channel))
            else:
               if stretch:
                  if im.get_format() == Image.FORMAT_RGB8:
                     # Can't directly resize this format
                     var float_heightmap := convert_heightmap_to_float(im, _logger)
                     float_heightmap.resize(_resolution, _resolution)
                     im = Image.create(
                        float_heightmap.get_width(),
                        float_heightmap.get_height(), im.has_mipmaps(), im.get_format())
                     convert_float_heightmap_to_rgb8(float_heightmap, im)
                  else:
                     # Assuming float or single-component fixed-point
                     im.resize(_resolution, _resolution)
               else:
                  var fill_color = _get_map_default_fill_color(channel, index)
                  im = HT_Util.get_cropped_image(im, _resolution, _resolution, \
                     fill_color, anchor)

         map.image = im
         map.modified = true

   _update_all_vertical_bounds()

   resolution_changed.emit()


# TODO Can't hint it, the return is a nullable Color
static func _get_map_default_fill_color(map_type: int, map_index: int):
   var config = _map_types[map_type].default_fill
   if config == null:
      # No fill required
      return null
   if typeof(config) == TYPE_COLOR:
      # Standard color fill
      return config
   assert(typeof(config) == TYPE_ARRAY)
   assert(len(config) == 2)
   if map_index == 0:
      # First map has this config
      return config[0]
   # Others have this
   return config[1]


# Gets the height at the given cell position.
# This height is raw and doesn't account for scaling of the terrain node.
# This function is relatively slow due to locking, so don't use it to fetch large areas.
func get_height_at(x: int, y: int) -> float:
   # Height data must be loaded in RAM
   var im := get_image(CHANNEL_HEIGHT)
   assert(im != null)
   match im.get_format():
      Image.FORMAT_RF:
         return HT_Util.get_pixel_clamped(im, x, y).r
      Image.FORMAT_RGB8:
         return decode_height_from_rgb8_unorm(HT_Util.get_pixel_clamped(im, x, y))
      _:
         _logger.error(str("Invalid heigthmap format ", im.get_format()))
         return 0.0


# Gets the height at the given floating-point cell position.
# This height is raw and doesn't account for scaling of the terrain node.
# This function is relatively slow due to locking, so don't use it to fetch large areas
func get_interpolated_height_at(pos: Vector3) -> float:
   # Height data must be loaded in RAM
   var im := get_image(CHANNEL_HEIGHT)
   assert(im != null)
   var map_type = _map_types[CHANNEL_HEIGHT]
   assert(im.get_format() == map_type.texture_format)

   # The function takes a Vector3 for convenience so it's easier to use in 3D scripting
   var x0 := int(floorf(pos.x))
   var y0 := int(floorf(pos.z))

   var xf := pos.x - x0
   var yf := pos.z - y0
   
   var h00 : float
   var h10 : float
   var h01 : float
   var h11 : float
   
   match im.get_format():
      Image.FORMAT_RF:
         h00 = HT_Util.get_pixel_clamped(im, x0, y0).r
         h10 = HT_Util.get_pixel_clamped(im, x0 + 1, y0).r
         h01 = HT_Util.get_pixel_clamped(im, x0, y0 + 1).r
         h11 = HT_Util.get_pixel_clamped(im, x0 + 1, y0 + 1).r
      
      Image.FORMAT_RGB8:
         var c00 := HT_Util.get_pixel_clamped(im, x0, y0)
         var c10 := HT_Util.get_pixel_clamped(im, x0 + 1, y0)
         var c01 := HT_Util.get_pixel_clamped(im, x0, y0 + 1)
         var c11 := HT_Util.get_pixel_clamped(im, x0 + 1, y0 + 1)

         h00 = decode_height_from_rgb8_unorm(c00)
         h10 = decode_height_from_rgb8_unorm(c10)
         h01 = decode_height_from_rgb8_unorm(c01)
         h11 = decode_height_from_rgb8_unorm(c11)
      
      _:
         _logger.error(str("Invalid heightmap format ", im.get_format()))
         return 0.0

   # Bilinear filter
   var h := lerpf(lerpf(h00, h10, xf), lerpf(h01, h11, xf), yf)
   return h

# Gets all heights within the given rectangle in cells.
# This height is raw and doesn't account for scaling of the terrain node.
# Data is returned as a PackedFloat32Array.
func get_heights_region(x0: int, y0: int, w: int, h: int) -> PackedFloat32Array:
   var im = get_image(CHANNEL_HEIGHT)
   assert(im != null)
   
   var min_x := clampi(x0, 0, im.get_width())
   var min_y := clampi(y0, 0, im.get_height())
   var max_x := clampi(x0 + w, 0, im.get_width() + 1)
   var max_y := clampi(y0 + h, 0, im.get_height() + 1)

   var heights := PackedFloat32Array()

   var area := (max_x - min_x) * (max_y - min_y)
   if area == 0:
      _logger.debug("Empty heights region!")
      return heights

   heights.resize(area)

   var i := 0
   
   if im.get_format() == Image.FORMAT_RF or im.get_format() == Image.FORMAT_RH:
      for y in range(min_y, max_y):
         for x in range(min_x, max_x):
            heights[i] = im.get_pixel(x, y).r
            i += 1
            
   elif im.get_format() == Image.FORMAT_RGB8:
      for y in range(min_y, max_y):
         for x in range(min_x, max_x):
            var c := im.get_pixel(x, y)
            heights[i] = decode_height_from_rgb8_unorm(c)
            i += 1
   
   else:
      _logger.error(str("Unknown heightmap format! ", im.get_format()))

   return heights


# Gets all heights as an array indexed as [x + y * width].
# This height is raw and doesn't account for scaling of the terrain node.
func get_all_heights() -> PackedFloat32Array:
   var im = get_image(CHANNEL_HEIGHT)
   assert(im != null)
   if im.get_format() == Image.FORMAT_RF:
      return im.get_data().to_float32_array()
   else:
      return get_heights_region(0, 0, _resolution, _resolution)


# Call this function after you end modifying a map.
# It will commit the change to the GPU so the change will take effect.
# In the editor, it will also mark the map as modified so it will be saved when needed.
# Finally, it will emit `region_changed`, 
# which allows other systems to catch up (like physics or grass)
#
# p_rect:
#     modified area.
#
# map_type:
#    which kind of map changed, see CHANNEL_* constants
#
# index:
#    index of the map that changed
#
# p_upload_to_texture:
#     the modified region will be copied from the map image to the texture.
#     If the change already occurred on GPU, you may set this to false.
#
# p_update_vertical_bounds:
#     if the modified map is the heightmap, vertical bounds will be updated.
#
func notify_region_change(
   p_rect: Rect2,
   p_map_type: int,
   p_index := 0,
   p_upload_to_texture := true,
   p_update_vertical_bounds := true):
   
   assert(p_map_type >= 0 and p_map_type < CHANNEL_COUNT)
   
   var min_x := int(p_rect.position.x)
   var min_y := int(p_rect.position.y)
   var size_x := int(p_rect.size.x)
   var size_y := int(p_rect.size.y)
   
   if p_map_type == CHANNEL_HEIGHT and p_update_vertical_bounds:
      assert(p_index == 0)
      _update_vertical_bounds(min_x, min_y, size_x, size_y)
   
   if p_upload_to_texture:
      _upload_region(p_map_type, p_index, min_x, min_y, size_x, size_y)
   
   _maps[p_map_type][p_index].modified = true

   region_changed.emit(min_x, min_y, size_x, size_y, p_map_type)
   changed.emit()


func notify_full_change():
   for maptype in range(CHANNEL_COUNT):
      # Ignore normals because they get updated along with heights
      if maptype == CHANNEL_NORMAL:
         continue
      var maps = _maps[maptype]
      for index in len(maps):
         notify_region_change(Rect2(0, 0, _resolution, _resolution), maptype, index)


func _edit_set_disable_apply_undo(e: bool):
   _edit_disable_apply_undo = e


func _edit_apply_undo(undo_data: Dictionary, image_cache: HT_ImageFileCache):
   if _edit_disable_apply_undo:
      return

   var chunk_positions: Array = undo_data["chunk_positions"]
   var map_infos: Array = undo_data["maps"]
   var chunk_size: int = undo_data["chunk_size"]

   _logger.debug(str("Applying ", len(chunk_positions), " undo/redo chunks"))

   # Validate input

   for map_info in map_infos:
      assert(map_info.map_type >= 0 and map_info.map_type < CHANNEL_COUNT)
      assert(len(map_info.chunks) == len(chunk_positions))
      for im_cache_id in map_info.chunks:
         assert(typeof(im_cache_id) == TYPE_INT)

   # Apply for each map
   for map_info in map_infos:
      var map_type := map_info.map_type as int
      var map_index := map_info.map_index as int
      
      var regions_changed := []
      
      for chunk_index in len(map_info.chunks):
         var cpos : Vector2 = chunk_positions[chunk_index]
         var cpos_x := int(cpos.x)
         var cpos_y := int(cpos.y)
   
         var min_x := cpos_x * chunk_size
         var min_y := cpos_y * chunk_size
         var max_x := min_x + chunk_size
         var max_y := min_y + chunk_size
   
         var data_id = map_info.chunks[chunk_index]
         var data := image_cache.load_image(data_id)
         assert(data != null)
   
         var dst_image := get_image(map_type, map_index)
         assert(dst_image != null)
   
         if _map_types[map_type].authored:
            #_logger.debug(str("Apply undo chunk ", cpos, " to ", Vector2(min_x, min_y)))
            var src_rect := Rect2i(0, 0, data.get_width(), data.get_height())
            dst_image.blit_rect(data, src_rect, Vector2i(min_x, min_y))
         else:
            _logger.error(
               str("Channel ", map_type, " is a calculated channel!, no undo on this one"))
   
         # Defer this to a second pass,
         # otherwise it causes order-dependent artifacts on the normal map
         regions_changed.append([
            Rect2(min_x, min_y, max_x - min_x, max_y - min_y), map_type, map_index])

      for args in regions_changed:
         notify_region_change(args[0], args[1], args[2])


#static func _debug_dump_heightmap(src: Image, fpath: String):
#  var im = Image.new()
#  im.create(src.get_width(), src.get_height(), false, Image.FORMAT_RGB8)
#  im.lock()
#  src.lock()
#  for y in im.get_height():
#     for x in im.get_width():
#        var col = src.get_pixel(x, y)
#        var c = col.r - floor(col.r)
#        im.set_pixel(x, y, Color(c, 0.0, 0.0, 1.0))
#  im.unlock()
#  src.unlock()
#  im.save_png(fpath)


# TODO Support map indexes
# Used for undoing full-terrain changes
func _edit_apply_maps_from_file_cache(image_file_cache: HT_ImageFileCache, map_ids: Dictionary):
   if _edit_disable_apply_undo:
      return
   for map_type in map_ids:
      var id = map_ids[map_type]
      var src_im := image_file_cache.load_image(id)
      if src_im == null:
         continue
      var index := 0
      var dst_im := get_image(map_type, index)
      var rect := Rect2i(0, 0, src_im.get_height(), src_im.get_height())
      dst_im.blit_rect(src_im, rect, Vector2i())
      notify_region_change(rect, map_type, index)


func _upload_channel(channel: int, index: int):
   _upload_region(channel, index, 0, 0, _resolution, _resolution)


func _upload_region(channel: int, index: int, min_x: int, min_y: int, size_x: int, size_y: int):
   #_logger.debug("Upload ", min_x, ", ", min_y, ", ", size_x, "x", size_y)
   #var time_before = OS.get_ticks_msec()

   var map : HT_Map = _maps[channel][index]

   var image := map.image
   assert(image != null)
   assert(size_x > 0 and size_y > 0)

   # TODO Actually, I think the input params should be valid in the first place...
   if min_x < 0:
      min_x = 0
   if min_y < 0:
      min_y = 0
   if min_x + size_x > image.get_width():
      size_x = image.get_width() - min_x
   if min_y + size_y > image.get_height():
      size_y = image.get_height() - min_y
   if size_x <= 0 or size_y <= 0:
      return

   var texture := map.texture

   if texture == null or not (texture is ImageTexture):
      # The texture doesn't exist yet in an editable format
      if texture != null and not (texture is ImageTexture):
         _logger.debug(str(
            "_upload_region was used but the texture isn't an ImageTexture. ",\
            "The map ", channel, "[", index, "] will be reuploaded entirely."))
      else:
         _logger.debug(str(
            "_upload_region was used but the texture is not created yet. ",\
            "The map ", channel, "[", index, "] will be uploaded entirely."))

      map.texture = ImageTexture.create_from_image(image)

      # Need to notify because other systems may want to grab the new texture object
      map_changed.emit(channel, index)

   # TODO Unfortunately Texture2D.get_size() wasn't updated to use Vector2i in Godot 4
   elif Vector2i(texture.get_size()) != image.get_size():
      _logger.debug(str(
         "_upload_region was used but the image size is different. ",\
         "The map ", channel, "[", index, "] will be reuploaded entirely."))

      map.texture = ImageTexture.create_from_image(image)

      # Since Godot 4, need to notify because other systems may want to grab the new texture
      # object. In Godot 3 it wasn't necessary because we were able to resize a texture without
      # having to recreate it from scratch...
      map_changed.emit(channel, index)

   else:
      HT_Util.update_texture_partial(texture, image, 
         Rect2i(min_x, min_y, size_x, size_y), Vector2i(min_x, min_y))

   #_logger.debug(str("Channel updated ", channel))

   #var time_elapsed = OS.get_ticks_msec() - time_before
   #_logger.debug(str("Texture upload time: ", time_elapsed, "ms"))


# Gets how many instances of a given map are present in the terrain data.
# A return value of 0 means there is no such map, and querying for it might cause errors.
func get_map_count(map_type: int) -> int:
   if map_type < len(_maps):
      return len(_maps[map_type])
   return 0


# TODO Deprecated
func _edit_add_detail_map():
   return _edit_add_map(CHANNEL_DETAIL)


# TODO Deprecated
func _edit_remove_detail_map(index):
   _edit_remove_map(CHANNEL_DETAIL, index)


func _edit_add_map(map_type: int) -> int:
   # TODO Check minimum and maximum instances of a given map
   _logger.debug(str("Adding map of type ", get_channel_name(map_type)))
   while map_type >= len(_maps):
      _maps.append([])
   var maps = _maps[map_type]
   var map = HT_Map.new(_get_free_id(map_type))
   map.image = Image.create(_resolution, _resolution, false, get_channel_format(map_type))
   var index = len(maps)
   var default_color = _get_map_default_fill_color(map_type, index)
   if default_color != null:
      map.image.fill(default_color)
   maps.append(map)
   map_added.emit(map_type, index)
   return index


func _edit_insert_map_from_image_cache(map_type: int, index: int, image_cache, image_id: int):
   if _edit_disable_apply_undo:
      return
   _logger.debug(str("Adding map of type ", get_channel_name(map_type), 
      " from an image at index ", index))
   while map_type >= len(_maps):
      _maps.append([])
   var maps = _maps[map_type]
   var map := HT_Map.new(_get_free_id(map_type))
   map.image = image_cache.load_image(image_id)
   maps.insert(index, map)
   map_added.emit(map_type, index)


func _edit_remove_map(map_type: int, index: int):
   # TODO Check minimum and maximum instances of a given map
   _logger.debug(str("Removing map ", get_channel_name(map_type), " at index ", index))
   var maps : Array = _maps[map_type]
   maps.remove_at(index)
   map_removed.emit(map_type, index)


func _get_free_id(map_type: int) -> int:
   var maps = _maps[map_type]
   var id = 0
   while _get_map_by_id(map_type, id) != null:
      id += 1
   return id


func _get_map_by_id(map_type: int, id: int) -> HT_Map:
   var maps = _maps[map_type]
   for map in maps:
      if map.id == id:
         return map
   return null


func get_image(map_type: int, index := 0) -> Image:
   var maps = _maps[map_type]
   return maps[index].image


func get_texture(map_type: int, index := 0, writable := false) -> Texture:
   # TODO Split into `get_texture` and `get_writable_texture`?
   
   var maps : Array = _maps[map_type]
   var map : HT_Map = maps[index]

   if map.image != null:
      if map.texture == null:
         _upload_channel(map_type, index)
      elif writable and not (map.texture is ImageTexture):
         _upload_channel(map_type, index)
   else:
      if writable:
         _logger.warn(str("Requested writable terrain texture ",
            get_map_debug_name(map_type, index), ", but it's not available in this context"))

   return map.texture


func has_texture(map_type: int, index: int) -> bool:
   var maps = _maps[map_type]
   return index < len(maps)


func get_aabb() -> AABB:
   # TODO Why subtract 1? I forgot
   # TODO Optimize for full region, this is actually quite costy
   return get_region_aabb(0, 0, _resolution - 1, _resolution - 1)


# Not so useful in itself, but GDScript is slow,
# so I needed it to speed up the LOD hack I had to do to take height into account
func get_point_aabb(cell_x: int, cell_y: int) -> Vector2:
   assert(typeof(cell_x) == TYPE_INT)
   assert(typeof(cell_y) == TYPE_INT)

   var cx = cell_x / VERTICAL_BOUNDS_CHUNK_SIZE
   var cy = cell_y / VERTICAL_BOUNDS_CHUNK_SIZE

   if cx < 0:
      cx = 0
   if cy < 0:
      cy = 0
   if cx >= _chunked_vertical_bounds.get_width():
      cx = _chunked_vertical_bounds.get_width() - 1
   if cy >= _chunked_vertical_bounds.get_height():
      cy = _chunked_vertical_bounds.get_height() - 1

   var b := _chunked_vertical_bounds.get_pixel(cx, cy)
   return Vector2(b.r, b.g)


func get_region_aabb(origin_in_cells_x: int, origin_in_cells_y: int,
   size_in_cells_x: int, size_in_cells_y: int) -> AABB:

   assert(typeof(origin_in_cells_x) == TYPE_INT)
   assert(typeof(origin_in_cells_y) == TYPE_INT)
   assert(typeof(size_in_cells_x) == TYPE_INT)
   assert(typeof(size_in_cells_y) == TYPE_INT)

   # Get info from cached vertical bounds,
   # which is a lot faster than directly fetching heights from the map.
   # It's not 100% accurate, but enough for culling use case if chunk size is decently chosen.

   var cmin_x := origin_in_cells_x / VERTICAL_BOUNDS_CHUNK_SIZE
   var cmin_y := origin_in_cells_y / VERTICAL_BOUNDS_CHUNK_SIZE

   var cmax_x := (origin_in_cells_x + size_in_cells_x - 1) / VERTICAL_BOUNDS_CHUNK_SIZE + 1
   var cmax_y := (origin_in_cells_y + size_in_cells_y - 1) / VERTICAL_BOUNDS_CHUNK_SIZE + 1

   cmin_x = clampi(cmin_x, 0, _chunked_vertical_bounds.get_width() - 1)
   cmin_y = clampi(cmin_y, 0, _chunked_vertical_bounds.get_height() - 1)
   cmax_x = clampi(cmax_x, 0, _chunked_vertical_bounds.get_width())
   cmax_y = clampi(cmax_y, 0, _chunked_vertical_bounds.get_height())

   var min_height := _chunked_vertical_bounds.get_pixel(cmin_x, cmin_y).r
   var max_height = min_height

   for y in range(cmin_y, cmax_y):
      for x in range(cmin_x, cmax_x):
         var b = _chunked_vertical_bounds.get_pixel(x, y)
         min_height = minf(b.r, min_height)
         max_height = maxf(b.g, max_height)

   var aabb = AABB()
   aabb.position = Vector3(origin_in_cells_x, min_height, origin_in_cells_y)
   aabb.size = Vector3(size_in_cells_x, max_height - min_height, size_in_cells_y)

   return aabb


func _update_all_vertical_bounds():
   var csize_x := _resolution / VERTICAL_BOUNDS_CHUNK_SIZE
   var csize_y := _resolution / VERTICAL_BOUNDS_CHUNK_SIZE
   _logger.debug(str("Updating all vertical bounds... (", csize_x , "x", csize_y, " chunks)"))
   _chunked_vertical_bounds = Image.create(csize_x, csize_y, false, Image.FORMAT_RGF)
   _update_vertical_bounds(0, 0, _resolution - 1, _resolution - 1)


func update_vertical_bounds(p_rect: Rect2):
   var min_x := int(p_rect.position.x)
   var min_y := int(p_rect.position.y)
   var size_x := int(p_rect.size.x)
   var size_y := int(p_rect.size.y)

   _update_vertical_bounds(min_x, min_y, size_x, size_y)


func _update_vertical_bounds(origin_in_cells_x: int, origin_in_cells_y: int, \
                     size_in_cells_x: int, size_in_cells_y: int):

   var cmin_x := origin_in_cells_x / VERTICAL_BOUNDS_CHUNK_SIZE
   var cmin_y := origin_in_cells_y / VERTICAL_BOUNDS_CHUNK_SIZE

   var cmax_x := (origin_in_cells_x + size_in_cells_x - 1) / VERTICAL_BOUNDS_CHUNK_SIZE + 1
   var cmax_y := (origin_in_cells_y + size_in_cells_y - 1) / VERTICAL_BOUNDS_CHUNK_SIZE + 1

   cmin_x = clampi(cmin_x, 0, _chunked_vertical_bounds.get_width() - 1)
   cmin_y = clampi(cmin_y, 0, _chunked_vertical_bounds.get_height() - 1)
   cmax_x = clampi(cmax_x, 0, _chunked_vertical_bounds.get_width())
   cmax_y = clampi(cmax_y, 0, _chunked_vertical_bounds.get_height())

   # Note: chunks in _chunked_vertical_bounds share their edge cells and
   # have an actual size of chunk size + 1.
   var chunk_size_x := VERTICAL_BOUNDS_CHUNK_SIZE + 1
   var chunk_size_y := VERTICAL_BOUNDS_CHUNK_SIZE + 1
   
   for y in range(cmin_y, cmax_y):
      var pmin_y := y * VERTICAL_BOUNDS_CHUNK_SIZE

      for x in range(cmin_x, cmax_x):
         var pmin_x := x * VERTICAL_BOUNDS_CHUNK_SIZE
         var b = _compute_vertical_bounds_at(pmin_x, pmin_y, chunk_size_x, chunk_size_y)
         _chunked_vertical_bounds.set_pixel(x, y, Color(b.x, b.y, 0))


func _compute_vertical_bounds_at(
   origin_x: int, origin_y: int, size_x: int, size_y: int) -> Vector2:
   
   var heights := get_image(CHANNEL_HEIGHT)
   assert(heights != null)
   match heights.get_format():
      Image.FORMAT_RF:
         return _get_heights_range_f(heights, Rect2i(origin_x, origin_y, size_x, size_y))
      Image.FORMAT_RGB8:
         return _get_heights_range_rgb8(heights, Rect2i(origin_x, origin_y, size_x, size_y))
      _:
         _logger.error(str("Unknown heightmap format ", heights.get_format()))
         return Vector2()


static func _get_heights_range_rgb8(im: Image, rect: Rect2i) -> Vector2:
   assert(im.get_format() == Image.FORMAT_RGB8)
   
   rect = rect.intersection(Rect2i(0, 0, im.get_width(), im.get_height()))
   var min_x := rect.position.x
   var min_y := rect.position.y
   var max_x := min_x + rect.size.x
   var max_y := min_y + rect.size.y
   
   var min_height := decode_height_from_rgb8_unorm(im.get_pixel(min_x, min_y))
   var max_height := min_height

   for y in range(min_y, max_y):
      for x in range(min_x, max_x):
         var h := decode_height_from_rgb8_unorm(im.get_pixel(x, y))
         min_height = minf(h, min_height)
         max_height = maxf(h, max_height)

   return Vector2(min_height, max_height)


static func _get_heights_range_f(im: Image, rect: Rect2i) -> Vector2:
   assert(im.get_format() == Image.FORMAT_RF)
   
   rect = rect.intersection(Rect2i(0, 0, im.get_width(), im.get_height()))
   var min_x := rect.position.x
   var min_y := rect.position.y
   var max_x := min_x + rect.size.x
   var max_y := min_y + rect.size.y
   
   var min_height := im.get_pixel(min_x, min_y).r
   var max_height := min_height

   for y in range(min_y, max_y):
      for x in range(min_x, max_x):
         var h := im.get_pixel(x, y).r
         min_height = minf(h, min_height)
         max_height = maxf(h, max_height)

   return Vector2(min_height, max_height)


func save_data(data_dir: String) -> bool:
   _logger.debug("Saving terrain data...")
   
   _locked = true

   _save_metadata(data_dir.path_join(META_FILENAME))

   var map_count = _get_total_map_count()

   var all_succeeded = true

   var pi = 0
   for map_type in CHANNEL_COUNT:
      var maps : Array = _maps[map_type]

      for index in len(maps):
         var map : HT_Map = maps[index]
         if not map.modified:
            _logger.debug(str(
               "Skipping non-modified ", get_map_debug_name(map_type, index)))
            continue

         _logger.debug(str("Saving map ", get_map_debug_name(map_type, index),
            " as ", _get_map_filename(map_type, index), "..."))

         all_succeeded = all_succeeded and _save_map(data_dir, map_type, index)

         map.modified = false
         pi += 1
   
   # TODO Cleanup unused map files?

   # TODO In editor, trigger reimport on generated assets
   _locked = false

   return all_succeeded


func _is_any_map_modified() -> bool:
   for maplist in _maps:
      for map in maplist:
         if map.modified:
            return true
   return false


func _get_total_map_count() -> int:
   var s = 0
   for maps in _maps:
      s += len(maps)
   return s


func _load_metadata(path: String):
   var f = FileAccess.open(path, FileAccess.READ)
   assert(f != null)
   var text = f.get_as_text()
   f = null # close file
   var json = JSON.new()
   assert(json.parse(text) == OK)
   _deserialize_metadata(json.data)


func _save_metadata(path: String):
   var d = _serialize_metadata()
   var text = JSON.stringify(d, "\t", true)
   var f = FileAccess.open(path, FileAccess.WRITE)
   var err = f.get_error()
   assert(err == OK)
   f.store_string(text)


func _serialize_metadata() -> Dictionary:
   var data := []
   data.resize(len(_maps))

   for i in range(len(_maps)):
      var maps = _maps[i]
      var maps_data := []

      for j in range(len(maps)):
         var map : HT_Map = maps[j]
         maps_data.append({ "id": map.id })

      data[i] = maps_data

   return {
      "version": META_VERSION,
      "maps": data
   }


# Parse metadata that we'll then use to load the actual terrain
# (How many maps, which files to load etc...)
func _deserialize_metadata(dict: Dictionary) -> bool:
   if not dict.has("version"):
      _logger.error("Terrain metadata has no version")
      return false

   if dict.version != META_VERSION:
      _logger.error("Terrain metadata version mismatch. Got {0}, expected {1}" \
         .format([dict.version, META_VERSION]))
      return false

   var data = dict["maps"]
   assert(len(data) <= len(_maps))

   for i in len(data):
      var maps = _maps[i]

      var maps_data = data[i]
      if len(maps) != len(maps_data):
         maps.resize(len(maps_data))

      for j in len(maps):
         var map = maps[j]
         # Cast because the data comes from json, where every number is double
         var id := int(maps_data[j].id)
         if map == null:
            map = HT_Map.new(id)
            maps[j] = map
         else:
            map.id = id

   return true


func load_data(dir_path: String):
   _locked = true

   _load_metadata(dir_path.path_join(META_FILENAME))

   _logger.debug("Loading terrain data...")

   var channel_instance_sum = _get_total_map_count()
   var pi = 0

   # Note: if we loaded all maps at once before uploading them to VRAM,
   # it would take a lot more RAM than if we load them one by one
   for map_type in len(_maps):
      var maps = _maps[map_type]

      for index in len(maps):
         _logger.debug(str("Loading map ", get_map_debug_name(map_type, index),
            " from ", _get_map_filename(map_type, index), "..."))

         _load_map(dir_path, map_type, index)

         # A map that was just loaded is considered not modified yet
         maps[index].modified = false

         pi += 1

   _logger.debug("Calculating vertical bounds...")
   _update_all_vertical_bounds()

   _logger.debug("Notify resolution change...")

   _locked = false
   resolution_changed.emit()


func get_data_dir() -> String:
   # The HTerrainData resource represents the metadata and entry point for Godot.
   # It should be placed within a folder dedicated for terrain storage.
   # Other heavy data such as maps are stored next to that file.
   return resource_path.get_base_dir()


func _save_map(dir_path: String, map_type: int, index: int) -> bool:
   var map : HT_Map = _maps[map_type][index]
   var im := map.image
   if im == null:
      var tex := map.texture
      if tex != null:
         _logger.debug(str("Image not found for map ", map_type, ", downloading from VRAM"))
         im = tex.get_image()
      else:
         _logger.debug(str("No data in map ", map_type, "[", index, "]"))
         # This data doesn't have such map
         return true

   # The function says "absolute" but in reality it accepts paths like `res://x`,
   # which from a user standpoint are not absolute. Also, `FileAccess.file_exists` exists but
   # isn't named "absolute" :shrug:
   if not DirAccess.dir_exists_absolute(dir_path):
      var err := DirAccess.make_dir_absolute(dir_path)
      if err != OK:
         _logger.error("Could not create directory '{0}', error {1}" \
            .format([dir_path, HT_Errors.get_message(err)]))
      return false

   var fpath := dir_path.path_join(_get_map_filename(map_type, index))

   return _save_map_image(fpath, map_type, im)


func _save_map_image(fpath: String, map_type: int, im: Image) -> bool:
   if _channel_can_be_saved_as_png(map_type):
      fpath += ".png"
      var err := im.save_png(fpath)
      if err != OK:
         _logger.error("Could not save '{0}', error {1}" \
            .format([fpath, HT_Errors.get_message(err)]))
         return false
      _try_write_default_import_options(fpath, map_type, _logger)

   else:
      fpath += ".res"
      var err := ResourceSaver.save(im, fpath)
      if err != OK:
         _logger.error("Could not save '{0}', error {1}" \
            .format([fpath, HT_Errors.get_message(err)]))
         return false

   return true


static func _try_write_default_import_options(
   fpath: String, channel: int, logger: HT_Logger.HT_LoggerBase):
   
   var imp_fpath := fpath + ".import"
   if FileAccess.file_exists(imp_fpath):
      # Already exists
      return
   
   var map_info = _map_types[channel]
   var srgb: bool = map_info.srgb
   
   var defaults : Dictionary
   
   if channel == CHANNEL_HEIGHT:
      defaults = {
         "remap": {
            # Have the heightmap editable as an image by default
            "importer": "image",
            "type": "Image"
         },
         "deps": {
            "source_file": fpath
         }
      }
   
   else:
      defaults = {
         "remap": {
            "importer": "texture",
            "type": "CompressedTexture2D"
         },
         "deps": {
            "source_file": fpath
         },
         "params": {
            # Use lossless compression.
            # Lossy ruins quality and makes the editor choke on big textures.
            # TODO I would have used ImageTexture.COMPRESS_LOSSLESS,
            # but apparently what is saved in the .import file does not match,
            # and rather corresponds TO THE UI IN THE IMPORT DOCK :facepalm:
            "compress/mode": 0,
            
            "compress/hdr_compression": 0,
            "compress/normal_map": 0,
            # No mipmaps
            "mipmaps/limit": 0,
            
            # Most textures aren't color.
            # Same here, this is mapping something from the import dock UI,
            # and doesn't have any enum associated, just raw numbers in C++ code...
            # 0 = "disabled", 1 = "enabled", 2 = "detect"
            "flags/srgb": 2 if srgb else 0,
            
            # No need for this, the meaning of alpha is never transparency
            "process/fix_alpha_border": false,
            
            # Don't try to be smart.
            # This can actually overwrite the settings with defaults...
            # https://github.com/godotengine/godot/issues/24220
            "detect_3d/compress_to": 0,
         }
      }

   HT_Util.write_import_file(defaults, imp_fpath, logger)


func _load_map(dir: String, map_type: int, index: int) -> bool:
   var fpath := dir.path_join(_get_map_filename(map_type, index))

   # Maps must be configured before being loaded
   var map : HT_Map = _maps[map_type][index]
   # while len(_maps) <= map_type:
   #  _maps.append([])
   # while len(_maps[map_type]) <= index:
   #  _maps[map_type].append(null)
   # var map = _maps[map_type][index]
   # if map == null:
   #  map = Map.new()
   #  _maps[map_type][index] = map

   if _channel_can_be_saved_as_png(map_type):
      fpath += ".png"
   else:
      fpath += ".res"
   
   var tex = load(fpath)
   
   var must_load_image_in_editor := true
   
   # Short-term compatibility with RGB8 encoding from the godot4 branch
   if Engine.is_editor_hint() and tex == null and map_type == CHANNEL_HEIGHT:
      var legacy_fpath := fpath.get_basename() + ".png"
      var temp = load(legacy_fpath)
      if temp != null:
         if temp is Texture2D:
            temp = temp.get_image()
         if temp is Image:
            if temp.get_format() == Image.FORMAT_RGB8:
               _logger.warn(str(
                  "Found a heightmap using legacy RGB8 format. It will be converted to RF. ",
                  "You may want to remove the old file: {0}").format([fpath]))
               tex = convert_heightmap_to_float(temp, _logger)
               _save_map_image(fpath.get_basename(), map_type, tex)

   if tex != null and tex is Image:
      # The texture is imported as Image,
      # perhaps the user wants it to be accessible from RAM in game.
      _logger.debug("Map {0} is imported as Image. An ImageTexture will be generated." \
            .format([get_map_debug_name(map_type, index)]))
      map.image = tex
      tex = ImageTexture.create_from_image(map.image)
      must_load_image_in_editor = false

   map.texture = tex

   if Engine.is_editor_hint():
      if must_load_image_in_editor:
         # But in the editor we want textures to be editable,
         # so we have to automatically load the data also in RAM
         if map.image == null:
            map.image = Image.load_from_file(fpath)
         else:
            map.image.load(fpath)
      _ensure_map_format(map.image, map_type, index)
   
   if map_type == CHANNEL_HEIGHT:
      _resolution = map.image.get_width()

   return true


func _ensure_map_format(im: Image, map_type: int, index: int):
   var format := im.get_format()
   var expected_format : int = _map_types[map_type].texture_format
   if format != expected_format:
      _logger.warn("Map {0} loaded as format {1}, expected {2}. Will be converted." \
         .format([get_map_debug_name(map_type, index), format, expected_format]))
      im.convert(expected_format)


# Imports images into the terrain data by converting them to the internal format.
# It is possible to omit some of them, in which case those already setup will be used.
# This function is quite permissive, and will only fail if there is really no way to import.
# It may involve cropping, so preliminary checks should be done to inform the user.
#
# TODO Plan is to make this function threaded, in case import takes too long.
# So anything that could mess with the main thread should be avoided.
# Eventually, it would be temporarily removed from the terrain node to work 
# in isolation during import.
func _edit_import_maps(input: Dictionary) -> bool:
   assert(typeof(input) == TYPE_DICTIONARY)

   if input.has(CHANNEL_HEIGHT):
      var params = input[CHANNEL_HEIGHT]
      if not _import_heightmap(
         params.path, params.min_height, params.max_height, params.big_endian):
         return false

   # TODO Import indexed maps?
   var maptypes := [CHANNEL_COLOR, CHANNEL_SPLAT]

   for map_type in maptypes:
      if input.has(map_type):
         var params = input[map_type]
         if not _import_map(map_type, params.path):
            return false

   return true


# Provided an arbitrary width and height,
# returns the closest size the terrain actuallysupports
static func get_adjusted_map_size(width: int, height: int) -> int:
   var width_po2 = HT_Util.next_power_of_two(width - 1) + 1
   var height_po2 = HT_Util.next_power_of_two(height - 1) + 1
   var size_po2 = mini(width_po2, height_po2)
   size_po2 = clampi(size_po2, MIN_RESOLUTION, MAX_RESOLUTION)
   return size_po2


func _import_heightmap(fpath: String, min_y: float, max_y: float, big_endian: bool) -> bool:
   var ext := fpath.get_extension().to_lower()

   if ext == "png":
      # Godot can only load 8-bit PNG,
      # so we have to bring it back to float in the wanted range

      var src_image := Image.load_from_file(fpath)
      # TODO No way to access the error code?
      if src_image == null:
         return false

      var res := get_adjusted_map_size(src_image.get_width(), src_image.get_height())
      if res != src_image.get_width():
         src_image.crop(res, res)

      _locked = true

      _logger.debug(str("Resizing terrain to ", res, "x", res, "..."))
      resize(src_image.get_width(), false, Vector2())

      var im := get_image(CHANNEL_HEIGHT)
      assert(im != null)

      var hrange := max_y - min_y

      var width := mini(im.get_width(), src_image.get_width())
      var height := mini(im.get_height(), src_image.get_height())

      _logger.debug("Converting to internal format...")

      # Convert to internal format with range scaling
      match im.get_format():
         Image.FORMAT_RF:
            for y in width:
               for x in height:
                  var gs := src_image.get_pixel(x, y).r
                  var h := min_y + hrange * gs
                  im.set_pixel(x, y, Color(h, h, h))
         Image.FORMAT_RGB8:
            for y in width:
               for x in height:
                  var gs := src_image.get_pixel(x, y).r
                  var h := min_y + hrange * gs
                  im.set_pixel(x, y, encode_height_to_rgb8_unorm(h))
         _:
            _logger.error(str("Invalid heightmap format ", im.get_format()))
   
   elif ext == "exr":
      var src_image := Image.load_from_file(fpath)
      # TODO No way to access the error code?
      if src_image == null:
         return false

      var res := get_adjusted_map_size(src_image.get_width(), src_image.get_height())
      if res != src_image.get_width():
         src_image.crop(res, res)

      _locked = true

      _logger.debug(str("Resizing terrain to ", res, "x", res, "..."))
      resize(src_image.get_width(), false, Vector2())

      var im := get_image(CHANNEL_HEIGHT)
      assert(im != null)

      _logger.debug("Converting to internal format...")
      
      match im.get_format():
         Image.FORMAT_RF:
            # See https://github.com/Zylann/godot_heightmap_plugin/issues/34
            # Godot can load EXR but it always makes them have at least 3-channels.
            # Heightmaps need only one, so we have to get rid of 2.
            var height_format = _map_types[CHANNEL_HEIGHT].texture_format
            src_image.convert(height_format)
            im.blit_rect(src_image, Rect2i(0, 0, res, res), Vector2i())
         
         Image.FORMAT_RGB8:
            convert_float_heightmap_to_rgb8(src_image, im)
            
         _:
            _logger.error(str("Invalid heightmap format ", im.get_format()))

   elif ext == "raw":
      # RAW files don't contain size, so we have to deduce it from 16-bit size.
      # We also need to bring it back to float in the wanted range.

      var f := FileAccess.open(fpath, FileAccess.READ)
      if f == null:
         return false

      var file_len := f.get_length()
      var file_res := HT_Util.integer_square_root(file_len / 2)
      if file_res == -1:
         # Can't deduce size
         return false

      # TODO Need a way to know which endianess our system has!
      # For now we have to make an assumption...
      # This function is most supposed to execute in the editor.
      # The editor officially runs on desktop architectures, which are
      # generally little-endian.
      if big_endian:
         f.big_endian = true

      var res := get_adjusted_map_size(file_res, file_res)

      var width := res
      var height := res

      _locked = true

      _logger.debug(str("Resizing terrain to ", width, "x", height, "..."))
      resize(res, false, Vector2())

      var im := get_image(CHANNEL_HEIGHT)
      assert(im != null)

      var hrange := max_y - min_y

      _logger.debug("Converting to internal format...")

      var rw := mini(res, file_res)
      var rh := mini(res, file_res)

      # Convert to internal format
      var h := 0.0
      for y in rh:
         for x in rw:
            var gs := float(f.get_16()) / 65535.0
            h = min_y + hrange * float(gs)
            match im.get_format():
               Image.FORMAT_RF:
                  im.set_pixel(x, y, Color(h, 0, 0))
               Image.FORMAT_RGB8:
                  im.set_pixel(x, y, encode_height_to_rgb8_unorm(h))
               _:
                  _logger.error(str("Invalid heightmap format ", im.get_format()))
                  return false
            
         # Skip next pixels if the file is bigger than the accepted resolution
         for x in range(rw, file_res):
            f.get_16()

   elif ext == "xyz":
      var f := FileAccess.open(fpath, FileAccess.READ)
      if f == null:
         return false

      var bounds := HT_XYZFormat.load_bounds(f)
      var res := get_adjusted_map_size(bounds.image_width, bounds.image_height)

      var width := res
      var height := res

      _locked = true

      _logger.debug(str("Resizing terrain to ", width, "x", height, "..."))
      resize(res, false, Vector2())

      var im := get_image(CHANNEL_HEIGHT)
      assert(im != null)

      im.fill(Color(0,0,0))

      _logger.debug(str("Parsing XYZ file (this can take a while)..."))
      f.seek(0)
      var float_heightmap := Image.create(im.get_width(), im.get_height(), false, Image.FORMAT_RF)
      HT_XYZFormat.load_heightmap(f, float_heightmap, bounds)

      # Flipping because in Godot, for X to mean "east"/"right", Z must be backward,
      # and we are using Z to map the Y axis of the heightmap image.
      float_heightmap.flip_y()
      
      match im.get_format():
         Image.FORMAT_RF:
            im.blit_rect(float_heightmap, Rect2i(0, 0, res, res), Vector2i())
         Image.FORMAT_RGB8:
            convert_float_heightmap_to_rgb8(float_heightmap, im)
         _:
            _logger.error(str("Invalid heightmap format ", im.get_format()))

      # Note: when importing maps with non-compliant sizes and flipping,
      # the result might not be aligned to global coordinates.
      # If this is a problem, we could just offset the terrain to compensate?

   else:
      # File extension not recognized
      return false

   _locked = false

   _logger.debug("Notify region change...")
   notify_region_change(Rect2(0, 0, get_resolution(), get_resolution()), CHANNEL_HEIGHT)

   return true


func _import_map(map_type: int, path: String) -> bool:
   # Heightmap requires special treatment
   assert(map_type != CHANNEL_HEIGHT)

   var im := Image.load_from_file(path)
   # TODO No way to get the error code?
   if im == null:
      return false

   var res := get_resolution()
   if im.get_width() != res or im.get_height() != res:
      im.crop(res, res)

   if im.get_format() != get_channel_format(map_type):
      im.convert(get_channel_format(map_type))

   var map : HT_Map = _maps[map_type][0]
   map.image = im

   notify_region_change(Rect2(0, 0, im.get_width(), im.get_height()), map_type)
   return true


# TODO Workaround for https://github.com/Zylann/godot_heightmap_plugin/issues/101
func _dummy_function():
   pass


static func _get_xz(v: Vector3) -> Vector2:
   return Vector2(v.x, v.z)


class HT_CellRaycastContext:
   var begin_pos := Vector3()
   var _cell_begin_pos_y := 0.0
   var _cell_begin_pos_2d := Vector2()
   var dir := Vector3()
   var dir_2d := Vector2()
   var vertical_bounds : Image
   var hit = null # Vector3
   var heightmap : Image
   var broad_param_2d_to_3d := 1.0
   var cell_param_2d_to_3d := 1.0
   # TODO Can't call static functions of the enclosing class.....................
   var decode_height_func : Callable
   #var dbg
   
   func broad_cb(cx: int, cz: int, enter_param: float, exit_param: float) -> bool:
      if cx < 0 or cz < 0 or cz >= vertical_bounds.get_height() \
      or cx >= vertical_bounds.get_width():
         # The function may occasionally be called at boundary values
         return false
      var vb := vertical_bounds.get_pixel(cx, cz)
      var begin := begin_pos + dir * (enter_param * broad_param_2d_to_3d)
      var exit_y := begin_pos.y + dir.y * exit_param * broad_param_2d_to_3d
      #_spawn_box(Vector3(cx * VERTICAL_BOUNDS_CHUNK_SIZE, \
      #  begin.y, cz * VERTICAL_BOUNDS_CHUNK_SIZE), 2.0)
      if begin.y < vb.r or exit_y > vb.g:
         # Not hitting this chunk
         return false
      # We may be hitting something in this chunk, perform a narrow phase
      # through terrain cells
      var distance_in_chunk_2d := (exit_param - enter_param) * VERTICAL_BOUNDS_CHUNK_SIZE
      var cell_ray_origin_2d := Vector2(begin.x, begin.z)
      _cell_begin_pos_y = begin.y
      _cell_begin_pos_2d = cell_ray_origin_2d
      var rhit = HT_Util.grid_raytrace_2d(
         cell_ray_origin_2d, dir_2d, cell_cb, distance_in_chunk_2d)
      return rhit != null
   
   func cell_cb(cx: int, cz: int, enter_param: float, exit_param: float) -> bool:
      var enter_pos := _cell_begin_pos_2d + dir_2d * enter_param
      #var exit_pos := _cell_begin_pos_2d + dir_2d * exit_param

      var enter_y := _cell_begin_pos_y + dir.y * enter_param * cell_param_2d_to_3d
      var exit_y := _cell_begin_pos_y + dir.y * exit_param * cell_param_2d_to_3d

      hit = _intersect_cell(heightmap, cx, cz, Vector3(enter_pos.x, enter_y, enter_pos.y), dir,
         decode_height_func)

      return hit != null

   static func _intersect_cell(heightmap: Image, cx: int, cz: int,
      begin_pos: Vector3, dir: Vector3, decode_func : Callable):
      
      var c00 := HT_Util.get_pixel_clamped(heightmap, cx,     cz)
      var c10 := HT_Util.get_pixel_clamped(heightmap, cx + 1, cz)
      var c01 := HT_Util.get_pixel_clamped(heightmap, cx,     cz + 1)
      var c11 := HT_Util.get_pixel_clamped(heightmap, cx + 1, cz + 1)
      
      var h00 : float = decode_func.call(c00)
      var h10 : float = decode_func.call(c10)
      var h01 : float = decode_func.call(c01)
      var h11 : float = decode_func.call(c11)

      var p00 := Vector3(cx,     h00, cz)
      var p10 := Vector3(cx + 1, h10, cz)
      var p01 := Vector3(cx,     h01, cz + 1)
      var p11 := Vector3(cx + 1, h11, cz + 1)

      var th0 = Geometry3D.ray_intersects_triangle(begin_pos, dir, p00, p10, p11)
      var th1 = Geometry3D.ray_intersects_triangle(begin_pos, dir, p00, p11, p01)

      if th0 != null:
         return th0
      return th1

#  func _spawn_box(pos: Vector3, r: float):
#     if not Input.is_key_pressed(KEY_CONTROL):
#        return
#     var mi = MeshInstance.new()
#     mi.mesh = CubeMesh.new()
#     mi.translation = pos * dbg.map_scale
#     mi.scale = Vector3(r, r, r)
#     dbg.add_child(mi)
#     mi.owner = dbg.get_tree().edited_scene_root


# Raycasts heightmap image directly without using a collider.
# The coordinate system is such that Y is up, terrain minimum corner is at (0, 0),
# and one heightmap pixel is one space unit.
# TODO Cannot hint as `-> Vector2` because it can be null if there is no hit
func cell_raycast(ray_origin: Vector3, ray_direction: Vector3, max_distance: float):
   var heightmap := get_image(CHANNEL_HEIGHT)
   if heightmap == null:
      return null

   var terrain_rect := Rect2(Vector2(), Vector2(_resolution, _resolution))

   # Project and clip into 2D
   var ray_origin_2d := _get_xz(ray_origin)
   var ray_end_2d := _get_xz(ray_origin + ray_direction * max_distance)
   var clipped_segment_2d := HT_Util.get_segment_clipped_by_rect(terrain_rect,
      ray_origin_2d, ray_end_2d)
   # TODO We could clip along Y too if we had total AABB cached somewhere

   if len(clipped_segment_2d) == 0:
      # Not hitting the terrain area
      return null

   var max_distance_2d := ray_origin_2d.distance_to(ray_end_2d)
   if max_distance_2d < 0.001:
      # TODO Direct vertical hit?
      return null
   
   # Get ratio along the segment where the first point was clipped
   var begin_clip_param := ray_origin_2d.distance_to(clipped_segment_2d[0]) / max_distance_2d
   
   var ray_direction_2d := _get_xz(ray_direction).normalized()
   
   var ctx := HT_CellRaycastContext.new()
   ctx.begin_pos = ray_origin + ray_direction * (begin_clip_param * max_distance)
   ctx.dir = ray_direction
   ctx.dir_2d = ray_direction_2d
   ctx.vertical_bounds = _chunked_vertical_bounds
   ctx.heightmap = heightmap
   ctx.cell_param_2d_to_3d = max_distance / max_distance_2d
   ctx.broad_param_2d_to_3d = ctx.cell_param_2d_to_3d * VERTICAL_BOUNDS_CHUNK_SIZE
   
   match heightmap.get_format():
      Image.FORMAT_RF:
         ctx.decode_height_func = decode_height_from_f
      Image.FORMAT_RGB8:
         ctx.decode_height_func = decode_height_from_rgb8_unorm
      _:
         _logger.error(str("Invalid heightmap format ", heightmap.get_format()))
         return null

   #ctx.dbg = dbg

   # Broad phase through cached vertical bound chunks
   var broad_ray_origin = clipped_segment_2d[0] / VERTICAL_BOUNDS_CHUNK_SIZE
   var broad_max_distance = \
      clipped_segment_2d[0].distance_to(clipped_segment_2d[1]) / VERTICAL_BOUNDS_CHUNK_SIZE
   var hit_bp = HT_Util.grid_raytrace_2d(broad_ray_origin, ray_direction_2d, ctx.broad_cb, 
      broad_max_distance)

   if hit_bp == null:
      # No hit
      return null

   return Vector2(ctx.hit.x, ctx.hit.z)


static func encode_normal(n: Vector3) -> Color:
   n = 0.5 * (n + Vector3.ONE)
   return Color(n.x, n.z, n.y)


static func get_channel_format(channel: int) -> int:
   return _map_types[channel].texture_format as int


# Note: PNG supports 16-bit channels, unfortunately Godot doesn't
static func _channel_can_be_saved_as_png(channel: int) -> bool:
   return _map_types[channel].can_be_saved_as_png


static func get_channel_name(c: int) -> String:
   return _map_types[c].name as String


static func get_map_debug_name(map_type: int, index: int) -> String:
   return str(get_channel_name(map_type), "[", index, "]")


func _get_map_filename(map_type: int, index: int) -> String:
   var name = get_channel_name(map_type)
   var id = _maps[map_type][index].id
   if id > 0:
      name += str(id + 1)
   return name


static func get_map_shader_param_name(map_type: int, index: int) -> String:
   var param_name = _map_types[map_type].shader_param_name
   if typeof(param_name) == TYPE_STRING:
      return param_name
   return param_name[index]


# TODO Can't type hint because it returns a nullable array
#static func get_map_type_and_index_from_shader_param_name(p_name: String):
#  for map_type in _map_types:
#     var pn = _map_types[map_type].shader_param_name
#     if typeof(pn) == TYPE_STRING:
#        if pn == p_name:
#           return [map_type, 0]
#     else:
#        for i in len(pn):
#           if pn[i] == p_name:
#              return [map_type, i]
#  return null


static func decode_height_from_f(c: Color) -> float:
   return c.r


const _V2_UNIT_STEPS = 1024.0
const _V2_MIN = -8192.0
const _V2_MAX = 8191.0
const _V2_DF = 255.0 / _V2_UNIT_STEPS

# This RGB8 encoding implementation is specific to this plugin.
# It was used in the port to Godot 4.0 for a time, until it was found float
# textures could be used.

static func decode_height_from_rgb8_unorm(c: Color) -> float:
   return (c.r * 0.25 + c.g * 64.0 + c.b * 16384.0) * (4.0 * _V2_DF) + _V2_MIN


static func encode_height_to_rgb8_unorm(h: float) -> Color:
   h -= _V2_MIN
   var i := int(h * _V2_UNIT_STEPS)
   var r := i % 256
   var g := (i / 256) % 256
   var b := i / 65536
   return Color(r, g, b, 255.0) / 255.0


static func convert_heightmap_to_float(src: Image, logger: HT_Logger.HT_LoggerBase) -> Image:
   var src_format := src.get_format()
   
   if src_format == Image.FORMAT_RH:
      var im : Image = src.duplicate()
      im.convert(Image.FORMAT_RF)
      return im

   if src_format == Image.FORMAT_RF:
      return src.duplicate() as Image
   
   if src_format == Image.FORMAT_RGB8:
      var im := Image.create(src.get_width(), src.get_height(), false, Image.FORMAT_RF)
      for y in src.get_height():
         for x in src.get_width():
            var c := src.get_pixel(x, y)
            var h := decode_height_from_rgb8_unorm(c)
            im.set_pixel(x, y, Color(h, h, h, 1.0))
      return im
   
   logger.error("Unknown source heightmap format!")
   return null


static func convert_float_heightmap_to_rgb8(src: Image, dst: Image):
   assert(dst.get_format() == Image.FORMAT_RGB8)
   assert(dst.get_size() == src.get_size())
   
   for y in src.get_height():
      for x in src.get_width():
         var h = src.get_pixel(x, y).r
         dst.set_pixel(x, y, encode_height_to_rgb8_unorm(h))