//export setGeom func setGeom(pixelsPerPt float32, widthPx, heightPx int) { windowHeightPx = float32(heightPx) eventsIn <- size.Event{ WidthPx: widthPx, HeightPx: heightPx, WidthPt: geom.Pt(float32(widthPx) / pixelsPerPt), HeightPt: geom.Pt(float32(heightPx) / pixelsPerPt), PixelsPerPt: pixelsPerPt, } }
//export onResize func onResize(w, h int) { // TODO(nigeltao): don't assume 72 DPI. DisplayWidth and DisplayWidthMM // is probably the best place to start looking. pixelsPerPt := float32(1) eventsIn <- size.Event{ WidthPx: w, HeightPx: h, WidthPt: geom.Pt(w), HeightPt: geom.Pt(h), PixelsPerPt: pixelsPerPt, } }
//export updateConfig func updateConfig(width, height, orientation int32) { o := size.OrientationUnknown switch orientation { case C.UIDeviceOrientationPortrait, C.UIDeviceOrientationPortraitUpsideDown: o = size.OrientationPortrait case C.UIDeviceOrientationLandscapeLeft, C.UIDeviceOrientationLandscapeRight: o = size.OrientationLandscape } widthPx := screenScale * int(width) heightPx := screenScale * int(height) eventsIn <- size.Event{ WidthPx: widthPx, HeightPx: heightPx, WidthPt: geom.Pt(float32(widthPx) / pixelsPerPt), HeightPt: geom.Pt(float32(heightPx) / pixelsPerPt), PixelsPerPt: pixelsPerPt, Orientation: o, } }
func (e *engine) render(n *sprite.Node, t clock.Time, sz size.Event) { if n.EngineFields.Index == 0 { panic("glsprite: sprite.Node not registered") } if n.Arranger != nil { n.Arranger.Arrange(e, n, t) } // Push absTransforms. // TODO: cache absolute transforms and use EngineFields.Dirty? rel := &e.nodes[n.EngineFields.Index].relTransform m := f32.Affine{} m.Mul(&e.absTransforms[len(e.absTransforms)-1], rel) e.absTransforms = append(e.absTransforms, m) if x := n.EngineFields.SubTex; x.T != nil { x.T.(*texture).glImage.Draw( sz, geom.Point{ geom.Pt(m[0][2]), geom.Pt(m[1][2]), }, geom.Point{ geom.Pt(m[0][2] + m[0][0]), geom.Pt(m[1][2] + m[1][0]), }, geom.Point{ geom.Pt(m[0][2] + m[0][1]), geom.Pt(m[1][2] + m[1][1]), }, x.R, ) } for c := n.FirstChild; c != nil; c = c.NextSibling { e.render(c, t, sz) } // Pop absTransforms. e.absTransforms = e.absTransforms[:len(e.absTransforms)-1] }
func TestAffine(t *testing.T) { f, err := os.Open("../../../testdata/testpattern.png") if err != nil { t.Fatal(err) } defer f.Close() srcOrig, _, err := image.Decode(f) if err != nil { t.Fatal(err) } src := image.NewRGBA(srcOrig.Bounds()) draw.Draw(src, src.Rect, srcOrig, srcOrig.Bounds().Min, draw.Src) const ( pixW = 100 pixH = 100 ptW = geom.Pt(50) ptH = geom.Pt(50) ) sz := size.Event{ WidthPx: pixW, HeightPx: pixH, WidthPt: ptW, HeightPt: ptH, PixelsPerPt: float32(pixW) / float32(ptW), } got := image.NewRGBA(image.Rect(0, 0, pixW, pixH)) blue := image.NewUniform(color.RGBA{B: 0xff, A: 0xff}) draw.Draw(got, got.Bounds(), blue, image.Point{}, draw.Src) b := src.Bounds() b.Min.X += 10 b.Max.Y /= 2 var a f32.Affine a.Identity() a.Scale(&a, sz.PixelsPerPt, sz.PixelsPerPt) a.Translate(&a, 0, 24) a.Rotate(&a, float32(math.Asin(12./20))) // See commentary in the render method defined in portable.go. a.Scale(&a, 40/float32(b.Dx()), 20/float32(b.Dy())) a.Inverse(&a) affine(got, src, b, nil, &a, draw.Over) ptTopLeft := geom.Point{0, 24} ptBottomRight := geom.Point{12 + 32, 16} drawCross(got, 0, 0) drawCross(got, int(ptTopLeft.X.Px(sz.PixelsPerPt)), int(ptTopLeft.Y.Px(sz.PixelsPerPt))) drawCross(got, int(ptBottomRight.X.Px(sz.PixelsPerPt)), int(ptBottomRight.Y.Px(sz.PixelsPerPt))) drawCross(got, pixW-1, pixH-1) const wantPath = "../../../testdata/testpattern-window.png" f, err = os.Open(wantPath) if err != nil { t.Fatal(err) } defer f.Close() wantSrc, _, err := image.Decode(f) if err != nil { t.Fatal(err) } want, ok := wantSrc.(*image.RGBA) if !ok { b := wantSrc.Bounds() want = image.NewRGBA(b) draw.Draw(want, b, wantSrc, b.Min, draw.Src) } if !imageEq(got, want) { gotPath, err := writeTempPNG("testpattern-window-got", got) if err != nil { t.Fatal(err) } t.Errorf("got\n%s\nwant\n%s", gotPath, wantPath) } }
func TestImage(t *testing.T) { done := make(chan error) defer close(done) go func() { runtime.LockOSThread() ctx, err := createContext() done <- err for { select { case <-gl.WorkAvailable: gl.DoWork() case <-done: ctx.destroy() return } } }() if err := <-done; err != nil { t.Fatalf("cannot create GL context: %v", err) } start() defer stop() // GL testing strategy: // 1. Create an offscreen framebuffer object. // 2. Configure framebuffer to render to a GL texture. // 3. Run test code: use glimage to draw testdata. // 4. Copy GL texture back into system memory. // 5. Compare to a pre-computed image. f, err := os.Open("../../../testdata/testpattern.png") if err != nil { t.Fatal(err) } defer f.Close() src, _, err := image.Decode(f) if err != nil { t.Fatal(err) } const ( pixW = 100 pixH = 100 ptW = geom.Pt(50) ptH = geom.Pt(50) ) sz := size.Event{ WidthPx: pixW, HeightPx: pixH, WidthPt: ptW, HeightPt: ptH, PixelsPerPt: float32(pixW) / float32(ptW), } fBuf := gl.CreateFramebuffer() gl.BindFramebuffer(gl.FRAMEBUFFER, fBuf) colorBuf := gl.CreateRenderbuffer() gl.BindRenderbuffer(gl.RENDERBUFFER, colorBuf) // https://www.khronos.org/opengles/sdk/docs/man/xhtml/glRenderbufferStorage.xml // says that the internalFormat "must be one of the following symbolic constants: // GL_RGBA4, GL_RGB565, GL_RGB5_A1, GL_DEPTH_COMPONENT16, or GL_STENCIL_INDEX8". gl.RenderbufferStorage(gl.RENDERBUFFER, gl.RGB565, pixW, pixH) gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, colorBuf) if status := gl.CheckFramebufferStatus(gl.FRAMEBUFFER); status != gl.FRAMEBUFFER_COMPLETE { t.Fatalf("framebuffer create failed: %v", status) } allocs := testing.AllocsPerRun(100, func() { gl.ClearColor(0, 0, 1, 1) // blue }) if allocs != 0 { t.Errorf("unexpected allocations from calling gl.ClearColor: %f", allocs) } gl.Clear(gl.COLOR_BUFFER_BIT) gl.Viewport(0, 0, pixW, pixH) m := NewImage(src.Bounds().Dx(), src.Bounds().Dy()) b := m.RGBA.Bounds() draw.Draw(m.RGBA, b, src, src.Bounds().Min, draw.Src) m.Upload() b.Min.X += 10 b.Max.Y /= 2 // All-integer right-angled triangles offsetting the // box: 24-32-40, 12-16-20. ptTopLeft := geom.Point{0, 24} ptTopRight := geom.Point{32, 0} ptBottomLeft := geom.Point{12, 24 + 16} ptBottomRight := geom.Point{12 + 32, 16} m.Draw(sz, ptTopLeft, ptTopRight, ptBottomLeft, b) // For unknown reasons, a windowless OpenGL context renders upside- // down. That is, a quad covering the initial viewport spans: // // (-1, -1) ( 1, -1) // (-1, 1) ( 1, 1) // // To avoid modifying live code for tests, we flip the rows // recovered from the renderbuffer. We are not the first: // // http://lists.apple.com/archives/mac-opengl/2010/Jun/msg00080.html got := image.NewRGBA(image.Rect(0, 0, pixW, pixH)) upsideDownPix := make([]byte, len(got.Pix)) gl.ReadPixels(upsideDownPix, 0, 0, pixW, pixH, gl.RGBA, gl.UNSIGNED_BYTE) for y := 0; y < pixH; y++ { i0 := (pixH - 1 - y) * got.Stride i1 := i0 + pixW*4 copy(got.Pix[y*got.Stride:], upsideDownPix[i0:i1]) } drawCross(got, 0, 0) drawCross(got, int(ptTopLeft.X.Px(sz.PixelsPerPt)), int(ptTopLeft.Y.Px(sz.PixelsPerPt))) drawCross(got, int(ptBottomRight.X.Px(sz.PixelsPerPt)), int(ptBottomRight.Y.Px(sz.PixelsPerPt))) drawCross(got, pixW-1, pixH-1) const wantPath = "../../../testdata/testpattern-window.png" f, err = os.Open(wantPath) if err != nil { t.Fatal(err) } defer f.Close() wantSrc, _, err := image.Decode(f) if err != nil { t.Fatal(err) } want, ok := wantSrc.(*image.RGBA) if !ok { b := wantSrc.Bounds() want = image.NewRGBA(b) draw.Draw(want, b, wantSrc, b.Min, draw.Src) } if !imageEq(got, want) { // Write out the image we got. f, err = ioutil.TempFile("", "testpattern-window-got") if err != nil { t.Fatal(err) } f.Close() gotPath := f.Name() + ".png" f, err = os.Create(gotPath) if err != nil { t.Fatal(err) } if err := png.Encode(f, got); err != nil { t.Fatal(err) } if err := f.Close(); err != nil { t.Fatal(err) } t.Errorf("got\n%s\nwant\n%s", gotPath, wantPath) } }
func main(f func(App)) { // Preserve this OS thread for: // 1. the attached JNI thread // 2. the GL context runtime.LockOSThread() // Calls into NativeActivity functions must be made from // a thread attached to the JNI. var env *C.JNIEnv if errStr := C.attachJNI(&env); errStr != nil { log.Fatalf("app: %s", C.GoString(errStr)) } donec := make(chan struct{}) go func() { f(app{}) close(donec) }() var q *C.AInputQueue var pixelsPerPt float32 var orientation size.Orientation // Android can send a windowRedrawNeeded event any time, including // in the middle of a paint cycle. The redraw event may have changed // the size of the screen, so any partial painting is now invalidated. // We must also not return to Android (via sending on windowRedrawDone) // until a complete paint with the new configuration is complete. // // When a windowRedrawNeeded request comes in, we increment redrawGen // (Gen is short for generation number), and do not make a paint cycle // visible on <-endPaint unless Generation agrees. If possible, // windowRedrawDone is signalled, allowing onNativeWindowRedrawNeeded // to return. var redrawGen uint32 for { if q != nil { processEvents(env, q) } select { case <-windowCreated: case q = <-inputQueue: case <-donec: return case cfg := <-windowConfigChange: pixelsPerPt = cfg.pixelsPerPt orientation = cfg.orientation case w := <-windowRedrawNeeded: if C.surface == nil { if errStr := C.createEGLSurface(w); errStr != nil { log.Printf("app: %s (%s)", C.GoString(errStr), eglGetError()) return } } sendLifecycle(lifecycle.StageFocused) widthPx := int(C.ANativeWindow_getWidth(w)) heightPx := int(C.ANativeWindow_getHeight(w)) eventsIn <- size.Event{ WidthPx: widthPx, HeightPx: heightPx, WidthPt: geom.Pt(float32(widthPx) / pixelsPerPt), HeightPt: geom.Pt(float32(heightPx) / pixelsPerPt), PixelsPerPt: pixelsPerPt, Orientation: orientation, } redrawGen++ eventsIn <- paint.Event{redrawGen} case <-windowDestroyed: if C.surface != nil { if errStr := C.destroyEGLSurface(); errStr != nil { log.Printf("app: %s (%s)", C.GoString(errStr), eglGetError()) return } } C.surface = nil sendLifecycle(lifecycle.StageAlive) case <-gl.WorkAvailable: gl.DoWork() case p := <-endPaint: if p.Generation != redrawGen { continue } if C.surface != nil { // eglSwapBuffers blocks until vsync. if C.eglSwapBuffers(C.display, C.surface) == C.EGL_FALSE { log.Printf("app: failed to swap buffers (%s)", eglGetError()) } } select { case windowRedrawDone <- struct{}{}: default: } if C.surface != nil { redrawGen++ eventsIn <- paint.Event{redrawGen} } } } }