ben/games
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

holy shit components are rendering whaaaaaaaaaaaaaaaat

Browse Source
This commit is contained in:
Ben Vezzani
2025-08-28 14:32:23 -04:00
parent 573396054f
commit ec5dceca78
12 changed files with 370 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
common/elements/v1/block.go
View File

@@ -1,28 +0,0 @@
package elements
import (
"github.com/hajimehoshi/ebiten/v2"
)
type BlockOption func(*block)
func Block(ops ...BlockOption) ElementFunc {
return func(d Dimensions) Element {
b := block{}
for i := range ops {
ops[i](&b)
}
return &b
}
}
type block struct {
width float64
height float64
xAlign xAlign
yAlign yAlign
}
func (b block) Draw(image *ebiten.Image, anchorX, anchorY float64) (w, h float64) {
return b.width, b.height
}

57
common/elements/v1/blocks/block.go Normal file
View File

@@ -0,0 +1,57 @@
package blocks
import (
"image/color"
"git.vezzani.net/ben/games/common/elements/v1"
"git.vezzani.net/ben/games/common/elements/v1/mouse"
"github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2/vector"
)
func New(ops ...Option) elements.ElementFunc {
return func(d elements.Dimensions) elements.Element {
b := Block{
parentDimensions: d,
}
for i := range ops {
ops[i](&b)
}
return &b
}
}
type Block struct {
parentDimensions elements.Dimensions
backgroundColor *color.Color
mouse.NopHandler
width float64
height float64
}
func (b *Block) Size() (w, h float64) {
w, h = b.parentDimensions.WX, b.parentDimensions.WY
if b.width != 0 {
w = b.width
}
if b.height != 0 {
h = b.height
}
return
}
func (b *Block) Draw(image *ebiten.Image, _, _ float64) (w, h float64) {
w, h = b.Size()
if b.backgroundColor != nil {
vector.DrawFilledRect(
image,
float32(b.parentDimensions.ZX),
float32(b.parentDimensions.ZY),
float32(w),
float32(h),
*b.backgroundColor,
true,
)
}
return
}

17
common/elements/v1/blocks/options.go Normal file
View File

@@ -0,0 +1,17 @@
package blocks
import "image/color"
type Option func(*Block)
func Size(w, h float64) Option {
return func(b *Block) {
b.width, b.height = w, h
}
}
func BackgroundColor(c color.Color) Option {
return func(b *Block) {
b.backgroundColor = &c
}
}

140
common/elements/v1/button.go
View File

@@ -1,74 +1,70 @@
package elements
import (
"context"
"image/color"
"github.com/hajimehoshi/ebiten/v2"
"github.com/hajimehoshi/ebiten/v2/vector"
"golang.org/x/image/font"
)
import "git.vezzani.net/ben/games/common/ux/v1"
type xAlign int
type yAlign int
const (
AlignCente xAlign = iota
AlignLeft
AlignRight
)
const (
AlignCenter yAlign = iota
AlignTop
AlignBottom
)
type Button struct {
mouseHandler
block
Label string
OnClick func() error
OnRightClick func() error
Style struct {
MouseDownColor *color.Color
}
}
func (b *Button) HandleClick(_ MouseState) error {
if b.OnClick == nil {
return nil
}
return b.OnClick()
}
func (b *Button) getFont() font.Face {
if b.block.block.Font == nil {
return ux.FontFace
}
return *b.block.block.Font
}
func (b *Button) backgroundColor() color.Color {
var c *color.Color
if b.block.block.BackgroundColor != nil {
c = b.block.block.BackgroundColor
} else {
c = &ux.BackgroundColor
}
if (b.mouseState.RightDown || b.mouseState.LeftDown) && b.Style.MouseDownColor != nil {
c = b.Style.MouseDownColor
}
return *c
}
func (b *Button) Draw(ctx context.Context, image *ebiten.Image) error {
vector.StrokeRect(image, xz, yz, w, h, 1, b.backgroundColor(), true)
return nil
}
//
//import (
// "image/color"
//)
//
//type xAlign int
//type yAlign int
//
//const (
// AlignCente xAlign = iota
// AlignLeft
// AlignRight
//)
//
//const (
// AlignCenter yAlign = iota
// AlignTop
// AlignBottom
//)
//
//type Button struct {
// mouseHandler
// block
// Label string
// OnClick func() error
// OnRightClick func() error
// Style struct {
// MouseDownColor *color.Color
// }
//}
//
//func (b *Button) HandleClick(_ MouseState) error {
// if b.OnClick == nil {
// return nil
// }
// return b.OnClick()
//}
//
//
//func (b *Button) getFont() font.Face {
// if b.block.Font == nil {
// return ux.FontFace
// }
//
// return *b.block.block.Font
//}
//
//func (b *Button) backgroundColor() color.Color {
// var c *color.Color
// if b.block.block.BackgroundColor != nil {
// c = b.block.block.BackgroundColor
// } else {
// c = &ux.BackgroundColor
// }
//
// if (b.mouseState.RightDown || b.mouseState.LeftDown) && b.Style.MouseDownColor != nil {
// c = b.Style.MouseDownColor
// }
//
// return *c
//}
//
//func (b *Button) Draw(ctx context.Context, image *ebiten.Image) error {
//
// vector.StrokeRect(image, xz, yz, w, h, 1, b.backgroundColor(), true)
//
// return nil
//}

