class Eagle::Camera2D

Overview

A 2D camera: it decides which part of the world is on screen. Its global position is the center of the view.

The first camera added to the tree becomes current automatically. The scene tree draws through the current camera, while CanvasLayer children stay fixed on screen.

player = Node2D.new("Player", position: v2(400, 300))
cam = Camera2D.new(zoom: 2)
cam.follow(player)                            # smooth follow
cam.limits = Rect.new(0, 0, 4000, 2000)       # never show outside the level
cam.drag_margin = v2(40, 20)                  # small dead zone before scrolling
SceneTree.root.add(player, cam)

cam.shake(6, 0.25)                            # on explosions
clicked = cam.mouse_world                     # mouse position in world space

Defined in:

eagle/nodes/camera2d.cr

Constructors

Class Method Summary

Instance Method Summary

Instance methods inherited from class Eagle::Node2D

direction_to(other : Node2D) : Vec2 direction_to, distance_to(other : Node2D) : Float32 distance_to, down : Vec2 down, forward : Vec2 forward, global_position : Vec2 global_position, global_position=(p : Vec2) global_position=, global_rotation : Float32 global_rotation, global_scale : Vec2 global_scale, global_transform : Transform2D global_transform, look_at(target : Vec2) : Nil look_at, modulate : Color modulate, modulate=(modulate : Color) modulate=, parent_2d : Node2D | Nil parent_2d, position : Vec2 position, position=(p : Vec2) position=, right : Vec2 right, rotate(rad : Number) : Nil rotate, rotation : Float32 rotation, rotation=(rotation : Float32) rotation=, rotation_degrees : Float32 rotation_degrees, rotation_degrees=(d : Number) rotation_degrees=, scale : Vec2 scale, scale=(s : Vec2)
scale=(s : Number) scale=, to_global(local : Vec2) : Vec2 to_global, to_local(global : Vec2) : Vec2 to_local, top_level=(top_level : Bool) top_level=, top_level? : Bool top_level?, transform : Transform2D transform, transform=(t : Transform2D) transform=, translate(x : Number, y : Number) : Nil
translate(v : Vec2) : Nil translate, x : Float32 x, x=(v : Number) x=, y : Float32 y, y=(v : Number) y=

Constructor methods inherited from class Eagle::Node2D

new(name : String = "", position : Eagle::Vec2 = Vec2::ZERO, rotation : Float32 = 0_f32, scale : Eagle::Vec2 = Vec2::ONE) new

Instance methods inherited from class Eagle::Node

<<(child : Node) : self <<, [](path : String) : Node [], []?(path : String) : Node | Nil []?, add(child : Node) : Node
add(*children : Node) : Nil add, add_child(child : Node) : Node add_child, add_to_group(group : String) : self add_to_group, ancestor_of?(node : Node) : Bool ancestor_of?, can_process? : Bool can_process?, child?(name : String) : Node | Nil child?, child_added : Eagle::Emitter(Node) child_added, child_count : Int32 child_count, child_removed : Eagle::Emitter(Node) child_removed, children : Array(Eagle::Node) children, children_of(type : T.class) : Array(T) forall T children_of, clear_children : Nil clear_children, draw(g : Graphics) : Nil draw, dump(io : IO = STDOUT, indent = 0) : Nil dump, each_ancestor(& : Node -> ) : Nil each_ancestor, each_child(& : Node -> ) : Nil each_child, each_descendant(&block : Node -> ) : Nil each_descendant, emit_child_added(*args) : Nil emit_child_added, emit_child_removed(*args) : Nil emit_child_removed, emit_tree_entered(*args) : Nil emit_tree_entered, emit_tree_exited(*args) : Nil emit_tree_exited, enter_tree : Nil enter_tree, exit_tree : Nil exit_tree, find(name : String) : Node | Nil find, find_all(type : T.class) : Array(T) forall T find_all, first_child : Node | Nil first_child, free : Nil free, get_node(path : String, type : T.class) : T forall T
get_node(path : String) : Node get_node, get_node?(path : String) : Node | Nil get_node?, groups : Set(String) groups, in_group?(group : String) : Bool in_group?, in_tree? : Bool in_tree?, input(event : Event) : Nil input, name : String name, name=(name : String) name=, on_child_added(&block : Node -> Nil) : Proc(Node, Nil) on_child_added, on_child_removed(&block : Node -> Nil) : Proc(Node, Nil) on_child_removed, on_tree_entered(&block : -> Nil) : Proc(Nil) on_tree_entered, on_tree_exited(&block : -> Nil) : Proc(Nil) on_tree_exited, parent : Node | Nil parent, path : String path, physics_process(dt : Float32) : Nil physics_process, process(dt : Float32) : Nil process, process_mode : Eagle::Node::ProcessMode process_mode, process_mode=(process_mode : Eagle::Node::ProcessMode) process_mode=, queue_free : Nil queue_free, queued_free? : Bool queued_free?, ready : Nil ready, ready_called? : Bool ready_called?, remove(child : Node) : Nil remove, remove_child(child : Node) : Nil remove_child, remove_from_group(group : String) : Nil remove_from_group, remove_from_parent : Nil remove_from_parent, resized(width : Int32, height : Int32) : Nil resized, root : Node root, to_s(io : IO) : Nil to_s, tree_entered : Eagle::Emitter() tree_entered, tree_exited : Eagle::Emitter() tree_exited, visible=(visible : Bool) visible=, visible? : Bool visible?, z_index : Int32 z_index, z_index=(z_index : Int32) z_index=

