154 lines
4.3 KiB
GDScript
154 lines
4.3 KiB
GDScript
@tool
|
|
class_name GrassMultiMesh extends MultiMeshInstance2D
|
|
|
|
@export_group("Visuals")
|
|
@export var texture_sheet : Texture2D:
|
|
set(value):
|
|
texture_sheet = value
|
|
texture = value
|
|
@export var blade_size : Vector2 = Vector2(16, 16)
|
|
@export var texture_sheet_size : Vector2 = Vector2(64, 16)
|
|
@export var grass_tint : Color = Color.WHITE:
|
|
set(value):
|
|
grass_tint = value
|
|
material.set_shader_parameter("modulate", grass_tint)
|
|
|
|
@export_group("Editor")
|
|
@export var editing : bool = false:
|
|
set(value):
|
|
editing = value
|
|
notify_property_list_changed()
|
|
@export var brush_radius : float = 50.0
|
|
@export var brush_density : int = 5
|
|
|
|
@export_storage var grass_data : Array[Dictionary] = []
|
|
|
|
enum GrassState {NORMAL = 0, CUT = 1}
|
|
|
|
var _blade_half_height: float
|
|
|
|
func _ready() -> void:
|
|
if not multimesh:
|
|
multimesh = MultiMesh.new()
|
|
multimesh.transform_format = MultiMesh.TRANSFORM_2D
|
|
multimesh.use_colors = true
|
|
multimesh.use_custom_data = true
|
|
|
|
multimesh.mesh = _create_mesh_rect()
|
|
|
|
if not material:
|
|
material = ShaderMaterial.new()
|
|
if ResourceLoader.exists("res://shaders/grass_shader.gdshader"):
|
|
material.shader = load("res://shaders/grass_shader.gdshader")
|
|
|
|
if material is ShaderMaterial:
|
|
material.set_shader_parameter("frame_size", blade_size)
|
|
material.set_shader_parameter("sheet_size", texture_sheet_size)
|
|
material.set_shader_parameter("modulate", grass_tint)
|
|
|
|
if material.get_shader_parameter("noise_tex") == null:
|
|
var noise = FastNoiseLite.new()
|
|
noise.frequency = 0.005
|
|
var noise_tex = NoiseTexture2D.new()
|
|
noise_tex.noise = noise
|
|
noise_tex.seamless = true
|
|
material.set_shader_parameter("noise_tex", noise_tex)
|
|
|
|
if texture_sheet:
|
|
texture = texture_sheet
|
|
|
|
_blade_half_height = blade_size.y / 2.0
|
|
_rebuild_multimesh()
|
|
|
|
func _process(_delta):
|
|
if editing and Engine.is_editor_hint():
|
|
queue_redraw()
|
|
|
|
if Input.is_key_pressed(KEY_K):
|
|
_brush_paint()
|
|
elif Input.is_key_pressed(KEY_E):
|
|
_brush_erase()
|
|
|
|
|
|
func interact_with_grass(global_target_pos: Vector2, rect_size: Vector2, new_state: int):
|
|
if global_position.distance_squared_to(global_target_pos) > 500 * 500:
|
|
return
|
|
|
|
var local_target = to_local(global_target_pos)
|
|
|
|
var half_w = rect_size.x * 0.5
|
|
var half_h = rect_size.y * 0.5
|
|
var left = local_target.x - half_w
|
|
var right = local_target.x + half_w
|
|
var top = local_target.y - half_h
|
|
var bottom = local_target.y + half_h
|
|
|
|
for i in range(multimesh.instance_count):
|
|
var t_origin = multimesh.get_instance_transform_2d(i).origin
|
|
|
|
if t_origin.x > left and t_origin.x < right and t_origin.y > top and t_origin.y < bottom:
|
|
|
|
var custom_data = multimesh.get_instance_custom_data(i)
|
|
if int(custom_data.b) == new_state:
|
|
continue
|
|
|
|
custom_data.b = float(new_state)
|
|
multimesh.set_instance_custom_data(i, custom_data)
|
|
grass_data[i]["state"] = new_state
|
|
|
|
func _create_mesh_rect() -> QuadMesh:
|
|
var mesh = QuadMesh.new()
|
|
mesh.size = blade_size
|
|
return mesh
|
|
|
|
func _rebuild_multimesh() -> void:
|
|
multimesh.instance_count = grass_data.size()
|
|
var pivot_offset = Vector2(0, -_blade_half_height)
|
|
|
|
for i in range(grass_data.size()):
|
|
var d = grass_data[i]
|
|
var xform = Transform2D().translated(d.pos).rotated(d.get("rot", 0.0)).translated(pivot_offset)
|
|
|
|
multimesh.set_instance_transform_2d(i, xform)
|
|
|
|
var custom = Color(
|
|
randf(),
|
|
float(d.get("tex_idx", 0)),
|
|
float(d.get("state", 0)),
|
|
0.0
|
|
)
|
|
multimesh.set_instance_custom_data(i, custom)
|
|
|
|
func _brush_paint() -> void:
|
|
var mouse_pos = get_local_mouse_position()
|
|
|
|
var columns = int(texture_sheet_size.x / blade_size.x)
|
|
if columns == 0: columns = 1
|
|
|
|
for i in range(brush_density):
|
|
var angle = randf() * TAU
|
|
var rad = sqrt(randf()) * brush_radius
|
|
var pos = mouse_pos + Vector2(cos(angle), sin(angle)) * rad
|
|
|
|
var new_blade = {
|
|
"pos": pos,
|
|
"tex_idx": randi() % columns,
|
|
"state": GrassState.NORMAL,
|
|
"rot": 0# randf_range(-0.2, 0.2)
|
|
}
|
|
grass_data.append(new_blade)
|
|
|
|
_rebuild_multimesh()
|
|
|
|
func _brush_erase() -> void:
|
|
var mouse_pos = get_local_mouse_position()
|
|
var r_sq = brush_radius * brush_radius
|
|
|
|
for i in range(grass_data.size() - 1, -1, -1):
|
|
if grass_data[i].pos.distance_squared_to(mouse_pos) < r_sq:
|
|
grass_data.remove_at(i)
|
|
_rebuild_multimesh()
|
|
|
|
func _draw() -> void:
|
|
if editing and Engine.is_editor_hint():
|
|
draw_arc(get_local_mouse_position(), brush_radius, 0, TAU, 32, Color.YELLOW, 2.0)
|