From cb1bdec005d19cedd18b9004afb828c84317dcc1 Mon Sep 17 00:00:00 2001
From: Manley <j@cloudsumu.com>
Date: Sun, 5 Jun 2022 12:54:30 -0400
Subject: [PATCH] Initial commit

---
 .gitignore                     |  21 ++++++
 LICENSE                        |   7 ++
 ReadMe.md                      |   9 +++
 core/rect2d.go                 |  14 ++++
 core/vector2.go                |  19 +++++
 game/game.go                   |  36 +++++++++
 go.mod                         |   5 ++
 go.sum                         |   2 +
 gopher.bmp                     | Bin 0 -> 12342 bytes
 main.go                        |  42 +++++++++++
 node/camera2d.go               |  48 ++++++++++++
 node/inode.go                  |   7 ++
 node/node.go                   | 120 +++++++++++++++++++++++++++++
 node/node2d.go                 |  38 ++++++++++
 node/sprite2d.go               |  46 ++++++++++++
 rendering/camera2d.go          |  18 +++++
 rendering/render2d.go          |  21 ++++++
 rendering/standard_camera2d.go |  37 +++++++++
 rendering/texture2d.go         |   9 +++
 sdl/sdl_render2d.go            | 133 +++++++++++++++++++++++++++++++++
 sdl/sdl_texture2d.go           |  70 +++++++++++++++++
 21 files changed, 702 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 LICENSE
 create mode 100644 ReadMe.md
 create mode 100644 core/rect2d.go
 create mode 100644 core/vector2.go
 create mode 100644 game/game.go
 create mode 100644 go.mod
 create mode 100644 go.sum
 create mode 100644 gopher.bmp
 create mode 100644 main.go
 create mode 100644 node/camera2d.go
 create mode 100644 node/inode.go
 create mode 100644 node/node.go
 create mode 100644 node/node2d.go
 create mode 100644 node/sprite2d.go
 create mode 100644 rendering/camera2d.go
 create mode 100644 rendering/render2d.go
 create mode 100644 rendering/standard_camera2d.go
 create mode 100644 rendering/texture2d.go
 create mode 100644 sdl/sdl_render2d.go
 create mode 100644 sdl/sdl_texture2d.go

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..3b735ec
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,21 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..c67edd6
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,7 @@
+Copyright 2022 Manley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/ReadMe.md b/ReadMe.md
new file mode 100644
index 0000000..9241b8b
--- /dev/null
+++ b/ReadMe.md
@@ -0,0 +1,9 @@
+# Golang Game Framework
+
+Framework in Golang to simplify game development with SDL in Go.
+
+Currently, only basic rendering has been implemented.
+
+For an example on how to use it, see `game/game.go` and make your own changes!
+
+I have a strong desire to make this into a more flexible and feature complete system, but I cannot give any guarantees. Hopefully at minimum, this project can be seen as a reference for others!
diff --git a/core/rect2d.go b/core/rect2d.go
new file mode 100644
index 0000000..146edda
--- /dev/null
+++ b/core/rect2d.go
@@ -0,0 +1,14 @@
+package core
+
+import "fmt"
+
+type Rect2D struct {
+	X float64
+	Y float64
+	W float64
+	H float64
+}
+
+func (rect Rect2D) String() string {
+	return fmt.Sprintf("X: %v, Y: %v, W: %v, H: %v", rect.X, rect.Y, rect.W, rect.H)
+}
diff --git a/core/vector2.go b/core/vector2.go
new file mode 100644
index 0000000..39c8b5d
--- /dev/null
+++ b/core/vector2.go
@@ -0,0 +1,19 @@
+package core
+
+import "fmt"
+
+type Vector2 struct {
+	X float64
+	Y float64
+}
+
+func (p Vector2) String() string {
+	return fmt.Sprintf("X: %v, Y: %v", p.X, p.Y)
+}
+
+func (vector Vector2) Add(other Vector2) Vector2 {
+	return Vector2{
+		X: vector.X + other.X,
+		Y: vector.Y + other.Y,
+	}
+}
diff --git a/game/game.go b/game/game.go
new file mode 100644
index 0000000..5e49075
--- /dev/null
+++ b/game/game.go
@@ -0,0 +1,36 @@
+package game
+
+import (
+	"log"
+
+	"github.com/manleydev/golang-game-framework/node"
+	"github.com/manleydev/golang-game-framework/rendering"
+	"github.com/manleydev/golang-game-framework/sdl"
+)
+
+func Run(root *node.Node, renderer rendering.Renderer2D) {
+	texture := sdl.NewSdlTexture2D(renderer, "gopher.bmp")
+
+	g := node.NewSprite2D(texture)
+	defer root.AddChild(g)
+
+	g.OnReady(func() error {
+		log.Println("Hello world!")
+		return nil
+	})
+
+	g.OnUpdate(func() error {
+		g.Rotation += 0.01
+		return nil
+	})
+
+	g.Name = "Gopher"
+
+	camera := node.NewCamera2D(&renderer, rendering.NewStandardCamera())
+	defer root.AddChild(camera)
+
+	camera.OnReady(func() error {
+		return camera.Enable()
+	})
+
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..59c6597
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,5 @@
+module github.com/manleydev/golang-game-framework
+
+go 1.16
+
+require github.com/veandco/go-sdl2 v0.4.21 // indirect
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..c551f58
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,2 @@
+github.com/veandco/go-sdl2 v0.4.21 h1:85AtFYv3vSPZvyOOxkJ03sHoJe8ESjPSZLr0KueQtVY=
+github.com/veandco/go-sdl2 v0.4.21/go.mod h1:OROqMhHD43nT4/i9crJukyVecjPNYYuCofep6SNiAjY=
diff --git a/gopher.bmp b/gopher.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..2078ea05dcf2aeb24a0da10708429e1fd0d52219
GIT binary patch
literal 12342
zcmeI0F;2rk6huQ!N5v5+sZt|)PQk69;w&k17p@Riu_M2gX06$b<OpS>1U|Fl`A=gP
z5$_-S*WLNGFF#+(=WYHx?4HY1UgiAhar#Vx_w)4qdGohNs$DmSF94d%QwM+EfY-Ek
z<=gWFP3Ecj_B_EO)vkPdo}kG*HQ$~mc%<5uZ_g7nnWyI4^8}AnyYlUMf+q9Se0!eY
zk!n}IJx|bNo|<pZ6FgGw%D3kUn#@!4?RkPns$Kc^JVBFrYQ8;B@JO{Q-<~IEGEdF7
z=LsIEcIDgi1Wo3t`Sv`)Bh{{ad!C@lJT>2*CwQdV)xG_+ypDJ+YMDC!r=-a|wRaae
zfq$glo9U5iSMM%z4*sb<-K?i3{qtT_^FMk1D`x&N_`QdxxbETk`8xbw{dW4X%N9l_
z|7!Shp_4DLY{|(V{Oc{*Weeka@;0Xe%a*nwT;F2D3gde6Hm3s1mbM{W-(tfGV>6lG
z2U;_~C$v1&>BlUvY-#Y%4Y23djLzAcUA8bXr<z*~)X77=HPeq-VA)c|j7%ahjCyq~
z4lF-*(ce2)49En|iJ8=^YjI%tv5WrRxne*ja0dUS4EBS$w{!YO|8oPEj?3?=ALy;F
z=<l6dnOw_E>eaP4u>9lsIoDKmh)z&vdrbVemiMc79{h6y?Yp#`pmX-t+d2Krspe&C
wdm>NUwVcq8nLNF7#f;3;;b(bM@12dDUS|3Sf3tz<PL2NgxQux;a5oM70nBv3!T<mO

literal 0
HcmV?d00001

diff --git a/main.go b/main.go
new file mode 100644
index 0000000..9c2d771
--- /dev/null
+++ b/main.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+	"log"
+
+	"github.com/manleydev/golang-game-framework/game"
+	"github.com/manleydev/golang-game-framework/node"
+	"github.com/manleydev/golang-game-framework/rendering"
+	"github.com/manleydev/golang-game-framework/sdl"
+)
+
+func main() {
+	var renderer rendering.Renderer2D = sdl.NewSdlRenderer2D(sdl.SdlRenderer2DInput{
+		WindowTitle:  "Sample Game",
+		WindowWidth:  1280,
+		WindowHeight: 720,
+	})
+	defer renderer.Destroy()
+
+	root := node.NewNode()
+	root.Name = "Root"
+
+	game.Run(&root, renderer)
+
+	running := true
+	for running {
+		if err := root.Update(); err != nil {
+			log.Fatal("Update: ", err)
+		}
+		if err := renderer.Update(); err != nil {
+			log.Fatal("Renderer Update: ", err)
+		}
+
+		if err := root.Draw(renderer); err != nil {
+			log.Fatal("Draw: ", err)
+		}
+		if err := renderer.Draw(); err != nil {
+			log.Fatal("Renderer Draw: ", err)
+		}
+
+	}
+}
diff --git a/node/camera2d.go b/node/camera2d.go
new file mode 100644
index 0000000..151123e
--- /dev/null
+++ b/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
+}
diff --git a/node/inode.go b/node/inode.go
new file mode 100644
index 0000000..f3d4de7
--- /dev/null
+++ b/node/inode.go
@@ -0,0 +1,7 @@
+package node
+
+type INode interface {
+	GetName() string
+	Update() error
+	ready(INode) error
+}
diff --git a/node/node.go b/node/node.go
new file mode 100644
index 0000000..757782e
--- /dev/null
+++ b/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{},
+	}
+}
diff --git a/node/node2d.go b/node/node2d.go
new file mode 100644
index 0000000..d831f05
--- /dev/null
+++ b/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(),
+	}
+}
diff --git a/node/sprite2d.go b/node/sprite2d.go
new file mode 100644
index 0000000..bc4a52b
--- /dev/null
+++ b/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
+}
diff --git a/rendering/camera2d.go b/rendering/camera2d.go
new file mode 100644
index 0000000..b6d966c
--- /dev/null
+++ b/rendering/camera2d.go
@@ -0,0 +1,18 @@
+package rendering
+
+import "github.com/manleydev/golang-game-framework/core"
+
+type Camera2D interface {
+	GetZoom() float64
+	SetZoom(float64)
+
+	GetOffset() core.Vector2
+	SetOffset(core.Vector2)
+
+	GetModifiers() Camera2DModifiers
+}
+
+type Camera2DModifiers struct {
+	Zoom   float64
+	Offset core.Vector2
+}
diff --git a/rendering/render2d.go b/rendering/render2d.go
new file mode 100644
index 0000000..855f343
--- /dev/null
+++ b/rendering/render2d.go
@@ -0,0 +1,21 @@
+package rendering
+
+import (
+	"github.com/manleydev/golang-game-framework/core"
+)
+
+type Renderer2D interface {
+	DrawTexture2D(DrawTexture2DInput) error
+
+	Draw() error
+	Update() error
+	Destroy()
+	SetCamera(*Camera2D) error
+}
+
+type DrawTexture2DInput struct {
+	Texture  Texture2D
+	Rect     core.Rect2D
+	Position core.Vector2
+	Rotation float64
+}
diff --git a/rendering/standard_camera2d.go b/rendering/standard_camera2d.go
new file mode 100644
index 0000000..f059958
--- /dev/null
+++ b/rendering/standard_camera2d.go
@@ -0,0 +1,37 @@
+package rendering
+
+import "github.com/manleydev/golang-game-framework/core"
+
+type StandardCamera2D struct {
+	zoom   float64
+	offset core.Vector2
+}
+
+func (camera *StandardCamera2D) GetZoom() float64 {
+	return camera.zoom
+}
+func (camera *StandardCamera2D) SetZoom(zoom float64) {
+	camera.zoom = zoom
+}
+
+func (camera *StandardCamera2D) GetOffset() core.Vector2 {
+	return camera.offset
+}
+func (camera *StandardCamera2D) SetOffset(offset core.Vector2) {
+	camera.offset = offset
+}
+
+func (camera *StandardCamera2D) GetModifiers() Camera2DModifiers {
+	return Camera2DModifiers{
+		Zoom:   camera.zoom,
+		Offset: camera.offset,
+	}
+}
+
+func NewStandardCamera() *Camera2D {
+	var camera Camera2D = &StandardCamera2D{
+		zoom:   1,
+		offset: core.Vector2{},
+	}
+	return &camera
+}
diff --git a/rendering/texture2d.go b/rendering/texture2d.go
new file mode 100644
index 0000000..9681bd0
--- /dev/null
+++ b/rendering/texture2d.go
@@ -0,0 +1,9 @@
+package rendering
+
+import "github.com/manleydev/golang-game-framework/core"
+
+type Texture2D interface {
+	Destroy()
+	GetCenter() core.Vector2
+	GetRect() core.Rect2D
+}
diff --git a/sdl/sdl_render2d.go b/sdl/sdl_render2d.go
new file mode 100644
index 0000000..e182578
--- /dev/null
+++ b/sdl/sdl_render2d.go
@@ -0,0 +1,133 @@
+package sdl
+
+import (
+	"errors"
+	"log"
+
+	"github.com/manleydev/golang-game-framework/core"
+	"github.com/manleydev/golang-game-framework/rendering"
+	"github.com/veandco/go-sdl2/sdl"
+)
+
+type SdlRenderer2D struct {
+	window        *sdl.Window
+	renderer      *sdl.Renderer
+	currentCamera *rendering.Camera2D
+}
+
+type SdlRenderer2DInput struct {
+	WindowTitle  string
+	WindowWidth  int32
+	WindowHeight int32
+	Fullscreen   bool
+}
+
+func NewSdlRenderer2D(input SdlRenderer2DInput) *SdlRenderer2D {
+	w := &SdlRenderer2D{}
+	var err error
+
+	w.window, err = sdl.CreateWindow(input.WindowTitle,
+		sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
+		input.WindowWidth, input.WindowHeight,
+		sdl.WINDOW_VULKAN)
+	if err != nil {
+		log.Print("Failed to create SDL window: ", err)
+		return nil
+	}
+
+	if input.Fullscreen {
+		if err := w.window.SetFullscreen(sdl.WINDOW_FULLSCREEN_DESKTOP); err != nil {
+			log.Print("Failed to set fullscreen: ", err)
+			return nil
+		}
+	}
+
+	w.window.SetResizable(true)
+
+	w.renderer, err = sdl.CreateRenderer(w.window, -1, sdl.RENDERER_ACCELERATED)
+	if err != nil {
+		log.Print("Failed to create SDL renderer: ", err)
+		return nil
+	}
+
+	return w
+}
+
+func (w SdlRenderer2D) Destroy() {
+	if err := w.window.Destroy(); err != nil {
+		log.Print("Failed to destroy SDL window: ", err)
+	}
+
+	if err := w.renderer.Destroy(); err != nil {
+		log.Print("Failed to destroy SDL renderer: ", err)
+	}
+}
+
+func (w *SdlRenderer2D) SetCamera(camera *rendering.Camera2D) error {
+	w.currentCamera = camera
+	return nil
+}
+
+func (w SdlRenderer2D) Update() error {
+	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
+		switch event.(type) {
+		case *sdl.QuitEvent:
+			return errors.New("Quit system not yet implemented!")
+		}
+	}
+	return nil
+}
+
+func (w SdlRenderer2D) DrawTexture2D(input rendering.DrawTexture2DInput) error {
+	tex, ok := input.Texture.(*SdlTexture2D)
+	if !ok {
+		return errors.New("Texture is not an SdlTexture2D!")
+	}
+
+	center := tex.GetCenter()
+	modifiers := rendering.Camera2DModifiers{
+		Zoom:   1.0,
+		Offset: core.Vector2{X: 0, Y: 0},
+	}
+	if w.currentCamera != nil {
+		modifiers = (*w.currentCamera).GetModifiers()
+	}
+
+	if err := w.renderer.CopyEx(tex.texture,
+		&sdl.Rect{
+			X: int32(input.Rect.X),
+			Y: int32(input.Rect.Y),
+			W: int32(input.Rect.W),
+			H: int32(input.Rect.H),
+		},
+		&sdl.Rect{
+			X: int32((input.Position.X - modifiers.Offset.X) * modifiers.Zoom),
+			Y: int32((input.Position.Y - modifiers.Offset.Y) * modifiers.Zoom),
+			W: int32(input.Rect.W * modifiers.Zoom),
+			H: int32(input.Rect.H * modifiers.Zoom),
+		}, input.Rotation,
+		&sdl.Point{
+			X: int32(center.X * modifiers.Zoom),
+			Y: int32(center.Y * modifiers.Zoom),
+		},
+		sdl.FLIP_NONE); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (w SdlRenderer2D) Draw() error {
+
+	w.renderer.Present()
+
+	if err := w.renderer.SetDrawColor(0, 0, 0, 255); err != nil {
+		return err
+	}
+
+	if err := w.renderer.Clear(); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/sdl/sdl_texture2d.go b/sdl/sdl_texture2d.go
new file mode 100644
index 0000000..c3f7874
--- /dev/null
+++ b/sdl/sdl_texture2d.go
@@ -0,0 +1,70 @@
+package sdl
+
+import (
+	"log"
+
+	"github.com/manleydev/golang-game-framework/core"
+	"github.com/manleydev/golang-game-framework/rendering"
+	"github.com/veandco/go-sdl2/sdl"
+)
+
+type SdlTexture2D struct {
+	texture *sdl.Texture
+}
+
+func NewSdlTexture2D(renderer rendering.Renderer2D, bmpPath string) *SdlTexture2D {
+	sdlRenderer, ok := renderer.(*SdlRenderer2D)
+	if !ok {
+		log.Print("Renderer is not an SDL renderer")
+		return nil
+	}
+
+	tex := SdlTexture2D{}
+	surface, err := sdl.LoadBMP(bmpPath)
+	if err != nil {
+		log.Print("Failed to load bmp: ", err)
+		return nil
+	}
+	defer surface.Free()
+
+	tex.texture, err = sdlRenderer.renderer.CreateTextureFromSurface(surface)
+	if err != nil {
+		log.Print("Failed to create SDL texture: ", err)
+		return nil
+	}
+
+	return &tex
+}
+
+func (tex SdlTexture2D) GetCenter() core.Vector2 {
+	_, _, width, height, err := tex.texture.Query()
+	if err != nil {
+		log.Print("Could not get texture center: ", err)
+		return core.Vector2{}
+	}
+
+	return core.Vector2{
+		X: float64(width / 2),
+		Y: float64(height / 2),
+	}
+}
+
+func (tex SdlTexture2D) GetRect() core.Rect2D {
+	_, _, width, height, err := tex.texture.Query()
+	if err != nil {
+		log.Print("Could not get texture data: ", err)
+		return core.Rect2D{}
+	}
+	return core.Rect2D{
+		X: 0,
+		Y: 0,
+		W: float64(width),
+		H: float64(height),
+	}
+}
+
+func (tex SdlTexture2D) Destroy() {
+	if err := tex.texture.Destroy(); err != nil {
+		log.Print("Failed to destroy SDL texture: ", err)
+	}
+}