// imgtest draws images at the corners and center func imagetest(w, h int) { openvg.Start(w, h) imgw := 422 imgh := 238 fiw := openvg.VGfloat(imgw) fih := openvg.VGfloat(imgh) fw := openvg.VGfloat(w) fh := openvg.VGfloat(h) vgzero := openvg.VGfloat(0.0) cx := (fw / 2) - (fiw / 2) cy := (fh / 2) - (fih / 2) ulx := vgzero uly := fh - fih urx := fw - fiw ury := uly llx := vgzero lly := vgzero lrx := urx lry := lly openvg.Start(w, h) openvg.Background(0, 0, 0) openvg.Image(cx, cy, imgw, imgh, "desert1.jpg") openvg.Image(ulx, uly, imgw, imgh, "desert2.jpg") openvg.Image(urx, ury, imgw, imgh, "desert3.jpg") openvg.Image(llx, lly, imgw, imgh, "desert4.jpg") openvg.Image(lrx, lry, imgw, imgh, "desert5.jpg") openvg.End() }
func main() { var color string openvg.Start(width, height) openvg.Background(200, 200, 200) for i := 0; i < niter; i++ { x := random(0, width) y := random(height/3, (height*2)/3) r := random(0, 10000) switch { case r >= 0 && r <= 2500: color = "white" case r > 2500 && r <= 5000: color = "maroon" case r > 5000 && r <= 7500: color = "gray" case r > 7500 && r <= 10000: color = "black" } openvg.FillColor(color, openvg.VGfloat(opacity)) openvg.Circle(openvg.VGfloat(x), openvg.VGfloat(y), openvg.VGfloat(size)) } openvg.End() bufio.NewReader(os.Stdin).ReadByte() openvg.Finish() }
// tb draws a block of text func tb(w, h int) { para := []string{ "For lo,", "the winter is past,", "the rain is over and gone", "the flowers appear on the earth;", "the time for the singing of birds is come,", "and the voice of the turtle is heard in our land", } tmargin := openvg.VGfloat(w) * 0.50 lmargin := openvg.VGfloat(w) * 0.10 top := openvg.VGfloat(h) * .9 mid := openvg.VGfloat(h) * .6 bot := openvg.VGfloat(h) * .3 fontsize := 24 leading := openvg.VGfloat(40.0) lfontsize := fontsize * 2 midb := ((leading * 2) + (leading / 2)) - openvg.VGfloat(lfontsize/2) openvg.Start(w, h) openvg.FillRGB(49, 79, 79, 1) textlines(tmargin, top, para, "serif", fontsize, leading) textlines(tmargin, mid, para, "sans", fontsize, leading) textlines(tmargin, bot, para, "mono", fontsize, leading) openvg.Text(lmargin, top-midb, "Serif", "sans", lfontsize) openvg.Text(lmargin, mid-midb, "Sans", "sans", lfontsize) openvg.Text(lmargin, bot-midb, "Mono", "sans", lfontsize) openvg.End() }
// rshapes draws shapes with random colors, openvg.Strokes, and sizes. func rshapes(width, height, n int) { var sx, sy, cx, cy, px, py, ex, ey, pox, poy openvg.VGfloat np := 10 polyx := make([]openvg.VGfloat, np) polyy := make([]openvg.VGfloat, np) openvg.Start(width, height) for i := 0; i < n; i++ { openvg.FillRGB(randcolor(), randcolor(), randcolor(), openvg.VGfloat(rand.Float32())) openvg.Ellipse(randf(width), randf(height), randf(200), randf(100)) openvg.Circle(randf(width), randf(height), randf(100)) openvg.Rect(randf(width), randf(height), randf(200), randf(100)) openvg.Arc(randf(width), randf(height), randf(200), randf(200), randf(360), randf(360)) sx = randf(width) sy = randf(height) openvg.StrokeRGB(randcolor(), randcolor(), randcolor(), 1) openvg.StrokeWidth(randf(5)) openvg.Line(sx, sy, sx+randf(200), sy+randf(100)) openvg.StrokeWidth(0) sx = randf(width) sy = randf(height) ex = sx + randf(200) ey = sy cx = sx + ((ex - sx) / 2.0) cy = sy + randf(100) openvg.Qbezier(sx, sy, cx, cy, ex, ey) sx = randf(width) sy = randf(height) ex = sx + randf(200) ey = sy cx = sx + ((ex - sx) / 2.0) cy = sy + randf(100) px = cx py = sy - randf(100) openvg.Cbezier(sx, sy, cx, cy, px, py, ex, ey) pox = randf(width) poy = randf(height) for j := 0; j < np; j++ { polyx[j] = pox + randf(200) polyy[j] = poy + randf(100) } openvg.Polygon(polyx, polyy) // , np) pox = randf(width) poy = randf(height) for j := 0; j < np; j++ { polyx[j] = pox + randf(200) polyy[j] = poy + randf(100) } openvg.Polyline(polyx, polyy) // , np) } openvg.FillRGB(128, 0, 0, 1) openvg.Text(20, 20, "OpenVG on the Raspberry Pi", "sans", 32) openvg.End() }
func main() { var cx, cy, cw, ch, midy int message := "Now is the time for all good men to come to the aid of the party" w, h := openvg.Init() var speed openvg.VGfloat = 0.5 var x openvg.VGfloat = 0 midy = (h / 2) fontsize := w / 50 cx = 0 ch = fontsize * 2 cw = w cy = midy - (ch / 2) rx, ry, rw, rh := openvg.VGfloat(cx), openvg.VGfloat(cy), openvg.VGfloat(cw), openvg.VGfloat(ch) // scroll the text, only in the clipping rectangle for x = 0; x < rw+speed; x += speed { openvg.Start(w, h) openvg.Background(255, 255, 255) openvg.FillRGB(0, 0, 0, .2) openvg.Rect(rx, ry, rw, rh) openvg.ClipRect(cx, cy, cw, ch) openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) openvg.FillRGB(0, 0, 0, 1) openvg.Text(0, 0, message, "sans", fontsize) openvg.ClipEnd() openvg.End() } bufio.NewReader(os.Stdin).ReadBytes('\n') openvg.Finish() os.Exit(0) }
// loadimage loads all the images of the deck into a map for later display func loadimage(d deck.Deck, m map[string]image.Image) { firstrun++ w, h := d.Canvas.Width, d.Canvas.Height cw := openvg.VGfloat(w) ch := openvg.VGfloat(h) msize := int(cw * .01) mx := cw / 2 my := ch * 0.05 mbg := "white" mfg := "black" for ns, s := range d.Slide { for ni, i := range s.Image { if !modfile(i.Name, StartTime) { continue } openvg.Start(w, h) if i.Link != "" { fmt.Fprintf(os.Stderr, "Found altimg %s\n", i.Link) } f, err := os.Open(i.Name) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) continue } img, _, err := image.Decode(f) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) continue } openvg.FillColor(mbg) openvg.Rect(0, 0, cw, ch) openvg.FillColor(mfg) openvg.TextMid(mx, my, fmt.Sprintf("Loading image %s %d from slide %d", i.Name, ni, ns), "sans", msize) bounds := img.Bounds() iw := i.Width ih := i.Height if i.Scale > 0 { iw = int(float64(iw) * (i.Scale / 100)) ih = int(float64(ih) * (i.Scale / 100)) } // if the specified dimensions are native use those, otherwise resize if iw == (bounds.Max.X-bounds.Min.X) && ih == (bounds.Max.Y-bounds.Min.Y) { m[i.Name] = img } else { g := gift.New(gift.Resize(iw, ih, gift.BoxResampling)) resized := image.NewRGBA(g.Bounds(img.Bounds())) g.Draw(resized, img) m[i.Name] = resized } f.Close() openvg.End() } } }
// raspberry pi, scaled to the screen dimensions func raspi(w, h int, s string) { midx := openvg.VGfloat(w) / 2 midy := openvg.VGfloat(h) / 2 rw := midx rh := (rw * 2) / 3 fontsize := w / 25 openvg.Start(w, h) openvg.Background(255, 255, 255) makepi(midx-(rw/2), midy-(rh/2), rw, rh) openvg.FillRGB(128, 0, 0, 1) openvg.TextMid(midx, midy-(rh/2)-openvg.VGfloat(fontsize*2), s, "sans", fontsize) openvg.End() }
//planets is an exploration of scale func planets(width, height int, message string) { w := openvg.VGfloat(width) h := openvg.VGfloat(height) y := h / 2 margin := openvg.VGfloat(100.0) minsize := openvg.VGfloat(7.0) labeloc := openvg.VGfloat(100.0) bgcolor := "black" labelcolor := "white" maxsize := (h / 2) * 0.05 origin := sun.distance mostDistant := neptune.distance firstSize := mercury.radius lastSize := neptune.radius openvg.Start(width, height) openvg.BackgroundColor(bgcolor) for _, p := range solarSystem { x := vmap(p.distance, origin, mostDistant, margin, w-margin) r := vmap(p.radius, firstSize, lastSize, minsize, maxsize) if p.name == "Sun" { openvg.FillRGB(p.color.Red, p.color.Green, p.color.Blue, 1) openvg.Circle(margin-(r/2), y, r) } else { light(x, y, r, p.color) openvg.Circle(x, y, r) if p.name == "Saturn" { ringwidth := r * 2.35 // Saturn's rings are over 2x the planet radius openvg.StrokeWidth(3) openvg.StrokeRGB(p.color.Red, p.color.Green, p.color.Blue, 1) openvg.Line((x - ringwidth/2), y, (x + ringwidth/2), y) openvg.StrokeWidth(0) } } if p.name == "Earth" && len(message) > 1 { openvg.StrokeColor(labelcolor) openvg.StrokeWidth(1) openvg.Line(x, y+(r/2), x, y+labeloc) openvg.StrokeWidth(0) openvg.FillColor(labelcolor) openvg.TextMid(x, y+labeloc+10, message, "sans", 12) } } openvg.End() }
// raspberry pi, scaled to the screen dimensions func main() { w, h := openvg.Init() midx := openvg.VGfloat(w) / 2 midy := openvg.VGfloat(h) / 2 rw := midx rh := (rw * 2) / 3 fontsize := w / 25 openvg.Start(w, h) openvg.Background(255, 255, 255) makepi(midx-(rw/2), midy-(rh/2), rw, rh) makepi(200, 100, 75, 50) openvg.FillRGB(128, 0, 0, 1) openvg.TextMid(midx, midy-(rh/2)-openvg.VGfloat(fontsize*2), "The Raspberry Pi", "sans", fontsize) WaitEnd() }
func main() { width, height := openvg.Init() w := openvg.VGfloat(width) h := openvg.VGfloat(height) y := h / 2 var ( margin openvg.VGfloat = 100.0 minsize openvg.VGfloat = 7.0 labeloc openvg.VGfloat = 100.0 ) bgcolor := "black" labelcolor := "white" maxsize := (h / 2) * 0.05 origin := sun.distance mostDistant := neptune.distance firstSize := mercury.radius lastSize := neptune.radius openvg.Start(width, height) openvg.BackgroundColor(bgcolor) for _, p := range solarSystem { x := vmap(p.distance, origin, mostDistant, margin, w-margin) r := vmap(p.radius, firstSize, lastSize, minsize, maxsize) if p.name == "Sun" { openvg.FillRGB(p.color.Red, p.color.Green, p.color.Blue, 1) openvg.Circle(margin-(r/2), y, r) } else { light(x, y, r, p.color) openvg.Circle(x, y, r) } if p.name == "Earth" && len(os.Args) > 1 { openvg.StrokeColor(labelcolor) openvg.StrokeWidth(1) openvg.Line(x, y+(r/2), x, y+labeloc) openvg.StrokeWidth(0) openvg.FillColor(labelcolor) openvg.TextMid(x, y+labeloc+10, os.Args[1], "sans", 12) } } openvg.End() bufio.NewReader(os.Stdin).ReadByte() openvg.Finish() }
func main() { width, height := openvg.Init() // OpenGL, etc initialization w2 := openvg.VGfloat(width / 2) h2 := openvg.VGfloat(height / 2) w := openvg.VGfloat(width) openvg.Start(width, height) // Start the picture openvg.BackgroundColor("black") // Black background openvg.FillRGB(44, 100, 232, 1) // Big blue marble openvg.Circle(w2, 0, w) // The "world" openvg.FillColor("white") // White text openvg.TextMid(w2, h2, "hello, world", "serif", width/10) // Greetings openvg.End() // End the picture bufio.NewReader(os.Stdin).ReadBytes('\n') // Pause until [RETURN] openvg.Finish() // Graphics cleanup }
func gradient(width, height int) { w := openvg.VGfloat(width) h := openvg.VGfloat(height) stops := []openvg.Offcolor{ {0.0, openvg.RGB{255, 255, 255}, 1.0}, {0.5, openvg.RGB{128, 128, 128}, 1.0}, {1.0, openvg.RGB{0, 0, 0}, 1.0}, } x1 := w / 8 x2 := (w * 3) / 8 y1 := h / 3 y2 := (h * 2) / 3 cx := (w * 3) / 4 cy := (h / 2) r := (x2 - x1) fx := cx + (r / 4) fy := cy + (r / 4) openvg.Start(width, height) openvg.BackgroundRGB(128, 128, 128, 1) openvg.FillLinearGradient(x1, y1, x2, y2, stops) openvg.Rect(x1, y1, x2-x1, y2-y1) openvg.FillRadialGradient(cx, cy, fx, fy, r, stops) openvg.Circle(cx, cy, r) openvg.FillRGB(0, 0, 0, 0.3) openvg.Circle(x1, y1, 10) openvg.Circle(x2, y2, 10) openvg.Circle(cx, cy, 10) openvg.Circle(cx+r/2, cy, 10) openvg.Circle(fx, fy, 10) openvg.FillColor("black") SansTypeface := "sans" openvg.TextMid(x1, y1-20, "(x1, y1)", SansTypeface, 18) openvg.TextMid(x2, y2+10, "(x2, y2)", SansTypeface, 18) openvg.TextMid(cx, cy, "(cx, cy)", SansTypeface, 18) openvg.TextMid(fx, fy, "(fx, fy)", SansTypeface, 18) openvg.TextEnd(cx+(r/2)+20, cy, "r", SansTypeface, 18) openvg.TextMid(x1+((x2-x1)/2), h/6, "Linear Gradient", SansTypeface, 36) openvg.TextMid(cx, h/6, "Radial Gradient", SansTypeface, 36) openvg.End() }
func main() { setOptions() rand.Seed(time.Now().Unix()) w, h := openvg.Init() width, height := openvg.VGfloat(w), openvg.VGfloat(h) initParticles(width, height) openvg.Start(w, h) i := 0 for { draw(width, height) time.Sleep(2 * time.Millisecond) //fmt.Printf(".") i++ if alternate && i == nswitch { // switch launch direction every nswitch draws directionRTL = !directionRTL i = 0 } } }
// textplay exercises text functions func textplay(w, h int) { forlo := `For lo, the winter is past, the rain is over and gone. The flowers appear on the earth, the time for the singing of birds is come, and the voice of the turtle is heard in our land.` // forsince := `For since by man came death, by man came also the resurrection of the dead, for as in Adam all die, even so in Christ shall all be made alive.` openvg.Start(w, h) var ( tw openvg.VGfloat = 300 begin openvg.VGfloat = 50 xincr openvg.VGfloat = 400 offset openvg.VGfloat = 100 ) for x, y := begin, openvg.VGfloat(h)-offset; x < openvg.VGfloat(w/2); x += xincr { textwrap(x, y, tw, forlo, "sans", 12, 24, 0.25, "black") textwrap(x, y-400, tw, forlo, "sans", 12, 24, 0.5, "black") tw -= offset } openvg.End() }
func main() { var loop = flag.Bool("loop", false, "Loop the show") var resize = flag.Bool("resize", false, `Resize image to fit the screen.`) var bgcolor = flag.String("bg", "black", `Background color (named color or rgb(r,g,b)).`) var delay = flag.Duration("delay", 2*time.Second, "Delay between pictures") flag.Usage = func() { fmt.Fprintf(os.Stderr, "usage: %s [ flags ] images...\n", os.Args[0]) flag.PrintDefaults() os.Exit(1) } flag.Parse() w, h := openvg.Init() images := []image.Image{} imgcount := 0 for _, imgfile := range flag.Args() { fmt.Fprintf(os.Stderr, "loading %q ", imgfile) img, err := getimage(imgfile, w, h, *resize) if err != nil { fmt.Fprintln(os.Stderr, err) continue } images = append(images, img) imgcount++ fmt.Fprintln(os.Stderr, "ok") } for { for _, img := range images { ib := img.Bounds() imw, imh := ib.Max.X-ib.Min.X, ib.Max.Y-ib.Min.Y openvg.Start(w, h) openvg.BackgroundColor(*bgcolor) x, y := openvg.VGfloat(w)/2-openvg.VGfloat(imw)/2, openvg.VGfloat(h)/2-openvg.VGfloat(imh)/2 openvg.Img(x, y, img) openvg.End() time.Sleep(*delay) } if !*loop { break } } }
// testpattern shows a test pattern func testpattern(w, h int, s string) { var midx, midy1, midy2, midy3 openvg.VGfloat fontsize := 256 h2 := openvg.VGfloat(h / 2) by := openvg.VGfloat(h - 100) bx := openvg.VGfloat(w - 100) tw1 := &FW{"mono", 0, fontsize} tw2 := &FW{"sans", 0, fontsize} tw3 := &FW{"serif", 0, fontsize} openvg.Start(w, h) // colored squares in the corners openvg.FillRGB(255, 0, 0, 1) openvg.Rect(0, 0, 100, 100) openvg.FillRGB(0, 255, 0, 1) openvg.Rect(0, by, 100, 100) openvg.FillRGB(0, 0, 255, 1) openvg.Rect(bx, 0, 100, 100) openvg.FillRGB(128, 128, 128, 1) openvg.Rect(bx, by, 100, 100) // for each font, (Sans, Serif, Mono), adjust the string to the w tw1.fitwidth(w, 20, s) tw2.fitwidth(w, 20, s) tw3.fitwidth(w, 20, s) midx = openvg.VGfloat(w / 2) // Adjust the baselines to be medial midy1 = h2 + 20 + openvg.VGfloat((tw1.fontsize)/2) midy2 = h2 - openvg.VGfloat((tw2.fontsize)/2) midy3 = h2 - 20 - openvg.VGfloat(tw2.fontsize) - openvg.VGfloat((tw3.fontsize)/2) openvg.FillRGB(128, 128, 128, 1) openvg.TextMid(midx, midy1, s, tw1.font, tw1.fontsize) openvg.FillRGB(128, 0, 0, 1) openvg.TextMid(midx, midy2, s, tw2.font, tw2.fontsize) openvg.FillRGB(0, 0, 128, 1) openvg.TextMid(midx, midy3, s, tw3.font, tw3.fontsize) openvg.End() }
// rotext draws text, rotated around the center of the screen, progressively faded func rotext(w, h, n int, s string) { fade := (100.0 / openvg.VGfloat(n)) / 100.0 deg := 360.0 / openvg.VGfloat(n) x := openvg.VGfloat(w) / 2.0 y := openvg.VGfloat(h) / 2.0 alpha := openvg.VGfloat(1.0) size := w / 8 openvg.Start(w, h) openvg.Background(0, 0, 0) openvg.Translate(x, y) for i := 0; i < n; i++ { openvg.FillRGB(255, 255, 255, alpha) openvg.Text(0, 0, s, "serif", size) alpha -= fade // fade size += n // enlarge openvg.Rotate(deg) } openvg.End() }
// main plots data from specified files or standard input in a // grid where plotc specifies the number of columns. func main() { w, h := openvg.Init() i := 1 filenames := flag.Args() for i <= 1000 { openvg.Start(w, h) openvg.FillColor("white") openvg.Rect(0, 0, gwidth, gheight) if len(filenames) == 0 { doplot(beginx, beginy, "") } else { plotgrid(beginx, beginy, filenames) } openvg.End() i = i + 1 } bufio.NewReader(os.Stdin).ReadByte() openvg.Finish() }
func imagetable(w, h int) { imgw, imgh := 422, 238 itable := []it{ {"desert0.jpg", imgw, imgh}, {"desert1.jpg", imgw, imgh}, {"desert2.jpg", imgw, imgh}, {"desert3.jpg", imgw, imgh}, {"desert4.jpg", imgw, imgh}, {"desert5.jpg", imgw, imgh}, {"desert6.jpg", imgw, imgh}, {"desert7.jpg", imgw, imgh}, //{"http://farm4.static.flickr.com/3546/3338566612_9c56bfb53e_m.jpg", 240, 164}, //{"http://farm4.static.flickr.com/3642/3337734413_e36baba755_m.jpg", 240, 164}, } offset := openvg.VGfloat(50) left := offset bot := openvg.VGfloat(h-imgh) - offset gutter := offset x := left y := bot openvg.Start(w, h) openvg.BackgroundColor("black") for _, iname := range itable { openvg.Image(x, y, iname.width, iname.height, iname.name) openvg.FillRGB(255, 255, 255, 0.3) openvg.Rect(x, y, openvg.VGfloat(imgw), 32) openvg.FillRGB(0, 0, 0, 1) openvg.TextMid(x+openvg.VGfloat(imgw/2), y+10, iname.name, "sans", 16) x += openvg.VGfloat(iname.width) + gutter if x > openvg.VGfloat(w) { x = left y -= openvg.VGfloat(iname.height) + gutter } } y = openvg.VGfloat(h) * 0.1 openvg.FillRGB(128, 128, 128, 1) openvg.TextMid(openvg.VGfloat(w/2), 100, "Joshua Tree National Park", "sans", 48) openvg.End() }
// advert is an ad for the package func advert(w, h int) { y := openvg.VGfloat(h) / 4 fontsize := (w * 4) / 100 f3 := fontsize / 3 s := "github.com/ajstarks/openvg" a := "*****@*****.**" imw := 110 imh := 110 rw := openvg.VGfloat(w / 4) rh := (rw * 2) / 3 midx := openvg.VGfloat(w / 2) openvg.Start(w, h) makepi(midx-openvg.VGfloat(rw/2), openvg.VGfloat(h/2), rw, rh) openvg.FillRGB(128, 0, 0, 1) openvg.TextMid(midx, y-openvg.VGfloat(fontsize/4), s, "sans", fontsize) y -= 100 openvg.FillRGB(128, 128, 128, 1) openvg.TextMid(midx, y, a, "sans", f3) openvg.Image(openvg.VGfloat(w/2)-openvg.VGfloat(imw/2), 20, imw, imh, "starx.jpg") openvg.End() }
// fontrange shows a range of fonts func fontrange(w, h int) { var x, lx, length openvg.VGfloat y := openvg.VGfloat(h) / 2.0 w2 := openvg.VGfloat(w) / 2.0 spacing := openvg.VGfloat(50.0) s2 := spacing / 2.0 sizes := []int{6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 21, 24, 36, 48, 60, 72, 96} openvg.Start(w, h) openvg.Background(255, 255, 255) // compute the length so we can center length = 0.0 for _, s := range sizes { length += openvg.VGfloat(s) + spacing } length -= spacing lx = w2 - (length / 2) // center point // for each size, display a character and label x = lx for _, s := range sizes { openvg.FillRGB(128, 0, 0, 1) openvg.TextMid(x, y, "a", "serif", s) openvg.FillRGB(128, 128, 128, 1) openvg.TextMid(x, y-spacing, fmt.Sprintf("%d", s), "sans", 16) x += openvg.VGfloat(s) + spacing } // draw a openvg.Line below the characters, a curve above x -= spacing openvg.StrokeRGB(150, 150, 150, 0.5) openvg.StrokeWidth(2) openvg.Line(lx, y-s2, x, y-s2) openvg.FillRGB(255, 255, 255, 1) openvg.Qbezier(lx, y+s2, x, y+s2, x, y+(spacing*3)) openvg.End() }
func main() { width, height := openvg.Init() // OpenGL, etc initialization w2 := openvg.VGfloat(width / 2) h2 := openvg.VGfloat(height / 2) w := openvg.VGfloat(width) stops := []openvg.Offcolor{ {0.0, openvg.RGB{44, 100, 232}, 1.0}, // blue-ish {0.5, openvg.RGB{22, 50, 151}, 1.0}, // darker blue {1.0, openvg.RGB{88, 200, 255}, 1.0}, // lighter blue } openvg.Start(width, height) // Start the picture openvg.BackgroundColor("black") // Black background openvg.FillRadialGradient(w2, 0, w2, w2, w*.5, stops) // Big blue marble openvg.Circle(w2, 0, w) // The "world" openvg.FillColor("white") // White text openvg.TextMid(w2, h2, "hello, world", "serif", width/10) // Greetings //openvg.SaveEnd("hvg.raw") // End the picture openvg.End() bufio.NewReader(os.Stdin).ReadBytes('\n') // Pause until [RETURN] openvg.Finish() // Graphics cleanup }
func main() { var nr = flag.Int("n", 500, "number of objects") var message = flag.String("m", "Go/OpenVG", "message") var bgcolor = flag.String("bg", "white", "background color") var fgcolor = flag.String("fg", "maroon", "text color") flag.Parse() rseed() width, height := openvg.Init() fw := openvg.VGfloat(width) fh := openvg.VGfloat(height) openvg.Start(width, height) openvg.BackgroundColor(*bgcolor) for i := 0; i < *nr; i++ { red := uint8(rand.Intn(255)) green := uint8(rand.Intn(255)) blue := uint8(rand.Intn(255)) alpha := randf() x := randf() * fw y := randf() * fh radius := randf() * fw / 10 openvg.FillRGB(red, green, blue, alpha) openvg.Circle(x, y, radius) } openvg.FillColor(*fgcolor) openvg.TextMid(fw/2, fh/2, *message, "sans", width/25) openvg.End() bufio.NewReader(os.Stdin).ReadBytes('\n') openvg.Finish() }
func main() { var ( filename = flag.String("f", "svgcolors.txt", "input file") fontname = flag.String("font", "sans", "fontname") neg = flag.Bool("neg", false, "negative") showrgb = flag.Bool("rgb", false, "show RGB") showcode = flag.Bool("showcode", true, "show colors and codes") circsw = flag.Bool("circle", true, "circle swatch") outline = flag.Bool("outline", false, "outline swatch") fontsize = flag.Int("fs", 12, "fontsize") rowsize = flag.Int("r", 32, "rowsize") colw = flag.Float64("c", 340, "column size") swatch = flag.Float64("s", 16, "swatch size") gutter = flag.Float64("g", 12, "gutter") err error tcolor, line string ) flag.Parse() f, oerr := os.Open(*filename) if oerr != nil { fmt.Fprintf(os.Stderr, "%v\n", oerr) return } width, height := openvg.Init() openvg.Start(width, height) fw := openvg.VGfloat(width) fh := openvg.VGfloat(height) if *neg { openvg.FillColor("black") openvg.Rect(0, 0, fw, fh) tcolor = "white" } else { openvg.FillColor("white") openvg.Rect(0, 0, fw, fh) tcolor = "black" } top := fh - 32.0 left := openvg.VGfloat(32.0) cw := openvg.VGfloat(*colw) sw := openvg.VGfloat(*swatch) g := openvg.VGfloat(*gutter) in := bufio.NewReader(f) for x, y, nr := left, top, 0; err == nil; nr++ { line, err = in.ReadString('\n') fields := strings.Split(strings.TrimSpace(line), "\t") if nr%*rowsize == 0 && nr > 0 { x += cw y = top } if len(fields) == 3 { var red, green, blue uint8 fmt.Sscanf(fields[2], "%d,%d,%d", &red, &green, &blue) openvg.FillRGB(red, green, blue, 1) if *outline { openvg.StrokeColor("black") openvg.StrokeWidth(1) } if *circsw { openvg.Circle(x+sw/2, y+sw/2, sw) } else { openvg.Rect(x, y, sw, sw) } openvg.StrokeWidth(0) openvg.FillColor(tcolor) openvg.Text(x+sw+openvg.VGfloat(*fontsize/2), y, fields[0], *fontname, *fontsize) var label string if *showcode { if *showrgb { label = fields[1] } else { label = fields[2] } openvg.FillColor("gray") openvg.TextEnd(x+cw-(sw+g), y, label, *fontname, *fontsize) } } y -= (sw + g) } openvg.End() bufio.NewReader(os.Stdin).ReadBytes('\n') openvg.Finish() }
// refcard shows a reference card of shapes func refcard(width, height int) { shapenames := []string{ "Circle", "Ellipse", "Rectangle", "Rounded Rectangle", "Line", "Polyline", "Polygon", "Arc", "Quadratic Bezier", "Cubic Bezier", "Image", } top := openvg.VGfloat(height) * .95 sx := openvg.VGfloat(width) * 0.10 sy := top sw := openvg.VGfloat(width) * .05 sh := openvg.VGfloat(height) * .045 dotsize := openvg.VGfloat(7.0) spacing := openvg.VGfloat(2.0) fontsize := int(openvg.VGfloat(height) * .033) shapecolor := Color{202, 225, 255, 1.0} openvg.Start(width, height) openvg.FillRGB(128, 0, 0, 1) openvg.TextEnd(openvg.VGfloat(width-20), openvg.VGfloat(height/2), "OpenVG on the Raspberry Pi", "sans", fontsize+(fontsize/2)) openvg.FillRGB(0, 0, 0, 1) for _, s := range shapenames { openvg.Text(sx+sw+sw/2, sy, s, "sans", fontsize) sy -= sh * spacing } sy = top cx := sx + (sw / 2) ex := sx + sw openvg.FillRGB(shapecolor.red, shapecolor.green, shapecolor.blue, shapecolor.alpha) openvg.Circle(cx, sy, sw) coordpoint(cx, sy, dotsize, shapecolor) sy -= sh * spacing openvg.Ellipse(cx, sy, sw, sh) coordpoint(cx, sy, dotsize, shapecolor) sy -= sh * spacing openvg.Rect(sx, sy, sw, sh) coordpoint(sx, sy, dotsize, shapecolor) sy -= sh * spacing openvg.Roundrect(sx, sy, sw, sh, 20, 20) coordpoint(sx, sy, dotsize, shapecolor) sy -= sh * spacing openvg.StrokeWidth(1) openvg.StrokeRGB(204, 204, 204, 1) openvg.Line(sx, sy, ex, sy) coordpoint(sx, sy, dotsize, shapecolor) coordpoint(ex, sy, dotsize, shapecolor) sy -= sh px := []openvg.VGfloat{sx, sx + (sw / 4), sx + (sw / 2), sx + ((sw * 3) / 4), sx + sw} py := []openvg.VGfloat{sy, sy - sh, sy, sy - sh, sy} openvg.Polyline(px, py) // , 5) coordpoint(px[0], py[0], dotsize, shapecolor) coordpoint(px[1], py[1], dotsize, shapecolor) coordpoint(px[2], py[2], dotsize, shapecolor) coordpoint(px[3], py[3], dotsize, shapecolor) coordpoint(px[4], py[4], dotsize, shapecolor) sy -= sh * spacing py[0] = sy py[1] = sy - sh py[2] = sy - (sh / 2) py[3] = py[1] - (sh / 4) py[4] = sy openvg.Polygon(px, py) // , 5) sy -= (sh * spacing) + sh openvg.Arc(sx+(sw/2), sy, sw, sh, 0, 180) coordpoint(sx+(sw/2), sy, dotsize, shapecolor) sy -= sh * spacing var cy, ey openvg.VGfloat cy = sy + (sh / 2) ey = sy openvg.Qbezier(sx, sy, cx, cy, ex, ey) coordpoint(sx, sy, dotsize, shapecolor) coordpoint(cx, cy, dotsize, shapecolor) coordpoint(ex, ey, dotsize, shapecolor) sy -= sh * spacing ey = sy cy = sy + sh openvg.Cbezier(sx, sy, cx, cy, cx, sy, ex, ey) coordpoint(sx, sy, dotsize, shapecolor) coordpoint(cx, cy, dotsize, shapecolor) coordpoint(cx, sy, dotsize, shapecolor) coordpoint(ex, ey, dotsize, shapecolor) sy -= (sh * spacing * 1.5) openvg.Image(sx, sy, 110, 110, "starx.jpg") openvg.End() }
func main() { var sreenHeight, cx, cy, cw, ch, midy int message := "Scrolling texts could be useful if the information does not fit on screen" w, h := openvg.Init() sreenHeight = h var speed openvg.VGfloat = 0.5 var x openvg.VGfloat = 0 midy = (h / 2) fontsize := w / 50 cx = 0 ch = fontsize * 2 cw = w cy = midy - (ch / 2) var jsonData SLData for { response, err := http.Get("http://localhost:8000") if err == nil { defer response.Body.Close() contents, err := ioutil.ReadAll(response.Body) if err != nil { fmt.Printf("Error reading http data, %s", err) } else { fmt.Printf("Got: %s\n", string(contents)) if err := json.Unmarshal(contents, &jsonData); err != nil { panic(err) } fmt.Println(jsonData) } } openvg.Start(w, h) imgw, imgh := 0, 0 openvg.Background(255, 255, 255) //SLHeight = 60 var imgPosY = openvg.VGfloat(sreenHeight - 70) openvg.Image(4, imgPosY, imgw, imgh, "SL.jpg") var TAB1 = openvg.VGfloat(4 * w / 20) var TAB2 = openvg.VGfloat(8 * w / 20) rx1, rw1, rh1 := openvg.VGfloat(cx), openvg.VGfloat(cw), openvg.VGfloat(ch) ty := 0 rix := 0 // Buses for ty = sreenHeight - (80 + int(rh1)); ty > 0 && rix < len(jsonData.ResponseData.Buses); ty -= ch { tempy := openvg.VGfloat(ty) //ry := openvg.VGfloat(ty) if rix%2 == 0 { openvg.FillRGB(0, 0, 0, .2) //openvg.Rect(rx1, tempy, rw1, rh1) openvg.FillRGB(0, 0, 0, 1) tempy = tempy + 6.0 } else { openvg.FillRGB(0, 0, 0, .4) openvg.Rect(rx1, tempy, rw1, rh1) tempy = tempy + 6.0 openvg.FillRGB(0, 0, 0, 1) } openvg.Text(rx1, tempy, jsonData.ResponseData.Buses[rix].LineNumber, "sans", fontsize) drawTypeOfTransport(rx1+60, tempy+2, rw1, ch-20, jsonData.ResponseData.Buses[rix].TransportMode) openvg.Text(rx1+100, tempy, jsonData.ResponseData.Buses[rix].StopPointDesignation, "sans", fontsize) openvg.Text(rx1+TAB1, tempy, jsonData.ResponseData.Buses[rix].DisplayTime, "sans", fontsize) var dest = jsonData.ResponseData.Buses[rix].Destination dest = replaceAO(dest) openvg.Text(rx1+TAB2, tempy, dest, "sans", fontsize) //openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) //openvg.Background(255,255,0) rix = rix + 1 } var trainIx = 0 for ty = ty - 20; ty > 0 && trainIx < len(jsonData.ResponseData.Trains); ty -= ch { tempy := openvg.VGfloat(ty) //ry := openvg.VGfloat(ty) if rix%2 == 0 { openvg.FillRGB(0, 0, 0, .2) //openvg.Rect(rx1, tempy, rw1, rh1) openvg.FillRGB(0, 0, 0, 1) tempy = tempy + 6.0 } else { openvg.FillRGB(0, 0, 0, .4) openvg.Rect(rx1, tempy, rw1, rh1) tempy = tempy + 6.0 openvg.FillRGB(0, 0, 0, 1) } openvg.Text(rx1, tempy, jsonData.ResponseData.Trains[trainIx].LineNumber, "sans", fontsize) drawTypeOfTransport(rx1+55, tempy+4, rw1, ch-20, jsonData.ResponseData.Trains[trainIx].TransportMode) openvg.Text(rx1+TAB1, tempy, jsonData.ResponseData.Trains[trainIx].DisplayTime, "sans", fontsize) var dest = jsonData.ResponseData.Trains[trainIx].Destination dest = replaceAO(dest) openvg.Text(rx1+TAB2, tempy, dest, "sans", fontsize) //openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) //openvg.Background(255,255,0) trainIx = trainIx + 1 rix = rix + 1 } //openvg.End() openvg.SaveEnd("dump.raw") time.Sleep(60 * time.Second) } bufio.NewReader(os.Stdin).ReadBytes('\n') rx, ry, rw, rh := openvg.VGfloat(cx), openvg.VGfloat(cy), openvg.VGfloat(cw), openvg.VGfloat(ch) // scroll the text, only in the clipping rectangle for x = 0; x < rw+speed; x += speed { openvg.Start(w, h) openvg.Background(255, 255, 255) openvg.FillRGB(0, 0, 0, .2) openvg.Rect(rx, ry, rw, rh) openvg.ClipRect(cx, cy, cw, ch) openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) openvg.FillRGB(0, 0, 0, 1) openvg.Text(0, 0, message, "sans", fontsize) openvg.ClipEnd() openvg.End() } bufio.NewReader(os.Stdin).ReadBytes('\n') openvg.Finish() os.Exit(0) }
func main() { flag.StringVar(&mincolor, "mincolor", "maroon", "minute color") flag.StringVar(&facecolor, "facecolor", "white", "face color") flag.StringVar(&hrcolor, "hourcolor", "gray", "hour color") flag.StringVar(&secolor, "secolor", "maroon", "second color") flag.StringVar(&digitcolor, "digitcolor", "black", "digit color") flag.StringVar(&dotcolor, "dotcolor", "silver", "dotcolor") flag.StringVar(&framecolor, "framecolor", "gray", "frame color") flag.StringVar(¢ercolor, "centercolor", "black", "center color") flag.StringVar(&handstyle, "handstyle", "combo", "handstyle (combo, arrow, or round)") flag.BoolVar(&showdigits, "showdigits", true, "show digits") flag.BoolVar(&showdots, "showdots", true, "show dots") flag.BoolVar(&secline, "secline", false, "show second hand") flag.Parse() width, height := openvg.Init() cx := openvg.VGfloat(width / 2) cy := openvg.VGfloat(height / 2) facesize := openvg.VGfloat(cy * 0.5) textsize := facesize / 10.0 framesize := facesize * 2.5 hourstroke := textsize minstroke := hourstroke * .6 // set up the ticker and signal handler ticker := time.NewTicker(1 * time.Second) sigint := make(chan os.Signal, 1) signal.Notify(sigint, os.Interrupt) // main loop: for each second, draw the clock components openvg.Start(width, height) for { select { case <-ticker.C: // get the current time hr, min, sec := time.Now().Clock() // compute element coordinates hx, hy, mx, my, sx, sy := timecoord(cx, cy, facesize, hr, min, sec) // frame and clock face frame(cx, cy, framesize, facesize, textsize, framecolor, facecolor) face(cx, cy, facesize, int(textsize*1.5)) // hour and minute hands switch handstyle { case "round", "r": roundhand(cx, cy, mx, my, minstroke, mincolor) roundhand(cx, cy, hx, hy, hourstroke, hrcolor) case "arrow", "a": arrowhand(cx, cy, mx, my, facesize*0.9, minangles[min], 0, mincolor) arrowhand(cx, cy, hx, hy, facesize*0.6, hourangles[hr%12], min, hrcolor) case "combo", "c": combohand(cx, cy, mx, my, facesize*0.9, minstroke/2, minangles[min], 0, mincolor) combohand(cx, cy, hx, hy, facesize*0.6, minstroke/2, hourangles[hr%12], min, hrcolor) default: combohand(cx, cy, mx, my, facesize*0.9, minstroke/2, minangles[min], 0, mincolor) combohand(cx, cy, hx, hy, facesize*0.6, minstroke/2, hourangles[hr%12], min, hrcolor) } // second indicator secondhand(cx, cy, sx, sy, textsize) // center dot centerdot(cx, cy, textsize) // make the picture openvg.End() case <-sigint: openvg.Finish() return } } }
func main() { var sreenHeight, cx, cy, cw, ch int message := "Hej Sandra tack forden mysiga kramen ..... <3 <3 Puss puss" w, h := openvg.Init() sreenHeight = h var speed openvg.VGfloat = 4.0 var x openvg.VGfloat = 0 //midy = (h / 2) fontsize := w / 50 cx = 0 ch = fontsize * 2 cw = w //cy = midy - (ch / 2) cy = h - 80 var jsonData SLData var lastmill = makeTimestamp() response, err := http.Get("http://localhost:8000") if err == nil { defer response.Body.Close() contents, err := ioutil.ReadAll(response.Body) if err != nil { fmt.Printf("Error reading http data, %s", err) } else { fmt.Printf("Got: %s\n", string(contents)) if err := json.Unmarshal(contents, &jsonData); err != nil { panic(err) } fmt.Println(jsonData) } } openvg.Start(w, h) openvg.End() go PlayVideo(w, h) for { openvg.Start(w, h) //fmt.Println("W,H",w,h) rx, ry, rw, rh := openvg.VGfloat(cx), openvg.VGfloat(cy), openvg.VGfloat(cw), openvg.VGfloat(ch) // scroll the text, only in the clipping rectangle for x = 0; x < rw+speed; x += speed { var mill = makeTimestamp() var delta = (mill - lastmill) / 5 //fmt.Println("delta ", delta) //speed x = openvg.VGfloat(delta) imgw, imgh := 0, 0 openvg.Background(0, 0, 0) //SLHeight = 60 var imgPosY = openvg.VGfloat(sreenHeight - 120) openvg.Image(8, imgPosY, imgw, imgh, "DA4FID.png") var TAB1 = openvg.VGfloat(4 * w / 20) //var TAB2 = openvg.VGfloat(8*w/20) rx1, rw1, rh1 := openvg.VGfloat(cx), openvg.VGfloat(cw), openvg.VGfloat(ch) ty := 0 rix := 0 // - (120 + int(rh1)) ty = sreenHeight - 140 var trainIx = 0 for ty = ty - 20; ty > 0 && trainIx < len(jsonData.ResponseData.Trains); ty -= ch { tempy := openvg.VGfloat(ty) //ry := openvg.VGfloat(ty) if rix%2 == 0 { openvg.FillRGB(255, 255, 255, .2) //openvg.Rect(rx1, tempy, rw1, rh1) tempy = tempy + 6.0 } else { openvg.FillRGB(255, 255, 255, .4) openvg.Rect(rx1, tempy, rw1/3, rh1) tempy = tempy + 6.0 } openvg.FillRGB(255, 255, 255, 1) //openvg.Text(rx1, tempy, jsonData.ResponseData.Trains[trainIx].LineNumber , "sans", fontsize) //drawTypeOfTransport(rx1+55,tempy+4,rw1,ch-20,jsonData.ResponseData.Trains[trainIx].TransportMode) openvg.Text(rx1, tempy, jsonData.ResponseData.Trains[trainIx].DisplayTime, "sans", fontsize) var dest = jsonData.ResponseData.Trains[trainIx].Destination dest = replaceAO(dest) openvg.Text(rx1+TAB1, tempy, dest, "sans", fontsize) //openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) //openvg.Background(255,255,0) trainIx = trainIx + 1 rix = rix + 1 } imgw = 20 imgh = 20 //openvg.Image(8, 100 , imgw, imgh, "no_smoking.png") // openvg.Start(w, h) //openvg.Background(255, 255, 255) openvg.FillRGB(100, 0, 0, 1) openvg.Rect(rx, ry, rw, rh) //openvg.ClipRect(cx, cy, cw, ch) //openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) openvg.FillRGB(255, 255, 255, 1) var pxp openvg.VGfloat = openvg.VGfloat(w) - openvg.VGfloat(x) var pyp openvg.VGfloat = openvg.VGfloat(h) - openvg.VGfloat(58) openvg.Text(pxp, pyp, message, "sans", fontsize) //openvg.ClipEnd() openvg.End() } //openvg.SaveEnd("dump.raw") //time.Sleep(60*time.Second); } bufio.NewReader(os.Stdin).ReadBytes('\n') bufio.NewReader(os.Stdin).ReadBytes('\n') openvg.Finish() os.Exit(0) }
func main() { var resize = flag.Bool("resize", false, "Resize image to fit the screen.") var bgcolor = flag.String("bg", "black", "Background color (named color or rgb(r,g,b)).") var fgcolor = flag.String("fg", "white", "text color (named color or rgb(r,g,b)).") var title = flag.String("t", "", "text annotation") var fontsize = flag.Float64("fp", 2.0, "fontsize %") var px = flag.Float64("px", 50, "x position %") var py = flag.Float64("py", 50, "y position %") var texty = flag.Float64("ty", 0, "text y %") var exit_code int defer func() { os.Exit(exit_code) }() flag.Usage = func() { fmt.Fprintf(os.Stderr, `usage: %s [ flags ] image-path Set specified image as an overlay screen via OpenVG lib. Default is to put this image to the center. `, os.Args[0]) flag.PrintDefaults() exit_code = 1 return } flag.Parse() if flag.NArg() != 1 { fmt.Fprintf(os.Stderr, "Exactly one image-path argument must be specified.\n") flag.Usage() exit_code = 2 return } openvg.SaveTerm() w, h := openvg.Init() openvg.RawTerm() defer openvg.Finish() defer openvg.RestoreTerm() img, err := getimage(flag.Args()[0], w, h, *resize) if err != nil { exit_code = 3 return } ib := img.Bounds() imw, imh := ib.Max.X-ib.Min.X, ib.Max.Y-ib.Min.Y sig_chan := make(chan os.Signal, 1) signal.Notify(sig_chan, os.Interrupt, os.Kill, syscall.SIGHUP, syscall.SIGTERM, syscall.SIGALRM) openvg.Start(w, h) openvg.BackgroundColor(*bgcolor) var x, y openvg.VGfloat if *px < 0 || *px > 100 { x = openvg.VGfloat(w)/2 - openvg.VGfloat(imw)/2 } else { x = openvg.VGfloat(w)*openvg.VGfloat(*px/100) - openvg.VGfloat(imw)/2 } if *py < 0 || *py > 100 { y = openvg.VGfloat(h)/2 - openvg.VGfloat(imh)/2 } else { y = openvg.VGfloat(h)*openvg.VGfloat(*py/100) - openvg.VGfloat(imh)/2 } openvg.Img(x, y, img) if len(*title) > 0 { var typ openvg.VGfloat fs := openvg.VGfloat(*fontsize/100.0) * openvg.VGfloat(w) if *texty == 0 { typ = y - fs*1.5 } else { typ = openvg.VGfloat(h) * openvg.VGfloat(*texty/100) } openvg.FillColor(*fgcolor) openvg.TextMid(x+openvg.VGfloat(imw)/2, typ, *title, "sans", int(fs)) } openvg.End() _ = <-sig_chan }
func main() { var cy, ch, midy int var message []string message = []string{" Black", "cats", "skitter", "and", "ghouls", "patter", "Happy", "Halloween"} w, h := openvg.Init() //var speed openvg.VGfloat = 0.5 var x openvg.VGfloat = 0 var vw, vh openvg.VGfloat var midxx openvg.VGfloat = openvg.VGfloat(w / 2) midy = (h / 2) fontsize := w / 8 //cx = 0 ch = fontsize * 2 //cw = w cy = midy - (ch / 2) var redness uint8 var index int //rx , rw, rh := openvg.VGfloat(cx) , openvg.VGfloat(cw), openvg.VGfloat(ch) ry := openvg.VGfloat(cy) // scroll the text, only in the clipping rectangle index = 0 for { for redness = 255; redness > 16; redness -= 2 { ch = fontsize * 2 //cw = w cy = midy - (ch / 2) openvg.Start(w, h) openvg.Background(redness, 0, 0) openvg.FillRGB(0, 0, 0, .2) //openvg.Rect(rx, ry, rw, rh) //openvg.ClipRect(cx, cy, cw, ch) openvg.Translate(x, ry+openvg.VGfloat(fontsize/2)) openvg.FillRGB(0, 0, 0, 1) var fsiz int fsiz = int(255 - redness) openvg.TextMid(midxx, 0, message[index], "shf", fsiz) openvg.ClipEnd() openvg.End() } index = (index + 1) % 8 if index == 0 { vw = openvg.VGfloat(w) - 200 vh = openvg.VGfloat(h) - 200 openvg.Video(100.0, 100.0, vw, vh, "test.h264") } if index == 0 { var test, oix int var xpos [40]float32 var ypos [40]float32 var rotate [40]float32 var spdx [40]float32 var spdy [40]float32 // Init positions for test = 0; test < 40; test++ { var rot = rand.Float32() var rax = rand.Float32() rax = float32(w) * rax var ray = rand.Float32() ray = float32(h) * ray spdx[test] = float32(test) * rand.Float32() spdy[test] = float32(test) * rand.Float32() ypos[test] = ray xpos[test] = rax rot = 0 rotate[test] = rot } // Move around for oix = 0; oix < 100; oix++ { openvg.Start(w, h) openvg.Background(0, 0, 0) openvg.FillColor("red") for test = 0; test < 40; test++ { var rot = rand.Float32() var rax = rand.Float32()*float32(4.0) - float32(2.0) var ray = float32(4.0)*rand.Float32() - float32(2.0) spdy[test] += ray spdx[test] += rax xpos[test] = xpos[test] + spdx[test] ypos[test] = ypos[test] + spdy[test] rotate[test] = rotate[test] + float32(rot*4-2) openvg.Rotate(openvg.VGfloat(rotate[test])) openvg.Translate(openvg.VGfloat(xpos[test]), openvg.VGfloat(ypos[test])) openvg.TextMid(0, 0, "Happy Halloween", "shf", 30) openvg.Translate(-openvg.VGfloat(xpos[test]), -openvg.VGfloat(ypos[test])) openvg.Rotate(-openvg.VGfloat(rotate[test])) } openvg.End() } } } bufio.NewReader(os.Stdin).ReadBytes('\n') openvg.Finish() os.Exit(0) }