40
common/elements/v1/element.go
View File

@@ -25,44 +25,12 @@ type Mouseable interface {
}
type Element interface {
Mouseable
Clickable
Draw(image *ebiten.Image, anchorX, anchorY float64) (w, h float64)
}
type Dimensions struct {
zx, zy float64
wx, wy float64
}
type mouseHandler struct {
mouseState MouseState
prevMouseState MouseState
}
func (b *mouseHandler) HandleMouseEnter(s MouseState) error {
b.mouseState = s
return nil
}
func (b *mouseHandler) HandleMouseLeave(s MouseState) error {
b.prevMouseState = b.mouseState
b.mouseState = MouseState{}
return nil
}
func (b *mouseHandler) HandleMouseMove(s MouseState) error {
b.prevMouseState = b.mouseState
b.mouseState = s
return nil
}
func (b *mouseHandler) HandleMouseDown(s MouseState) error {
b.prevMouseState = b.mouseState
b.mouseState = s
return nil
}
func (b *mouseHandler) HandleMouseUp(s MouseState) error {
b.prevMouseState = b.mouseState
b.mouseState = s
return nil
ZX, ZY float64
WX, WY float64
}

29
common/elements/v1/mouse/mouse.go Normal file
View File

@@ -0,0 +1,29 @@
package mouse
import "git.vezzani.net/ben/games/common/elements/v1"
type NopHandler struct{}
func (n NopHandler) HandleClick(s elements.MouseState) error {
return nil
}
func (n NopHandler) HandleMouseEnter(s elements.MouseState) error {
return nil
}
func (n NopHandler) HandleMouseLeave(s elements.MouseState) error {
return nil
}
func (n NopHandler) HandleMouseMove(s elements.MouseState) error {
return nil
}
func (n NopHandler) HandleMouseDown(s elements.MouseState) error {
return nil
}
func (n NopHandler) HandleMouseUp(s elements.MouseState) error {
return nil
}

31
common/elements/v1/stack.go
View File

@@ -1,31 +0,0 @@
package elements
import "github.com/hajimehoshi/ebiten/v2"
type StackOption func(*stack)
func Stack(ops ...StackOption) ElementFunc {
return func(parentDimensions Dimensions) Element {
}
}
type stack struct {
block
horizontal bool
children []Element
}
func (s *stack) Draw(image *ebiten.Image, anchorX, anchorY float64) (w, h float64) {
var offsetX, offsetY float64
originalX, originalY := anchorX, anchorY
for i := range s.children {
offsetX, offsetY = s.children[i].Draw(image, anchorX, anchorY)
if s.horizontal {
anchorX += offsetX
} else {
anchorY += offsetY
}
}
return anchorX - originalX, anchorY - originalY
}

20
common/elements/v1/stacks/options.go Normal file
View File

@@ -0,0 +1,20 @@
package stacks
import (
"git.vezzani.net/ben/games/common/elements/v1"
"git.vezzani.net/ben/games/common/elements/v1/blocks"
)
type Option func(*Stack)
func BlockOpt(o blocks.Option) Option {
return func(s *Stack) {
o(&s.Block)
}
}
func Children(children ...elements.ElementFunc) Option {
return func(s *Stack) {
s.children = children
}
}

