# Holds data of the terrain.
# This is mostly a set of textures using specific formats, some precalculated, and metadata.
tool
extends Resource
const Grid = preload("./util/grid.gd")
const Util = preload("./util/util.gd")
const Errors = preload("./util/errors.gd")
const NativeFactory = preload("./native/factory.gd")
const Logger = preload("./util/logger.gd")
const ImageFileCache = preload("./util/image_file_cache.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",
texture_flags = Texture.FLAG_FILTER,
texture_format = Image.FORMAT_RH,
default_fill = null,
default_count = 1,
can_be_saved_as_png = false,
authored = true,
srgb = false
},
CHANNEL_NORMAL: {
name = "normal",
shader_param_name = "u_terrain_normalmap",
texture_flags = Texture.FLAG_FILTER,
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"
],
texture_flags = Texture.FLAG_FILTER,
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",
texture_flags = Texture.FLAG_FILTER,
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",
texture_flags = Texture.FLAG_FILTER,
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",
texture_flags = Texture.FLAG_FILTER | Texture.FLAG_MIPMAPS,
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",
texture_flags = 0,
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",
texture_flags = Texture.FLAG_FILTER,
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 minimum 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 Map:
var texture: Texture
# 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 _image_utils = NativeFactory.get_image_utils()
var _edit_disable_apply_undo := false
var _logger = 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 = _map_types[c].default_count
for i in range(n):
maps.append(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 = Util.clamp_int(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 = Util.next_power_of_two(p_res - 1) + 1
_resolution = p_res;
for channel in range(CHANNEL_COUNT):
var maps := _maps[channel] as Array
for index in len(maps):
_logger.debug(str("Resizing ", get_map_debug_name(channel, index), "..."))
var map := maps[index] as Map
var im := map.image
if im == null:
_logger.debug("Image not in memory, creating it")
im = Image.new()
im.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)
map.image = im
else:
if stretch and not _map_types[channel].authored:
im.create(_resolution, _resolution, false, get_channel_format(channel))
else:
if stretch:
im.resize(_resolution, _resolution)
else:
var fill_color = _get_map_default_fill_color(channel, index)
map.image = Util.get_cropped_image(im, _resolution, _resolution, \
fill_color, anchor)
map.modified = true
_update_all_vertical_bounds()
emit_signal("resolution_changed")
# 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)
im.lock();
var h = Util.get_pixel_clamped(im, x, y).r;
im.unlock();
return h;
# 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)
# The function takes a Vector3 for convenience so it's easier to use in 3D scripting
var x0 := int(floor(pos.x))
var y0 := int(floor(pos.z))
var xf := pos.x - x0
var yf := pos.z - y0
im.lock()
var h00 = Util.get_pixel_clamped(im, x0, y0).r
var h10 = Util.get_pixel_clamped(im, x0 + 1, y0).r
var h01 = Util.get_pixel_clamped(im, x0, y0 + 1).r
var h11 = Util.get_pixel_clamped(im, x0 + 1, y0 + 1).r
im.unlock()
# Bilinear filter
var h = lerp(lerp(h00, h10, xf), lerp(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 PoolRealArray.
func get_heights_region(x0: int, y0: int, w: int, h: int) -> PoolRealArray:
var im = get_image(CHANNEL_HEIGHT)
assert(im != null)
var min_x := Util.clamp_int(x0, 0, im.get_width())
var min_y := Util.clamp_int(y0, 0, im.get_height())
var max_x := Util.clamp_int(x0 + w, 0, im.get_width() + 1)
var max_y := Util.clamp_int(y0 + h, 0, im.get_height() + 1)
var heights := PoolRealArray()
var area = (max_x - min_x) * (max_y - min_y)
if area == 0:
_logger.debug("Empty heights region!")
return heights
heights.resize(area)
im.lock()
var i := 0
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
im.unlock()
return heights
# Gets all heights.
# This height is raw and doesn't account for scaling of the terrain node.
# Data is returned as a PoolRealArray.
func get_all_heights() -> PoolRealArray:
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
#
# 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
emit_signal("region_changed", min_x, min_y, size_x, size_y, p_map_type)
emit_signal("changed")
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: 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 := Rect2(0, 0, data.get_width(), data.get_height())
dst_image.blit_rect(data, src_rect, Vector2(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, 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 = Rect2(0, 0, src_im.get_height(), src_im.get_height())
dst_im.blit_rect(src_im, rect, Vector2())
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 : 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 flags = _map_types[channel].texture_flags
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."))
texture = ImageTexture.new()
texture.create_from_image(image, flags)
map.texture = texture
# Need to notify because other systems may want to grab the new texture object
emit_signal("map_changed", channel, index)
elif 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."))
texture.create_from_image(image, flags)
else:
if VisualServer.has_method("texture_set_data_partial"):
VisualServer.texture_set_data_partial( \
texture.get_rid(), image, \
min_x, min_y, \
size_x, size_y, \
min_x, min_y, \
0, 0)
else:
# Godot 3.0.6 and earlier...
# It is slow.
# ..ooo@@@XXX%%%xx..
# .oo@@XXX%x%xxx.. ` .
# .o@XX%%xx.. ` .
# o@X%.. ..ooooooo
# .@X%x. ..o@@^^ ^^@@o
# .ooo@@@@@@ooo.. ..o@@^ @X%
# o@@^^^ ^^^@@@ooo.oo@@^ %
# xzI -*-- ^^^o^^ --*- %
# @@@o ooooooo^@@^o^@X^@oooooo .X%x
# I@@@@@@@@@XX%%xx ( o@o )X%x@ROMBASED@@@X%x
# I@@@@XX%%xx oo@@@@X% @@X%x ^^^@@@@@@@X%x
# @X%xx o@@@@@@@X% @@XX%%x ) ^^@X%x
# ^ xx o@@@@@@@@Xx ^ @XX%%x xxx
# o@@^^^ooo I^^ I^o ooo . x
# oo @^ IX I ^X @^ oo
# IX U . V IX
# V . . V
#
texture.create_from_image(image, flags)
#_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 = Map.new(_get_free_id(map_type))
map.image = Image.new()
map.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)
emit_signal("map_added", 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 = Map.new(_get_free_id(map_type))
map.image = image_cache.load_image(image_id)
maps.insert(index, map)
emit_signal("map_added", 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 = _maps[map_type]
maps.remove(index)
emit_signal("map_removed", 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) -> 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:
var maps : Array = _maps[map_type]
var map : 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
_chunked_vertical_bounds.lock()
var b := _chunked_vertical_bounds.get_pixel(cx, cy)
_chunked_vertical_bounds.unlock()
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 = Util.clamp_int(cmin_x, 0, _chunked_vertical_bounds.get_width() - 1)
cmin_y = Util.clamp_int(cmin_y, 0, _chunked_vertical_bounds.get_height() - 1)
cmax_x = Util.clamp_int(cmax_x, 0, _chunked_vertical_bounds.get_width())
cmax_y = Util.clamp_int(cmax_y, 0, _chunked_vertical_bounds.get_height())
_chunked_vertical_bounds.lock()
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 = min(b.r, min_height)
max_height = max(b.g, max_height)
_chunked_vertical_bounds.unlock()
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.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 = Util.clamp_int(cmin_x, 0, _chunked_vertical_bounds.get_width() - 1)
cmin_y = Util.clamp_int(cmin_y, 0, _chunked_vertical_bounds.get_height() - 1)
cmax_x = Util.clamp_int(cmax_x, 0, _chunked_vertical_bounds.get_width())
cmax_y = Util.clamp_int(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
_chunked_vertical_bounds.lock()
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))
_chunked_vertical_bounds.unlock()
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)
return _image_utils.get_red_range(heights, Rect2(origin_x, origin_y, size_x, size_y))
func save_data(data_dir: String):
_logger.debug("Saving terrain data...")
_locked = true
_save_metadata(data_dir.plus_file(META_FILENAME))
var map_count = _get_total_map_count()
var pi = 0
for map_type in range(CHANNEL_COUNT):
var maps = _maps[map_type]
for index in range(len(maps)):
var map = _maps[map_type][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), "..."))
_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
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 = File.new()
var err = f.open(path, File.READ)
assert(err == OK)
var text = f.get_as_text()
f.close()
var res = JSON.parse(text)
assert(res.error == OK)
_deserialize_metadata(res.result)
func _save_metadata(path: String):
var f = File.new()
var d = _serialize_metadata()
var text = JSON.print(d, "\t", true)
var err = f.open(path, File.WRITE)
assert(err == OK)
f.store_string(text)
f.close()
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 = 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 range(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 range(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 = Map.new(id)
maps[j] = map
else:
map.id = id
return true
func load_data(dir_path: String):
_locked = true
_load_metadata(dir_path.plus_file(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 range(len(_maps)):
var maps = _maps[map_type]
for index in range(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[map_type][index].modified = false
pi += 1
_logger.debug("Calculating vertical bounds...")
_update_all_vertical_bounds()
_logger.debug("Notify resolution change...")
_locked = false
emit_signal("resolution_changed")
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 = _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_data()
else:
_logger.debug(str("No data in map ", map_type, "[", index, "]"))
# This data doesn't have such map
return true
var dir = Directory.new()
if not dir.dir_exists(dir_path):
dir.make_dir(dir_path)
var fpath = dir_path.plus_file(_get_map_filename(map_type, index))
if _channel_can_be_saved_as_png(map_type):
fpath += ".png"
im.save_png(fpath)
_try_write_default_import_options(fpath, map_type, _logger)
else:
fpath += ".res"
var err = ResourceSaver.save(fpath, im)
if err != OK:
_logger.error("Could not save '{0}', error {1}" \
.format([fpath, Errors.get_message(err)]))
return false
_try_delete_0_8_0_heightmap(fpath.get_basename(), _logger)
return true
static func _try_write_default_import_options(fpath: String, channel: int, logger):
var imp_fpath = fpath + ".import"
var f := File.new()
if f.file_exists(imp_fpath):
# Already exists
return
var map_info = _map_types[channel]
var texture_flags: int = map_info.texture_flags
var filter := (texture_flags & Texture.FLAG_FILTER) != 0
var srgb: bool = map_info.srgb
var defaults = {
"remap": {
"importer": "texture",
"type": "StreamTexture"
},
"deps": {
"source_file": fpath
},
"params": {
# Don't compress. It 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_mode": 0,
"compress/normal_map": 0,
"flags/mipmaps": false,
"flags/filter": filter,
# 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": false,
}
}
Util.write_import_file(defaults, imp_fpath, logger)
func _load_map(dir: String, map_type: int, index: int) -> bool:
var fpath = dir.plus_file(_get_map_filename(map_type, index))
# Maps must be configured before being loaded
var 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"
# In this particular case, we can use Godot ResourceLoader directly,
# if the texture got imported.
if Engine.editor_hint:
# 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.new()
map.image.load(fpath)
_ensure_map_format(map.image, map_type, index)
var tex = load(fpath)
map.texture = tex
else:
var im = _try_load_0_8_0_heightmap(fpath, map_type, map.image, _logger)
if typeof(im) == TYPE_BOOL:
return false
if im == null:
fpath += ".res"
im = load(fpath)
if im == null:
_logger.error("Could not load '{0}'".format([fpath]))
return false
_resolution = im.get_width()
map.image = im
_ensure_map_format(map.image, map_type, index)
_upload_channel(map_type, index)
return true
func _ensure_map_format(im: Image, map_type: int, index: int):
var format = im.get_format()
var expected_format = _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)
# Legacy
# TODO Drop after a few versions
static func _try_load_0_8_0_heightmap(fpath: String, channel: int, existing_image: Image, logger):
fpath += ".bin"
var f = File.new()
if not f.file_exists(fpath):
return null
var err = f.open(fpath, File.READ)
if err != OK:
logger.error("Could not open '{0}' for reading, error {1}" \
.format([fpath, Errors.get_message(err)]))
return false
var width = f.get_32()
var height = f.get_32()
var pixel_size = f.get_32()
var data_size = width * height * pixel_size
var data = f.get_buffer(data_size)
if data.size() != data_size:
logger.error("Unexpected end of buffer, expected size {0}, got {1}" \
.format([data_size, data.size()]))
return false
var im = existing_image
if im == null:
im = Image.new()
im.create_from_data(width, height, false, get_channel_format(channel), data)
return im
static func _try_delete_0_8_0_heightmap(fpath: String, logger):
fpath += ".bin"
var d = Directory.new()
if d.file_exists(fpath):
var err = d.remove(fpath)
if err != OK:
logger.error("Could not erase file '{0}', error {1}" \
.format([fpath, Errors.get_message(err)]))
# 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 = Util.next_power_of_two(width - 1) + 1
var height_po2 = Util.next_power_of_two(height - 1) + 1
var size_po2 = Util.min_int(width_po2, height_po2)
size_po2 = Util.clamp_int(size_po2, MIN_RESOLUTION, MAX_RESOLUTION)
return size_po2
func _import_heightmap(fpath: String, min_y: int, max_y: int, 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.new()
var err := src_image.load(fpath)
if err != OK:
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 = Util.min_int(im.get_width(), src_image.get_width())
var height = Util.min_int(im.get_height(), src_image.get_height())
_logger.debug("Converting to internal format...")
im.lock()
src_image.lock()
# Convert to internal format (from RGBA8 to RH16) with range scaling
for y in range(0, width):
for x in range(0, height):
var gs := src_image.get_pixel(x, y).r
var h := min_y + hrange * gs
im.set_pixel(x, y, Color(h, 0, 0))
src_image.unlock()
im.unlock()
elif ext == "exr":
var src_image := Image.new()
var err := src_image.load(fpath)
if err != OK:
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...")
# 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, Rect2(0, 0, res, res), Vector2())
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 := File.new()
var err := f.open(fpath, File.READ)
if err != OK:
return false
var file_len = f.get_len()
var file_res = 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.endian_swap = 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...")
im.lock()
var rw := Util.min_int(res, file_res)
var rh := Util.min_int(res, file_res)
# Convert to internal format (from bytes to RH16)
var h := 0.0
for y in range(0, rh):
for x in range(0, rw):
var gs := float(f.get_16()) / 65535.0
h = min_y + hrange * float(gs)
im.set_pixel(x, y, Color(h, 0, 0))
# Skip next pixels if the file is bigger than the accepted resolution
for x in range(rw, file_res):
f.get_16()
im.unlock()
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.new()
var err = im.load(path)
if err != OK:
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 = _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 _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 cell_cb_funcref : FuncRef
var broad_param_2d_to_3d := 1.0
var cell_param_2d_to_3d := 1.0
#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 = Util.grid_raytrace_2d(
cell_ray_origin_2d, dir_2d, cell_cb_funcref, 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)
return hit != null
static func _intersect_cell(heightmap: Image, cx: int, cz: int,
begin_pos: Vector3, dir: Vector3):
var h00 := Util.get_pixel_clamped(heightmap, cx, cz).r
var h10 := Util.get_pixel_clamped(heightmap, cx + 1, cz).r
var h01 := Util.get_pixel_clamped(heightmap, cx, cz + 1).r
var h11 := Util.get_pixel_clamped(heightmap, cx + 1, cz + 1).r
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 = Geometry.ray_intersects_triangle(begin_pos, dir, p00, p10, p11)
var th1 = Geometry.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 := 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 := _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
# We are lucky FuncRef does not keep a strong reference to the object
ctx.cell_cb_funcref = funcref(ctx, "cell_cb")
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
#ctx.dbg = dbg
heightmap.lock()
_chunked_vertical_bounds.lock()
# 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 = Util.grid_raytrace_2d(broad_ray_origin, ray_direction_2d,
funcref(ctx, "broad_cb"), broad_max_distance)
heightmap.unlock()
_chunked_vertical_bounds.unlock()
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