tool
const Errors = preload("./errors.gd")
# Godot has this internally but doesn't expose it
static func next_power_of_two(x: int) -> int:
x -= 1
x |= x >> 1
x |= x >> 2
x |= x >> 4
x |= x >> 8
x |= x >> 16
x += 1
return x
# Godot doesn't expose Vector2i, and Vector2 has float limitations
#static func encode_v2i(x: int, y: int):
# return (x & 0xffff) | ((y << 16) & 0xffff0000)
# Godot doesn't expose Vector2i, and Vector2 has float limitations
#static func decode_v2i(k: int) -> Array:
# return [
# k & 0xffff,
# (k >> 16) & 0xffff
# ]
# `min` turns numbers into float
static func min_int(a: int, b: int) -> int:
return a if a < b else b
# `max` turns numbers into float
static func max_int(a: int, b: int) -> int:
return a if a > b else b
# `clamp` turns numbers into float
static func clamp_int(x: int, a: int, b: int) -> int:
if x < a:
return a
if x > b:
return b
return x
# CubeMesh doesn't have a wireframe option
static func create_wirecube_mesh(color = Color(1,1,1)) -> Mesh:
var positions := PoolVector3Array([
Vector3(0, 0, 0),
Vector3(1, 0, 0),
Vector3(1, 0, 1),
Vector3(0, 0, 1),
Vector3(0, 1, 0),
Vector3(1, 1, 0),
Vector3(1, 1, 1),
Vector3(0, 1, 1),
])
var colors := PoolColorArray([
color, color, color, color,
color, color, color, color,
])
var indices := PoolIntArray([
0, 1,
1, 2,
2, 3,
3, 0,
4, 5,
5, 6,
6, 7,
7, 4,
0, 4,
1, 5,
2, 6,
3, 7
])
var arrays := []
arrays.resize(Mesh.ARRAY_MAX)
arrays[Mesh.ARRAY_VERTEX] = positions
arrays[Mesh.ARRAY_COLOR] = colors
arrays[Mesh.ARRAY_INDEX] = indices
var mesh := ArrayMesh.new()
mesh.add_surface_from_arrays(Mesh.PRIMITIVE_LINES, arrays)
return mesh
static func integer_square_root(x: int) -> int:
assert(typeof(x) == TYPE_INT)
var r = int(round(sqrt(x)))
if r * r == x:
return r
# Does not exist
return -1
# Formats integer using a separator between each 3-digit group
static func format_integer(n: int, sep := ",") -> String:
assert(typeof(n) == TYPE_INT)
var negative = false
if n < 0:
negative = true
n = -n
var s = ""
while n >= 1000:
s = str(sep, str(n % 1000).pad_zeros(3), s)
n /= 1000
if negative:
return str("-", str(n), s)
else:
return str(str(n), s)
# Goes up all parents until a node of the given class is found
static func get_node_in_parents(node: Node, klass) -> Node:
while node != null:
node = node.get_parent()
if node != null and node is klass:
return node
return null
# Goes down all children until a node of the given class is found
static func find_first_node(node: Node, klass) -> Node:
if node is klass:
return node
for i in node.get_child_count():
var child = node.get_child(i)
var found_node = find_first_node(child, klass)
if found_node != null:
return found_node
return null
static func is_in_edited_scene(node: Node) -> bool:
if not node.is_inside_tree():
return false
var edited_scene = node.get_tree().edited_scene_root
if node == edited_scene:
return true
return edited_scene != null and edited_scene.is_a_parent_of(node)
# Get an extended or cropped version of an image,
# with optional anchoring to decide in which direction to extend or crop.
# New pixels are filled with the provided fill color.
static func get_cropped_image(src: Image, width: int, height: int,
fill_color=null, anchor=Vector2(-1, -1)) -> Image:
width = int(width)
height = int(height)
if width == src.get_width() and height == src.get_height():
return src
var im = Image.new()
im.create(width, height, false, src.get_format())
if fill_color != null:
im.fill(fill_color)
var p = get_cropped_image_params(
src.get_width(), src.get_height(), width, height, anchor)
im.blit_rect(src, p.src_rect, p.dst_pos)
return im
static func get_cropped_image_params(src_w: int, src_h: int, dst_w: int, dst_h: int,
anchor: Vector2) -> Dictionary:
var rel_anchor := (anchor + Vector2(1, 1)) / 2.0
var dst_x := (dst_w - src_w) * rel_anchor.x
var dst_y := (dst_h - src_h) * rel_anchor.y
var src_x := 0
var src_y := 0
if dst_x < 0:
src_x -= dst_x
src_w -= dst_x
dst_x = 0
if dst_y < 0:
src_y -= dst_y
src_h -= dst_y
dst_y = 0
if dst_x + src_w >= dst_w:
src_w = dst_w - dst_x
if dst_y + src_h >= dst_h:
src_h = dst_h - dst_y
return {
"src_rect": Rect2(src_x, src_y, src_w, src_h),
"dst_pos": Vector2(dst_x, dst_y)
}
# TODO Workaround for https://github.com/godotengine/godot/issues/24488
# TODO Simplify in Godot 3.1 if that's still not fixed,
# using https://github.com/godotengine/godot/pull/21806
# And actually that function does not even work.
#static func get_shader_param_or_default(mat: Material, name: String):
# assert(mat.shader != null)
# var v = mat.get_shader_param(name)
# if v != null:
# return v
# var params = VisualServer.shader_get_param_list(mat.shader)
# for p in params:
# if p.name == name:
# match p.type:
# TYPE_OBJECT:
# return null
# # I should normally check default values,
# # however they are not accessible
# TYPE_BOOL:
# return false
# TYPE_REAL:
# return 0.0
# TYPE_VECTOR2:
# return Vector2()
# TYPE_VECTOR3:
# return Vector3()
# TYPE_COLOR:
# return Color()
# return null
# Generic way to apply editor scale to a plugin UI scene.
# It is slower than doing it manually on specific controls.
static func apply_dpi_scale(root: Control, dpi_scale: float):
if dpi_scale == 1.0:
return
var to_process := [root]
while len(to_process) > 0:
var node : Node = to_process[-1]
to_process.pop_back()
if node is Viewport:
continue
if node is Control:
if node.rect_min_size != Vector2(0, 0):
node.rect_min_size *= dpi_scale
var parent = node.get_parent()
if parent != null:
if not (parent is Container):
node.margin_bottom *= dpi_scale
node.margin_left *= dpi_scale
node.margin_top *= dpi_scale
node.margin_right *= dpi_scale
for i in node.get_child_count():
to_process.append(node.get_child(i))
# TODO AABB has `intersects_segment` but doesn't provide the hit point
# So we have to rely on a less efficient method.
# Returns a list of intersections between an AABB and a segment, sorted
# by distance to the beginning of the segment.
static func get_aabb_intersection_with_segment(aabb: AABB,
segment_begin: Vector3, segment_end: Vector3) -> Array:
var hits := []
if not aabb.intersects_segment(segment_begin, segment_end):
return hits
var hit
var x_rect = Rect2(aabb.position.y, aabb.position.z, aabb.size.y, aabb.size.z)
hit = Plane(Vector3(1, 0, 0), aabb.position.x) \
.intersects_segment(segment_begin, segment_end)
if hit != null and x_rect.has_point(Vector2(hit.y, hit.z)):
hits.append(hit)
hit = Plane(Vector3(1, 0, 0), aabb.end.x) \
.intersects_segment(segment_begin, segment_end)
if hit != null and x_rect.has_point(Vector2(hit.y, hit.z)):
hits.append(hit)
var y_rect = Rect2(aabb.position.x, aabb.position.z, aabb.size.x, aabb.size.z)
hit = Plane(Vector3(0, 1, 0), aabb.position.y) \
.intersects_segment(segment_begin, segment_end)
if hit != null and y_rect.has_point(Vector2(hit.x, hit.z)):
hits.append(hit)
hit = Plane(Vector3(0, 1, 0), aabb.end.y) \
.intersects_segment(segment_begin, segment_end)
if hit != null and y_rect.has_point(Vector2(hit.x, hit.z)):
hits.append(hit)
var z_rect = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y)
hit = Plane(Vector3(0, 0, 1), aabb.position.z) \
.intersects_segment(segment_begin, segment_end)
if hit != null and z_rect.has_point(Vector2(hit.x, hit.y)):
hits.append(hit)
hit = Plane(Vector3(0, 0, 1), aabb.end.z) \
.intersects_segment(segment_begin, segment_end)
if hit != null and z_rect.has_point(Vector2(hit.x, hit.y)):
hits.append(hit)
if len(hits) == 2:
# The segment has two hit points. Sort them by distance
var d0 = hits[0].distance_squared_to(segment_begin)
var d1 = hits[1].distance_squared_to(segment_begin)
if d0 > d1:
var temp = hits[0]
hits[0] = hits[1]
hits[1] = temp
else:
assert(len(hits) < 2)
return hits
class GridRaytraceResult2D:
var hit_cell_pos: Vector2
var prev_cell_pos: Vector2
# Iterates through a virtual 2D grid of unit-sized square cells,
# and executes an action on each cell intersecting the given segment,
# ordered from begin to end.
# One of my most re-used pieces of code :)
#
# Initially inspired by http://www.cse.yorku.ca/~amana/research/grid.pdf
#
# Ported from https://github.com/bulletphysics/bullet3/blob/
# 687780af6b491056700cfb22cab57e61aeec6ab8/src/BulletCollision/CollisionShapes/
# btHeightfieldTerrainShape.cpp#L418
#
static func grid_raytrace_2d(ray_origin: Vector2, ray_direction: Vector2,
quad_predicate: FuncRef, max_distance: float) -> GridRaytraceResult2D:
if max_distance < 0.0001:
# Consider the ray is too small to hit anything
return null
var xi_step := 0
if ray_direction.x > 0:
xi_step = 1
elif ray_direction.x < 0:
xi_step = -1
var yi_step := 0
if ray_direction.y > 0:
yi_step = 1
elif ray_direction.y < 0:
yi_step = -1
var infinite := 9999999.0
var param_delta_x := infinite
if xi_step != 0:
param_delta_x = 1.0 / abs(ray_direction.x)
var param_delta_y := infinite
if yi_step != 0:
param_delta_y = 1.0 / abs(ray_direction.y)
# pos = param * dir
# At which value of `param` we will cross a x-axis lane?
var param_cross_x := infinite
# At which value of `param` we will cross a y-axis lane?
var param_cross_y := infinite
# param_cross_x and param_cross_z are initialized as being the first cross
# X initialization
if xi_step != 0:
if xi_step == 1:
param_cross_x = (ceil(ray_origin.x) - ray_origin.x) * param_delta_x
else:
param_cross_x = (ray_origin.x - floor(ray_origin.x)) * param_delta_x
else:
# Will never cross on X
param_cross_x = infinite
# Y initialization
if yi_step != 0:
if yi_step == 1:
param_cross_y = (ceil(ray_origin.y) - ray_origin.y) * param_delta_y
else:
param_cross_y = (ray_origin.y - floor(ray_origin.y)) * param_delta_y
else:
# Will never cross on Y
param_cross_y = infinite
var x := int(floor(ray_origin.x))
var y := int(floor(ray_origin.y))
# Workaround cases where the ray starts at an integer position
if param_cross_x == 0.0:
param_cross_x += param_delta_x
# If going backwards, we should ignore the position we would get by the above flooring,
# because the ray is not heading in that direction
if xi_step == -1:
x -= 1
if param_cross_y == 0.0:
param_cross_y += param_delta_y
if yi_step == -1:
y -= 1
var prev_x := x
var prev_y := y
var param := 0.0
var prev_param := 0.0
while true:
prev_x = x
prev_y = y
prev_param = param
if param_cross_x < param_cross_y:
# X lane
x += xi_step
# Assign before advancing the param,
# to be in sync with the initialization step
param = param_cross_x
param_cross_x += param_delta_x
else:
# Y lane
y += yi_step
param = param_cross_y
param_cross_y += param_delta_y
if param > max_distance:
param = max_distance
# quad coordinates, enter param, exit/end param
if quad_predicate.call_func(prev_x, prev_y, prev_param, param):
var res := GridRaytraceResult2D.new()
res.hit_cell_pos = Vector2(x, y)
res.prev_cell_pos = Vector2(prev_x, prev_y)
return res
else:
break
elif quad_predicate.call_func(prev_x, prev_y, prev_param, param):
var res := GridRaytraceResult2D.new()
res.hit_cell_pos = Vector2(x, y)
res.prev_cell_pos = Vector2(prev_x, prev_y)
return res
return null
static func get_segment_clipped_by_rect(rect: Rect2,
segment_begin: Vector2, segment_end: Vector2) -> Array:
# /
# A-----/---B A-----+---B
# | / | => | / |
# | / | | / |
# C--/------D C--+------D
# /
if rect.has_point(segment_begin) and rect.has_point(segment_end):
return [segment_begin, segment_end]
var a := rect.position
var b := Vector2(rect.end.x, rect.position.y)
var c := Vector2(rect.position.x, rect.end.y)
var d := rect.end
var ab = Geometry.segment_intersects_segment_2d(segment_begin, segment_end, a, b)
var cd = Geometry.segment_intersects_segment_2d(segment_begin, segment_end, c, d)
var ac = Geometry.segment_intersects_segment_2d(segment_begin, segment_end, a, c)
var bd = Geometry.segment_intersects_segment_2d(segment_begin, segment_end, b, d)
var hits = []
if ab != null:
hits.append(ab)
if cd != null:
hits.append(cd)
if ac != null:
hits.append(ac)
if bd != null:
hits.append(bd)
# Now we need to order the hits from begin to end
if len(hits) == 1:
if rect.has_point(segment_begin):
hits = [segment_begin, hits[0]]
elif rect.has_point(segment_end):
hits = [hits[0], segment_end]
else:
# TODO This has a tendency to happen with integer coordinates...
# How can you get only 1 hit and have no end of the segment
# inside of the rectangle? Float precision shit? Assume no hit...
return []
elif len(hits) == 2:
var d0 = hits[0].distance_squared_to(segment_begin)
var d1 = hits[1].distance_squared_to(segment_begin)
if d0 > d1:
hits = [hits[1], hits[0]]
return hits
static func get_pixel_clamped(im: Image, x: int, y: int) -> Color:
if x < 0:
x = 0
elif x >= im.get_width():
x = im.get_width() - 1
if y < 0:
y = 0
elif y >= im.get_height():
y = im.get_height() - 1
return im.get_pixel(x, y)
static func update_configuration_warning(node: Node, recursive: bool):
if not Engine.editor_hint:
return
# Godot 3.1 and older doesn't have this function
if node.has_method("update_configuration_warning"):
node.call("update_configuration_warning")
if recursive:
for i in node.get_child_count():
var child = node.get_child(i)
update_configuration_warning(child, true)
static func write_import_file(settings: Dictionary, imp_fpath: String, logger) -> bool:
# TODO Should use ConfigFile instead
var f := File.new()
var err := f.open(imp_fpath, File.WRITE)
if err != OK:
logger.error("Could not open '{0}' for write, error {1}" \
.format([imp_fpath, Errors.get_message(err)]))
return false
for section in settings:
f.store_line(str("[", section, "]"))
f.store_line("")
var params = settings[section]
for key in params:
var v = params[key]
var sv
match typeof(v):
TYPE_STRING:
sv = str('"', v.replace('"', '\"'), '"')
TYPE_BOOL:
sv = "true" if v else "false"
_:
sv = str(v)
f.store_line(str(key, "=", sv))
f.store_line("")
f.close()
return true