* All private Doodle source code into the pkg/ folder. * Potentially public code into the lib/ folder. * Centralize the logger into a subpackage.master
commit
cddc41465f
15 changed files with 1309 additions and 0 deletions
@ -0,0 +1,192 @@ |
||||
package render |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"errors" |
||||
"fmt" |
||||
"image/color" |
||||
"regexp" |
||||
"strconv" |
||||
) |
||||
|
||||
var ( |
||||
// Regexps to parse hex color codes. Three formats are supported:
|
||||
// * reHexColor3 uses only 3 hex characters, like #F90
|
||||
// * reHexColor6 uses standard 6 characters, like #FF9900
|
||||
// * reHexColor8 is the standard 6 plus alpha channel, like #FF9900FF
|
||||
reHexColor3 = regexp.MustCompile(`^([A-Fa-f0-9])([A-Fa-f0-9])([A-Fa-f0-9])$`) |
||||
reHexColor6 = regexp.MustCompile(`^([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})$`) |
||||
reHexColor8 = regexp.MustCompile(`^([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})$`) |
||||
) |
||||
|
||||
// Color holds an RGBA color value.
|
||||
type Color struct { |
||||
Red uint8 |
||||
Green uint8 |
||||
Blue uint8 |
||||
Alpha uint8 |
||||
} |
||||
|
||||
// RGBA creates a new Color.
|
||||
func RGBA(r, g, b, a uint8) Color { |
||||
return Color{ |
||||
Red: r, |
||||
Green: g, |
||||
Blue: b, |
||||
Alpha: a, |
||||
} |
||||
} |
||||
|
||||
// FromColor creates a render.Color from a Go color.Color
|
||||
func FromColor(from color.Color) Color { |
||||
// downscale a 16-bit color value to 8-bit. input range 0x0000..0xffff
|
||||
downscale := func(in uint32) uint8 { |
||||
var scale = float64(in) / 0xffff |
||||
return uint8(scale * 0xff) |
||||
} |
||||
r, g, b, a := from.RGBA() |
||||
return RGBA( |
||||
downscale(r), |
||||
downscale(g), |
||||
downscale(b), |
||||
downscale(a), |
||||
) |
||||
} |
||||
|
||||
// MustHexColor parses a color from hex code or panics.
|
||||
func MustHexColor(hex string) Color { |
||||
color, err := HexColor(hex) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
return color |
||||
} |
||||
|
||||
// HexColor parses a color from hexadecimal code.
|
||||
func HexColor(hex string) (Color, error) { |
||||
c := Black // default color
|
||||
|
||||
if len(hex) > 0 && hex[0] == '#' { |
||||
hex = hex[1:] |
||||
} |
||||
|
||||
var m []string |
||||
if len(hex) == 3 { |
||||
m = reHexColor3.FindStringSubmatch(hex) |
||||
} else if len(hex) == 6 { |
||||
m = reHexColor6.FindStringSubmatch(hex) |
||||
} else if len(hex) == 8 { |
||||
m = reHexColor8.FindStringSubmatch(hex) |
||||
} else { |
||||
return c, errors.New("not a valid length for color code; only 3, 6 and 8 supported") |
||||
} |
||||
|
||||
// Any luck?
|
||||
if m == nil { |
||||
return c, errors.New("not a valid hex color code") |
||||
} |
||||
|
||||
// Parse the color values. 16=base, 8=bit size
|
||||
red, _ := strconv.ParseUint(m[1], 16, 8) |
||||
green, _ := strconv.ParseUint(m[2], 16, 8) |
||||
blue, _ := strconv.ParseUint(m[3], 16, 8) |
||||
|
||||
// Alpha channel available?
|
||||
var alpha uint64 = 255 |
||||
if len(m) == 5 { |
||||
alpha, _ = strconv.ParseUint(m[4], 16, 8) |
||||
} |
||||
|
||||
c.Red = uint8(red) |
||||
c.Green = uint8(green) |
||||
c.Blue = uint8(blue) |
||||
c.Alpha = uint8(alpha) |
||||
return c, nil |
||||
} |
||||
|
||||
func (c Color) String() string { |
||||
return fmt.Sprintf( |
||||
"Color<#%02x%02x%02x+%02x>", |
||||
c.Red, c.Green, c.Blue, c.Alpha, |
||||
) |
||||
} |
||||
|
||||
// ToColor converts a render.Color into a Go standard color.Color
|
||||
func (c Color) ToColor() color.RGBA { |
||||
return color.RGBA{ |
||||
R: c.Red, |
||||
G: c.Green, |
||||
B: c.Blue, |
||||
A: c.Alpha, |
||||
} |
||||
} |
||||
|
||||
// Transparent returns whether the alpha channel is zeroed out and the pixel
|
||||
// won't appear as anything when rendered.
|
||||
func (c Color) Transparent() bool { |
||||
return c.Alpha == 0x00 |
||||
} |
||||
|
||||
// MarshalJSON serializes the Color for JSON.
|
||||
func (c Color) MarshalJSON() ([]byte, error) { |
||||
return []byte(fmt.Sprintf( |
||||
`"#%02x%02x%02x"`, |
||||
c.Red, c.Green, c.Blue, |
||||
)), nil |
||||
} |
||||
|
||||
// UnmarshalJSON reloads the Color from JSON.
|
||||
func (c *Color) UnmarshalJSON(b []byte) error { |
||||
var hex string |
||||
err := json.Unmarshal(b, &hex) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
parsed, err := HexColor(hex) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
c.Red = parsed.Red |
||||
c.Blue = parsed.Blue |
||||
c.Green = parsed.Green |
||||
c.Alpha = parsed.Alpha |
||||
return nil |
||||
} |
||||
|
||||
// Add a relative color value to the color.
|
||||
func (c Color) Add(r, g, b, a int32) Color { |
||||
var ( |
||||
R = int32(c.Red) + r |
||||
G = int32(c.Green) + g |
||||
B = int32(c.Blue) + b |
||||
A = int32(c.Alpha) + a |
||||
) |
||||
|
||||
cap8 := func(v int32) uint8 { |
||||
if v > 255 { |
||||
v = 255 |
||||
} else if v < 0 { |
||||
v = 0 |
||||
} |
||||
return uint8(v) |
||||
} |
||||
|
||||
return Color{ |
||||
Red: cap8(R), |
||||
Green: cap8(G), |
||||
Blue: cap8(B), |
||||
Alpha: cap8(A), |
||||
} |
||||
} |
||||
|
||||
// Lighten a color value.
|
||||
func (c Color) Lighten(v int32) Color { |
||||
return c.Add(v, v, v, 0) |
||||
} |
||||
|
||||
// Darken a color value.
|
||||
func (c Color) Darken(v int32) Color { |
||||
return c.Add(-v, -v, -v, 0) |
||||
} |
||||
@ -0,0 +1,69 @@ |
||||
package render |
||||
|
||||
// TrimBox helps with Engine.Copy() to trim a destination box so that it
|
||||
// won't overflow with the parent container.
|
||||
func TrimBox(src, dst *Rect, p Point, S Rect, thickness int32) { |
||||
// Constrain source width to not bigger than Canvas width.
|
||||
if src.W > S.W { |
||||
src.W = S.W |
||||
} |
||||
if src.H > S.H { |
||||
src.H = S.H |
||||
} |
||||
|
||||
// If the destination width will cause it to overflow the widget
|
||||
// box, trim off the right edge of the destination rect.
|
||||
//
|
||||
// Keep in mind we're dealing with chunks here, and a chunk is
|
||||
// a small part of the image. Example:
|
||||
// - Canvas is 800x600 (S.W=800 S.H=600)
|
||||
// - Chunk wants to render at 790,0 width 100,100 or whatever
|
||||
// dst={790, 0, 100, 100}
|
||||
// - Chunk box would exceed 800px width (X=790 + W=100 == 890)
|
||||
// - Find the delta how much it exceeds as negative (800 - 890 == -90)
|
||||
// - Lower the Source and Dest rects by that delta size so they
|
||||
// stay proportional and don't scale or anything dumb.
|
||||
if dst.X+src.W > p.X+S.W { |
||||
// NOTE: delta is a negative number,
|
||||
// so it will subtract from the width.
|
||||
delta := (p.X + S.W - thickness) - (dst.W + dst.X) |
||||
src.W += delta |
||||
dst.W += delta |
||||
} |
||||
if dst.Y+src.H > p.Y+S.H { |
||||
// NOTE: delta is a negative number
|
||||
delta := (p.Y + S.H - thickness) - (dst.H + dst.Y) |
||||
src.H += delta |
||||
dst.H += delta |
||||
} |
||||
|
||||
// The same for the top left edge, so the drawings don't overlap
|
||||
// menu bars or left side toolbars.
|
||||
// - Canvas was placed 80px from the left of the screen.
|
||||
// Canvas.MoveTo(80, 0)
|
||||
// - A texture wants to draw at 60, 0 which would cause it to
|
||||
// overlap 20 pixels into the left toolbar. It needs to be cropped.
|
||||
// - The delta is: p.X=80 - dst.X=60 == 20
|
||||
// - Set destination X to p.X to constrain it there: 20
|
||||
// - Subtract the delta from destination W so we don't scale it.
|
||||
// - Add 20 to X of the source: the left edge of source is not visible
|
||||
if dst.X < p.X { |
||||
// NOTE: delta is a positive number,
|
||||
// so it will add to the destination coordinates.
|
||||
delta := p.X - dst.X |
||||
dst.X = p.X + thickness |
||||
dst.W -= delta |
||||
src.X += delta |
||||
} |
||||
if dst.Y < p.Y { |
||||
delta := p.Y - dst.Y |
||||
dst.Y = p.Y + thickness |
||||
dst.H -= delta |
||||
src.Y += delta |
||||
} |
||||
|
||||
// Trim the destination width so it doesn't overlap the Canvas border.
|
||||
if dst.W >= S.W-thickness { |
||||
dst.W = S.W - thickness |
||||
} |
||||
} |
||||
@ -0,0 +1,221 @@ |
||||
package render |
||||
|
||||
import ( |
||||
"fmt" |
||||
"math" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/events" |
||||
) |
||||
|
||||
// Engine is the interface for the rendering engine, keeping SDL-specific stuff
|
||||
// far away from the core of Doodle.
|
||||
type Engine interface { |
||||
Setup() error |
||||
|
||||
// Poll for events like keypresses and mouse clicks.
|
||||
Poll() (*events.State, error) |
||||
GetTicks() uint32 |
||||
WindowSize() (w, h int) |
||||
|
||||
// Present presents the current state to the screen.
|
||||
Present() error |
||||
|
||||
// Clear the full canvas and set this color.
|
||||
Clear(Color) |
||||
DrawPoint(Color, Point) |
||||
DrawLine(Color, Point, Point) |
||||
DrawRect(Color, Rect) |
||||
DrawBox(Color, Rect) |
||||
DrawText(Text, Point) error |
||||
ComputeTextRect(Text) (Rect, error) |
||||
|
||||
// Texture caching.
|
||||
NewBitmap(filename string) (Texturer, error) |
||||
Copy(t Texturer, src, dst Rect) |
||||
|
||||
// Delay for a moment using the render engine's delay method,
|
||||
// implemented by sdl.Delay(uint32)
|
||||
Delay(uint32) |
||||
|
||||
// Tasks that the Setup function should defer until tear-down.
|
||||
Teardown() |
||||
|
||||
Loop() error // maybe?
|
||||
} |
||||
|
||||
// Texturer is a stored image texture used by the rendering engine while
|
||||
// abstracting away its inner workings.
|
||||
type Texturer interface { |
||||
Size() Rect |
||||
} |
||||
|
||||
// Rect has a coordinate and a width and height.
|
||||
type Rect struct { |
||||
X int32 |
||||
Y int32 |
||||
W int32 |
||||
H int32 |
||||
} |
||||
|
||||
// NewRect creates a rectangle of size `width` and `height`. The X,Y values
|
||||
// are initialized to zero.
|
||||
func NewRect(width, height int32) Rect { |
||||
return Rect{ |
||||
W: width, |
||||
H: height, |
||||
} |
||||
} |
||||
|
||||
func (r Rect) String() string { |
||||
return fmt.Sprintf("Rect<%d,%d,%d,%d>", |
||||
r.X, r.Y, r.W, r.H, |
||||
) |
||||
} |
||||
|
||||
// Point returns the rectangle's X,Y values as a Point.
|
||||
func (r Rect) Point() Point { |
||||
return Point{ |
||||
X: r.X, |
||||
Y: r.Y, |
||||
} |
||||
} |
||||
|
||||
// Bigger returns if the given rect is larger than the current one.
|
||||
func (r Rect) Bigger(other Rect) bool { |
||||
// TODO: don't know why this is !
|
||||
return !(other.X < r.X || // Lefter
|
||||
other.Y < r.Y || // Higher
|
||||
other.W > r.W || // Wider
|
||||
other.H > r.H) // Taller
|
||||
} |
||||
|
||||
// Intersects with the other rectangle in any way.
|
||||
func (r Rect) Intersects(other Rect) bool { |
||||
// Do a bidirectional compare.
|
||||
compare := func(a, b Rect) bool { |
||||
var corners = []Point{ |
||||
NewPoint(b.X, b.Y), |
||||
NewPoint(b.X, b.Y+b.H), |
||||
NewPoint(b.X+b.W, b.Y), |
||||
NewPoint(b.X+b.W, b.Y+b.H), |
||||
} |
||||
for _, pt := range corners { |
||||
if pt.Inside(a) { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
return compare(r, other) || compare(other, r) || false |
||||
} |
||||
|
||||
// IsZero returns if the Rect is uninitialized.
|
||||
func (r Rect) IsZero() bool { |
||||
return r.X == 0 && r.Y == 0 && r.W == 0 && r.H == 0 |
||||
} |
||||
|
||||
// Add another rect.
|
||||
func (r Rect) Add(other Rect) Rect { |
||||
return Rect{ |
||||
X: r.X + other.X, |
||||
Y: r.Y + other.Y, |
||||
W: r.W + other.W, |
||||
H: r.H + other.H, |
||||
} |
||||
} |
||||
|
||||
// Add a point to move the rect.
|
||||
func (r Rect) AddPoint(other Point) Rect { |
||||
return Rect{ |
||||
X: r.X + other.X, |
||||
Y: r.Y + other.Y, |
||||
W: r.W, |
||||
H: r.H, |
||||
} |
||||
} |
||||
|
||||
// Text holds information for drawing text.
|
||||
type Text struct { |
||||
Text string |
||||
Size int |
||||
Color Color |
||||
Padding int32 |
||||
PadX int32 |
||||
PadY int32 |
||||
Stroke Color // Stroke color (if not zero)
|
||||
Shadow Color // Drop shadow color (if not zero)
|
||||
FontFilename string // Path to *.ttf file on disk
|
||||
} |
||||
|
||||
func (t Text) String() string { |
||||
return fmt.Sprintf(`Text<"%s" %dpx %s>`, t.Text, t.Size, t.Color) |
||||
} |
||||
|
||||
// IsZero returns if the Text is the zero value.
|
||||
func (t Text) IsZero() bool { |
||||
return t.Text == "" && t.Size == 0 && t.Color == Invisible && t.Padding == 0 && t.Stroke == Invisible && t.Shadow == Invisible |
||||
} |
||||
|
||||
// Common color names.
|
||||
var ( |
||||
Invisible = Color{} |
||||
White = RGBA(255, 255, 255, 255) |
||||
Grey = RGBA(153, 153, 153, 255) |
||||
Black = RGBA(0, 0, 0, 255) |
||||
SkyBlue = RGBA(0, 153, 255, 255) |
||||
Blue = RGBA(0, 0, 255, 255) |
||||
DarkBlue = RGBA(0, 0, 153, 255) |
||||
Red = RGBA(255, 0, 0, 255) |
||||
DarkRed = RGBA(153, 0, 0, 255) |
||||
Green = RGBA(0, 255, 0, 255) |
||||
DarkGreen = RGBA(0, 153, 0, 255) |
||||
Cyan = RGBA(0, 255, 255, 255) |
||||
DarkCyan = RGBA(0, 153, 153, 255) |
||||
Yellow = RGBA(255, 255, 0, 255) |
||||
DarkYellow = RGBA(153, 153, 0, 255) |
||||
Magenta = RGBA(255, 0, 255, 255) |
||||
Purple = RGBA(153, 0, 153, 255) |
||||
Pink = RGBA(255, 153, 255, 255) |
||||
) |
||||
|
||||
// IterLine is a generator that returns the X,Y coordinates to draw a line.
|
||||
// https://en.wikipedia.org/wiki/Digital_differential_analyzer_(graphics_algorithm)
|
||||
func IterLine(x1, y1, x2, y2 int32) chan Point { |
||||
generator := make(chan Point) |
||||
|
||||
go func() { |
||||
var ( |
||||
dx = float64(x2 - x1) |
||||
dy = float64(y2 - y1) |
||||
) |
||||
var step float64 |
||||
if math.Abs(dx) >= math.Abs(dy) { |
||||
step = math.Abs(dx) |
||||
} else { |
||||
step = math.Abs(dy) |
||||
} |
||||
|
||||
dx = dx / step |
||||
dy = dy / step |
||||
x := float64(x1) |
||||
y := float64(y1) |
||||
for i := 0; i <= int(step); i++ { |
||||
generator <- Point{ |
||||
X: int32(x), |
||||
Y: int32(y), |
||||
} |
||||
x += dx |
||||
y += dy |
||||
} |
||||
|
||||
close(generator) |
||||
}() |
||||
|
||||
return generator |
||||
} |
||||
|
||||
// IterLine2 works with two Points rather than four coordinates.
|
||||
func IterLine2(p1 Point, p2 Point) chan Point { |
||||
return IterLine(p1.X, p1.Y, p2.X, p2.Y) |
||||
} |
||||
@ -0,0 +1,14 @@ |
||||
package render |
||||
|
||||
import "github.com/kirsle/golog" |
||||
|
||||
var log *golog.Logger |
||||
|
||||
func init() { |
||||
log = golog.GetLogger("doodle") |
||||
log.Configure(&golog.Config{ |
||||
Level: golog.DebugLevel, |
||||
Theme: golog.DarkTheme, |
||||
Colors: golog.ExtendedColor, |
||||
}) |
||||
} |
||||
@ -0,0 +1,103 @@ |
||||
package render |
||||
|
||||
import ( |
||||
"fmt" |
||||
"strconv" |
||||
"strings" |
||||
) |
||||
|
||||
// Point holds an X,Y coordinate value.
|
||||
type Point struct { |
||||
X int32 |
||||
Y int32 |
||||
} |
||||
|
||||
// Common points.
|
||||
var ( |
||||
Origin Point |
||||
) |
||||
|
||||
// NewPoint makes a new Point at an X,Y coordinate.
|
||||
func NewPoint(x, y int32) Point { |
||||
return Point{ |
||||
X: x, |
||||
Y: y, |
||||
} |
||||
} |
||||
|
||||
func (p Point) String() string { |
||||
return fmt.Sprintf("%d,%d", p.X, p.Y) |
||||
} |
||||
|
||||
// ParsePoint to parse a point from its string representation.
|
||||
func ParsePoint(v string) (Point, error) { |
||||
halves := strings.Split(v, ",") |
||||
if len(halves) != 2 { |
||||
return Point{}, fmt.Errorf("'%s': not a valid coordinate string", v) |
||||
} |
||||
x, errX := strconv.Atoi(halves[0]) |
||||
y, errY := strconv.Atoi(halves[1]) |
||||
if errX != nil || errY != nil { |
||||
return Point{}, fmt.Errorf("invalid coordinate string (X: %v; Y: %v)", |
||||
errX, |
||||
errY, |
||||
) |
||||
} |
||||
return Point{ |
||||
X: int32(x), |
||||
Y: int32(y), |
||||
}, nil |
||||
} |
||||
|
||||
// IsZero returns if the point is the zero value.
|
||||
func (p Point) IsZero() bool { |
||||
return p.X == 0 && p.Y == 0 |
||||
} |
||||
|
||||
// Inside returns whether the Point falls inside the rect.
|
||||
//
|
||||
// NOTICE: the W and H are zero-relative, so a 100x100 box at coordinate
|
||||
// X,Y would still have W,H of 100.
|
||||
func (p Point) Inside(r Rect) bool { |
||||
var ( |
||||
x1 = r.X |
||||
y1 = r.Y |
||||
x2 = r.X + r.W |
||||
y2 = r.Y + r.H |
||||
) |
||||
return ((p.X >= x1 && p.X <= x2) && |
||||
(p.Y >= y1 && p.Y <= y2)) |
||||
} |
||||
|
||||
// Add (or subtract) the other point to your current point.
|
||||
func (p *Point) Add(other Point) { |
||||
p.X += other.X |
||||
p.Y += other.Y |
||||
} |
||||
|
||||
// MarshalText to convert the point into text so that a render.Point may be used
|
||||
// as a map key and serialized to JSON.
|
||||
func (p *Point) MarshalText() ([]byte, error) { |
||||
return []byte(fmt.Sprintf("%d,%d", p.X, p.Y)), nil |
||||
} |
||||
|
||||
// UnmarshalText to restore it from text.
|
||||
func (p *Point) UnmarshalText(b []byte) error { |
||||
halves := strings.Split(strings.Trim(string(b), `"`), ",") |
||||
if len(halves) != 2 { |
||||
return fmt.Errorf("'%s': not a valid coordinate string", b) |
||||
} |
||||
|
||||
x, errX := strconv.Atoi(halves[0]) |
||||
y, errY := strconv.Atoi(halves[1]) |
||||
if errX != nil || errY != nil { |
||||
return fmt.Errorf("Point.UnmarshalJSON: Atoi errors (X=%s Y=%s)", |
||||
errX, |
||||
errY, |
||||
) |
||||
} |
||||
|
||||
p.X = int32(x) |
||||
p.Y = int32(y) |
||||
return nil |
||||
} |
||||
@ -0,0 +1,60 @@ |
||||
package render_test |
||||
|
||||
import ( |
||||
"strconv" |
||||
"testing" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
) |
||||
|
||||
func TestPointInside(t *testing.T) { |
||||
type testCase struct { |
||||
rect render.Rect |
||||
p render.Point |
||||
shouldPass bool |
||||
} |
||||
tests := []testCase{ |
||||
testCase{ |
||||
rect: render.Rect{ |
||||
X: 0, |
||||
Y: 0, |
||||
W: 500, |
||||
H: 500, |
||||
}, |
||||
p: render.NewPoint(128, 256), |
||||
shouldPass: true, |
||||
}, |
||||
testCase{ |
||||
rect: render.Rect{ |
||||
X: 100, |
||||
Y: 80, |
||||
W: 40, |
||||
H: 60, |
||||
}, |
||||
p: render.NewPoint(128, 256), |
||||
shouldPass: false, |
||||
}, |
||||
testCase{ |
||||
// true values when debugging why Doodads weren't
|
||||
// considered inside the viewport.
|
||||
rect: render.Rect{ |
||||
X: 0, |
||||
Y: -232, |
||||
H: 874, |
||||
W: 490, |
||||
}, |
||||
p: render.NewPoint(509, 260), |
||||
shouldPass: false, |
||||
}, |
||||
} |
||||
|
||||
for _, test := range tests { |
||||
if test.p.Inside(test.rect) != test.shouldPass { |
||||
t.Errorf("Failed: %s inside %s should be %s", |
||||
test.p, |
||||
test.rect, |
||||
strconv.FormatBool(test.shouldPass), |
||||
) |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,71 @@ |
||||
package render_test |
||||
|
||||
import ( |
||||
"strconv" |
||||
"testing" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
) |
||||
|
||||
func TestIntersection(t *testing.T) { |
||||
newRect := func(x, y, w, h int) render.Rect { |
||||
return render.Rect{ |
||||
X: int32(x), |
||||
Y: int32(y), |
||||
W: int32(w), |
||||
H: int32(h), |
||||
} |
||||
} |
||||
|
||||
type TestCase struct { |
||||
A render.Rect |
||||
B render.Rect |
||||
Expect bool |
||||
} |
||||
var tests = []TestCase{ |
||||
{ |
||||
A: newRect(0, 0, 1000, 1000), |
||||
B: newRect(200, 200, 100, 100), |
||||
Expect: true, |
||||
}, |
||||
{ |
||||
A: newRect(200, 200, 100, 100), |
||||
B: newRect(0, 0, 1000, 1000), |
||||
Expect: true, |
||||
}, |
||||
{ |
||||
A: newRect(0, 0, 100, 100), |
||||
B: newRect(100, 0, 100, 100), |
||||
Expect: true, |
||||
}, |
||||
{ |
||||
A: newRect(0, 0, 99, 99), |
||||
B: newRect(100, 0, 99, 99), |
||||
Expect: false, |
||||
}, |
||||
{ |
||||
// Real coords of a test doodad!
|
||||
A: newRect(183, 256, 283, 356), |
||||
B: newRect(0, -232, 874, 490), |
||||
Expect: true, |
||||
}, |
||||
{ |
||||
A: newRect(183, 256, 283, 356), |
||||
B: newRect(0, -240, 874, 490), |
||||
Expect: false, // XXX: must be true
|
||||
}, |
||||
} |
||||
|
||||
for _, test := range tests { |
||||
actual := test.A.Intersects(test.B) |
||||
if actual != test.Expect { |
||||
t.Errorf( |
||||
"%s collision with %s: expected %s, got %s", |
||||
test.A, |
||||
test.B, |
||||
strconv.FormatBool(test.Expect), |
||||
strconv.FormatBool(actual), |
||||
) |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,57 @@ |
||||
// Package sdl provides an SDL2 renderer for Doodle.
|
||||
package sdl |
||||
|
||||
import ( |
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
"github.com/veandco/go-sdl2/sdl" |
||||
) |
||||
|
||||
// Clear the canvas and set this color.
|
||||
func (r *Renderer) Clear(color render.Color) { |
||||
if color != r.lastColor { |
||||
r.renderer.SetDrawColor(color.Red, color.Green, color.Blue, color.Alpha) |
||||
} |
||||
r.renderer.Clear() |
||||
} |
||||
|
||||
// DrawPoint puts a color at a pixel.
|
||||
func (r *Renderer) DrawPoint(color render.Color, point render.Point) { |
||||
if color != r.lastColor { |
||||
r.renderer.SetDrawColor(color.Red, color.Green, color.Blue, color.Alpha) |
||||
} |
||||
r.renderer.DrawPoint(point.X, point.Y) |
||||
} |
||||
|
||||
// DrawLine draws a line between two points.
|
||||
func (r *Renderer) DrawLine(color render.Color, a, b render.Point) { |
||||
if color != r.lastColor { |
||||
r.renderer.SetDrawColor(color.Red, color.Green, color.Blue, color.Alpha) |
||||
} |
||||
r.renderer.DrawLine(a.X, a.Y, b.X, b.Y) |
||||
} |
||||
|
||||
// DrawRect draws a rectangle.
|
||||
func (r *Renderer) DrawRect(color render.Color, rect render.Rect) { |
||||
if color != r.lastColor { |
||||
r.renderer.SetDrawColor(color.Red, color.Green, color.Blue, color.Alpha) |
||||
} |
||||
r.renderer.DrawRect(&sdl.Rect{ |
||||
X: rect.X, |
||||
Y: rect.Y, |
||||
W: rect.W, |
||||
H: rect.H, |
||||
}) |
||||
} |
||||
|
||||
// DrawBox draws a filled rectangle.
|
||||
func (r *Renderer) DrawBox(color render.Color, rect render.Rect) { |
||||
if color != r.lastColor { |
||||
r.renderer.SetDrawColor(color.Red, color.Green, color.Blue, color.Alpha) |
||||
} |
||||
r.renderer.FillRect(&sdl.Rect{ |
||||
X: rect.X, |
||||
Y: rect.Y, |
||||
W: rect.W, |
||||
H: rect.H, |
||||
}) |
||||
} |
||||
@ -0,0 +1,131 @@ |
||||
package sdl |
||||
|
||||
import ( |
||||
"errors" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/events" |
||||
"github.com/veandco/go-sdl2/sdl" |
||||
) |
||||
|
||||
// Poll for events.
|
||||
func (r *Renderer) Poll() (*events.State, error) { |
||||
s := r.events |
||||
for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() { |
||||
switch t := event.(type) { |
||||
case *sdl.QuitEvent: |
||||
return s, errors.New("quit") |
||||
case *sdl.WindowEvent: |
||||
if DebugWindowEvents { |
||||
if t.Event == sdl.WINDOWEVENT_RESIZED { |
||||
log.Debug("[%d ms] tick:%d Window Resized to %dx%d", |
||||
t.Timestamp, |
||||
r.ticks, |
||||
t.Data1, |
||||
t.Data2, |
||||
) |
||||
} |
||||
} |
||||
s.Resized.Push(true) |
||||
case *sdl.MouseMotionEvent: |
||||
if DebugMouseEvents { |
||||
log.Debug("[%d ms] tick:%d MouseMotion type:%d id:%d x:%d y:%d xrel:%d yrel:%d", |
||||
t.Timestamp, r.ticks, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel, |
||||
) |
||||
} |
||||
|
||||
// Push the cursor position.
|
||||
s.CursorX.Push(t.X) |
||||
s.CursorY.Push(t.Y) |
||||
s.Button1.Push(t.State == 1) |
||||
case *sdl.MouseButtonEvent: |
||||
if DebugClickEvents { |
||||
log.Debug("[%d ms] tick:%d MouseButton type:%d id:%d x:%d y:%d button:%d state:%d", |
||||
t.Timestamp, r.ticks, t.Type, t.Which, t.X, t.Y, t.Button, t.State, |
||||
) |
||||
} |
||||
|
||||
// Push the cursor position.
|
||||
s.CursorX.Push(t.X) |
||||
s.CursorY.Push(t.Y) |
||||
|
||||
// Is a mouse button pressed down?
|
||||
checkDown := func(number uint8, target *events.BoolTick) bool { |
||||
if t.Button == number { |
||||
var eventName string |
||||
if t.State == 1 && target.Now == false { |
||||
eventName = "DOWN" |
||||
} else if t.State == 0 && target.Now == true { |
||||
eventName = "UP" |
||||
} |
||||
|
||||
if eventName != "" { |
||||
target.Push(eventName == "DOWN") |
||||
} |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
if checkDown(1, s.Button1) || checkDown(3, s.Button2) { |
||||
// Return the event immediately.
|
||||
return s, nil |
||||
} |
||||
case *sdl.MouseWheelEvent: |
||||
if DebugMouseEvents { |
||||
log.Debug("[%d ms] tick:%d MouseWheel type:%d id:%d x:%d y:%d", |
||||
t.Timestamp, r.ticks, t.Type, t.Which, t.X, t.Y, |
||||
) |
||||
} |
||||
case *sdl.KeyboardEvent: |
||||
if DebugKeyEvents { |
||||
log.Debug("[%d ms] tick:%d Keyboard type:%d sym:%c modifiers:%d state:%d repeat:%d\n", |
||||
t.Timestamp, r.ticks, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat, |
||||
) |
||||
} |
||||
|
||||
switch t.Keysym.Scancode { |
||||
case sdl.SCANCODE_ESCAPE: |
||||
if t.Repeat == 1 { |
||||
continue |
||||
} |
||||
s.EscapeKey.Push(t.State == 1) |
||||
case sdl.SCANCODE_RETURN: |
||||
if t.Repeat == 1 { |
||||
continue |
||||
} |
||||
s.EnterKey.Push(t.State == 1) |
||||
case sdl.SCANCODE_F12: |
||||
s.ScreenshotKey.Push(t.State == 1) |
||||
case sdl.SCANCODE_UP: |
||||
s.Up.Push(t.State == 1) |
||||
case sdl.SCANCODE_LEFT: |
||||
s.Left.Push(t.State == 1) |
||||
case sdl.SCANCODE_RIGHT: |
||||
s.Right.Push(t.State == 1) |
||||
case sdl.SCANCODE_DOWN: |
||||
s.Down.Push(t.State == 1) |
||||
case sdl.SCANCODE_LSHIFT: |
||||
case sdl.SCANCODE_RSHIFT: |
||||
s.ShiftActive.Push(t.State == 1) |
||||
continue |
||||
case sdl.SCANCODE_LALT: |
||||
case sdl.SCANCODE_RALT: |
||||
case sdl.SCANCODE_LCTRL: |
||||
case sdl.SCANCODE_RCTRL: |
||||
continue |
||||
case sdl.SCANCODE_BACKSPACE: |
||||
// Make it a key event with "\b" as the sequence.
|
||||
if t.State == 1 || t.Repeat == 1 { |
||||
s.KeyName.Push(`\b`) |
||||
} |
||||
default: |
||||
// Push the string value of the key.
|
||||
if t.State == 1 { |
||||
s.KeyName.Push(string(t.Keysym.Sym)) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
return s, nil |
||||
} |
||||
@ -0,0 +1,20 @@ |
||||
package sdl |
||||
|
||||
import "git.kirsle.net/apps/doodle/pkg/level" |
||||
|
||||
// Frames to cache for FPS calculation.
|
||||
const ( |
||||
maxSamples = 100 |
||||
TargetFPS = 1000 / 60 |
||||
) |
||||
|
||||
var ( |
||||
fpsCurrentTicks uint32 // current time we get sdl.GetTicks()
|
||||
fpsLastTime uint32 // last time we printed the fpsCurrentTicks
|
||||
fpsCurrent int |
||||
fpsFrames int |
||||
fpsSkipped uint32 |
||||
fpsInterval uint32 = 1000 |
||||
) |
||||
|
||||
var pixelHistory []level.Pixel |
||||
@ -0,0 +1,17 @@ |
||||
package sdl |
||||
|
||||
import "github.com/kirsle/golog" |
||||
|
||||
var log *golog.Logger |
||||
|
||||
// Verbose debug logging.
|
||||
var ( |
||||
DebugMouseEvents = false |
||||
DebugClickEvents = false |
||||
DebugKeyEvents = false |
||||
DebugWindowEvents = false |
||||
) |
||||
|
||||
func init() { |
||||
log = golog.GetLogger("doodle") |
||||
} |
||||
@ -0,0 +1,115 @@ |
||||
// Package sdl provides an SDL2 renderer for Doodle.
|
||||
package sdl |
||||
|
||||
import ( |
||||
"time" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/events" |
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
"github.com/veandco/go-sdl2/sdl" |
||||
"github.com/veandco/go-sdl2/ttf" |
||||
) |
||||
|
||||
// Renderer manages the SDL state.
|
||||
type Renderer struct { |
||||
// Configurable fields.
|
||||
title string |
||||
width int32 |
||||
height int32 |
||||
startTime time.Time |
||||
|
||||
// Private fields.
|
||||
events *events.State |
||||
window *sdl.Window |
||||
renderer *sdl.Renderer |
||||
running bool |
||||
ticks uint64 |
||||
|
||||
// Optimizations to minimize SDL calls.
|
||||
lastColor render.Color |
||||
} |
||||
|
||||
// New creates the SDL renderer.
|
||||
func New(title string, width, height int) *Renderer { |
||||
return &Renderer{ |
||||
events: events.New(), |
||||
title: title, |
||||
width: int32(width), |
||||
height: int32(height), |
||||
} |
||||
} |
||||
|
||||
// Teardown tasks when exiting the program.
|
||||
func (r *Renderer) Teardown() { |
||||
r.renderer.Destroy() |
||||
r.window.Destroy() |
||||
sdl.Quit() |
||||
} |
||||
|
||||
// Setup the renderer.
|
||||
func (r *Renderer) Setup() error { |
||||
// Initialize SDL.
|
||||
log.Info("Initializing SDL") |
||||
if err := sdl.Init(sdl.INIT_EVERYTHING); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Initialize SDL_TTF.
|
||||
log.Info("Initializing SDL_TTF") |
||||
if err := ttf.Init(); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Create our window.
|
||||
log.Info("Creating the Main Window") |
||||
window, err := sdl.CreateWindow( |
||||
r.title, |
||||
sdl.WINDOWPOS_CENTERED, |
||||
sdl.WINDOWPOS_CENTERED, |
||||
r.width, |
||||
r.height, |
||||
sdl.WINDOW_SHOWN|sdl.WINDOW_RESIZABLE, |
||||
) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
r.window = window |
||||
|
||||
// Blank out the window in white.
|
||||
log.Info("Creating the SDL Renderer") |
||||
renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
renderer.SetDrawBlendMode(sdl.BLENDMODE_BLEND) |
||||
r.renderer = renderer |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// GetTicks gets SDL's current tick count.
|
||||
func (r *Renderer) GetTicks() uint32 { |
||||
return sdl.GetTicks() |
||||
} |
||||
|
||||
// WindowSize returns the SDL window size.
|
||||
func (r *Renderer) WindowSize() (int, int) { |
||||
w, h := r.window.GetSize() |
||||
return int(w), int(h) |
||||
} |
||||
|
||||
// Present the current frame.
|
||||
func (r *Renderer) Present() error { |
||||
r.renderer.Present() |
||||
return nil |
||||
} |
||||
|
||||
// Delay using sdl.Delay
|
||||
func (r *Renderer) Delay(time uint32) { |
||||
sdl.Delay(time) |
||||
} |
||||
|
||||
// Loop is the main loop.
|
||||
func (r *Renderer) Loop() error { |
||||
return nil |
||||
} |
||||
@ -0,0 +1,158 @@ |
||||
package sdl |
||||
|
||||
import ( |
||||
"fmt" |
||||
"strings" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/events" |
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
"github.com/veandco/go-sdl2/sdl" |
||||
"github.com/veandco/go-sdl2/ttf" |
||||
) |
||||
|
||||
// TODO: font filenames
|
||||
var defaultFontFilename = "./fonts/DejaVuSans.ttf" |
||||
|
||||
var fonts = map[string]*ttf.Font{} |
||||
|
||||
// LoadFont loads and caches the font at a given size.
|
||||
func LoadFont(filename string, size int) (*ttf.Font, error) { |
||||
if filename == "" { |
||||
filename = defaultFontFilename |
||||
} |
||||
|
||||
// Cached font available?
|
||||
keyName := fmt.Sprintf("%s@%d", filename, size) |
||||
if font, ok := fonts[keyName]; ok { |
||||
return font, nil |
||||
} |
||||
|
||||
font, err := ttf.OpenFont(filename, size) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
fonts[keyName] = font |
||||
|
||||
return font, nil |
||||
} |
||||
|
||||
// Keysym returns the current key pressed, taking into account the Shift
|
||||
// key modifier.
|
||||
func (r *Renderer) Keysym(ev *events.State) string { |
||||
if key := ev.KeyName.Read(); key != "" { |
||||
if ev.ShiftActive.Pressed() { |
||||
if symbol, ok := shiftMap[key]; ok { |
||||
return symbol |
||||
} |
||||
return strings.ToUpper(key) |
||||
} |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
// ComputeTextRect computes and returns a Rect for how large the text would
|
||||
// appear if rendered.
|
||||
func (r *Renderer) ComputeTextRect(text render.Text) (render.Rect, error) { |
||||
var ( |
||||
rect render.Rect |
||||
font *ttf.Font |
||||
surface *sdl.Surface |
||||
color = ColorToSDL(text.Color) |
||||
err error |
||||
) |
||||
|
||||
if font, err = LoadFont(text.FontFilename, text.Size); err != nil { |
||||
return rect, err |
||||
} |
||||
|
||||
if surface, err = font.RenderUTF8Blended(text.Text, color); err != nil { |
||||
return rect, err |
||||
} |
||||
defer surface.Free() |
||||
|
||||
rect.W = surface.W |
||||
rect.H = surface.H |
||||
return rect, err |
||||
} |
||||
|
||||
// DrawText draws text on the canvas.
|
||||
func (r *Renderer) DrawText(text render.Text, point render.Point) error { |
||||
var ( |
||||
font *ttf.Font |
||||
surface *sdl.Surface |
||||
tex *sdl.Texture |
||||
err error |
||||
) |
||||
|
||||
if font, err = LoadFont(text.FontFilename, text.Size); err != nil { |
||||
return err |
||||
} |
||||
|
||||
write := func(dx, dy int32, color sdl.Color) { |
||||
if surface, err = font.RenderUTF8Blended(text.Text, color); err != nil { |
||||
return |
||||
} |
||||
defer surface.Free() |
||||
|
||||
if tex, err = r.renderer.CreateTextureFromSurface(surface); err != nil { |
||||
return |
||||
} |
||||
defer tex.Destroy() |
||||
|
||||
tmp := &sdl.Rect{ |
||||
X: point.X + dx, |
||||
Y: point.Y + dy, |
||||
W: surface.W, |
||||
H: surface.H, |
||||
} |
||||
r.renderer.Copy(tex, nil, tmp) |
||||
} |
||||
|
||||
// Does the text have a stroke around it?
|
||||
if text.Stroke != render.Invisible { |
||||
color := ColorToSDL(text.Stroke) |
||||
write(-1, -1, color) |
||||
write(-1, 0, color) |
||||
write(-1, 1, color) |
||||
write(1, -1, color) |
||||
write(1, 0, color) |
||||
write(1, 1, color) |
||||
write(0, -1, color) |
||||
write(0, 1, color) |
||||
} |
||||
|
||||
// Does it have a drop shadow?
|
||||
if text.Shadow != render.Invisible { |
||||
write(1, 1, ColorToSDL(text.Shadow)) |
||||
} |
||||
|
||||
// Draw the text itself.
|
||||
write(0, 0, ColorToSDL(text.Color)) |
||||
|
||||
return err |
||||
} |
||||
|
||||
// shiftMap maps keys to their Shift versions.
|
||||
var shiftMap = map[string]string{ |
||||
"`": "~", |
||||
"1": "!", |
||||
"2": "@", |
||||
"3": "#", |
||||
"4": "$", |
||||
"5": "%", |
||||
"6": "^", |
||||
"7": "&", |
||||
"8": "*", |
||||
"9": "(", |
||||
"0": ")", |
||||
"-": "_", |
||||
"=": "+", |
||||
"[": "{", |
||||
"]": "}", |
||||
`\`: "|", |
||||
";": ":", |
||||
`'`: `"`, |
||||
",": "<", |
||||
".": ">", |
||||
"/": "?", |
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
package sdl |
||||
|
||||
import ( |
||||
"fmt" |
||||
|
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
"github.com/veandco/go-sdl2/sdl" |
||||
) |
||||
|
||||
// Copy a texture into the renderer.
|
||||
func (r *Renderer) Copy(t render.Texturer, src, dst render.Rect) { |
||||
if tex, ok := t.(*Texture); ok { |
||||
var ( |
||||
a = RectToSDL(src) |
||||
b = RectToSDL(dst) |
||||
) |
||||
r.renderer.Copy(tex.tex, &a, &b) |
||||
} |
||||
} |
||||
|
||||
// Texture can hold on to SDL textures for caching and optimization.
|
||||
type Texture struct { |
||||
tex *sdl.Texture |
||||
width int32 |
||||
height int32 |
||||
} |
||||
|
||||
// Size returns the dimensions of the texture.
|
||||
func (t *Texture) Size() render.Rect { |
||||
return render.NewRect(t.width, t.height) |
||||
} |
||||
|
||||
// NewBitmap initializes a texture from a bitmap image.
|
||||
func (r *Renderer) NewBitmap(filename string) (render.Texturer, error) { |
||||
surface, err := sdl.LoadBMP(filename) |
||||
if err != nil { |
||||
return nil, fmt.Errorf("NewBitmap: LoadBMP: %s", err) |
||||
} |
||||
defer surface.Free() |
||||
|
||||
// TODO: chroma key color hardcoded to white here
|
||||
key := sdl.MapRGB(surface.Format, 255, 255, 255) |
||||
surface.SetColorKey(true, key) |
||||
|
||||
tex, err := r.renderer.CreateTextureFromSurface(surface) |
||||
if err != nil { |
||||
return nil, fmt.Errorf("NewBitmap: create texture: %s", err) |
||||
} |
||||
|
||||
return &Texture{ |
||||
width: surface.W, |
||||
height: surface.H, |
||||
tex: tex, |
||||
}, nil |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
package sdl |
||||
|
||||
import ( |
||||
"git.kirsle.net/apps/doodle/lib/render" |
||||
"github.com/veandco/go-sdl2/sdl" |
||||
) |
||||
|
||||
// ColorToSDL converts Doodle's Color type to an sdl.Color.
|
||||
func ColorToSDL(c render.Color) sdl.Color { |
||||
return sdl.Color{ |
||||
R: c.Red, |
||||
G: c.Green, |
||||
B: c.Blue, |
||||
A: c.Alpha, |
||||
} |
||||
} |
||||
|
||||
// RectToSDL converts Doodle's Rect type to an sdl.Rect.
|
||||
func RectToSDL(r render.Rect) sdl.Rect { |
||||
return sdl.Rect{ |
||||
X: r.X, |
||||
Y: r.Y, |
||||
W: r.W, |
||||
H: r.H, |
||||
} |
||||
} |
||||
Loading…
Reference in new issue