1649 lines
48 KiB
GDScript3
1649 lines
48 KiB
GDScript3
|
|
||
|
|
# 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
|
||
|
|
|