Constructor methods inherited from class Eagle::Node

new(name : String = "") new

Constructor Detail

def self.new(name : String = "", position : Vec2 = Vec2::ZERO, zoom : Number = 1, viewport : Eagle::Vec2 | Nil = nil, current : Bool = false) #

Creates a camera. Pass current: true to make it current right away.


Class Method Detail

def self.current : Camera2D | Nil #

The camera the scene tree is drawn through, if any.


def self.current=(c : Camera2D | Nil) #

Switches the active camera.


Instance Method Detail

def bounds : Rect #

The visible part of the world. Use it to skip work for things off screen.


def current? : Bool #

True when this is the camera the scene is drawn through.


def drag_margin : Vec2 #

How far, in world units, the target can move from the center before the camera follows.


def drag_margin=(drag_margin : Vec2) #

How far, in world units, the target can move from the center before the camera follows.


def draw_tree(g : Graphics) : Nil #

Cameras draw nothing and don't move their children.


def effective_position : Vec2 #

The actual view center after limits and shake.


def enter_tree : Nil #

Becomes current if no other camera is.


def exit_tree : Nil #

Stops being current when removed.


def follow(node : Node2D | Nil, offset : Vec2 = Vec2::ZERO) : Nil #

Follows node every frame, smoothed by #smoothing. Pass nil to stop.


def limits : Rect | Nil #

World-space rectangle the view is kept inside.


def limits=(limits : Rect | Nil) #

World-space rectangle the view is kept inside.


def make_current : self #

Makes this the active camera. Returns self.


def mouse_world : Vec2 #

The mouse position in world space.


def process(dt : Float32) : Nil #

Updates following and shake. Called by the engine.


def screen_to_world(p : Vec2) : Vec2 #

Converts a screen point, such as the mouse, to world space.


def shake(amount : Number, duration : Number = 0.3) : Nil #

Shakes the view by up to amount points, fading out over duration seconds.


def smoothing : Float32 #

How quickly the camera catches up with its target. Higher is snappier, and 0 snaps instantly.


def smoothing=(smoothing : Float32) #

How quickly the camera catches up with its target. Higher is snappier, and 0 snaps instantly.


def target : Node2D | Nil #

The node being followed.


def target=(target : Node2D | Nil) #

The node being followed.


def target_offset : Vec2 #

Offset added to the target's position, for example to look ahead of the player.


def target_offset=(target_offset : Vec2) #

Offset added to the target's position, for example to look ahead of the player.


def view : Transform2D #

The world-to-screen transform.


def viewport : Vec2 | Nil #

Size of the screen area the camera renders into. nil means the window.


def viewport=(viewport : Vec2 | Nil) #

Size of the screen area the camera renders into. nil means the window.


def viewport_size : Vec2 #

The size of the area the camera renders into.


def world_to_screen(p : Vec2) : Vec2 #

Converts a world point to screen space, for drawing HUD markers over objects.


def zoom : Float32 #

Magnification: 2 shows everything twice as large, 0.5 shows twice as much of the world.


def zoom=(zoom : Float32) #

Magnification: 2 shows everything twice as large, 0.5 shows twice as much of the world.