This thread contains a patchset. You're looking at the original emails,
but you may wish to use the patch review UI.
Review patch
[PATCH gio] io/router: use f32.Rectangle in areaOp
From: pierre <pierre.curto@gmail.com>
Also introduce a function to decode a float32 from ops.
Signed-off-by: pierre <pierre.curto@gmail.com>
---
io/router/pointer.go | 36 +++++++++++++++++ -------------------
1 file changed, 17 insertions(+), 19 deletions(-)
diff --git a/io/router/pointer.go b/io/router/pointer.go
index ab9348b..ef56841 100644
--- a/io/router/pointer.go
+++ b/io/router/pointer.go
@@ -4,7 +4,6 @@ package router
import (
"encoding/binary"
- "image"
"gioui.org/f32"
"gioui.org/internal/opconst"
@@ -64,7 +63,7 @@ type pointerHandler struct {
type areaOp struct {
kind areaKind
- rect image.Rectangle+ rect f32.Rectangle }
type areaNode struct {
@@ -409,19 +408,22 @@ func searchTag(tags []event.Tag, tag event.Tag) (int, bool) {
return 0, false
}
+ func opDecodeFloat32(d []byte) float32 {+ return float32(binary.LittleEndian.Uint32(d))+ }+ func (op *areaOp) Decode(d []byte) {
if opconst.OpType(d[0]) != opconst.TypeArea {
panic("invalid op")
}
- bo := binary.LittleEndian- rect := image.Rectangle{- Min: image.Point{- X: int(int32(bo.Uint32(d[2:]))),- Y: int(int32(bo.Uint32(d[6:]))),+ rect := f32.Rectangle{+ Min: f32.Point{+ X: opDecodeFloat32(d[2:]),+ Y: opDecodeFloat32(d[6:]), },
- Max: image.Point{- X: int(int32(bo.Uint32(d[10:]))),- Y: int(int32(bo.Uint32(d[14:]))),+ Max: f32.Point{+ X: opDecodeFloat32(d[10:]),+ Y: opDecodeFloat32(d[14:]), },
}
*op = areaOp{
@@ -431,19 +433,15 @@ func (op *areaOp) Decode(d []byte) {
}
func (op *areaOp) Hit(pos f32.Point) bool {
- min := f32.Point{- X: float32(op.rect.Min.X),- Y: float32(op.rect.Min.Y),- }- pos = pos.Sub(min)+ pos = pos.Sub(op.rect.Min) size := op.rect.Size()
switch op.kind {
case areaRect:
- return 0 <= pos.X && pos.X < float32(size.X) &&- 0 <= pos.Y && pos.Y < float32(size.Y)+ return 0 <= pos.X && pos.X < size.X &&+ 0 <= pos.Y && pos.Y < size.Y case areaEllipse:
- rx := float32(size.X) / 2- ry := float32(size.Y) / 2+ rx := size.X / 2+ ry := size.Y / 2 xh := pos.X - rx
yk := pos.Y - ry
// The ellipse function works in all cases because
--
2.30.1
[gio/patches] build success
What's the point? If it is performance, please mention it in the commit
message, preferably with a benchmark.
On Tue Feb 23, 2021 at 22:22, ~pierrec wrote:
> From: pierre <pierre.curto@gmail.com >
>
> Also introduce a function to decode a float32 from ops.
>
> Signed-off-by: pierre <pierre.curto@gmail.com >
> ---
> io/router/pointer.go | 36 +++++++++++++++++-------------------
> 1 file changed, 17 insertions(+), 19 deletions(-)
>
> diff --git a/io/router/pointer.go b/io/router/pointer.go
> index ab9348b..ef56841 100644
> --- a/io/router/pointer.go
> +++ b/io/router/pointer.go
> @@ -4,7 +4,6 @@ package router
>
> import (
> "encoding/binary"
> - "image"
>
> "gioui.org/f32"
> "gioui.org/internal/opconst"
> @@ -64,7 +63,7 @@ type pointerHandler struct {
>
> type areaOp struct {
> kind areaKind
> - rect image.Rectangle
> + rect f32.Rectangle
> }
>
> type areaNode struct {
> @@ -409,19 +408,22 @@ func searchTag(tags []event.Tag, tag event.Tag) (int, bool) {
> return 0, false
> }
>
> +func opDecodeFloat32(d []byte) float32 {
> + return float32(binary.LittleEndian.Uint32(d))
> +}
> +
> func (op *areaOp) Decode(d []byte) {
> if opconst.OpType(d[0]) != opconst.TypeArea {
> panic("invalid op")
> }
> - bo := binary.LittleEndian
> - rect := image.Rectangle{
> - Min: image.Point{
> - X: int(int32(bo.Uint32(d[2:]))),
> - Y: int(int32(bo.Uint32(d[6:]))),
> + rect := f32.Rectangle{
> + Min: f32.Point{
> + X: opDecodeFloat32(d[2:]),
> + Y: opDecodeFloat32(d[6:]),
> },
> - Max: image.Point{
> - X: int(int32(bo.Uint32(d[10:]))),
> - Y: int(int32(bo.Uint32(d[14:]))),
> + Max: f32.Point{
> + X: opDecodeFloat32(d[10:]),
> + Y: opDecodeFloat32(d[14:]),
> },
> }
> *op = areaOp{
> @@ -431,19 +433,15 @@ func (op *areaOp) Decode(d []byte) {
> }
>
> func (op *areaOp) Hit(pos f32.Point) bool {
> - min := f32.Point{
> - X: float32(op.rect.Min.X),
> - Y: float32(op.rect.Min.Y),
> - }
> - pos = pos.Sub(min)
> + pos = pos.Sub(op.rect.Min)
> size := op.rect.Size()
> switch op.kind {
> case areaRect:
> - return 0 <= pos.X && pos.X < float32(size.X) &&
> - 0 <= pos.Y && pos.Y < float32(size.Y)
> + return 0 <= pos.X && pos.X < size.X &&
> + 0 <= pos.Y && pos.Y < size.Y
> case areaEllipse:
> - rx := float32(size.X) / 2
> - ry := float32(size.Y) / 2
> + rx := size.X / 2
> + ry := size.Y / 2
> xh := pos.X - rx
> yk := pos.Y - ry
> // The ellipse function works in all cases because
> --
> 2.30.1
Le mer. 24 févr. 2021 à 10:20, Elias Naur <mail@eliasnaur.com > a écrit :
>
> What's the point? If it is performance, please mention it in the commit
> message, preferably with a benchmark.
This is indirectly related to the preparation of the ScrollRange patch.
Will add benchmarks though and resend if they are conclusive (also
slightly less memory footprint for very common struct).
>
> On Tue Feb 23, 2021 at 22:22, ~pierrec wrote:
> > From: pierre <pierre.curto@gmail.com >
> >
> > Also introduce a function to decode a float32 from ops.
> >
> > Signed-off-by: pierre <pierre.curto@gmail.com >
> > ---
> > io/router/pointer.go | 36 +++++++++++++++++-------------------
> > 1 file changed, 17 insertions(+), 19 deletions(-)
> >
> > diff --git a/io/router/pointer.go b/io/router/pointer.go
> > index ab9348b..ef56841 100644
> > --- a/io/router/pointer.go
> > +++ b/io/router/pointer.go
> > @@ -4,7 +4,6 @@ package router
> >
> > import (
> > "encoding/binary"
> > - "image"
> >
> > "gioui.org/f32"
> > "gioui.org/internal/opconst"
> > @@ -64,7 +63,7 @@ type pointerHandler struct {
> >
> > type areaOp struct {
> > kind areaKind
> > - rect image.Rectangle
> > + rect f32.Rectangle
> > }
> >
> > type areaNode struct {
> > @@ -409,19 +408,22 @@ func searchTag(tags []event.Tag, tag event.Tag) (int, bool) {
> > return 0, false
> > }
> >
> > +func opDecodeFloat32(d []byte) float32 {
> > + return float32(binary.LittleEndian.Uint32(d))
> > +}
> > +
> > func (op *areaOp) Decode(d []byte) {
> > if opconst.OpType(d[0]) != opconst.TypeArea {
> > panic("invalid op")
> > }
> > - bo := binary.LittleEndian
> > - rect := image.Rectangle{
> > - Min: image.Point{
> > - X: int(int32(bo.Uint32(d[2:]))),
> > - Y: int(int32(bo.Uint32(d[6:]))),
> > + rect := f32.Rectangle{
> > + Min: f32.Point{
> > + X: opDecodeFloat32(d[2:]),
> > + Y: opDecodeFloat32(d[6:]),
> > },
> > - Max: image.Point{
> > - X: int(int32(bo.Uint32(d[10:]))),
> > - Y: int(int32(bo.Uint32(d[14:]))),
> > + Max: f32.Point{
> > + X: opDecodeFloat32(d[10:]),
> > + Y: opDecodeFloat32(d[14:]),
> > },
> > }
> > *op = areaOp{
> > @@ -431,19 +433,15 @@ func (op *areaOp) Decode(d []byte) {
> > }
> >
> > func (op *areaOp) Hit(pos f32.Point) bool {
> > - min := f32.Point{
> > - X: float32(op.rect.Min.X),
> > - Y: float32(op.rect.Min.Y),
> > - }
> > - pos = pos.Sub(min)
> > + pos = pos.Sub(op.rect.Min)
> > size := op.rect.Size()
> > switch op.kind {
> > case areaRect:
> > - return 0 <= pos.X && pos.X < float32(size.X) &&
> > - 0 <= pos.Y && pos.Y < float32(size.Y)
> > + return 0 <= pos.X && pos.X < size.X &&
> > + 0 <= pos.Y && pos.Y < size.Y
> > case areaEllipse:
> > - rx := float32(size.X) / 2
> > - ry := float32(size.Y) / 2
> > + rx := size.X / 2
> > + ry := size.Y / 2
> > xh := pos.X - rx
> > yk := pos.Y - ry
> > // The ellipse function works in all cases because
> > --
> > 2.30.1
>
On Wed Feb 24, 2021 at 11:00, Pierre Curto wrote:
> Le mer. 24 févr. 2021 à 10:20, Elias Naur <mail@eliasnaur.com > a écrit :
> >
> > What's the point? If it is performance, please mention it in the commit
> > message, preferably with a benchmark.
>
> This is indirectly related to the preparation of the ScrollRange patch.
> Will add benchmarks though and resend if they are conclusive (also
> slightly less memory footprint for very common struct).
>
Smaller footprint how? Isn't image.Rectangle the same size as
f32.Rectangle?
Elias