7d1a584c15
Reviewed against the rule issues #6 and #10 set for the buildings: geometry is rasterised once and thereafter only moved, scaled or faded, because every NeonDraw call expands into four antialiased polylines. The planet visuals never got that refactor. The black hole rebuilt ten glowing paths of twenty-five points every frame - forty polylines - to spin five rings; each ring is a NeonPiece that rotates now. The research lab spent nine draw calls a frame, eight of them fixed geometry, to turn one dish and blink six lights; the dish is a child that rotates and the lights a child whose modulate breathes. The gas giant's bands genuinely deform, so they still draw, but its constant rim moved out to a child. NeonPiece gained add_path, which it needed for open arcs. And I had broken the rule myself. ScannerGuidance re-queued a redraw of its arrow every frame for a colour that changes only with the destination - and it runs with PROCESS_MODE_ALWAYS, so it was re-tessellating through every dialog that stops the rest of the game. Guarded, and pinned by a test that counts CanvasItem's own draw signal: 36 rasterisations in 0.6s before, one after. Two smaller things from the same pass: the station menu drew its condition bar by hand where the ship lab already uses a ProgressBar node, so it uses one now and its _draw is gone; and station/upkeep refreshes were wired into _refresh_garrison(), which nothing but a test calls, so both menus showed whatever was true when they opened. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_019AJMdB7iuHuLFZM1aBu3GD
74 lines
2.7 KiB
GDScript
74 lines
2.7 KiB
GDScript
extends Node2D
|
|
|
|
# Same informal interface as GasGiantVisual/RockyPlanetVisual - configure(),
|
|
# extractor_anchor(), animates via its own _process(). No solid body: the
|
|
# core stays genuinely empty (nothing drawn inside CORE_RADIUS), and an
|
|
# accretion disc of rotating arc segments - not closed rings - stands in
|
|
# for a surface, brighter and thicker toward the centre.
|
|
#
|
|
# Each ring is a NeonPiece that is SPUN, not redrawn. Issues #6 and #10 made
|
|
# that the rule for the buildings and it applies here more than anywhere: the
|
|
# disc was ten glowing paths of twenty-five points re-tessellated every frame
|
|
# - forty antialiased polylines - to turn five rings at five different rates.
|
|
# Rotation is a node property, so now nothing is rasterised after the first
|
|
# frame and the disc turns for free.
|
|
|
|
var disc_phase: float = 0.0
|
|
|
|
const CORE_RADIUS: float = 46.0
|
|
const RING_COUNT: int = 5
|
|
const RING_STEP: float = 16.0
|
|
const DISC_COLOR: Color = Color(0.55, 0.15, 0.85)
|
|
const DISC_HOT_COLOR: Color = Color(0.9, 0.6, 1.0)
|
|
|
|
# One per ring, with the rate and direction it turns at.
|
|
var _rings: Array = []
|
|
|
|
|
|
func _ready() -> void:
|
|
_build()
|
|
|
|
|
|
func configure(_shape_seed: int) -> void:
|
|
if _rings.is_empty():
|
|
_build()
|
|
|
|
|
|
func extractor_anchor() -> Vector2:
|
|
return Vector2(0.0, -(CORE_RADIUS + float(RING_COUNT - 1) * RING_STEP + 12.0))
|
|
|
|
|
|
func _build() -> void:
|
|
for child in get_children():
|
|
child.queue_free()
|
|
_rings.clear()
|
|
for i in range(RING_COUNT):
|
|
var radius: float = CORE_RADIUS + float(i) * RING_STEP
|
|
# 1.0 at the innermost ring, fading to 0.0 at the outermost - drives
|
|
# both colour (hotter inward) and stroke weight/brightness.
|
|
var t: float = 1.0 - float(i) / float(maxi(RING_COUNT - 1, 1))
|
|
var piece: NeonPiece = NeonPiece.create(self, Vector2.ZERO,
|
|
DISC_COLOR.lerp(DISC_HOT_COLOR, t * 0.65))
|
|
# The two arcs are built at their resting angles; the ring node turns
|
|
# them. Alternating direction per ring and a speed tied to t reads as
|
|
# genuine turbulence rather than one disc rotating as a rigid whole.
|
|
for arc_i in range(2):
|
|
var start: float = float(arc_i) * PI + 0.15
|
|
var end: float = start + PI - 0.3
|
|
var points := PackedVector2Array()
|
|
var steps: int = 24
|
|
for j in range(steps + 1):
|
|
var angle: float = lerpf(start, end, float(j) / float(steps))
|
|
points.append(Vector2(cos(angle), sin(angle)) * radius)
|
|
piece.add_path(points, 0.5 + t * 0.5, 0.45 + t * 0.35)
|
|
_rings.append({
|
|
"piece": piece,
|
|
"rate": (0.12 + t * 0.22) * (1.0 if i % 2 == 0 else -1.0),
|
|
})
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
disc_phase += delta
|
|
# One property per ring. Nothing is rasterised again.
|
|
for ring in _rings:
|
|
(ring.piece as NeonPiece).rotation = disc_phase * float(ring.rate)
|