48
common/elements/v1/stacks/stack.go Normal file
View File

@@ -0,0 +1,48 @@
package stacks
import (
"git.vezzani.net/ben/games/common/elements/v1"
"git.vezzani.net/ben/games/common/elements/v1/blocks"
"git.vezzani.net/ben/games/common/elements/v1/mouse"
"github.com/hajimehoshi/ebiten/v2"
)
func New(ops ...Option) elements.ElementFunc {
return func(parentDimensions elements.Dimensions) elements.Element {
s := Stack{}
for op := range ops {
ops[op](&s)
}
return &s
}
}
type Stack struct {
blocks.Block
mouse.NopHandler
horizontal bool
children []elements.ElementFunc
}
func (s *Stack) Draw(image *ebiten.Image, anchorX, anchorY float64) (w, h float64) {
s.Block.Draw(image, anchorX, anchorY)
var offsetX, offsetY float64
originalX, originalY := anchorX, anchorY
d := elements.Dimensions{
ZX: originalX,
ZY: originalY,
}
d.WX, d.WY = s.Block.Size()
for i := range s.children {
offsetX, offsetY = s.children[i](d).Draw(image, anchorX, anchorY)
if s.horizontal {
anchorX += offsetX
} else {
anchorY += offsetY
}
}
return anchorX - originalX, anchorY - originalY
}

181
common/elements/v1/table.go
View File

@@ -1,92 +1,93 @@
package elements
import (
"context"
"fmt"
"github.com/hajimehoshi/ebiten/v2"
)
type Table struct {
mouseHandler
block
ColumnCount int
RowCount int
Cells []Dimensions
Style struct {
}
mouseOverCell int
}
func (t *Table) HandleClick(ctx context.Context, s MouseState) error {
address := t.getAddressUnderMouse()
if address < 0 || address >= len(t.Cells) {
return fmt.Errorf("cell address under mouse is out of bounds")
}
if clickable, ok := t.Cells[address].(Clickable); ok {
return clickable.HandleClick(s)
}
return nil
}
func (t *Table) HandleMouseEnter(ctx context.Context, s MouseState) error {
_ = t.mouseHandler.HandleMouseEnter(s)
address := t.getAddressUnderMouse()
if address < 0 || address >= len(t.Cells) {
return fmt.Errorf("cell address under mouse is out of bounds")
}
if mouseable, ok := t.Cells[address].(Mouseable); ok {
s.X -=
return mouseable.HandleMouseEnter(s)
}
return nil
}
func (t *Table) HandleMouseLeave(ctx context.Context, s MouseState) error {
_ = t.mouseHandler.HandleMouseLeave(s)
return nil
}
func (t *Table) HandleMouseMove(ctx context.Context, s MouseState) error {
_ = t.mouseHandler.HandleMouseMove(s)
return nil
}
func (t *Table) HandleMouseDown(ctx context.Context, s MouseState) error {
_ = t.mouseHandler.HandleMouseDown(s)
return nil
}
func (t *Table) HandleMouseUp(ctx context.Context, s MouseState) error {
_ = t.mouseHandler.HandleMouseUp(s)
return nil
}
func (t *Table) CellSize() (w, h float32) {
w, h = t.
return w / float32(t.ColumnCount), h / float32(t.RowCount)
}
func (t *Table) CellZero(ctx context.Context, addr int) (x, y float32) {
x, y = GetZero(ctx)
w, h := t.CellSize(ctx)
col, row := addr%t.ColumnCount, addr/t.ColumnCount
return x + float32(col)*w, y + float32(row) + h
}
func (t *Table) Draw(screen *ebiten.Image, zx, zy float64) error {
return nil
}
func (t *Table) getAddressUnderMouse() int {
return int(t.mouseState.Y)*t.RowCount + int(t.mouseState.X)
}
//
//import (
// "context"
// "fmt"
//
// "github.com/hajimehoshi/ebiten/v2"
//)
//
//type Table struct {
// mouseHandler
// block
//
// ColumnCount int
// RowCount int
//
// Cells []Dimensions
//
// Style struct {
// }
//
// mouseOverCell int
//}
//
//func (t *Table) HandleClick(ctx context.Context, s MouseState) error {
// address := t.getAddressUnderMouse()
// if address < 0 || address >= len(t.Cells) {
// return fmt.Errorf("cell address under mouse is out of bounds")
// }
//
// if clickable, ok := t.Cells[address].(Clickable); ok {
// return clickable.HandleClick(s)
// }
//
// return nil
//}
//
//func (t *Table) HandleMouseEnter(ctx context.Context, s MouseState) error {
// _ = t.mouseHandler.HandleMouseEnter(s)
// address := t.getAddressUnderMouse()
// if address < 0 || address >= len(t.Cells) {
// return fmt.Errorf("cell address under mouse is out of bounds")
// }
//
// if mouseable, ok := t.Cells[address].(Mouseable); ok {
// s.X -=
// return mouseable.HandleMouseEnter(s)
// }
//
// return nil
//}
//
//func (t *Table) HandleMouseLeave(ctx context.Context, s MouseState) error {
// _ = t.mouseHandler.HandleMouseLeave(s)
// return nil
//}
//
//func (t *Table) HandleMouseMove(ctx context.Context, s MouseState) error {
// _ = t.mouseHandler.HandleMouseMove(s)
// return nil
//}
//
//func (t *Table) HandleMouseDown(ctx context.Context, s MouseState) error {
// _ = t.mouseHandler.HandleMouseDown(s)
// return nil
//}
//
//func (t *Table) HandleMouseUp(ctx context.Context, s MouseState) error {
// _ = t.mouseHandler.HandleMouseUp(s)
// return nil
//}
//
//func (t *Table) CellSize() (w, h float32) {
// w, h = t.
// return w / float32(t.ColumnCount), h / float32(t.RowCount)
//}
//
//func (t *Table) CellZero(ctx context.Context, addr int) (x, y float32) {
// x, y = GetZero(ctx)
// w, h := t.CellSize(ctx)
//
// col, row := addr%t.ColumnCount, addr/t.ColumnCount
// return x + float32(col)*w, y + float32(row) + h
//}
//
//func (t *Table) Draw(screen *ebiten.Image, zx, zy float64) error {
// return nil
//}
//
//func (t *Table) getAddressUnderMouse() int {
// return int(t.mouseState.Y)*t.RowCount + int(t.mouseState.X)
//}

