298 lines
8.2 KiB
Go
298 lines
8.2 KiB
Go
package xcanvas
|
|
|
|
import "sort"
|
|
import "math"
|
|
import "image"
|
|
import "github.com/jezek/xgbutil/xgraphics"
|
|
|
|
func (this *pen) textureRectangle (bounds image.Rectangle) {
|
|
if this.texture.Opaque() {
|
|
this.textureRectangleOpaque(bounds)
|
|
} else {
|
|
this.textureRectangleTransparent(bounds)
|
|
}
|
|
}
|
|
|
|
func (this *pen) textureRectangleOpaque (bounds image.Rectangle) {
|
|
dstBounds := bounds.Intersect(this.image.Bounds())
|
|
var pos image.Point
|
|
|
|
dst := this.image.Pix
|
|
src := this.texture.pix
|
|
offset := this.texture.rect.Min.Sub(bounds.Min)
|
|
|
|
for pos.Y = dstBounds.Min.Y; pos.Y < dstBounds.Max.Y; pos.Y ++ {
|
|
for pos.X = dstBounds.Min.X; pos.X < dstBounds.Max.X; pos.X ++ {
|
|
srcPos := pos.Add(offset)
|
|
dstIndex := this.image.PixOffset(pos.X, pos.Y)
|
|
srcIndex := this.texture.PixOffset(srcPos.X, srcPos.Y)
|
|
dst[dstIndex + 0] = src[srcIndex + 0]
|
|
dst[dstIndex + 1] = src[srcIndex + 1]
|
|
dst[dstIndex + 2] = src[srcIndex + 2]
|
|
dst[dstIndex + 3] = src[srcIndex + 3]
|
|
}}
|
|
}
|
|
|
|
func (this *pen) textureRectangleTransparent (bounds image.Rectangle) {
|
|
dstBounds := bounds.Intersect(this.image.Bounds())
|
|
var pos image.Point
|
|
|
|
dst := this.image.Pix
|
|
src := this.texture.pix
|
|
offset := this.texture.rect.Min.Sub(bounds.Min)
|
|
|
|
for pos.Y = dstBounds.Min.Y; pos.Y < dstBounds.Max.Y; pos.Y ++ {
|
|
for pos.X = dstBounds.Min.X; pos.X < dstBounds.Max.X; pos.X ++ {
|
|
srcPos := pos.Add(offset)
|
|
dstIndex := this.image.PixOffset(pos.X, pos.Y)
|
|
srcIndex := this.texture.PixOffset(srcPos.X, srcPos.Y)
|
|
pixel := blendPremultipliedBGRA(xgraphics.BGRA {
|
|
B: dst[dstIndex + 0],
|
|
G: dst[dstIndex + 1],
|
|
R: dst[dstIndex + 2],
|
|
A: dst[dstIndex + 3],
|
|
}, xgraphics.BGRA {
|
|
B: src[srcIndex + 0],
|
|
G: src[srcIndex + 1],
|
|
R: src[srcIndex + 2],
|
|
A: src[srcIndex + 3],
|
|
})
|
|
dst[dstIndex + 0] = pixel.B
|
|
dst[dstIndex + 1] = pixel.G
|
|
dst[dstIndex + 2] = pixel.R
|
|
dst[dstIndex + 3] = pixel.A
|
|
}}
|
|
}
|
|
|
|
func (this *pen) fillRectangle (c xgraphics.BGRA, bounds image.Rectangle) {
|
|
if c.A == 255 {
|
|
this.fillRectangleOpaque(c, bounds)
|
|
} else {
|
|
this.fillRectangleTransparent(c, bounds)
|
|
}
|
|
}
|
|
|
|
func (this *pen) fillRectangleOpaque (c xgraphics.BGRA, bounds image.Rectangle) {
|
|
bounds = bounds.Intersect(this.image.Bounds())
|
|
var pos image.Point
|
|
|
|
for pos.Y = bounds.Min.Y; pos.Y < bounds.Max.Y; pos.Y ++ {
|
|
for pos.X = bounds.Min.X; pos.X < bounds.Max.X; pos.X ++ {
|
|
index := this.image.PixOffset(pos.X, pos.Y)
|
|
this.image.Pix[index + 0] = c.B
|
|
this.image.Pix[index + 1] = c.G
|
|
this.image.Pix[index + 2] = c.R
|
|
this.image.Pix[index + 3] = c.A
|
|
}}
|
|
}
|
|
|
|
func (this *pen) fillRectangleTransparent (c xgraphics.BGRA, bounds image.Rectangle) {
|
|
bounds = bounds.Intersect(this.image.Bounds())
|
|
var pos image.Point
|
|
|
|
for pos.Y = bounds.Min.Y; pos.Y < bounds.Max.Y; pos.Y ++ {
|
|
for pos.X = bounds.Min.X; pos.X < bounds.Max.X; pos.X ++ {
|
|
index := this.image.PixOffset(pos.X, pos.Y)
|
|
pixel := blendPremultipliedBGRA(xgraphics.BGRA {
|
|
B: this.image.Pix[index + 0],
|
|
G: this.image.Pix[index + 1],
|
|
R: this.image.Pix[index + 2],
|
|
A: this.image.Pix[index + 3],
|
|
}, c)
|
|
this.image.Pix[index + 0] = pixel.B
|
|
this.image.Pix[index + 1] = pixel.G
|
|
this.image.Pix[index + 2] = pixel.R
|
|
this.image.Pix[index + 3] = pixel.A
|
|
}}
|
|
}
|
|
|
|
func (this *pen) strokeRectangle (c xgraphics.BGRA, bounds image.Rectangle) {
|
|
if this.weight > bounds.Dx() / 2 || this.weight > bounds.Dy() / 2 {
|
|
this.fillRectangle(c, bounds)
|
|
return
|
|
}
|
|
|
|
top := image.Rect (
|
|
bounds.Min.X,
|
|
bounds.Min.Y,
|
|
bounds.Max.X,
|
|
bounds.Min.Y + this.weight)
|
|
bottom := image.Rect (
|
|
bounds.Min.X,
|
|
bounds.Max.Y - this.weight,
|
|
bounds.Max.X,
|
|
bounds.Max.Y)
|
|
left := image.Rect (
|
|
bounds.Min.X,
|
|
bounds.Min.Y + this.weight,
|
|
bounds.Min.X + this.weight,
|
|
bounds.Max.Y - this.weight)
|
|
right := image.Rect (
|
|
bounds.Max.X - this.weight,
|
|
bounds.Min.Y + this.weight,
|
|
bounds.Max.X,
|
|
bounds.Max.Y - this.weight)
|
|
|
|
this.fillRectangle(c, top,)
|
|
this.fillRectangle(c, bottom,)
|
|
this.fillRectangle(c, left,)
|
|
this.fillRectangle(c, right,)
|
|
}
|
|
|
|
// the polygon filling algorithm is adapted from:
|
|
// https://www.alienryderflex.com/polygon_fill/
|
|
// (if you write C like that i will disassemble you)
|
|
|
|
func (this *pen) fillPolygon (c xgraphics.BGRA, points ...image.Point) {
|
|
if len(points) < 3 { return }
|
|
|
|
// figure out the bounds of the polygon so we don't test empty space
|
|
var area image.Rectangle
|
|
area.Min = points[0]
|
|
area.Max = points[0]
|
|
for _, point := range points[1:] {
|
|
if point.X < area.Min.X { area.Min.X = point.X }
|
|
if point.Y < area.Min.Y { area.Min.Y = point.Y }
|
|
if point.X > area.Max.X { area.Max.X = point.X }
|
|
if point.Y > area.Max.Y { area.Max.Y = point.Y }
|
|
}
|
|
area = this.image.Bounds().Intersect(area)
|
|
if area.Empty() { return }
|
|
|
|
boundaries := make([]int, len(points))
|
|
context := fillingContext {
|
|
image: this.image,
|
|
color: this.fill,
|
|
min: area.Min.X,
|
|
max: area.Max.X,
|
|
points: points,
|
|
}
|
|
|
|
for context.y = area.Min.Y; context.y < area.Max.Y; context.y ++ {
|
|
// build boundary list
|
|
boundaryCount := 0
|
|
prevPoint := points[len(points) - 1]
|
|
for _, point := range points {
|
|
fy := float64(context.y)
|
|
fPointX := float64(point.X)
|
|
fPointY := float64(point.Y)
|
|
fPrevX := float64(prevPoint.X)
|
|
fPrevY := float64(prevPoint.Y)
|
|
addboundary :=
|
|
(fPointY < fy && fPrevY >= fy) ||
|
|
(fPrevY < fy && fPointY >= fy)
|
|
if addboundary {
|
|
boundaries[boundaryCount] = int(math.Round (
|
|
fPointX +
|
|
(fy - fPointY) /
|
|
(fPrevY - fPointY) *
|
|
(fPrevX - fPointX)))
|
|
boundaryCount ++
|
|
}
|
|
prevPoint = point
|
|
}
|
|
|
|
// sort boundary list
|
|
context.boundaries = boundaries[:boundaryCount]
|
|
sort.Ints(context.boundaries)
|
|
|
|
// fill pixels between boundary pairs
|
|
if c.A == 255 {
|
|
context.fillPolygonHotOpaque()
|
|
} else {
|
|
context.fillPolygonHotTransparent()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
type fillingContext struct {
|
|
image *xgraphics.Image
|
|
color xgraphics.BGRA
|
|
min, max int
|
|
y int
|
|
boundaries []int
|
|
points []image.Point
|
|
}
|
|
|
|
func (context *fillingContext) fillPolygonHotOpaque () {
|
|
for index := 0; index < len(context.boundaries) - 1; index += 2 {
|
|
left := context.boundaries[index]
|
|
right := context.boundaries[index + 1]
|
|
|
|
// stop if we have exited the polygon
|
|
if left >= context.max { break }
|
|
// begin filling if we are within the polygon
|
|
if right > context.min {
|
|
// constrain boundaries to image size
|
|
if left < context.min { left = context.min }
|
|
if right > context.max { right = context.max }
|
|
|
|
// fill pixels in between
|
|
for x := left; x < right; x ++ {
|
|
index := context.image.PixOffset(x, context.y)
|
|
context.image.Pix[index + 0] = context.color.B
|
|
context.image.Pix[index + 1] = context.color.G
|
|
context.image.Pix[index + 2] = context.color.R
|
|
context.image.Pix[index + 3] = context.color.A
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (context *fillingContext) fillPolygonHotTransparent () {
|
|
for index := 0; index < len(context.boundaries) - 1; index += 2 {
|
|
left := context.boundaries[index]
|
|
right := context.boundaries[index + 1]
|
|
|
|
// stop if we have exited the polygon
|
|
if left >= context.max { break }
|
|
// begin filling if we are within the polygon
|
|
if right > context.min {
|
|
// constrain boundaries to image size
|
|
if left < context.min { left = context.min }
|
|
if right > context.max { right = context.max }
|
|
|
|
// fill pixels in between
|
|
for x := left; x < right; x ++ {
|
|
index := context.image.PixOffset(x, context.y)
|
|
pixel := blendPremultipliedBGRA(xgraphics.BGRA {
|
|
B: context.image.Pix[index + 0],
|
|
G: context.image.Pix[index + 1],
|
|
R: context.image.Pix[index + 2],
|
|
A: context.image.Pix[index + 3],
|
|
}, context.color)
|
|
context.image.Pix[index + 0] = pixel.B
|
|
context.image.Pix[index + 1] = pixel.G
|
|
context.image.Pix[index + 2] = pixel.R
|
|
context.image.Pix[index + 3] = pixel.A
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (this *pen) strokePolygon (c xgraphics.BGRA, points ...image.Point) {
|
|
prevPoint := points[len(points) - 1]
|
|
for _, point := range points {
|
|
this.line(c, prevPoint, point)
|
|
prevPoint = point
|
|
}
|
|
}
|
|
|
|
func (this *pen) polyLine (c xgraphics.BGRA, points ...image.Point) {
|
|
if len(points) < 2 { return }
|
|
prevPoint := points[0]
|
|
for _, point := range points[1:] {
|
|
this.line(c, prevPoint, point)
|
|
prevPoint = point
|
|
}
|
|
}
|
|
|
|
func wrap (n, min, max int) int {
|
|
max -= min
|
|
n -= min
|
|
n %= max
|
|
if n < 0 { n += max }
|
|
return n + min
|
|
}
|