func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "glfw: %s\n", err)
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.WindowNoResize, 0)
if err := glfw.OpenWindow(Width, Height, 0, 0, 0, 0, 16, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "glfw: %s\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetSwapInterval(60)
glfw.SetWindowTitle(Title)
if err := gl.Init(); err != nil {
fmt.Fprintf(os.Stderr, "gl: %s\n", err)
}
keybindings.BindKeyboard()
gl.ClearColor(0, 0, 0, 1)
GameLoop()
}
func initScene() {
input.Init()
life = automata.NewLife(*flagRule, *flagSize, *flagDelay, *flagSeed)
input.Sim = life
go life.Run()
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.Viewport(0, 0, Width, Height)
}
func (g *Gui) Draw() {
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(g.region.X), gl.Double(g.region.X+g.region.Dx), gl.Double(g.region.Y+g.region.Dy), gl.Double(g.region.Y), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
g.root.Draw(g.region, &styleStack{})
}
func ClearScene() {
ambient := []gl.Float{0.7, 0.7, 0.7, 1}
diffuse := []gl.Float{0.9, 0.9, 0.9, 1}
lightpos := []gl.Float{0.2, 0.5, 1, 1}
gl.Lightfv(gl.LIGHT0, gl.AMBIENT, &ambient[0])
gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, &diffuse[0])
gl.Lightfv(gl.LIGHT0, gl.POSITION, &lightpos[0])
gl.Enable(gl.LIGHT0)
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
}
func (g *Gui) Draw() {
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
region := g.root.Render_region
gl.Ortho(gl.Double(region.X), gl.Double(region.X+region.Dx), gl.Double(region.Y), gl.Double(region.Y+region.Dy), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
g.root.Draw(region)
if g.FocusWidget() != nil {
g.FocusWidget().DrawFocused(region)
}
}
func initScene(width, height int, init func()) (err error) {
gl.Disable(gl.DEPTH_TEST)
gl.ClearColor(0.5, 0.5, 0.5, 0.0)
gl.Viewport(0, 0, gl.Sizei(width), gl.Sizei(height))
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, gl.Double(width), gl.Double(height), 0, 0, 1)
gl.MatrixMode(gl.MODELVIEW)
init()
return
}
func (s *Scene) Init() (err error) {
runtime.LockOSThread()
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.DEPTH_TEST)
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.ClearDepth(1)
//gl.DepthFunc(gl.LEQUAL)
gl.Viewport(0, 0, Width, Height)
mm.init()
return
}
func initDraw() error {
runtime.LockOSThread()
err := gl.Init()
if err != nil {
return err
}
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Enable(gl.BLEND)
gl.BlendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ZERO)
return checkForErrors()
}
func getPlayers(console *base.Console) []gin.DeviceId {
var ct controllerTracker
gin.In().RegisterEventListener(&ct)
defer gin.In().UnregisterEventListener(&ct)
ticker := time.Tick(time.Millisecond * 17)
start := time.Time{}
readyDuration := time.Second * 2
for start.IsZero() || time.Now().Sub(start) < readyDuration {
<-ticker
sys.Think()
if ct.Ready() && start.IsZero() {
start = time.Now()
}
if !ct.Ready() {
start = time.Time{}
}
render.Queue(func() {
defer console.Draw(0, 0, wdx, wdy)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Disable(gl.DEPTH_TEST)
gui.SetFontColor(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(0), gl.Double(wdx), gl.Double(wdy), gl.Double(0), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
base.GetDictionary("crackin").RenderString(fmt.Sprintf("Num players: %d", len(ct.ids)), float64(wdx)/2, 300, 0, 100, gui.Center)
base.GetDictionary("crackin").RenderString(fmt.Sprintf("Num ready: %d", ct.NumReady()), float64(wdx)/2, 400, 0, 100, gui.Center)
if !start.IsZero() {
base.GetDictionary("crackin").RenderString(fmt.Sprintf("Starting in %2.2f", (readyDuration-time.Now().Sub(start)).Seconds()), float64(wdx)/2, 500, 0, 100, gui.Center)
}
})
render.Queue(func() {
sys.SwapBuffers()
})
render.Purge()
}
var devices []gin.DeviceId
for id := range ct.ids {
devices = append(devices, id)
}
return devices
}
func mainLoop(client sgf.ClientEngine, controllers []gin.DeviceId, console *base.Console) {
client.MakeRequest(game.Join{Rebels: make([]*game.RebelPlayer, 2)})
ticker := time.Tick(time.Millisecond * 17)
render.Queue(func() {
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
})
for {
<-ticker
if gin.In().GetKey(gin.AnyEscape).FramePressCount() != 0 {
return
}
sys.Think()
render.Queue(func() {
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Disable(gl.DEPTH_TEST)
gui.SetFontColor(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(0), gl.Double(wdx), gl.Double(wdy), gl.Double(0), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
base.GetDictionary("crackin").RenderString("Waiting on some nubs", float64(wdx)/2, 300, 0, 100, gui.Center)
})
client.RLock()
g := client.Game().(*game.Game)
mode := g.Mode
client.RUnlock()
if mode == game.ModeWaiting {
} else if mode == game.ModeProgram {
programLoop(client, controllers, console)
} else if mode == game.ModeRun {
}
render.Queue(func() {
sys.SwapBuffers()
})
render.Purge()
}
}
func initWindow(sys system.System, width int, height int) {
sys.CreateWindow(10, 10, width, height)
sys.EnableVSync(false)
err := gl.Init()
if err != nil {
panic(err)
}
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.EnableClientState(gl.COLOR_ARRAY)
gl.Enable(gl.CULL_FACE)
gl.FrontFace(gl.CW)
gl.ClearColor(0, 0, 0, 1)
}
func initScene() {
gl.Disable(gl.TEXTURE_2D)
gl.Disable(gl.DEPTH_TEST)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Disable(gl.ALPHA_TEST)
gl.Enable(gl.LINE_SMOOTH)
gl.Hint(gl.LINE_SMOOTH_HINT, gl.NICEST)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
gl.LineWidth(1.0)
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.ClearDepth(1)
//gl.DepthFunc(gl.LEQUAL)
gl.Viewport(0, 0, Width, Height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
perspective(110.0, 1.0, 4, 8192)
}
func (o *OpenGl) initScene() (err error) {
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
ambient := []gl.Float{0.5, 0.5, 0.5, 1}
diffuse := []gl.Float{1, 1, 1, 1}
position := []gl.Float{-5, 5, 10, 0}
gl.Lightfv(gl.LIGHT0, gl.AMBIENT, &ambient[0])
gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, &diffuse[0])
gl.Lightfv(gl.LIGHT0, gl.POSITION, &position[0])
gl.Viewport(0, 0, gl.Sizei(o.width), gl.Sizei(o.height))
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Frustum(-1, 1, -1, 1, 1.0, 10.0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
return nil
}
func DrawTestScene() {
ambient := []gl.Float{0.7, 0.7, 0.7, 1}
diffuse := []gl.Float{1, 1, 1, 1}
lightpos := []gl.Float{0.2, 0.5, 1, 1}
gl.Lightfv(gl.LIGHT0, gl.AMBIENT, &ambient[0])
gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, &diffuse[0])
gl.Lightfv(gl.LIGHT0, gl.POSITION, &lightpos[0])
gl.Enable(gl.LIGHT0)
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
const r = 0.5
const z = r
red := color.NRGBA{R: 255, A: 255}
blue := color.NRGBA{B: 255, A: 255}
gl.Begin(gl.QUADS)
(&Poly{[3]float32{0, 0, 0}, [4][3]float32{{-r, -r, z}, {r, -r, z}, {r, r, z}, {-r, r, z}}, red}).Render()
(&Poly{[3]float32{0, 0, 0}, [4][3]float32{{-r, -r, -z}, {-r, r, -z}, {r, r, -z}, {r, -r, -z}}, blue}).Render()
gl.End()
}
func initScene() (err error) {
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.LIGHTING)
gl.ClearColor(0.5, 0.5, 0.5, 0.0)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
gl.Lightfv(gl.LIGHT0, gl.AMBIENT, &ambient[0])
gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, &diffuse[0])
gl.Lightfv(gl.LIGHT0, gl.POSITION, &lightpos[0])
gl.Enable(gl.LIGHT0)
gl.Viewport(0, 0, Width, Height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Frustum(-1, 1, -1, 1, 1.0, 10.0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
texture, err = createTextureFromBytes(gopher_png[:])
return
}
// draw draws the triangle.
func draw() {
gl.ClearColor(0.3, 0.3, 0.3, 0.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.ShadeModel(gl.SMOOTH)
gl.LoadIdentity()
gl.Translatef(-15.0, -15.0, 0.0)
gl.Begin(gl.TRIANGLES)
gl.Color3f(1.0, 0.0, 0.0)
gl.Vertex2f(0.0, 0.0)
gl.Color3f(0.0, 1.0, 0.0)
gl.Vertex2f(30.0, 0.0)
gl.Color3f(0.0, 0.0, 1.0)
gl.Vertex2f(0.0, 30.0)
gl.End()
win.SwapBuffers()
}
func initScene() {
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.LIGHTING)
gl.ClearColor(0.1, 0.1, 0.6, 1.0)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
gl.Lightfv(gl.LIGHT0, gl.AMBIENT, &ambient[0])
gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, &diffuse[0])
gl.Lightfv(gl.LIGHT0, gl.POSITION, &lightPos[0])
gl.Enable(gl.LIGHT0)
gl.Viewport(0, 0, Width, Height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Frustum(-1, 1, -1, 1, 1.0, 1000.0)
gl.Rotatef(20, 1, 0, 0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.PushMatrix()
return
}
func programLoop(client sgf.ClientEngine, controllers []gin.DeviceId, console *base.Console) {
ticker := time.Tick(time.Millisecond * 17)
var selections cardSelections
selections.cols = 7
selections.players = make([]cardSelection, len(controllers))
client.RLock()
g := client.Game().(*game.Game)
for _, card := range g.Cards {
selections.cards = append(selections.cards, card)
selections.used = append(selections.used, -1)
}
client.RUnlock()
for {
<-ticker
if gin.In().GetKey(gin.AnyEscape).FramePressCount() != 0 {
return
}
for i, device := range controllers {
up := gin.In().GetKeyFlat(gin.ControllerHatSwitchUp, device.Type, device.Index).FramePressCount()
down := gin.In().GetKeyFlat(gin.ControllerHatSwitchDown, device.Type, device.Index).FramePressCount()
left := gin.In().GetKeyFlat(gin.ControllerHatSwitchLeft, device.Type, device.Index).FramePressCount()
right := gin.In().GetKeyFlat(gin.ControllerHatSwitchRight, device.Type, device.Index).FramePressCount()
selections.HandleMove(i, right-left, down-up)
drop := gin.In().GetKeyFlat(gin.ControllerButton0+1, device.Type, device.Index).FramePressCount() > 0
choose := gin.In().GetKeyFlat(gin.ControllerButton0+2, device.Type, device.Index).FramePressCount() > 0
if choose {
selections.HandleChoose(i)
}
if drop {
selections.HandleDrop(i)
}
}
sys.Think()
render.Queue(func() {
defer console.Draw(0, 0, wdx, wdy)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Disable(gl.DEPTH_TEST)
gui.SetFontColor(1, 1, 1, 1)
gl.Disable(gl.TEXTURE_2D)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(gl.Double(0), gl.Double(wdx), gl.Double(wdy), gl.Double(0), 1000, -1000)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
client.RLock()
g := client.Game().(*game.Game)
renderBoard(g, 10, 10, 400, 400)
client.RUnlock()
renderCards(selections.cards, 64, 400, 400, selections.cols, &selections)
for i, player := range selections.players {
setColorForIndex(i)
renderCardReticle(false, 64, player.sx, player.sy, 400, 400)
renderCards(player.cards, 64, 400, 300-100*i, selections.cols, nil)
}
})
render.Queue(func() {
sys.SwapBuffers()
})
render.Purge()
}
}
func main() {
sys = system.Make(gos.GetSystemInterface())
sys.Startup()
wdx := 1000
wdy := 500
render.Init()
var ui *gui.Gui
render.Queue(func() {
sys.CreateWindow(50, 150, wdx, wdy)
sys.EnableVSync(true)
err := gl.Init()
if err != nil {
f, err2 := os.Create(filepath.Join(datadir, "gl_log.txt"))
if err2 != nil {
fmt.Printf("Unable to write log to a file:%v\n%v\v", err, err2)
} else {
fmt.Fprintf(f, "%v\n", err)
f.Close()
}
}
ui, _ = gui.Make(gin.In(), gui.Dims{wdx, wdy}, filepath.Join(datadir, "fonts", "luxisr.ttf"))
font, err := loadFont()
if err != nil {
panic(err.Error())
}
dict = gui.MakeDictionary(font, 15)
})
render.Purge()
anchor := gui.MakeAnchorBox(gui.Dims{wdx, wdy})
ui.AddChild(anchor)
var event_handler handler
gin.In().RegisterEventListener(&event_handler)
actions_list := gui.MakeVerticalTable()
keyname_list := gui.MakeVerticalTable()
both_lists := gui.MakeHorizontalTable()
both_lists.AddChild(actions_list)
both_lists.AddChild(keyname_list)
anchor.AddChild(both_lists, gui.Anchor{1, 0.5, 1, 0.5})
var actions []string
for action := range action_map {
actions = append(actions, action)
}
sort.Strings(actions)
for _, action := range actions {
actions_list.AddChild(gui.MakeTextLine("standard", action, 150, 1, 1, 1, 1))
keyname_list.AddChild(gui.MakeTextLine("standard", commands[action].Cmd, 100, 1, 1, 1, 1))
}
current_anim := gui.MakeTextLine("standard", "", 300, 1, 1, 1, 1)
current_state := gui.MakeTextLine("standard", "", 300, 1, 1, 1, 1)
frame_data := gui.MakeVerticalTable()
frame_data.AddChild(current_anim)
frame_data.AddChild(current_state)
anchor.AddChild(frame_data, gui.Anchor{0, 1, 0, 1})
speed := 100
speed_text := gui.MakeTextLine("standard", "Speed: 100%", 150, 1, 1, 1, 1)
anchor.AddChild(speed_text, gui.Anchor{0, 0, 0, 0})
var box1, box2 boxdata
box1.name = "box1"
box1.sb = makeSpriteBox(nil)
anchor.AddChild(box1.sb, gui.Anchor{0.5, 0.5, 0.25, 0.5})
box1.load(GetStoreVal("box1"))
box := box1
box2.name = "box2"
box2.sb = makeSpriteBox(nil)
anchor.AddChild(box2.sb, gui.Anchor{0.5, 0.5, 0.45, 0.5})
box2.load(GetStoreVal("box2"))
box2.sb.top = true
box_other := box2
box2.sb.r, box2.sb.g, box2.sb.b = 0.2, 0.1, 0.4
box1.sb.r, box1.sb.g, box1.sb.b = 0.4, 0.2, 0.8
error_msg = gui.MakeTextLine("standard", "", wdx, 1, 0.5, 0.5, 1)
anchor.AddChild(error_msg, gui.Anchor{0, 0, 0, 0.1})
var chooser gui.Widget
// curdir := GetStoreVal("curdir")
// if curdir == "" {
// curdir = "."
// } else {
// _,err := os.Stat(filepath.Join(datadir, curdir))
// if err == nil {
// go func() {
// anim, err := sprite.LoadSprite(filepath.Join(datadir, curdir))
// loaded <- loadResult{ anim, err }
// } ()
// } else {
// curdir = "."
// }
// }
// var profile_output *os.File
then := time.Now()
sys.Think()
for key_map["quit"].FramePressCount() == 0 {
event_handler.box1 = &box
event_handler.box2 = &box_other
now := time.Now()
dt := (now.Nanosecond() - then.Nanosecond()) / 1000000
then = now
render.Queue(func() {
sys.Think()
if box1.sb.s != nil {
box1.sb.s.Think(int64(float64(dt) * float64(speed) / 100))
}
if box2.sb.s != nil {
box2.sb.s.Think(int64(float64(dt) * float64(speed) / 100))
}
gl.ClearColor(1, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
ui.Draw()
sys.SwapBuffers()
})
render.Purge()
select {
case load := <-loaded:
if load.err != nil {
error_msg.SetText(load.err.Error())
current_anim.SetText("")
} else {
box.sb.s = load.anim
error_msg.SetText("")
}
default:
}
// if box.sb.s != nil {
// box.sb.s.Think()
// current_anim.SetText(fmt.Sprintf("%d: %s", box.sb.s.Facing(), box.sb.s.Anim()))
// current_state.SetText(box.sb.s.AnimState())
// }
if box.sb.s != nil {
if key_map["reset"].FramePressCount() > 0 {
box.load(box.dir)
box_other.load(box_other.dir)
}
}
// if key_map["profile"].FramePressCount() > 0 {
// if profile_output == nil {
// var err error
// profile_output, err = os.Create(filepath.Join(datadir, "cpu.prof"))
// if err == nil {
// err = pprof.StartCPUProfile(profile_output)
// if err != nil {
// fmt.Printf("Unable to start CPU profile: %v\n", err)
// profile_output.Close()
// profile_output = nil
// }
// fmt.Printf("profout: %v\n", profile_output)
// } else {
// fmt.Printf("Unable to open CPU profile: %v\n", err)
// }
// } else {
// pprof.StopCPUProfile()
// profile_output.Close()
// profile_output = nil
// }
// }
if key_map["load"].FramePressCount() > 0 && chooser == nil {
anch := gui.MakeAnchorBox(gui.Dims{wdx, wdy})
file_chooser := gui.MakeFileChooser(filepath.Join(datadir, box.dir),
func(path string, err error) {
if err == nil && len(path) > 0 {
curpath, _ := filepath.Split(path)
box.load(curpath)
}
ui.RemoveChild(chooser)
chooser = nil
},
func(path string, is_dir bool) bool {
return true
})
anch.AddChild(file_chooser, gui.Anchor{0.5, 0.5, 0.5, 0.5})
chooser = anch
ui.AddChild(chooser)
}
delta := key_map["speed up"].FramePressAmt() - key_map["slow down"].FramePressAmt()
if delta != 0 {
speed += int(delta)
if speed < 1 {
speed = 1
}
if speed > 100 {
speed = 100
}
speed_text.SetText(fmt.Sprintf("Speed: %d%%", speed))
}
if key_map["select1"].FramePressCount() > 0 {
box2.sb.r, box2.sb.g, box2.sb.b = 0.2, 0.1, 0.4
box1.sb.r, box1.sb.g, box1.sb.b = 0.4, 0.2, 0.8
box = box1
box_other = box2
}
if key_map["select2"].FramePressCount() > 0 {
box2.sb.r, box2.sb.g, box2.sb.b = 0.4, 0.2, 0.8
box1.sb.r, box1.sb.g, box1.sb.b = 0.2, 0.1, 0.4
box = box2
box_other = box1
}
}
}
func standardHookup() {
g := g2.Make(0, 0, wdx, wdy)
var tm g2.ThunderMenu
tm.Subs = make(map[string]*g2.ThunderSubMenu)
triggers := map[gin.KeyId]struct{}{
gin.AnyReturn: struct{}{},
gin.In().GetKeyFlat(gin.ControllerButton0+2, gin.DeviceTypeController, gin.DeviceIndexAny).Id(): struct{}{},
}
action := ""
tm.Subs[""] = g2.MakeThunderSubMenu(
[]g2.Widget{
&g2.Button{Size: 50, Triggers: triggers, Name: "Debug", Callback: func() { tm.Push("debug") }},
&g2.Button{Size: 50, Triggers: triggers, Name: "Host LAN game", Callback: func() { base.Log().Printf("HOST"); print("HOST\n") }},
&g2.Button{Size: 50, Triggers: triggers, Name: "Join LAN game", Callback: func() { base.Log().Printf("JOIN"); print("JOIN\n") }},
&g2.Button{Size: 50, Triggers: triggers, Name: "Quit", Callback: func() { action = "Quit" }},
})
tm.Subs["debug"] = g2.MakeThunderSubMenu(
[]g2.Widget{
&g2.Button{Size: 50, Triggers: triggers, Name: "Standard", Callback: func() { action = "standard" }},
&g2.Button{Size: 50, Triggers: triggers, Name: "Moba", Callback: func() { action = "moba" }},
&g2.Button{Size: 50, Triggers: triggers, Name: "Back", Callback: func() { tm.Pop() }},
})
tm.Start(500)
g.AddChild(&tm, g2.AnchorDeadCenter)
g.AddChild(g2.MakeConsole(wdx, wdy), g2.AnchorDeadCenter)
t := texture.LoadFromPath(filepath.Join(base.GetDataDir(), "background/buttons1.jpg"))
for {
sys.Think()
if action == "Quit" {
return
}
if action == "standard" || action == "moba" {
g.StopEventListening()
engine, local := debugHookup(action)
mainLoop(engine, local, action)
g.RestartEventListening()
action = ""
}
render.Queue(func() {
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
if true {
ratio := float64(wdx) / float64(wdy)
t.RenderAdvanced(-1+(1-1/ratio), -1, 2/ratio, 2, 0, false)
}
gl.Disable(gl.TEXTURE_2D)
base.GetDictionary("luxisr").RenderString("INvASioN!!!", 0, 0.5, 0, 0.03, gui.Center)
})
render.Queue(func() {
g.Draw()
sys.SwapBuffers()
})
render.Purge()
}
// 1 Start with a title screen
// 2 Option to host or join
// 3a If host then wait for a connection
// 3b If join then ping and connect
// 4 Once joined up the 'game' will handle choosing sides and whatnot
}
func (w *glfwBackend) SetScreenColor(color RGB) {
r := gl.Float(float64(color.R) / 255.0)
g := gl.Float(float64(color.G) / 255.0)
b := gl.Float(float64(color.B) / 255.0)
gl.ClearColor(r, g, b, gl.Float(1.0))
}
func main() {
runtime.LockOSThread()
flag.Parse()
if *workers <= 0 {
*workers = 1
}
runtime.GOMAXPROCS(*workers + 1)
buildPalette()
sdl.Init(sdl.INIT_VIDEO)
defer sdl.Quit()
if !*noVSync {
sdl.GL_SetAttribute(sdl.GL_SWAP_CONTROL, 1)
}
if sdl.SetVideoMode(512, 512, 32, sdl.OPENGL) == nil {
panic("sdl error")
}
sdl.WM_SetCaption("Gomandel", "Gomandel")
if err := gl.Init(); err != nil {
panic(err)
}
gl.Enable(gl.TEXTURE_2D)
gl.Viewport(0, 0, 512, 512)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, 512, 512, 0, -1, 1)
gl.ClearColor(0, 0, 0, 0)
//-----------------------------------------------------------------------------
var dndDragging bool = false
var dnd3 bool = false
var dndStart Point
var dndEnd Point
initialRect := Rect{-1.5, -1.5, 3, 3}
rect := initialRect
tm := NewTileManager(512, 512)
tm.ZoomRequest(&rect)
running := true
for running {
for {
var event interface{}
select {
case event = <-sdl.Events:
default:
}
if event == nil {
break
}
switch e := event.(type) {
case sdl.QuitEvent:
running = false
case sdl.MouseButtonEvent:
if e.Type == sdl.MOUSEBUTTONDOWN {
dndDragging = true
dndStart.X = gl.Int(e.X)
dndStart.Y = gl.Int(e.Y)
dndEnd = dndStart
if e.Button == 3 {
dnd3 = true
} else {
dndDragging = true
}
} else {
dndDragging = false
dndEnd.X = gl.Int(e.X)
dndEnd.Y = gl.Int(e.Y)
switch e.Button {
case 1:
rect = rectFromSelection(dndStart, dndEnd, 512, 512, rect)
tm.ZoomRequest(&rect)
case 2:
rect = initialRect
tm.ZoomRequest(&rect)
case 3:
dnd3 = false
}
}
case sdl.MouseMotionEvent:
if dnd3 {
dndEnd.X = gl.Int(e.X)
dndEnd.Y = gl.Int(e.Y)
rect = moveRectBy(rect, dndStart, dndEnd, 512, 512)
tm.MoveRequest(rect)
dndStart = dndEnd
} else if dndDragging {
dndEnd.X = gl.Int(e.X)
dndEnd.Y = gl.Int(e.Y)
}
}
}
tm.Update()
gl.Clear(gl.COLOR_BUFFER_BIT)
tm.Draw()
gl.BindTexture(gl.TEXTURE_2D, 0)
if dndDragging {
drawSelection(dndStart, dndEnd)
}
sdl.GL_SwapBuffers()
}
}
// SetClearColor sets the color the screen will become after a call to the
// Clear function.
func SetClearColor(r uint8, g uint8, b uint8) {
gl.ClearColor(gl.Float(r)/255, gl.Float(g)/255, gl.Float(b)/255, 1.0)
}