40
tools/spritedit/editor.go
View File

@@ -1,21 +1,47 @@
package main
import "github.com/hajimehoshi/ebiten/v2"
import (
"image/color"
"git.vezzani.net/ben/games/common/elements/v1"
"git.vezzani.net/ben/games/common/elements/v1/blocks"
"git.vezzani.net/ben/games/common/elements/v1/stacks"
"git.vezzani.net/ben/games/common/sprites/v1"
"github.com/hajimehoshi/ebiten/v2"
)
var menu = stacks.New(
stacks.BlockOpt(blocks.BackgroundColor(color.White)),
stacks.BlockOpt(blocks.Size(100, 100)),
stacks.Children(
blocks.New(),
blocks.New(),
),
)
func newEditor() *editor {
return &editor{}
}
type editor struct {
}
func (e *editor) Update() error {
//TODO implement me
panic("implement me")
sprites.Update()
return nil
}
func (e *editor) Draw(screen *ebiten.Image) {
//TODO implement me
panic("implement me")
b := screen.Bounds()
menu(elements.Dimensions{
ZX: float64(b.Min.X),
ZY: float64(b.Min.Y),
WX: float64(b.Max.X),
WY: float64(b.Max.Y),
}).Draw(screen, 0, 0)
}
func (e *editor) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
//TODO implement me
panic("implement me")
return outsideWidth, outsideHeight
}

6
tools/spritedit/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"bytes"
"github.com/hajimehoshi/ebiten/v2"
)
func main() {
ebiten.SetWindowSize(480, 320)
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
if err := ebiten.RunGame(); err != nil {
ebiten.SetWindowTitle("Sprite Editor")
e := newEditor()
if err := ebiten.RunGame(e); err != nil {
panic(err)
}
}