class Eagle::Sprite2D

Overview

Draws a texture, or part of one, at the node's position. It is the workhorse of 2D games.

Sprites are centered on their position by default, so rotation and scale happen around the middle. For sprite sheets, set #hframes/#vframes and pick a #frame, or use an AnimatedSprite2D.

player = Sprite2D.new(Texture.new(Image.circle(32, Color::YELLOW)), v2(200, 150))
player.flip_h = true              # face left
player.modulate = Color::RED      # tint, including children
SceneTree.root.add(player)

coin = Sprite2D.load("res://coin.png", v2(300, 150))
coin.hframes = 6                  # a 6-frame strip
coin.frame = 2

Direct Known Subclasses

Defined in:

eagle/nodes/sprite2d.cr

Constructors

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.load(path : String, position : Vec2 = Vec2::ZERO, filter : GPU::Filter = Texture.default_filter) : Sprite2D #

Creates a sprite from an image file.


def self.new(name : String = "", texture : Drawable | Nil = nil, position : Vec2 = Vec2::ZERO, centered : Bool = true) #

Creates a sprite, optionally with a texture.


def self.new(texture : Drawable, position : Vec2 = Vec2::ZERO, name : String = "") #

Creates a sprite showing texture at position.


Instance Method Detail

def centered=(centered : Bool) #

Draw centered on the node's position (the default) or with the top-left there.


def centered? : Bool #

Draw centered on the node's position (the default) or with the top-left there.


def color : Color #

Tint for this sprite only. modulate also tints children.


def color=(color : Color) #

Tint for this sprite only. modulate also tints children.


def contains_point?(global : Vec2) : Bool #

True when a world-space point falls on the sprite's rect. Handy for clicking sprites.

card = Sprite2D.new(Texture.new(Image.new(60, 90, Color::WHITE)), v2(100, 100))
card.modulate = Color::YELLOW if card.contains_point?(Input.mouse)

def current_region : Drawable | Nil #

The region actually drawn this frame, after frame selection and flips.


def draw(g : Graphics) : Nil #

Draws the current region.


def flip_h=(flip_h : Bool) #

Mirror horizontally, for characters that turn around.


def flip_h? : Bool #

Mirror horizontally, for characters that turn around.


def flip_v=(flip_v : Bool) #

Mirror vertically.


def flip_v? : Bool #

Mirror vertically.


def frame : Int32 #

Which cell of the sheet to show, counting left to right, top to bottom.


def frame=(frame : Int32) #

Which cell of the sheet to show, counting left to right, top to bottom.


def global_rect : Rect #

The drawn area in world space. When rotated, this is the axis-aligned box around it.


def height : Float32 #

Frame height in pixels.


def hframes : Int32 #

Number of columns when the texture is a sprite sheet.


def hframes=(hframes : Int32) #

Number of columns when the texture is a sprite sheet.


def offset : Vec2 #

Extra offset in local space, for example to line up feet with the position.


def offset=(offset : Vec2) #

Extra offset in local space, for example to line up feet with the position.


def rect : Rect #

The drawn area in local space, accounting for centered and #offset.


def size : Vec2 #

Size of one frame in pixels, before scale.


def texture : Drawable | Nil #

The texture or region to draw. nil draws nothing.


def texture=(t : Drawable | Nil) #

Sets the texture.


def texture=(path : String) #

Sets the texture by loading a file.


def vframes : Int32 #

Number of rows when the texture is a sprite sheet.


def vframes=(vframes : Int32) #

Number of rows when the texture is a sprite sheet.


def width : Float32 #

Frame width in pixels.