core/gg
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rebranding.

Browse source
This commit is contained in:
Andrey Parhomenko 2023-10-23 15:45:18 +03:00
parent d0aeb9d9e4
commit 27b803e4e5
30 changed files with 193 additions and 196 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

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

2
gx/camera.go → camera.go
View file

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

7
cmd/math/main.go
View file

@ -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())
}

317
cmd/test/main.go
View file

@ -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
MoveSpeed gx.Float
ScaleSpeed gx.Float
gx.Layer
*gg.Sprite
MoveSpeed gg.Float
ScaleSpeed gg.Float
gg.Layer
}
type Debug struct{
gx.Layer
type Debug struct {
gg.Layer
}
type Rect struct {
*gx.DrawableRectangle
gx.Layer
*gg.DrawableRectangle
gg.Layer
}
type Tri struct {
*gx.DrawablePolygon
gx.Layer
*gg.DrawablePolygon
gg.Layer
}
func NewTri() *Tri {
ret := &Tri{}
ret.DrawablePolygon = &gx.DrawablePolygon{}
ret.Transform.S = gx.V(1, 1)
ret.Triangles = gx.Triangles{
gx.Triangle{
gx.V(0, 0),
gx.V(100, 100),
gx.V(0, -50),
ret.DrawablePolygon = &gg.DrawablePolygon{}
ret.Transform.S = gg.V(1, 1)
ret.Triangles = gg.Triangles{
gg.Triangle{
gg.V(0, 0),
gg.V(100, 100),
gg.V(0, -50),
},
gx.Triangle{
gx.V(0, 0),
gx.V(-100, -100),
gx.V(0, 50),
gg.Triangle{
gg.V(0, 0),
gg.V(-100, -100),
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{
Rectangle: gx.Rectangle{
Transform: gx.Transform{
S: gx.Vector{
X: 200,
Y: 400,
},
ret := &Rect{&gg.DrawableRectangle{
Rectangle: gg.Rectangle{
Transform: gg.Transform{
S: gg.Vector{
X: 200,
Y: 400,
},
},
Color: gx.Color{
gx.MaxColorV,
0,
0,
gx.MaxColorV,
},
Color: gg.Color{
gg.MaxColorV,
0,
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
player *Player
rectMove gx.Rectangle
rect *Rect
tri *Tri
playerImg *gg.Image
player *Player
rectMove gg.Rectangle
rect *Rect
tri *Tri
)
func NewPlayer() *Player {
ret := &Player{
Sprite: &gx.Sprite{
Transform: gx.Transform {
S: gx.Vector{5, 5},
RA: gx.Vector{.5, .5},
Sprite: &gg.Sprite{
Transform: gg.Transform{
S: gg.Vector{5, 5},
RA: gg.Vector{.5, .5},
},
Visible: true,
ShaderOptions: gx.ShaderOptions {
Shader: gx.SolidWhiteColorShader,
Uniforms: make(map[string] any),
ShaderOptions: gg.ShaderOptions{
Shader: gg.SolidWhiteColorShader,
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 {
case ebiten.KeyArrowUp :
c.P.Y += p.MoveSpeed * dt
case ebiten.KeyArrowLeft :
c.P.X -= p.MoveSpeed * dt
case ebiten.KeyArrowDown :
c.P.Y -= p.MoveSpeed * dt
case ebiten.KeyArrowRight :
c.P.X += p.MoveSpeed * dt
case ebiten.KeyW :
p.P.Y += p.MoveSpeed * dt
case ebiten.KeyA :
p.P.X -= p.MoveSpeed * dt
case ebiten.KeyS :
p.P.Y -= p.MoveSpeed * dt
case ebiten.KeyD :
p.P.X += p.MoveSpeed * dt
case ebiten.KeyR :
c.R += gx.Pi * p.ScaleSpeed * dt
case ebiten.KeyT :
c.R -= gx.Pi * p.ScaleSpeed * dt
case ebiten.KeyRightBracket :
if e.KeyIsPressed(ebiten.KeyShift) {
p.R -= gx.Pi * 0.3 * dt
} else {
p.R += gx.Pi * 0.3 * dt
for _, v := range keys {
switch v {
case ebiten.KeyArrowUp:
c.P.Y += p.MoveSpeed * dt
case ebiten.KeyArrowLeft:
c.P.X -= p.MoveSpeed * dt
case ebiten.KeyArrowDown:
c.P.Y -= p.MoveSpeed * dt
case ebiten.KeyArrowRight:
c.P.X += p.MoveSpeed * dt
case ebiten.KeyW:
p.P.Y += p.MoveSpeed * dt
case ebiten.KeyA:
p.P.X -= p.MoveSpeed * dt
case ebiten.KeyS:
p.P.Y -= p.MoveSpeed * dt
case ebiten.KeyD:
p.P.X += p.MoveSpeed * dt
case ebiten.KeyR:
c.R += gg.Pi * p.ScaleSpeed * dt
case ebiten.KeyT:
c.R -= gg.Pi * p.ScaleSpeed * dt
case ebiten.KeyRightBracket:
if e.KeyIsPressed(ebiten.KeyShift) {
p.R -= gg.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,
i *gx.Image,
e *gg.Engine,
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{
Title: "Test title",
Width: 720,
e := gg.NewEngine(&gg.WindowConfig{
Title: "Test title",
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()
}

2
gx/collider.go → collider.go
View file

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

2
gx/debug.go → debug.go
View file

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

2
gx/elipse.go → elipse.go
View file

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

2
gx/engine.go → engine.go
View file

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

2
gx/errors.go → errors.go
View file

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

6
gix/main.go
View file

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

2
go.mod
View file

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

3
gx/misc.go
View file

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

2
gx/img.go → img.go
View file

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

2
gx/keys.go → keys.go
View file

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

2
gx/line.go → line.go
View file

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

2
gx/math.go → math.go
View file

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

2
gx/matrix.go → matrix.go
View file

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

BIN
media/gopher.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 172 KiB

3
misc.go Normal file
View file

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

2
gx/object.go → object.go
View file

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

2
gx/polygon.go → polygon.go
View file

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

2
gx/ray.go → ray.go
View file

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

8
readme.md
View file

@ -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).

2
gx/rect.go → rect.go
View file

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

2
gx/shader.go → shader.go
View file

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

2
gx/sprite.go → sprite.go
View file

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

2
gx/time.go → time.go
View file

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

2
gx/transform.go → transform.go
View file

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

2
gx/triangle.go → triangle.go
View file

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

2
gx/vector.go → vector.go
View file

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