func main() { h = hge.Create(VERSION) defer h.Release() // Set desired system states and initialize HGE h.System_SetState(LOGFILE, "tutorial07.log") h.System_SetState(FRAMEFUNC, frame) h.System_SetState(RENDERFUNC, render) h.System_SetState(TITLE, "HGE Tutorial 07 - Thousand of Hares") h.System_SetState(USESOUND, false) h.System_SetState(WINDOWED, true) h.System_SetState(SCREENWIDTH, SCREEN_WIDTH) h.System_SetState(SCREENHEIGHT, SCREEN_HEIGHT) h.System_SetState(SCREENBPP, 32) if h.System_Initiate() { defer h.System_Shutdown() // Load textures bgtex = h.Texture_Load("bg2.png") tex = h.Texture_Load("zazaka.png") if bgtex == nil || tex == nil { fmt.Println("Error: Can't load bg2.png or zazaka.png\n") return } // Delete created objects and free loaded resources defer h.Texture_Free(tex) defer h.Texture_Free(bgtex) // Load font, create sprites fnt = font.New("font1.fnt") spr = sprite.New(tex, 0, 0, 64, 64) spr.SetHotSpot(32, 32) bgspr = sprite.New(bgtex, 0, 0, 800, 600) bgspr.SetBlendMode(BLEND_COLORADD | BLEND_ALPHABLEND | BLEND_NOZWRITE) bgspr.SetColor(0xFF000000, 0) bgspr.SetColor(0xFF000000, 1) bgspr.SetColor(0xFF000040, 2) bgspr.SetColor(0xFF000040, 3) // Initialize objects list objects = 1000 for i := 0; i < MAX_OBJECTS; i++ { objs[i].x = h.Random_Float(0, SCREEN_WIDTH) objs[i].y = h.Random_Float(0, SCREEN_HEIGHT) objs[i].dx = h.Random_Float(-200, 200) objs[i].dy = h.Random_Float(-200, 200) objs[i].scale = h.Random_Float(0.5, 2.0) objs[i].dscale = h.Random_Float(-1.0, 1.0) objs[i].rot = h.Random_Float(0, Pi*2) objs[i].drot = h.Random_Float(-1.0, 1.0) } setBlend(0) // Let's rock now! h.System_Start() } }
func NewGUIButton(id int, x, y, w, h float64, tex *gfx.Texture, tx, ty float64) *GUIButton { b := new(GUIButton) b.GUIObject.Initialize() b.GUIObject.Id = id b.GUIObject.Visible = true b.GUIObject.Enabled = true b.GUIObject.Rect.Set(x, y, x+w, y+h) b.up = sprite.New(tex, tx, ty, w, h) b.down = sprite.New(tex, tx+w, ty, w, h) b.GUIObject.Render = func() { if b.pressed { b.down.Render(b.GUIObject.Rect.X1, b.GUIObject.Rect.Y1) } else { b.up.Render(b.GUIObject.Rect.X1, b.GUIObject.Rect.Y1) } } b.GUIObject.MouseLButton = func(down bool) bool { if down { b.oldState = b.pressed b.pressed = true return false } if b.trigger { b.pressed = !b.oldState } else { b.pressed = false } return true } return b }
func New(tex *gfx.Texture, frames int, fps, x, y, w, h float64) Animation { var a Animation a.Sprite = sprite.New(tex, x, y, w, h) a.origWidth = tex.Width(true) a.sinceLastFrame = -1.0 a.speed = 1.0 / fps a.frames = frames a.mode = FWD | LOOP a.delta = 1 a.SetFrame(0) return a }
func InitSimulation() bool { // Load texture texObjects = LoadTexture("objects.png") if texObjects == nil { return false } rand = New(0) // Create sprites sky = sprite.New(nil, 0, 0, SCREEN_WIDTH, SKY_HEIGHT) sea = dist.New(SEA_SUBDIVISION, SEA_SUBDIVISION) sea.SetTextureRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT-SKY_HEIGHT) sun = sprite.New(texObjects, 81, 0, 114, 114) sun.SetHotSpot(57, 57) moon = sprite.New(texObjects, 0, 0, 81, 81) moon.SetHotSpot(40, 40) star = sprite.New(texObjects, 72, 81, 9, 9) star.SetHotSpot(5, 5) glow = sprite.New(texObjects, 128, 128, 128, 128) glow.SetHotSpot(64, 64) glow.SetBlendMode(BLEND_COLORADD | BLEND_ALPHABLEND | BLEND_NOZWRITE) seaglow = sprite.New(texObjects, 128, 224, 128, 32) seaglow.SetHotSpot(64, 0) seaglow.SetBlendMode(BLEND_COLORADD | BLEND_ALPHAADD | BLEND_NOZWRITE) // Initialize simulation state colWhite.SetHWColor(0xFFFFFFFF) timet = GetTime() speed = 0.0 for i := 0; i < NUM_STARS; i++ { // star positions starX[i] = rand.Float64(0, SCREEN_WIDTH) starY[i] = rand.Float64(0, STARS_HEIGHT) starS[i] = rand.Float64(0.1, 0.7) } for i := 0; i < SEA_SUBDIVISION; i++ { // sea waves phase shifts seaP[i] = float64(i) + rand.Float64(-15.0, 15.0) } // Systems are ready now! return true }
func main() { h := hge.New() h.SetState(hge.LOGFILE, "tutorial06.log") h.SetState(hge.FRAMEFUNC, frame) h.SetState(hge.RENDERFUNC, render) h.SetState(hge.TITLE, "HGE Tutorial 06 - Creating menus") h.SetState(hge.WINDOWED, true) h.SetState(hge.SCREENWIDTH, 800) h.SetState(hge.SCREENHEIGHT, 600) h.SetState(hge.SCREENBPP, 32) if err := h.Initiate(); err != nil { fmt.Println("Error: ", h.GetErrorMessage()) } else { defer h.Shutdown() quad.Texture = LoadTexture("bg.png") if quad.Texture == nil { fmt.Println("Error loading bg.png") return } snd := NewEffect("menu.ogg") if snd == nil { fmt.Println("Error loading menu.ogg") return } cursorTex := LoadTexture("cursor.png") if cursorTex == nil { fmt.Println("Error loading cursor.png") return } // Set up the quad we will use for background animation quad.Blend = BLEND_ALPHABLEND | BLEND_COLORMUL | BLEND_NOZWRITE for i := 0; i < 4; i++ { // Set up z-coordinate of vertices quad.V[i].Z = 0.5 // Set up color. The format of DWORD col is 0xAARRGGBB quad.V[i].Color = 0xFFFFFFFF } quad.V[0].X, quad.V[0].Y = 0, 0 quad.V[1].X, quad.V[1].Y = 800, 0 quad.V[2].X, quad.V[2].Y = 800, 600 quad.V[3].X, quad.V[3].Y = 0, 600 fnt = font.New("font1.fnt") if fnt == nil { fmt.Println("Error loading font1.fnt") return } cursor := sprite.New(cursorTex, 0, 0, 32, 32) GUI = gui.New() GUI.AddCtrl(NewGUIMenuItem(1, fnt, snd, 400, 200, 0.0, "Play")) GUI.AddCtrl(NewGUIMenuItem(2, fnt, snd, 400, 240, 0.1, "Options")) GUI.AddCtrl(NewGUIMenuItem(3, fnt, snd, 400, 280, 0.2, "Instructions")) GUI.AddCtrl(NewGUIMenuItem(4, fnt, snd, 400, 320, 0.3, "Credits")) GUI.AddCtrl(NewGUIMenuItem(5, fnt, snd, 400, 360, 0.4, "Exit")) GUI.SetNavMode(gui.GUI_UPDOWN | gui.GUI_CYCLED) GUI.SetCursor(&cursor) GUI.SetFocus(1) GUI.Enter() h.Start() } }
func New(filename string, arg ...interface{}) *Font { mipmap := false if len(arg) == 1 { if m, ok := arg[0].(bool); ok { mipmap = m } } f := new(Font) h := hge.New() f.scale, f.proportion = 1.0, 1.0 f.spacing = 1.0 f.z = 0.5 f.blend = gfx.BLEND_COLORMUL | gfx.BLEND_ALPHABLEND | gfx.BLEND_NOZWRITE f.color = 0xFFFFFFFF desc := resource.LoadString(filename) if desc == nil { h.Log("Font %s seems to be empty.", filename) return nil } lines := getLines(*desc) if len(lines) == 0 || lines[0] != fntHEADERTAG { h.Log("Font %s has incorrect format.", filename) return nil } // parse the font description for _, line := range lines { if line == fntHEADERTAG { continue } option, value, err := tokenizeLine(line) if err != nil || len(line) == 0 || len(option) == 0 || len(value) == 0 { h.Log("Unreadable line (%s) in font file: %s", line, filename) continue } if option == fntBITMAPTAG { f.texture = gfx.LoadTexture(value, 0, mipmap) } else if option == fntCHARTAG { chr, x, y, w, h, a, c := tokenizeChar(value) sprt := sprite.New(f.texture, x, y, w, h) f.letters[chr] = &sprt f.pre[chr] = a f.post[chr] = c f.height = h } } return f }
// An example of using closures func main() { func() { const ( speed = 90.0 friction = 0.98 ) var ( spr sprite.Sprite fnt *font.Font par *particle.ParticleSystem snd *Effect x = 100.0 y = 100.0 dx = 0.0 dy = 0.0 ) hge := New() hge.SetState(LOGFILE, "tutorial03.log") hge.SetState(TITLE, "HGE Tutorial 03 - Using helper classes") hge.SetState(FPS, 100) hge.SetState(WINDOWED, true) hge.SetState(SCREENWIDTH, 800) hge.SetState(SCREENHEIGHT, 600) hge.SetState(SCREENBPP, 32) hge.SetState(FRAMEFUNC, func() int { dt := float64(Delta()) boom := func() { pan := int((x - 400) / 4) pitch := (dx*dx+dy*dy)*0.0005 + 0.2 snd.PlayEx(100, pan, pitch) } // Process keys if NewKey(K_ESCAPE).State() { return 1 } if NewKey(K_LEFT).State() { dx -= speed * dt } if NewKey(K_RIGHT).State() { dx += speed * dt } if NewKey(K_UP).State() { dy -= speed * dt } if NewKey(K_DOWN).State() { dy += speed * dt } // Do some movement calculations and collision detection dx *= friction dy *= friction x += dx y += dy if x > 784 { x = 784 - (x - 784) dx = -dx boom() } if x < 16 { x = 16 + 16 - x dx = -dx boom() } if y > 584 { y = 584 - (y - 584) dy = -dy boom() } if y < 16 { y = 16 + 16 - y dy = -dy boom() } // Update particle system par.Info.Emission = (int)(dx*dx+dy*dy) * 2 par.MoveTo(x, y) par.Update(dt) return 0 }) hge.SetState(RENDERFUNC, func() int { BeginScene() Clear(0) par.Render() spr.Render(x, y) fnt.Printf(5, 5, font.TEXT_LEFT, "dt:%.3f\nFPS:%d (constant)", Delta(), GetFPS()) EndScene() return 0 }) if err := hge.Initiate(); err == nil { defer hge.Shutdown() snd = NewEffect("menu.ogg") tex := LoadTexture("particles.png") if snd == nil || tex == nil { fmt.Printf("Error: Can't load one of the following files:\nmenu.ogg, particles.png, font1.fnt, font1.png, trail.psi\n") return } spr = sprite.New(tex, 96, 64, 32, 32) spr.SetColor(0xFFFFA000) spr.SetHotSpot(16, 16) if fnt = font.New("font1.fnt"); fnt == nil { fmt.Println("Error loading font1.fnt") return } spt := sprite.New(tex, 32, 32, 32, 32) spt.SetBlendMode(BLEND_COLORMUL | BLEND_ALPHAADD | BLEND_NOZWRITE) spt.SetHotSpot(16, 16) par = particle.New("trail.psi", spt) if par == nil { fmt.Println("Error loading trail.psi") return } par.Fire() hge.Start() } }() for i := 0; i < 10; i++ { fmt.Println("Sleeping") time.Sleep(1 * time.Second) runtime.GC() } }
func main() { h := hge.New() h.SetState(hge.LOGFILE, "tutorial04.log") h.SetState(hge.FRAMEFUNC, FrameFunc) h.SetState(hge.RENDERFUNC, RenderFunc) h.SetState(hge.GFXRESTOREFUNC, RestoreFunc) h.SetState(hge.TITLE, "HGE Tutorial 04 - Using render targets") h.SetState(hge.FPS, 100) h.SetState(hge.WINDOWED, true) h.SetState(hge.SCREENWIDTH, 800) h.SetState(hge.SCREENHEIGHT, 600) h.SetState(hge.SCREENBPP, 32) if err := h.Initiate(); err == nil { defer h.Shutdown() snd = NewEffect("menu.ogg") tex = LoadTexture("particles.png") if snd == nil || tex == nil { // If one of the data files is not found, display // an error message and shutdown. fmt.Printf("Error: Can't load one of the following files:\nmenu.ogg, particles.png, font1.fnt, font1.png, trail.psi\n") return } // Delete created objects and free loaded resources defer snd.Free() defer tex.Free() spr = sprite.New(tex, 96, 64, 32, 32) spr.SetColor(0xFFFFA000) spr.SetHotSpot(16, 16) fnt = font.New("font1.fnt") if fnt == nil { fmt.Println("Error: Can't load font1.fnt or font1.png") return } spt = sprite.New(tex, 32, 32, 32, 32) spt.SetBlendMode(BLEND_COLORMUL | BLEND_ALPHAADD | BLEND_NOZWRITE) spt.SetHotSpot(16, 16) par = particle.New("trail.psi", spt) if par == nil { fmt.Println("Error: Cannot load trail.psi") return } par.Fire() // Create a render target and a sprite for it target = NewTarget(512, 512, false) defer target.Free() tar = sprite.New(target.Texture(), 0, 0, 512, 512) tar.SetBlendMode(BLEND_COLORMUL | BLEND_ALPHAADD | BLEND_NOZWRITE) // Let's rock now! h.Start() } }
func NewGUIListBox(id int, x, y, w, h float64, fnt *font.Font, color, highlightColor, spriteHighlightColor hge.Dword) *GUIListBox { l := new(GUIListBox) l.GUIObject.Initialize() l.GUIObject.Id = id l.GUIObject.Visible = true l.GUIObject.Enabled = true l.GUIObject.Rect.Set(x, y, x+w, y+h) l.Font = fnt l.highlight = sprite.New(nil, 0, 0, w, fnt.GetHeight()) l.highlight.SetColor(highlightColor) l.color = color l.highlightColor = highlightColor l.List = list.New() l.GUIObject.Render = func() { item := l.List.Front() for i := 0; i < l.topItem; i++ { if item == nil { return } item = item.Next() } for i := 0; i < l.NumRows(); i++ { if i >= l.items { return } if l.topItem+i == l.selectedItem { l.highlight.Render(l.GUIObject.Rect.X1, l.GUIObject.Rect.Y1+float64(i)*l.Font.GetHeight()) l.Font.SetColor(l.highlightColor) } else { l.Font.SetColor(l.color) } l.Font.Render(l.GUIObject.Rect.X1+3, l.GUIObject.Rect.Y1+float64(i)*l.Font.GetHeight(), font.TEXT_LEFT, item.Value.(*guiListboxItem).text) item = item.Next() } } l.GUIObject.MouseMove = func(x, y float64) bool { l.mx, l.my = x, y return false } l.GUIObject.MouseLButton = func(down bool) bool { if down { item := l.topItem + int(l.my)/int(l.Font.GetHeight()) if item < l.Len() { l.selectedItem = item return true } } return false } l.GUIObject.MouseWheel = func(notches int) bool { l.topItem -= notches if l.topItem < 0 { l.topItem = 0 } if l.topItem > l.Len()-l.NumRows() { l.topItem = l.Len() - l.NumRows() } return true } l.GUIObject.KeyClick = func(key input.Key, chr int) bool { switch key { case input.K_DOWN: if l.selectedItem < l.Len()-1 { l.selectedItem++ if l.selectedItem > l.topItem+l.NumRows()-1 { l.topItem = l.selectedItem - l.NumRows() + 1 } return true } case input.K_UP: if l.selectedItem > 0 { l.selectedItem-- if l.selectedItem < l.topItem { l.topItem = l.selectedItem } return true } } return false } return l }
func NewGUISlider(id int, x, y, w, h float64, tex *gfx.Texture, tx, ty, sw, sh float64, a ...interface{}) *GUISlider { s := new(GUISlider) if len(a) == 1 { if b, ok := a[0].(bool); ok { s.vertical = b } } s.GUIObject.Initialize() s.GUIObject.Id = id s.GUIObject.Visible = true s.GUIObject.Enabled = true s.GUIObject.Rect.Set(x, y, x+w, y+h) s.mode = SLIDER_BAR s.max, s.val = 100, 50 s.sl_w, s.sl_h = sw, sh s.Sprite = sprite.New(tex, tx, ty, sw, sh) s.GUIObject.Render = func() { var x1, y1, x2, y2 float64 xx := s.GUIObject.Rect.X1 + (s.GUIObject.Rect.X2-s.GUIObject.Rect.X1)*(s.val-s.min)/(s.max-s.min) yy := s.GUIObject.Rect.Y1 + (s.GUIObject.Rect.Y2-s.GUIObject.Rect.Y1)*(s.val-s.min)/(s.max-s.min) if s.vertical { switch s.mode { case SLIDER_BAR: x1 = s.GUIObject.Rect.X1 y1 = s.GUIObject.Rect.Y1 x2 = s.GUIObject.Rect.X2 y2 = y case SLIDER_BARRELATIVE: x1 = s.GUIObject.Rect.X1 y1 = (s.GUIObject.Rect.Y1 + s.GUIObject.Rect.Y2) / 2 x2 = s.GUIObject.Rect.X2 y2 = y case SLIDER_SLIDER: x1 = (s.GUIObject.Rect.X1 + s.GUIObject.Rect.X2 - s.sl_w) / 2 y1 = yy - s.sl_h/2 x2 = (s.GUIObject.Rect.X1 + s.GUIObject.Rect.X2 + s.sl_w) / 2 y2 = yy + s.sl_h/2 } } else { switch s.mode { case SLIDER_BAR: x1 = s.GUIObject.Rect.X1 y1 = s.GUIObject.Rect.Y1 x2 = xx y2 = s.GUIObject.Rect.Y2 case SLIDER_BARRELATIVE: x1 = (s.GUIObject.Rect.X1 + s.GUIObject.Rect.X2) / 2 y1 = s.GUIObject.Rect.Y1 x2 = xx y2 = s.GUIObject.Rect.Y2 case SLIDER_SLIDER: x1 = xx - s.sl_w/2 y1 = (s.GUIObject.Rect.Y1 + s.GUIObject.Rect.Y2 - s.sl_h) / 2 x2 = xx + s.sl_w/2 y2 = (s.GUIObject.Rect.Y1 + s.GUIObject.Rect.Y2 + s.sl_h) / 2 } } s.Sprite.RenderStretch(x1, y1, x2, y2) } s.GUIObject.MouseMove = func(x, y float64) bool { if s.pressed { if s.vertical { if y > s.GUIObject.Rect.Y2-s.GUIObject.Rect.Y1 { y = s.GUIObject.Rect.Y2 - s.GUIObject.Rect.Y1 } if y < 0 { y = 0 } s.val = s.min + (s.max-s.min)*y/(s.GUIObject.Rect.Y2-s.GUIObject.Rect.Y1) } else { if x > s.GUIObject.Rect.X2-s.GUIObject.Rect.X1 { x = s.GUIObject.Rect.X2 - s.GUIObject.Rect.X1 } if x < 0 { x = 0 } s.val = s.min + (s.max-s.min)*x/(s.GUIObject.Rect.X2-s.GUIObject.Rect.X1) } return true } return false } s.GUIObject.MouseLButton = func(down bool) bool { s.pressed = down return false } return s }