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 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)
}
// showlide displays slides
func showslide(d deck.Deck, imap map[string]image.Image, n int) {
var video videoType
if n < 0 || n > len(d.Slide)-1 {
return
}
slide := d.Slide[n]
if slide.Bg == "" {
slide.Bg = "white"
}
if slide.Fg == "" {
slide.Fg = "black"
}
openvg.Start(d.Canvas.Width, d.Canvas.Height)
cw := openvg.VGfloat(d.Canvas.Width)
ch := openvg.VGfloat(d.Canvas.Height)
if slide.Gradcolor1 != "" && slide.Gradcolor2 != "" {
oc := []openvg.Offcolor{
{0, openvg.Colorlookup(slide.Gradcolor1), 1},
{1, openvg.Colorlookup(slide.Gradcolor2), 1},
}
openvg.FillLinearGradient(0, ch, 0, 0, oc)
} else {
openvg.FillColor(slide.Bg)
}
openvg.Rect(0, 0, cw, ch)
var x, y, fs openvg.VGfloat
// every image in the slide
for _, im := range slide.Image {
x = pct(im.Xp, cw)
y = pct(im.Yp, ch)
imw := openvg.VGfloat(im.Width)
imh := openvg.VGfloat(im.Height)
if im.Scale > 0 {
imw *= openvg.VGfloat(im.Scale / 100)
imh *= openvg.VGfloat(im.Scale / 100)
}
midx := openvg.VGfloat(imw / 2)
midy := openvg.VGfloat(imh / 2)
if im.Type == "video" {
// Only one video per slide supported
video.name = im.Name
video.x = x - midx
video.y = y - midy
video.w = imw
video.h = imh
video.altimg = im.Link
} else {
img, ok := imap[im.Name]
if ok {
openvg.Img(x-midx, y-midy, img)
}
if len(im.Caption) > 0 {
capfs := pctwidth(im.Sp, cw, cw/100)
if im.Font == "" {
im.Font = "sans"
}
if im.Color == "" {
openvg.FillColor(slide.Fg)
} else {
openvg.FillColor(im.Color)
}
if im.Align == "" {
im.Align = "center"
}
switch im.Align {
case "left", "start":
x -= midx
case "right", "end":
x += midx
}
showtext(x, y-((midy)+(capfs*2.0)), im.Caption, im.Align, im.Font, capfs)
}
}
}
// every graphic on the slide
const defaultColor = "rgb(127,127,127)"
const defaultSw = 1.5
var strokeopacity float64
// line
for _, line := range slide.Line {
if line.Color == "" {
line.Color = slide.Fg // defaultColor
}
if line.Opacity == 0 {
strokeopacity = 1
} else {
strokeopacity = line.Opacity / 100.0
}
x1, y1, sw := dimen(d, line.Xp1, line.Yp1, line.Sp)
x2, y2, _ := dimen(d, line.Xp2, line.Yp2, 0)
openvg.StrokeColor(line.Color, openvg.VGfloat(strokeopacity))
if sw == 0 {
sw = defaultSw
}
openvg.StrokeWidth(openvg.VGfloat(sw))
openvg.StrokeColor(line.Color)
openvg.Line(x1, y1, x2, y2)
openvg.StrokeWidth(0)
}
// ellipse
for _, ellipse := range slide.Ellipse {
x, y, _ = dimen(d, ellipse.Xp, ellipse.Yp, 0)
var w, h openvg.VGfloat
w = pct(ellipse.Wp, cw)
if ellipse.Hr == 0 { // if relative height not specified, base height on overall height
h = pct(ellipse.Hp, ch)
} else {
h = pct(ellipse.Hr, w)
}
if ellipse.Color == "" {
ellipse.Color = defaultColor
}
if ellipse.Opacity == 0 {
ellipse.Opacity = 1
} else {
ellipse.Opacity /= 100
}
openvg.FillColor(ellipse.Color, openvg.VGfloat(ellipse.Opacity))
openvg.Ellipse(x, y, w, h)
}
// rect
for _, rect := range slide.Rect {
x, y, _ = dimen(d, rect.Xp, rect.Yp, 0)
var w, h openvg.VGfloat
w = pct(rect.Wp, cw)
if rect.Hr == 0 { // if relative height not specified, base height on overall height
h = pct(rect.Hp, ch)
} else {
h = pct(rect.Hr, w)
}
if rect.Color == "" {
rect.Color = defaultColor
}
if rect.Opacity == 0 {
rect.Opacity = 1
} else {
rect.Opacity /= 100
}
openvg.FillColor(rect.Color, openvg.VGfloat(rect.Opacity))
openvg.Rect(x-(w/2), y-(h/2), w, h)
}
// curve
for _, curve := range slide.Curve {
if curve.Color == "" {
curve.Color = defaultColor
}
if curve.Opacity == 0 {
strokeopacity = 1
} else {
strokeopacity = curve.Opacity / 100.0
}
x1, y1, sw := dimen(d, curve.Xp1, curve.Yp1, curve.Sp)
x2, y2, _ := dimen(d, curve.Xp2, curve.Yp2, 0)
x3, y3, _ := dimen(d, curve.Xp3, curve.Yp3, 0)
openvg.StrokeColor(curve.Color, openvg.VGfloat(strokeopacity))
openvg.FillColor(slide.Bg, openvg.VGfloat(curve.Opacity))
if sw == 0 {
sw = defaultSw
}
openvg.StrokeWidth(sw)
openvg.Qbezier(x1, y1, x2, y2, x3, y3)
openvg.StrokeWidth(0)
}
// arc
for _, arc := range slide.Arc {
if arc.Color == "" {
arc.Color = defaultColor
}
if arc.Opacity == 0 {
strokeopacity = 1
} else {
strokeopacity = arc.Opacity / 100.0
}
ax, ay, sw := dimen(d, arc.Xp, arc.Yp, arc.Sp)
w := pct(arc.Wp, cw)
h := pct(arc.Hp, cw)
openvg.StrokeColor(arc.Color, openvg.VGfloat(strokeopacity))
openvg.FillColor(slide.Bg, openvg.VGfloat(arc.Opacity))
if sw == 0 {
sw = defaultSw
}
openvg.StrokeWidth(sw)
openvg.Arc(ax, ay, w, h, openvg.VGfloat(arc.A1), openvg.VGfloat(arc.A2))
openvg.StrokeWidth(0)
}
// polygon
for _, poly := range slide.Polygon {
if poly.Color == "" {
poly.Color = defaultColor
}
if poly.Opacity == 0 {
poly.Opacity = 1
} else {
poly.Opacity /= 100
}
xs := strings.Split(poly.XC, " ")
ys := strings.Split(poly.YC, " ")
if len(xs) != len(ys) {
continue
}
if len(xs) < 3 || len(ys) < 3 {
continue
}
px := make([]openvg.VGfloat, len(xs))
py := make([]openvg.VGfloat, len(ys))
for i := 0; i < len(xs); i++ {
x, err := strconv.ParseFloat(xs[i], 32)
if err != nil {
px[i] = 0
} else {
px[i] = pct(x, cw)
}
y, err := strconv.ParseFloat(ys[i], 32)
if err != nil {
py[i] = 0
} else {
py[i] = pct(y, ch)
}
}
openvg.FillColor(poly.Color, openvg.VGfloat(poly.Opacity))
openvg.Polygon(px, py)
}
openvg.FillColor(slide.Fg)
// every list in the slide
var offset, textopacity openvg.VGfloat
const blinespacing = 2.4
for _, l := range slide.List {
if l.Font == "" {
l.Font = "sans"
}
x, y, fs = dimen(d, l.Xp, l.Yp, l.Sp)
if l.Type == "bullet" {
offset = 1.2 * fs
} else {
offset = 0
}
if l.Lp == 0 {
l.Lp = blinespacing
}
if l.Opacity == 0 {
textopacity = 1
} else {
textopacity = openvg.VGfloat(l.Opacity / 100)
}
// every list item
var li, lifont string
for ln, tl := range l.Li {
if len(l.Color) > 0 {
openvg.FillColor(l.Color, textopacity)
} else {
openvg.FillColor(slide.Fg)
}
if l.Type == "bullet" {
boffset := fs / 2
openvg.Ellipse(x, y+boffset, boffset, boffset)
//openvg.Rect(x, y+boffset/2, boffset, boffset)
}
if l.Type == "number" {
li = fmt.Sprintf("%d. ", ln+1) + tl.ListText
} else {
li = tl.ListText
}
if len(tl.Color) > 0 {
openvg.FillColor(tl.Color, textopacity)
}
if len(tl.Font) > 0 {
lifont = tl.Font
} else {
lifont = l.Font
}
showtext(x+offset, y, li, l.Align, lifont, fs)
y -= fs * openvg.VGfloat(l.Lp)
}
}
openvg.FillColor(slide.Fg)
// every text in the slide
const linespacing = 1.8
var tdata string
for _, t := range slide.Text {
if t.File != "" {
tdata = includefile(t.File)
} else {
tdata = t.Tdata
}
if t.Font == "" {
t.Font = "sans"
}
if t.Opacity == 0 {
textopacity = 1
} else {
textopacity = openvg.VGfloat(t.Opacity / 100)
}
if t.Lp == 0 {
t.Lp = linespacing
}
x, y, fs = dimen(d, t.Xp, t.Yp, t.Sp)
td := strings.Split(tdata, "\n")
if t.Type == "code" {
ls := fs * openvg.VGfloat(t.Lp)
t.Font = "mono"
tdepth := (ls * openvg.VGfloat(len(td))) + fs
openvg.FillColor("rgb(240,240,240)")
openvg.Rect(x-20, y-tdepth+(ls), pctwidth(t.Wp, cw, cw-x-20), tdepth)
}
if t.Color == "" {
openvg.FillColor(slide.Fg, textopacity)
} else {
openvg.FillColor(t.Color, textopacity)
}
if t.Type == "block" {
textwrap(x, y, pctwidth(t.Wp, cw, cw/2), tdata, t.Font, fs, fs*openvg.VGfloat(t.Lp), 0.3)
} else {
// every text line
ls := fs * openvg.VGfloat(t.Lp)
for _, txt := range td {
showtext(x, y, txt, t.Align, t.Font, fs)
y -= ls
}
}
}
openvg.FillColor(slide.Fg)
openvg.End()
if video.altimg != "" {
img, ok := imap[video.altimg]
if ok {
openvg.Img(video.x, video.y, img)
}
}
if video.name != "" {
openvg.Video(video.x, video.y, video.w, video.h, video.name)
}
}
