Example #1
0
File: main.go Project: rdterner/exp
func main() {
	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(nil)
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		winSize := image.Point{256, 256}
		b, err := s.NewBuffer(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer b.Release()
		drawGradient(b.RGBA())

		t, err := s.NewTexture(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer t.Release()
		t.Upload(image.Point{}, b, b.Bounds(), w)

		var sz size.Event
		for e := range w.Events() {
			switch e := e.(type) {
			default:
				// TODO: be more interesting.
				fmt.Printf("got %#v\n", e)

			case key.Event:
				fmt.Printf("got %v\n", e)
				if e.Code == key.CodeEscape {
					return
				}

			case paint.Event:
				w.Fill(sz.Bounds(), blue0, draw.Src)
				w.Fill(sz.Bounds().Inset(10), blue1, draw.Src)
				w.Upload(image.Point{}, b, b.Bounds(), w)
				c := math.Cos(math.Pi / 6)
				s := math.Sin(math.Pi / 6)
				w.Draw(f64.Aff3{
					+c, -s, 100,
					+s, +c, 200,
				}, t, t.Bounds(), screen.Over, nil)
				w.Publish()

			case screen.UploadedEvent:
				// No-op.

			case size.Event:
				sz = e

			case error:
				log.Print(e)
			}
		}
	})
}
Example #2
0
File: main.go Project: morero/exp
func main() {
	flag.Parse()

	rand.Seed(int64(time.Now().Nanosecond()))
	board := NewBoard(9, *scale)

	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(nil)
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		var b screen.Buffer
		defer func() {
			if b != nil {
				b.Release()
			}
		}()

		for {
			switch e := w.NextEvent().(type) {
			case lifecycle.Event:
				if e.To == lifecycle.StageDead {
					return
				}

			case key.Event:
				if e.Code == key.CodeEscape {
					return
				}

			case mouse.Event:
				if e.Direction == mouse.DirRelease && e.Button != 0 {
					board.click(b.RGBA(), int(e.X), int(e.Y), int(e.Button))
					w.Send(paint.Event{})
				}

			case paint.Event:
				w.Upload(image.Point{}, b, b.Bounds())
				w.Publish()

			case size.Event:
				// TODO: Set board size.
				if b != nil {
					b.Release()
				}
				b, err = s.NewBuffer(e.Size())
				if err != nil {
					log.Fatal(err)
				}
				render(b.RGBA(), board)

			case error:
				log.Print(e)
			}
		}
	})
}
Example #3
0
func Main(f func(NewFunc)) {
	driver.Main(func(s screen.Screen) {
		ctxt := context{
			screen: s,
		}
		f(ctxt.new)
	})
}
Example #4
0
File: win.go Project: s2607/mbrot
func main() {
	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(nil)
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()
		winSize := image.Point{1000, 1000}
		b, err := s.NewBuffer(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer b.Release()
		drawGradient(b.RGBA())
		t, err := s.NewTexture(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer t.Release()
		t.Upload(image.Point{}, b, b.Bounds())
		var sz size.Event
		for e := range w.Events() {
			// This print message is to help programmers learn what events this
			// example program generates. A real program shouldn't print such
			// messages; they're not important to end users.
			format := "got %#v\n"
			if _, ok := e.(fmt.Stringer); ok {
				format = "got %v\n"
			}
			fmt.Printf(format, e)
			switch e := e.(type) {
			case lifecycle.Event:
				if e.To == lifecycle.StageDead {
					return
				}
			case key.Event:
				if e.Code == key.CodeEscape {
					return
				}
			case paint.Event:
				w.Fill(sz.Bounds(), blue0, draw.Src)
				w.Fill(sz.Bounds().Inset(10), blue1, draw.Src)
				w.Upload(image.Point{}, b, b.Bounds())
				w.Publish()
			case size.Event:
				sz = e
			case error:
				log.Print(e)
			}
		}
	})
}
Example #5
0
func main() {
	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(nil)
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		winSize := image.Point{256, 256}
		b, err := s.NewBuffer(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer b.Release()
		drawGradient(b.RGBA())

		t, err := s.NewTexture(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer t.Release()
		t.Upload(image.Point{}, b, b.Bounds(), w)

		var sz size.Event
		for e := range w.Events() {
			switch e := e.(type) {
			default:
				// TODO: be more interesting.
				fmt.Printf("got event %#v\n", e)

			case size.Event:
				sz = e

			case paint.Event:
				wBounds := image.Rectangle{Max: image.Point{sz.WidthPx, sz.HeightPx}}
				w.Fill(wBounds, color.RGBA{0x00, 0x00, 0x3f, 0xff}, draw.Src)
				w.Upload(image.Point{}, b, b.Bounds(), w)
				w.Draw(f64.Aff3{
					1, 0, 100,
					0, 1, 200,
				}, t, t.Bounds(), screen.Over, nil)
				w.EndPaint(e)

			case screen.UploadedEvent:
				// No-op.

			case error:
				log.Print(e)
			}
		}
	})
}
Example #6
0
File: main.go Project: PieterD/crap
func main() {
	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(&screen.NewWindowOptions{
			Width:  480,
			Height: 640,
		})
		Panic(err)

		g := Game{}

		g.Init(s, w)

		publish := false
		for {
			switch e := w.NextEvent().(type) {
			case lifecycle.Event:
				if e.To == lifecycle.StageDead {
					g.Exit()
					return
				}
			case key.Event:
				fmt.Printf("key\n")
				g.Key(e)
			case mouse.Event:
				fmt.Printf("%f, %f\n", e.X, e.Y)
			case paint.Event:
				fmt.Printf("paint %t\n", e.External)
				publish = true
			case size.Event:
				fmt.Printf("resize %d, %d\n", e.WidthPx, e.HeightPx)
				g.Resize(e.WidthPx, e.HeightPx)
			}

			if publish {
				publish = false
				g.Draw()
			}
		}
	})
}
Example #7
0
func Main(f func(driver.Display)) {
	shiny.Main(func(s screen.Screen) { Run(s, f) })
}
Example #8
0
func main() {
	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(nil)
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		var (
			pool = &tilePool{
				screen:   s,
				drawRGBA: drawRGBA,
				m:        map[image.Point]*tilePoolEntry{},
			}
			dragging     bool
			paintPending bool
			drag         image.Point
			origin       image.Point
			sz           size.Event
		)
		for e := range w.Events() {
			switch e := e.(type) {
			case key.Event:
				if e.Code == key.CodeEscape {
					return
				}

			case mouse.Event:
				p := image.Point{X: int(e.X), Y: int(e.Y)}
				if e.Button == mouse.ButtonLeft && e.Direction != mouse.DirNone {
					dragging = e.Direction == mouse.DirPress
					drag = p
				}
				if !dragging {
					break
				}
				origin = origin.Sub(p.Sub(drag))
				drag = p
				if origin.X < 0 {
					origin.X = 0
				}
				if origin.Y < 0 {
					origin.Y = 0
				}
				if !paintPending {
					paintPending = true
					w.Send(paint.Event{})
				}

			case paint.Event:
				generation++
				var wg sync.WaitGroup
				for y := -(origin.Y & 0xff); y < sz.HeightPx; y += 256 {
					for x := -(origin.X & 0xff); x < sz.WidthPx; x += 256 {
						wg.Add(1)
						go drawTile(&wg, w, pool, origin, x, y)
					}
				}
				wg.Wait()
				w.Publish()
				paintPending = false
				pool.releaseUnused()

			case size.Event:
				sz = e

			case error:
				log.Print(e)
			}
		}
	})
}
Example #9
0
func main() {
	log.SetFlags(0)
	log.SetPrefix("preview: ")
	flag.Usage = func() {
		log.Print("Usage: preview [options] file")
		flag.PrintDefaults()
	}
	flag.Parse()
	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	if *prof != "" {
		log.Print("profile mode: will write out CPU profile after 5 seconds")
		f, err := os.Create(*prof)
		if err != nil {
			log.Fatal(err)
		}
		err = pprof.StartCPUProfile(f)
		if err != nil {
			log.Fatal(err)
		}
		go func() {
			time.Sleep(5 * time.Second)
			pprof.StopCPUProfile()
			log.Print("done writing CPU profile")
		}()
	}

	f, err := os.Open(flag.Arg(0))
	if err != nil {
		log.Fatal(err)
	}

	log.Print("parsing STL...")
	t := time.Now()
	stl, err := slice.Parse(f)
	if err != nil {
		log.Fatal(err)
	}
	f.Close()
	log.Printf("parsing took %v", time.Now().Sub(t))

	if err := sliceSTL(stl); err != nil {
		log.Fatal(err)
	}
	imgs, err := drawLayers(stl)
	if err != nil {
		log.Fatal(err)
	}
	r := imgs[0].Bounds()

	log.Print("Launching UI...")
	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(&screen.NewWindowOptions{
			Width:  r.Dx(),
			Height: r.Dy(),
		})
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		r := image.Rect(int(stl.Min.X), int(stl.Min.Y), int(stl.Max.X)+1, int(stl.Max.Y)+1)
		winSize := r.Size()
		var b screen.Buffer
		defer func() {
			if b != nil {
				b.Release()
			}
		}()

		var sz size.Event
		var lastClick mouse.Event

		var layer int
		redraw := func() {
			draw.Draw(b.RGBA(), b.RGBA().Bounds(), imgs[layer], imgs[layer].Bounds().Min, draw.Src)
			drawLayerNumber(b.RGBA(), layer)
			w.Send(paint.Event{})
		}

		for e := range w.Events() {
			switch e := e.(type) {
			default:

			case mouse.Event:
				if e.Button == mouse.ButtonLeft {
					if e.Y > lastClick.Y && layer < len(imgs)-1 {
						layer++
						redraw()
					} else if e.Y < lastClick.Y && layer > 0 {
						layer--
						redraw()
					}
					lastClick = e
				}

			case key.Event:
				log.Printf("key: %v", e)
				if e.Code == key.CodeEscape {
					log.Print("quitting")
					return
				}

			case paint.Event:
				w.Upload(image.Point{}, b, b.Bounds(), w)
				w.Publish()

			case screen.UploadedEvent:
				// No-op.

			case size.Event:
				sz = e
				if b != nil {
					b.Release()
				}
				winSize = image.Point{sz.WidthPx, sz.HeightPx}
				b, err = s.NewBuffer(winSize)
				if err != nil {
					log.Fatal(err)
				}
				redraw()

			case error:
				log.Printf("error: %v", e)
			}
		}
	})
}
Example #10
0
File: main.go Project: rdterner/exp
func main() {
	flag.Parse()

	rand.Seed(int64(time.Now().Nanosecond()))
	board := NewBoard(9, *scale)

	driver.Main(func(s screen.Screen) {
		w, err := s.NewWindow(nil)
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		var b screen.Buffer
		defer func() {
			if b != nil {
				b.Release()
			}
		}()

		for e := range w.Events() {
			switch e := e.(type) {
			case mouse.Event:
				if e.Direction == mouse.DirRelease && e.Button != 0 {
					board.click(b.RGBA(), int(e.X), int(e.Y), int(e.Button))
					dirty = true
				}

			case key.Event:
				if e.Code == key.CodeEscape {
					return
				}

			case paint.Event:
				// TODO: we shouldn't rely on the library sending us a constant
				// stream of paint events. If we're dirty, we should just draw
				// on the window and then call w.Publish.
				//
				// TODO: This check should save CPU time but causes flicker on Darwin.
				//if dirty && !uploading {
				w.Upload(image.Point{}, b, b.Bounds(), w) // TODO: On Darwin always writes to 0,0, ignoring first arg.
				dirty = false
				uploading = true
				//}
				w.Publish()

			case screen.UploadedEvent:
				// No-op.
				uploading = false

			case size.Event:
				// TODO: Set board size.
				if b != nil {
					b.Release()
				}
				b, err = s.NewBuffer(e.Size())
				if err != nil {
					log.Fatal(err)
				}
				render(b.RGBA(), board)

			case error:
				log.Print(e)
			}
		}
	})
}
Example #11
0
File: main.go Project: sbinet/iview
func main() {
	// Run the CPU profile if we're instructed to.
	if len(flagProfile) > 0 {
		f, err := os.Create(flagProfile)
		if err != nil {
			log.Fatal(err)
		}
		pprof.StartCPUProfile(f)
		defer pprof.StopCPUProfile()
	}

	// Whoops!
	if flag.NArg() == 0 {
		fmt.Fprint(os.Stderr, "\n")
		log.Print("No images specified.\n\n")
		usage()
	}

	driver.Main(func(s screen.Screen) {
		// Decode all images (in parallel).
		names, imgs := decodeImages(findFiles(flag.Args()))

		// Die now if we don't have any images!
		if len(imgs) == 0 {
			log.Fatal("No images specified could be shown. Quitting...")
		}

		winSize := image.Point{flagWidth, flagHeight}
		// Auto-size the window if appropriate.
		if flagAutoResize {
			log.Printf(">>> img[%s]...\n", names[0])
			b := imgs[0].Bounds()
			winSize = image.Point{b.Dx(), b.Dy()}
		}

		w, err := s.NewWindow(&screen.NewWindowOptions{
			Width:  winSize.X,
			Height: winSize.Y,
		})
		if err != nil {
			log.Fatal(err)
		}
		defer w.Release()

		b, err := s.NewBuffer(winSize)
		if err != nil {
			log.Fatal(err)
		}
		defer b.Release()

		w.Fill(b.Bounds(), color.White, draw.Src)
		w.Publish()

		var sz size.Event
		var i int // index of image to display
		for {
			e := w.NextEvent()
			switch e := e.(type) {
			default:

			case mouse.Event:

			case key.Event:
				repaint := false
				switch e.Code {
				case key.CodeEscape, key.CodeQ:
					return
				case key.CodeRightArrow:
					if e.Direction == key.DirPress {
						if i == len(imgs)-1 {
							i = -1
						}
						i++
						repaint = true
						b.Release()
						b, err = s.NewBuffer(sz.Size())
						if err != nil {
							log.Fatal(err)
						}
					}

				case key.CodeLeftArrow:
					if e.Direction == key.DirPress {
						if i == 0 {
							i = len(imgs)
						}
						i--
						repaint = true
						b, err = s.NewBuffer(sz.Size())
						if err != nil {
							log.Fatal(err)
						}
					}

				case key.CodeR:
					if e.Direction == key.DirPress {
						// resize to current image
						r := imgs[i].Bounds()
						sz.HeightPx = r.Dy()
						sz.WidthPx = r.Dx()
						repaint = true
						b, err = s.NewBuffer(sz.Size())
						if err != nil {
							log.Fatal(err)
						}
						w.Publish()

					}
				}
				if repaint {
					w.Send(paint.Event{})
				}

			case paint.Event:
				img := imgs[i]
				draw.Draw(b.RGBA(), b.Bounds(), img, image.Point{}, draw.Src)
				dp := vpCenter(img, sz.WidthPx, sz.HeightPx)
				zero := image.Point{}
				if dp != zero {
					w.Fill(sz.Bounds(), color.Black, draw.Src)
				}
				w.Upload(dp, b, b.Bounds())

			case size.Event:
				sz = e

			case error:
				log.Print(e)
			}
		}
	})
}