Rebranding.

.gitignore

@@ -1,2 +1,3 @@
 exe
 *.vim
+*.exe

camera.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 // Implements the camera component
 // for the main window.

cmd/math/main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/surdeus/gox/src/gx"
+	"github.com/reklesio/gg/src/gx"
 	"fmt"
 )
 
@@ -13,10 +13,7 @@ func main() {
 		gx.Vertex{30, 40},
 		gx.Vertex{40, 30},
 	}
-	
+
 	fmt.Println("barycenter:", p.Barycenter())
 	fmt.Println("edges:", p.Edges())
 }
-
-
-

cmd/test/main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/surdeus/gox/gx"
+	"github.com/reklesio/gg"
 	"github.com/hajimehoshi/ebiten/v2/examples/resources/images"
 	"github.com/hajimehoshi/ebiten/v2"
 	"bytes"
@@ -12,7 +12,7 @@ import (
 )
 
 const (
-	HighestL gx.Layer = -iota
+	HighestL gg.Layer = -iota
 	DebugL
 	TriangleL
 	PlayerL
@@ -21,76 +21,76 @@ const (
 )
 
 type Player struct {
-	*gx.Sprite
+	*gg.Sprite
-	MoveSpeed gx.Float
+	MoveSpeed  gg.Float
-	ScaleSpeed gx.Float
+	ScaleSpeed gg.Float
-	gx.Layer
+	gg.Layer
 }
 
-type Debug struct{
+type Debug struct {
-	gx.Layer
+	gg.Layer
 }
 
 type Rect struct {
-	*gx.DrawableRectangle
+	*gg.DrawableRectangle
-	gx.Layer
+	gg.Layer
 }
 
 type Tri struct {
-	*gx.DrawablePolygon
+	*gg.DrawablePolygon
-	gx.Layer
+	gg.Layer
 }
 
 func NewTri() *Tri {
 	ret := &Tri{}
-	ret.DrawablePolygon = &gx.DrawablePolygon{}
+	ret.DrawablePolygon = &gg.DrawablePolygon{}
-	ret.Transform.S = gx.V(1, 1)
+	ret.Transform.S = gg.V(1, 1)
-	
+
-	ret.Triangles = gx.Triangles{
+	ret.Triangles = gg.Triangles{
-		gx.Triangle{
+		gg.Triangle{
-			gx.V(0, 0),
+			gg.V(0, 0),
-			gx.V(100, 100),
+			gg.V(100, 100),
-			gx.V(0, -50),
+			gg.V(0, -50),
 		},
-		gx.Triangle{
+		gg.Triangle{
-			gx.V(0, 0),
+			gg.V(0, 0),
-			gx.V(-100, -100),
+			gg.V(-100, -100),
-			gx.V(0, 50),
+			gg.V(0, 50),
 		},
 	}
-	ret.Color = gx.Color{gx.MaxColorV, gx.MaxColorV, 0, gx.MaxColorV}
+	ret.Color = gg.Color{gg.MaxColorV, gg.MaxColorV, 0, gg.MaxColorV}
 	ret.Visible = true
 	ret.Layer = TriangleL
-	
+
 	return ret
 }
 
 func NewRect() *Rect {
-	ret := &Rect{&gx.DrawableRectangle{
+	ret := &Rect{&gg.DrawableRectangle{
-			Rectangle: gx.Rectangle{
+		Rectangle: gg.Rectangle{
-				Transform: gx.Transform{
+			Transform: gg.Transform{
-					S: gx.Vector{
+				S: gg.Vector{
-						X: 200,
+					X: 200,
-						Y: 400,
+					Y: 400,
-					},
 				},
 			},
-			Color: gx.Color{
+		},
-				gx.MaxColorV,
+		Color: gg.Color{
-				0,
+			gg.MaxColorV,
-				0,
+			0,
-				gx.MaxColorV,
+			0,
+			gg.MaxColorV,
+		},
+		Visible: true,
+		/*Shader: gg.SolidWhiteColorShader,
+		Options: gg.ShaderOptions{
+			Images: [4]*gg.Image{
+				playerImg,
+				nil,
+				nil,
+				nil,
 			},
-			Visible: true,
+		},*/
-			/*Shader: gx.SolidWhiteColorShader,
-			Options: gx.ShaderOptions{
-				Images: [4]*gx.Image{
-					playerImg,
-					nil,
-					nil,
-					nil,
-				},
-			},*/
 	},
 		RectL,
 	}
@@ -98,190 +98,191 @@ func NewRect() *Rect {
 	return ret
 }
 
-func (r *Rect) Update(e *gx.Engine) error {
+func (r *Rect) Update(e *gg.Engine) error {
 	//r.R += 0.3 * e.DT()
 	return nil
 }
 
 var (
-	playerImg *gx.Image
+	playerImg *gg.Image
-	player *Player
+	player    *Player
-	rectMove gx.Rectangle
+	rectMove  gg.Rectangle
-	rect *Rect
+	rect      *Rect
-	tri *Tri
+	tri       *Tri
 )
 
 func NewPlayer() *Player {
 	ret := &Player{
-		Sprite: &gx.Sprite{
+		Sprite: &gg.Sprite{
-			Transform: gx.Transform {
+			Transform: gg.Transform{
-				S: gx.Vector{5, 5},
+				S:  gg.Vector{5, 5},
-				RA: gx.Vector{.5, .5},
+				RA: gg.Vector{.5, .5},
 			},
 			Visible: true,
-			ShaderOptions: gx.ShaderOptions {
+			ShaderOptions: gg.ShaderOptions{
-				Shader: gx.SolidWhiteColorShader,
+				Shader:   gg.SolidWhiteColorShader,
-				Uniforms: make(map[string] any),
+				Uniforms: make(map[string]any),
 			},
 		},
-		MoveSpeed: 90.,
+		MoveSpeed:  90.,
 		ScaleSpeed: .2,
 	}
-	
+
 	ret.Images[0] = playerImg
 	ret.Layer = PlayerL
-	
+
 	return ret
 }
 
-func (p *Player) Draw(e *gx.Engine, i *gx.Image) {
+func (p *Player) Draw(e *gg.Engine, i *gg.Image) {
 	p.Sprite.Draw(e, i)
 	t := p.Transform
 	t.S.X *= 4.
 	t.S.Y *= 4.
-	rectMove = gx.Rectangle{
+	rectMove = gg.Rectangle{
 		Transform: t,
 	}
-	r := &gx.DrawableRectangle{
+	r := &gg.DrawableRectangle{
 		Rectangle: rectMove,
-		Color: gx.Color{0, 0, gx.MaxColorV, gx.MaxColorV},
+		Color:     gg.Color{0, 0, gg.MaxColorV, gg.MaxColorV},
 	}
 	r.Draw(e, i)
 }
 
-func (p *Player) Start(e *gx.Engine, v ...any) {
+func (p *Player) Start(e *gg.Engine, v ...any) {
 	fmt.Println("starting")
 	c := e.Camera()
-	c.RA = gx.V(360, 240)
+	c.RA = gg.V(360, 240)
 }
 
-func (p *Player) Update(e *gx.Engine) error {
+func (p *Player) Update(e *gg.Engine) error {
 	dt := e.DT()
 	c := e.Camera()
 	keys := e.Keys()
-	
+
 	p.Uniforms["Random"] = any(rand.Float32())
-	for _, v := range keys {switch v {
+	for _, v := range keys {
-	case ebiten.KeyArrowUp :
+		switch v {
-		c.P.Y += p.MoveSpeed * dt
+		case ebiten.KeyArrowUp:
-	case ebiten.KeyArrowLeft :
+			c.P.Y += p.MoveSpeed * dt
-		c.P.X -= p.MoveSpeed * dt
+		case ebiten.KeyArrowLeft:
-	case ebiten.KeyArrowDown :
+			c.P.X -= p.MoveSpeed * dt
-		c.P.Y -= p.MoveSpeed * dt
+		case ebiten.KeyArrowDown:
-	case ebiten.KeyArrowRight :
+			c.P.Y -= p.MoveSpeed * dt
-		c.P.X += p.MoveSpeed * dt
+		case ebiten.KeyArrowRight:
-	case ebiten.KeyW :
+			c.P.X += p.MoveSpeed * dt
-		p.P.Y += p.MoveSpeed * dt
+		case ebiten.KeyW:
-	case ebiten.KeyA :
+			p.P.Y += p.MoveSpeed * dt
-		p.P.X -= p.MoveSpeed * dt
+		case ebiten.KeyA:
-	case ebiten.KeyS :
+			p.P.X -= p.MoveSpeed * dt
-		p.P.Y -= p.MoveSpeed * dt
+		case ebiten.KeyS:
-	case ebiten.KeyD :
+			p.P.Y -= p.MoveSpeed * dt
-		p.P.X += p.MoveSpeed * dt
+		case ebiten.KeyD:
-	case ebiten.KeyR :
+			p.P.X += p.MoveSpeed * dt
-		c.R += gx.Pi * p.ScaleSpeed * dt
+		case ebiten.KeyR:
-	case ebiten.KeyT :
+			c.R += gg.Pi * p.ScaleSpeed * dt
-		c.R -= gx.Pi * p.ScaleSpeed * dt
+		case ebiten.KeyT:
-	case ebiten.KeyRightBracket :
+			c.R -= gg.Pi * p.ScaleSpeed * dt
-		if e.KeyIsPressed(ebiten.KeyShift) {
+		case ebiten.KeyRightBracket:
-			p.R -= gx.Pi * 0.3 * dt
+			if e.KeyIsPressed(ebiten.KeyShift) {
-		} else {
+				p.R -= gg.Pi * 0.3 * dt
-			p.R += gx.Pi * 0.3 * dt
+			} else {
+				p.R += gg.Pi * 0.3 * dt
+			}
+		case ebiten.KeyF:
+			if e.KeyIsPressed(ebiten.KeyShift) {
+				c.S.X -= gg.Pi * p.ScaleSpeed * dt
+			} else {
+				c.S.X += gg.Pi * p.ScaleSpeed * dt
+			}
+		case ebiten.KeyG:
+			if e.KeyIsPressed(ebiten.KeyShift) {
+				c.S.Y -= gg.Pi * p.ScaleSpeed * dt
+			} else {
+				c.S.Y += gg.Pi * p.ScaleSpeed * dt
+			}
+		case ebiten.KeyZ:
+			if e.KeyIsPressed(ebiten.KeyShift) {
+				c.RA.X -= gg.Pi * p.MoveSpeed * dt
+			} else {
+				c.RA.X += gg.Pi * p.MoveSpeed * dt
+			}
+		case ebiten.KeyX:
+			if e.KeyIsPressed(ebiten.KeyShift) {
+				c.RA.Y -= gg.Pi * p.MoveSpeed * dt
+			} else {
+				c.RA.Y += gg.Pi * p.MoveSpeed * dt
+			}
+		case ebiten.KeyV:
+			if e.KeyIsPressed(ebiten.KeyShift) {
+				tri.R -= gg.Pi * 0.3 * dt
+			} else {
+				tri.R += gg.Pi * 0.3 * dt
+			}
+		case ebiten.KeyLeftBracket:
+			if e.KeyIsPressed(ebiten.KeyShift) {
+				rect.R -= gg.Pi * 0.3 * dt
+			} else {
+				rect.R += gg.Pi * 0.3 * dt
+			}
+		case ebiten.Key0:
+			e.Del(p)
+		case ebiten.KeyB:
+			if p.Layer != PlayerL {
+				p.Layer = PlayerL
+			} else {
+				p.Layer = HighestL
+			}
 		}
-	case ebiten.KeyF :
+	}
-		if e.KeyIsPressed(ebiten.KeyShift) {
-			c.S.X -= gx.Pi * p.ScaleSpeed * dt
-		} else {
-			c.S.X += gx.Pi * p.ScaleSpeed * dt
-		}
-	case ebiten.KeyG :
-		if e.KeyIsPressed(ebiten.KeyShift) {
-			c.S.Y -= gx.Pi * p.ScaleSpeed * dt
-		} else {
-			c.S.Y += gx.Pi * p.ScaleSpeed * dt
-		}
-	case ebiten.KeyZ :
-		if e.KeyIsPressed(ebiten.KeyShift) {
-			c.RA.X -= gx.Pi * p.MoveSpeed * dt
-		} else {
-			c.RA.X += gx.Pi * p.MoveSpeed * dt
-		}
-	case ebiten.KeyX :
-		if e.KeyIsPressed(ebiten.KeyShift) {
-			c.RA.Y -= gx.Pi * p.MoveSpeed * dt
-		} else {
-			c.RA.Y += gx.Pi * p.MoveSpeed * dt
-		}
-	case ebiten.KeyV :
-		if e.KeyIsPressed(ebiten.KeyShift) {
-			tri.R -= gx.Pi * 0.3 * dt
-		} else {
-			tri.R += gx.Pi * 0.3 * dt
-		}
-	case ebiten.KeyLeftBracket :
-		if e.KeyIsPressed(ebiten.KeyShift) {
-			rect.R -= gx.Pi * 0.3 * dt
-		} else {
-			rect.R += gx.Pi * 0.3 * dt
-		}
-	case ebiten.Key0 :
-		e.Del(p)
-	case ebiten.KeyB :
-		if p.Layer != PlayerL {
-			p.Layer = PlayerL
-		} else {
-			p.Layer = HighestL
-		}
-	}}
 
 	return nil
 }
 
 func (d *Debug) Draw(
-	e *gx.Engine,
+	e *gg.Engine,
-	i *gx.Image,
+	i *gg.Image,
 ) {
 	keyStrs := []string{}
 	for _, k := range e.Keys() {
 		keyStrs = append(keyStrs, k.String())
 	}
-	
+
 	if rectMove.Vertices().Contained(rect).Len() > 0 ||
-			rect.Vertices().Contained(rectMove).Len() > 0 {
+		rect.Vertices().Contained(rectMove).Len() > 0 {
 		keyStrs = append(keyStrs, "THIS IS SHIT")
 	}
-	
+
 	e.DebugPrint(i,
 		strings.Join(keyStrs, ", "))
-	
+
 }
 
-func (d *Debug) IsVisible() bool {return true}
+func (d *Debug) IsVisible() bool { return true }
 
 func main() {
-	e := gx.NewEngine(&gx.WindowConfig{
+	e := gg.NewEngine(&gg.WindowConfig{
-		Title: "Test title",
+		Title:  "Test title",
-		Width: 720,
+		Width:  720,
 		Height: 480,
-		VSync: true,
+		VSync:  true,
 	})
 
 	var err error
-	playerImg, err = gx.LoadImage(bytes.NewReader(images.Runner_png))
+	playerImg, err = gg.LoadImage(bytes.NewReader(images.Runner_png))
 	if err != nil {
 		log.Fatal(err)
 	}
 
-
 	player = NewPlayer()
 	rect = NewRect()
 	tri = NewTri()
-	
+
 	e.Add(&Debug{})
 	e.Add(player)
 	e.Add(rect)
 	e.Add(tri)
 	fmt.Println(rect.GetLayer(), player.GetLayer())
-	
+
 	e.Run()
 }

collider.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 // Implementing the interface lets 
 // the engine to work faster about

debug.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2/ebitenutil"

elipse.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 // The structure represents elipses.
 type Elipse struct {

engine.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

errors.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"errors"

gix/main.go

@@ -1,6 +0,0 @@
-package gix
-
-import (
-)
-
-

go.mod

@@ -1,4 +1,4 @@
-module github.com/surdeus/gox
+module github.com/reklesio/gg
 
 go 1.20
 

gx/misc.go

@@ -1,3 +0,0 @@
-package gx
-
-

img.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

keys.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

line.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"math"

math.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"math"

matrix.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

misc.go

@@ -0,0 +1,3 @@
+package gg
+
+

object.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 // Implementing the interface type
 // will call the function OnStart

polygon.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 )

ray.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 // The type represents math ray.
 type Ray struct {

readme.md

@@ -1,4 +1,8 @@
-# gox
+# gg
 
-2D graphcs engine based on [ebiten](https://github.com/hajimehoshi/ebiten).
+![Insert here a gopher, please](https://raw.githubusercontent.com/reklesio/gg/master/media/gopher.png)
+
+Golang Graphics, Gopher Games or Good Game engine for 2D applications.
+
+Basing on [ebiten](https://github.com/hajimehoshi/ebiten).
 

rect.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

shader.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

sprite.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"

time.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"time"

transform.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	//"github.com/hajimehoshi/ebiten/v2"

triangle.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	"math"

vector.go

@@ -1,4 +1,4 @@
-package gx
+package gg
 
 import (
 	//"github.com/hajimehoshi/ebiten/v2"