Initial commit

node/camera2d.go

@@ -0,0 +1,48 @@
+package node
+
+import (
+	"errors"
+
+	"github.com/manleydev/golang-game-framework/rendering"
+)
+
+type Camera2D struct {
+	Node2D
+	Zoom     float64
+	camera   *rendering.Camera2D
+	renderer *rendering.Renderer2D
+}
+
+func (camera *Camera2D) Update() error {
+	if err := camera.Node2D.Update(); err != nil {
+		return err
+	}
+
+	camRef := *(camera.camera)
+	camRef.SetOffset(camera.GetGlobalPosition())
+	camRef.SetZoom(camera.Zoom)
+
+	return nil
+}
+
+func (camera *Camera2D) Enable() error {
+	if camera.camera == nil {
+		return errors.New("camera is nil")
+	}
+	return (*camera.renderer).SetCamera(camera.camera)
+}
+
+func (node *Camera2D) AddChild(child INode) {
+	node.internalAddChild(node, child)
+}
+
+func NewCamera2D(renderer *rendering.Renderer2D, cam *rendering.Camera2D) *Camera2D {
+	camera := Camera2D{
+		Node2D:   NewNode2D(),
+		camera:   cam,
+		renderer: renderer,
+		Zoom:     1.0,
+	}
+
+	return &camera
+}

node/inode.go

@@ -0,0 +1,7 @@
+package node
+
+type INode interface {
+	GetName() string
+	Update() error
+	ready(INode) error
+}

node/node.go

@@ -0,0 +1,120 @@
+package node
+
+import (
+	"log"
+
+	"github.com/manleydev/golang-game-framework/rendering"
+)
+
+type Node struct {
+	Name     string
+	children []INode
+	parent   INode
+
+	onReadyMethods  []func() error
+	onUpdateMethods []func() error
+	onDraw2dMethods []func(rendering.Renderer2D) error
+}
+
+func (node *Node) ready(parent INode) error {
+	node.parent = parent
+
+	for _, readyMethod := range node.onReadyMethods {
+		if err := readyMethod(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (node *Node) OnReady(callback func() error) {
+	if callback == nil {
+		return
+	}
+	node.onReadyMethods = append(node.onReadyMethods, callback)
+}
+
+func (node *Node) Update() error {
+	for _, child := range node.children {
+		if err := child.Update(); err != nil {
+			return err
+		}
+	}
+
+	for _, updateMethod := range node.onUpdateMethods {
+		if err := updateMethod(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (node *Node) OnUpdate(callback func() error) {
+	if callback == nil {
+		return
+	}
+	node.onUpdateMethods = append(node.onUpdateMethods, callback)
+}
+
+func (node *Node) Draw(renderer rendering.Renderer2D) error {
+	for _, child := range node.children {
+		drawable, ok := child.(interface {
+			Draw(rendering.Renderer2D) error
+		})
+		if !ok {
+			continue
+		}
+		if err := drawable.Draw(renderer); err != nil {
+			return err
+		}
+	}
+
+	for _, drawMethod := range node.onDraw2dMethods {
+		if err := drawMethod(renderer); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (node *Node) OnDraw2D(callback func(rendering.Renderer2D) error) {
+	if callback == nil {
+		return
+	}
+	node.onDraw2dMethods = append(node.onDraw2dMethods, callback)
+}
+
+func (node *Node) GetName() string {
+	return node.Name
+}
+
+func (node *Node) GetChild(index int) INode {
+	if index < len(node.children) {
+		return nil
+	}
+	return node.children[index]
+}
+
+func (node *Node) internalAddChild(parent INode, child INode) {
+	node.children = append(node.children, child)
+
+	if err := child.ready(parent); err != nil {
+		log.Fatalf("Node(%s) AddChild: %v", node.Name, err)
+	}
+}
+
+func (node *Node) AddChild(child INode) {
+	node.internalAddChild(node, child)
+}
+
+func (node *Node) GetParent() INode {
+	return node.parent
+}
+
+func NewNode() Node {
+	return Node{
+		children: []INode{},
+	}
+}

node/node2d.go

@@ -0,0 +1,38 @@
+package node
+
+import (
+	"github.com/manleydev/golang-game-framework/core"
+)
+
+type Node2D struct {
+	Node
+	Position core.Vector2
+	Rotation float64
+}
+
+func (node *Node2D) GetPosition() core.Vector2 {
+	return node.Position
+}
+
+func (node *Node2D) GetGlobalPosition() core.Vector2 {
+	if node.parent == nil {
+		return node.Position
+	}
+	global2d, ok := (node.parent).(interface {
+		GetGlobalPosition() core.Vector2
+	})
+	if ok {
+		return node.Position.Add(global2d.GetGlobalPosition())
+	}
+	return node.Position
+}
+
+func (node *Node2D) AddChild(child INode) {
+	node.internalAddChild(node, child)
+}
+
+func NewNode2D() Node2D {
+	return Node2D{
+		Node: NewNode(),
+	}
+}

node/sprite2d.go

@@ -0,0 +1,46 @@
+package node
+
+import (
+	"github.com/manleydev/golang-game-framework/rendering"
+)
+
+type Sprite2D struct {
+	Node2D
+	texture rendering.Texture2D
+	visible bool
+}
+
+func (sprite *Sprite2D) Draw(renderer rendering.Renderer2D) error {
+	if !sprite.visible {
+		return nil
+	}
+	if err := sprite.Node.Draw(renderer); err != nil {
+		return err
+	}
+
+	return renderer.DrawTexture2D(rendering.DrawTexture2DInput{
+		Texture:  sprite.texture,
+		Rect:     sprite.texture.GetRect(),
+		Position: sprite.GetGlobalPosition(),
+		Rotation: sprite.Rotation,
+	})
+}
+
+func (sprite *Sprite2D) SetVisible(v bool) {
+	sprite.visible = v
+}
+
+func (node *Sprite2D) AddChild(child INode) {
+	node.internalAddChild(node, child)
+}
+
+func NewSprite2D(texture rendering.Texture2D) *Sprite2D {
+	sprite := Sprite2D{
+		Node2D:  NewNode2D(),
+		visible: true,
+	}
+
+	sprite.texture = texture
+
+	return &sprite
+}