mirror of
https://git.sr.ht/~eliasnaur/gio
synced 2026-07-01 15:45:38 +00:00
Elias Naur
99 lines
2.1 KiB
Go
99 lines
2.1 KiB
Go
// SPDX-License-Identifier: Unlicense OR MIT
|
|
|
|
package draw
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"image"
|
|
"math"
|
|
|
|
"gioui.org/ui"
|
|
"gioui.org/ui/f32"
|
|
"gioui.org/ui/internal/ops"
|
|
"gioui.org/ui/internal/path"
|
|
)
|
|
|
|
type OpImage struct {
|
|
Rect f32.Rectangle
|
|
Src image.Image
|
|
SrcRect image.Rectangle
|
|
}
|
|
|
|
func (i OpImage) Add(o *ui.Ops) {
|
|
data := make([]byte, ops.TypeImageLen)
|
|
data[0] = byte(ops.TypeImage)
|
|
bo := binary.LittleEndian
|
|
ref := o.Ref(i.Src)
|
|
bo.PutUint32(data[1:], uint32(ref))
|
|
bo.PutUint32(data[5:], math.Float32bits(i.Rect.Min.X))
|
|
bo.PutUint32(data[9:], math.Float32bits(i.Rect.Min.Y))
|
|
bo.PutUint32(data[13:], math.Float32bits(i.Rect.Max.X))
|
|
bo.PutUint32(data[17:], math.Float32bits(i.Rect.Max.Y))
|
|
bo.PutUint32(data[21:], uint32(i.SrcRect.Min.X))
|
|
bo.PutUint32(data[25:], uint32(i.SrcRect.Min.Y))
|
|
bo.PutUint32(data[29:], uint32(i.SrcRect.Max.X))
|
|
bo.PutUint32(data[33:], uint32(i.SrcRect.Max.Y))
|
|
o.Write(data)
|
|
}
|
|
|
|
func (i *OpImage) Decode(d []byte, refs []interface{}) {
|
|
bo := binary.LittleEndian
|
|
if ops.OpType(d[0]) != ops.TypeImage {
|
|
panic("invalid op")
|
|
}
|
|
ref := int(bo.Uint32(d[1:]))
|
|
r := f32.Rectangle{
|
|
Min: f32.Point{
|
|
X: math.Float32frombits(bo.Uint32(d[5:])),
|
|
Y: math.Float32frombits(bo.Uint32(d[9:])),
|
|
},
|
|
Max: f32.Point{
|
|
X: math.Float32frombits(bo.Uint32(d[13:])),
|
|
Y: math.Float32frombits(bo.Uint32(d[17:])),
|
|
},
|
|
}
|
|
sr := image.Rectangle{
|
|
Min: image.Point{
|
|
X: int(bo.Uint32(d[21:])),
|
|
Y: int(bo.Uint32(d[25:])),
|
|
},
|
|
Max: image.Point{
|
|
X: int(bo.Uint32(d[29:])),
|
|
Y: int(bo.Uint32(d[33:])),
|
|
},
|
|
}
|
|
*i = OpImage{
|
|
Rect: r,
|
|
Src: refs[ref].(image.Image),
|
|
SrcRect: sr,
|
|
}
|
|
}
|
|
|
|
// RectPath constructs a path corresponding to
|
|
// a pixel aligned rectangular area.
|
|
func RectPath(r image.Rectangle) *Path {
|
|
return &Path{
|
|
data: &path.Path{
|
|
Bounds: toRectF(r),
|
|
},
|
|
}
|
|
}
|
|
|
|
func itof(i int) float32 {
|
|
switch i {
|
|
case ui.Inf:
|
|
return float32(math.Inf(+1))
|
|
case -ui.Inf:
|
|
return float32(math.Inf(-1))
|
|
default:
|
|
return float32(i)
|
|
}
|
|
}
|
|
|
|
func toRectF(r image.Rectangle) f32.Rectangle {
|
|
return f32.Rectangle{
|
|
Min: f32.Point{X: itof(r.Min.X), Y: itof(r.Min.Y)},
|
|
Max: f32.Point{X: itof(r.Max.X), Y: itof(r.Max.Y)},
|
|
}
|
|
}
|