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)
}
// 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()
}
// 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()
}
}
}
func arrowhand(cx, cy, px, py, r openvg.VGfloat, t float64, value int, color string) {
ax := []openvg.VGfloat{cx, 0, px, 0, cx}
ay := []openvg.VGfloat{cy, 0, py, 0, cy}
t = minadjust(t, value) * deg2rad
rf := float64(r * 0.9)
tf := math.Pi / 45.0
ax[1] = cx + openvg.VGfloat(rf*math.Cos(t-tf))
ay[1] = cy + openvg.VGfloat(rf*math.Sin(t-tf))
ax[3] = cx + openvg.VGfloat(rf*math.Cos(t+tf))
ay[3] = cy + openvg.VGfloat(rf*math.Sin(t+tf))
openvg.FillColor(color)
openvg.Polygon(ax, ay)
}
// 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()
}
func draw(w, h openvg.VGfloat) {
paintBG(w, h)
var p particle
var grav = openvg.VGfloat(gravity)
for i := 0; i < nparticles; i++ {
p = particles[i]
openvg.FillRGB(p.r, p.g, p.b, 1)
openvg.Circle(p.x, p.y, p.radius)
// Apply the velocity
p.x += p.vx
p.y += p.vy
p.vx *= 0.98
if p.vy > 0 {
p.vy *= 0.97
}
// Gravity
p.vy -= grav
// Stop p leaving the canvas
if p.x < -50 {
p.x = w + 50
}
if p.x > w+50 {
p.x = -50
}
// When particle reaches the bottom of screen reset velocity & start posn
if p.y < -50 {
p.x = 0
p.y = 0
p.vx = openvg.VGfloat(rand.Intn(maxrand)%30) + 30
p.vy = openvg.VGfloat(rand.Intn(maxrand)%20) + 40
if directionRTL {
p.vx *= -1
p.x = w
}
}
if p.y > h+50 {
p.y = -50
}
particles[i] = p
}
openvg.End()
}
func combohand(cx, cy, px, py, r, stroke openvg.VGfloat, t float64, value int, color string) {
thinr := float64(r * 0.25)
t = minadjust(t, value) * deg2rad
tx := cx + openvg.VGfloat(thinr*math.Cos(t))
ty := cy + openvg.VGfloat(thinr*math.Sin(t))
openvg.FillColor(color)
openvg.Ellipse(px, py, stroke*2, stroke*2)
openvg.Ellipse(tx, ty, stroke*2, stroke*2)
openvg.StrokeWidth(stroke)
openvg.StrokeColor(color)
openvg.Line(cx, cy, tx, ty)
openvg.StrokeWidth(stroke * 2)
openvg.Line(tx, ty, px, py)
openvg.StrokeWidth(0)
}
// 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()
}
// adjust the font to fit within a width
func (f *FW) fitwidth(width, adj int, s string) {
f.tw = openvg.TextWidth(s, f.font, f.fontsize)
for f.tw > openvg.VGfloat(width) {
f.fontsize -= adj
f.tw = openvg.TextWidth(s, f.font, f.fontsize)
}
}
// 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() {
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
}
// 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()
}
// Initialize _all_ the particles
func initParticles(w, h openvg.VGfloat) {
particles = make([]particle, nparticles)
for i := 0; i < nparticles; i++ {
particles[i].x = 0
particles[i].y = 0
particles[i].vx = openvg.VGfloat(rand.Intn(maxrand)%30) + 30/100
particles[i].vy = openvg.VGfloat(rand.Intn(maxrand)%20) + 40/100
particles[i].r = uint8(rand.Intn(255))
particles[i].g = uint8(rand.Intn(255))
particles[i].b = uint8(rand.Intn(255))
particles[i].radius = openvg.VGfloat(rand.Intn(maxrand)%20) + 20
if directionRTL {
particles[i].vx *= -0.01
particles[i].x = w
}
}
}
// dodeck sets up the graphics environment and kicks off the interaction
func dodeck(filename, searchterm string, pausetime time.Duration, slidenum, cw, ch int, gp float64) {
firstrun = 0
w, h := openvg.Init()
openvg.FillRGB(200, 200, 200, 1)
openvg.Rect(0, 0, openvg.VGfloat(w), openvg.VGfloat(h))
if cw > 0 {
w = cw
}
if ch > 0 {
h = ch
}
if pausetime == 0 {
interact(filename, searchterm, w, h, slidenum, gp)
} else {
loop(filename, w, h, slidenum, pausetime)
}
openvg.Finish()
}
func PlayVideo(w, h int) {
for {
openvg.Video(openvg.VGfloat(w-900), openvg.VGfloat(h-600), openvg.VGfloat(800), openvg.VGfloat(600), "siATM_video2.mpg.h264")
openvg.Video(openvg.VGfloat(w-900), openvg.VGfloat(h-600), openvg.VGfloat(800), openvg.VGfloat(600), "sketchers_15s.ogv.h264")
}
//openvg.Video(openvg.VGfloat(w-800),openvg.VGfloat(h-600),openvg.VGfloat(800),openvg.VGfloat(600),"test.h264")
//openvg.Video(openvg.VGfloat(w-800),openvg.VGfloat(h-600),openvg.VGfloat(800),openvg.VGfloat(600),"test.h264")
}
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()
}
// 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() {
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
}
}
}
func face(x, y, r openvg.VGfloat, ts int) {
var fx, fy, va openvg.VGfloat
va = openvg.VGfloat(ts) / 2.0
secsize := openvg.VGfloat(ts) / 3
radius := float64(r)
ir := radius * 1.2
// hour display
openvg.FillColor(digitcolor)
openvg.StrokeColor(digitcolor)
openvg.StrokeWidth(5)
for h := 12; h > 0; h-- {
t := hourangles[h%12] * deg2rad
fx = x + openvg.VGfloat(radius*math.Cos(t))
fy = y + openvg.VGfloat(radius*math.Sin(t))
ix := x + openvg.VGfloat(ir*math.Cos(t))
iy := y + openvg.VGfloat(ir*math.Sin(t))
if showdigits {
openvg.TextMid(fx, fy-va, hourdigits[h%12], "sans", ts)
} else {
openvg.Line(fx, fy, ix, iy)
}
}
// second display
openvg.FillColor(dotcolor)
openvg.StrokeColor(dotcolor)
openvg.StrokeWidth(2)
re := radius * edge
for a := 0.0; a < 360; a += 6.0 {
t := a * deg2rad
sx := x + openvg.VGfloat(re*math.Cos(t))
sy := y + openvg.VGfloat(re*math.Sin(t))
if showdots {
openvg.Ellipse(sx, sy, secsize, secsize)
} else {
ix := x + openvg.VGfloat(ir*math.Cos(t))
iy := y + openvg.VGfloat(ir*math.Sin(t))
openvg.Line(sx, sy, ix, iy)
}
}
openvg.StrokeWidth(0)
}
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
}
}
}
// 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()
}
// 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 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()
}
// 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()
}
// showgrid xrays a slide
func showgrid(d deck.Deck, n int, p float64) {
w := openvg.VGfloat(d.Canvas.Width)
h := openvg.VGfloat(d.Canvas.Height)
percent := openvg.VGfloat(p)
fs := (w / 100) // labels are 1% of the width
xpct := (percent / 100.0) * w
ypct := (percent / 100.0) * h
openvg.StrokeColor("lightgray", 0.5)
openvg.StrokeWidth(3)
// horizontal gridlines
xl := percent
for x := xpct; x <= w; x += xpct {
openvg.Line(x, 0, x, h)
openvg.Text(x, percent, fmt.Sprintf("%.0f%%", xl), "sans", int(fs))
xl += percent
}
// vertical gridlines
yl := percent
for y := ypct; y <= h; y += ypct {
openvg.Line(0, y, w, y)
openvg.Text(percent, y, fmt.Sprintf("%.0f%%", yl), "sans", int(fs))
yl += percent
}
// show boundary and location of images
if n < 0 || n > len(d.Slide) {
return
}
for _, im := range d.Slide[n].Image {
x := pct(im.Xp, w)
y := pct(im.Yp, h)
iw := openvg.VGfloat(im.Width)
ih := openvg.VGfloat(im.Height)
if im.Scale > 0 {
iw *= openvg.VGfloat(im.Scale / 100)
ih *= openvg.VGfloat(im.Scale / 100)
}
openvg.FillRGB(127, 0, 0, 0.3)
openvg.Circle(x, y, fs)
openvg.FillRGB(255, 0, 0, 0.1)
openvg.Rect(x-iw/2, y-ih/2, iw, ih)
}
openvg.End()
}
