func (v *Video) Init(t <-chan []uint32, d <-chan []uint32, n string) {
v.tick = t
v.debug = d
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
if err := glfw.OpenWindow(512, 480, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
if gl.Init() != 0 {
panic("gl error")
}
gl.Enable(gl.TEXTURE_2D)
glfw.SetWindowTitle(fmt.Sprintf("Fergulator - %s", n))
glfw.SetWindowSizeCallback(reshape)
glfw.SetWindowCloseCallback(quit_event)
glfw.SetKeyCallback(KeyListener)
reshape(512, 480)
v.tex = gl.GenTexture()
v.fpsmanager = gfx.NewFramerate()
v.fpsmanager.SetFramerate(70)
}
func initScreen() {
sdl.Init(sdl.INIT_VIDEO)
const (
resx int = 640
resy int = 480
)
var (
screen = sdl.SetVideoMode(resx, resy, 16, sdl.OPENGL)
)
if screen == nil {
sdl.Quit()
panic("Couldn't set GL video mode: " + sdl.GetError() + "\n")
}
if gl.Init() != 0 {
panic("gl error")
}
gl.MatrixMode(gl.PROJECTION)
//gl.MatrixMode(gl.MODELVIEW)
gl.Viewport(0, 0, int(screen.W), int(screen.H))
gl.LoadIdentity()
gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0)
//gl.DepthRange(-1, 1)
gl.ClearColor(0, 0, 0, 0)
gl.Clear(gl.COLOR_BUFFER_BIT)
}
func (this *Window) initGL() {
runtime.LockOSThread()
if gl.Init() != 0 {
panic("gl init error")
}
gl.ShadeModel(gl.SMOOTH)
gl.CullFace(gl.BACK)
gl.FrontFace(gl.CCW)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.LIGHTING)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.TEXTURE_2D)
gl.TexEnvf(gl.TEXTURE_ENV, gl.TEXTURE_ENV_MODE, gl.MODULATE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
var magFilter, minFilter = gl.LINEAR, gl.LINEAR
if globals.CreateMipmaps {
minFilter = gl.LINEAR_MIPMAP_LINEAR
}
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter)
gl.Enable(gl.NORMALIZE)
gl.ClearColor(.1, .1, .1, 1)
this.setGLViewport()
}
// OpenWindow opens a new window with the given size.
func OpenWindow(w, h int) error {
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
r, g, b := 0, 0, 0 // defaults
a := 8 // 8-bit alpha channel
d, s := 0, 0 // no depth or stencil buffers
m := glfw.Windowed
if err := glfw.OpenWindow(w, h, r, g, b, a, d, s, m); err != nil {
return err
}
if gl.Init() != 0 {
return errors.New("Failed to initialize OpenGL")
}
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0.0, 0.0, 0.0, 0.0)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(w), 0, float64(-h), -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translated(0, float64(-h), 0)
return nil
}
func Open(w, h int, sWin string, fullscreen bool) *Window {
if GWindow != nil {
panic("only one Window is allowed")
}
listener.GListener = listener.New()
win := &Window{width: w, height: h, title: sWin, inputListener: listener.GListener}
GWindow = win
var err error
if err = glfw.Init(); err != nil {
panic(fmt.Sprintf("[e] %v\n", err))
}
mode := glfw.Windowed
if fullscreen {
mode = glfw.Fullscreen
}
if err = glfw.OpenWindow(win.width, win.height, 8, 8, 8, 0, 16, 0, mode); err != nil {
panic(fmt.Sprintf("[e] %v\n", err))
}
gl.Init() //WHY?? (shader creation fails when not)
glfw.SetSwapInterval(1) // Enable vertical sync on cards that support it.
glfw.SetWindowTitle(win.title) // Set window title
//CALLBACKS
glfw.SetWindowSizeCallback(func(w, h int) { GWindow.reshape(w, h) })
glfw.SetWindowCloseCallback(listener.OnClose)
glfw.SetMouseButtonCallback(listener.OnMouseButton)
glfw.SetMouseWheelCallback(listener.OnMouseWheel)
glfw.SetKeyCallback(listener.OnKey)
glfw.SetCharCallback(listener.OnChar)
win.initGL()
return win
}
func main() {
sdl.Init(sdl.INIT_VIDEO)
var screen = sdl.SetVideoMode(640, 480, 32, sdl.OPENGL)
if screen == nil {
panic("sdl error")
}
if gl.Init() != 0 {
panic("gl error")
}
pen := Pen{}
gl.MatrixMode(gl.PROJECTION)
gl.Viewport(0, 0, int(screen.W), int(screen.H))
gl.LoadIdentity()
gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0)
gl.ClearColor(1, 1, 1, 0)
gl.Clear(gl.COLOR_BUFFER_BIT)
var running = true
for running {
for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
switch ev := e.(type) {
case *sdl.QuitEvent:
running = false
case *sdl.KeyboardEvent:
if ev.Keysym.Sym == sdl.K_ESCAPE {
running = false
}
case *sdl.MouseMotionEvent:
if ev.State != 0 {
pen.lineTo(Point{int(ev.X), int(ev.Y)})
} else {
pen.moveTo(Point{int(ev.X), int(ev.Y)})
}
}
}
sdl.GL_SwapBuffers()
sdl.Delay(25)
}
sdl.Quit()
}
func (v *Video) Init(t <-chan []uint32, n string) chan [2]int {
v.tick = t
v.resize = make(chan [2]int)
if sdl.Init(sdl.INIT_VIDEO|sdl.INIT_JOYSTICK|sdl.INIT_AUDIO) != 0 {
log.Fatal(sdl.GetError())
}
v.screen = sdl.SetVideoMode(512, 480, 32, sdl.OPENGL|sdl.RESIZABLE)
if v.screen == nil {
log.Fatal(sdl.GetError())
}
sdl.WM_SetCaption(fmt.Sprintf("Fergulator - %s", n), "")
if gl.Init() != 0 {
panic(sdl.GetError())
}
gl.Enable(gl.TEXTURE_2D)
v.Reshape(int(v.screen.W), int(v.screen.H))
v.tex = gl.GenTexture()
v.fpsmanager = gfx.NewFramerate()
v.fpsmanager.SetFramerate(70)
joy = make([]*sdl.Joystick, sdl.NumJoysticks())
for i := 0; i < sdl.NumJoysticks(); i++ {
joy[i] = sdl.JoystickOpen(i)
fmt.Println("-----------------")
if joy[i] != nil {
fmt.Printf("Joystick %d\n", i)
fmt.Println(" Name: ", sdl.JoystickName(0))
fmt.Println(" Number of Axes: ", joy[i].NumAxes())
fmt.Println(" Number of Buttons: ", joy[i].NumButtons())
fmt.Println(" Number of Balls: ", joy[i].NumBalls())
} else {
fmt.Println(" Couldn't open Joystick!")
}
}
return v.resize
}
func main() {
sdl.Init(sdl.INIT_VIDEO)
defer sdl.Quit()
screen := sdl.SetVideoMode(width, height, 32, sdl.OPENGL)
if screen == nil {
panic("Couldn't set video mode: " + sdl.GetError() + "\n")
}
if err := gl.Init(); err != 0 {
panic("gl error")
}
initGl()
initShaders()
mainLoop()
}
func InitUI() *UI {
ui := &UI{
running: false,
}
if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
panic(sdl.GetError())
}
if ttf.Init() != 0 {
panic(sdl.GetError())
}
ui.screen = sdl.SetVideoMode(300, 300, 32, sdl.OPENGL)
if ui.screen == nil {
panic("sdl error")
}
if gl.Init() != 0 {
panic("gl error")
}
gl.MatrixMode(gl.PROJECTION)
gl.Viewport(0, 0, int(ui.screen.W), int(ui.screen.H))
gl.LoadIdentity()
gl.Ortho(0, float64(ui.screen.W), float64(ui.screen.H), 0, -1.0, 1.0)
gl.ClearColor(1, 1, 1, 0)
gl.Clear(gl.COLOR_BUFFER_BIT)
// TTF
sdl.EnableUNICODE(1)
ui.font = ttf.OpenFont("FontinSans.otf", 20)
ui.font.SetStyle(ttf.STYLE_UNDERLINE)
if ui.font == nil {
panic(sdl.GetError())
}
ui.running = true
return ui
}
func main() {
if e := glfw.Init(); e != nil {
panic(e.Error())
}
defer glfw.Terminate()
if e := glfw.OpenWindow(468, 320, 0, 0, 0, 0, 0, 0, glfw.Windowed); e != nil {
panic(e.Error())
}
if gl.Init() != 0 {
panic("GL Err")
}
glfw.SetKeyCallback(escHandler)
loop()
}
func initGL() {
gl.Init()
gl.ShadeModel(gl.SMOOTH)
gl.ClearColor(0, 0, 0, 0)
gl.ClearDepth(1)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
globalState.light[0] = 0
globalState.light[1] = 20
globalState.light[2] = -10
globalState.light[3] = 1
gl.Lightfv(gl.LIGHT1, gl.AMBIENT, []float32{1, 1, 1})
gl.Lightfv(gl.LIGHT1, gl.DIFFUSE, []float32{1, 1, 1})
gl.Lightfv(gl.LIGHT1, gl.POSITION, globalState.light[:])
gl.Enable(gl.LIGHT1)
gl.Enable(gl.LIGHTING)
}
func main() {
flag.Parse()
var done bool
var err os.Error
if err = glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
defer glfw.Terminate()
if err = glfw.OpenWindow(300, 300, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
if gl.Init() != 0 {
panic("gl error")
}
defer glfw.CloseWindow()
glfw.SetWindowTitle("gears")
glfw.SetWindowSizeCallback(reshape)
init_()
reshape(300, 300)
done = false
for !done {
idle()
draw()
done = glfw.Key(glfw.KeyEsc) != 0 || glfw.WindowParam(glfw.Opened) == 0
}
}
func Open(w, h int, fullscreen bool, title, tabname string) *Window {
if GWindow != nil {
panic("only one Window is allowed")
}
win := &Window{width: w, height: h, title: title, tabname: tabname}
GWindow = win
sdl.Init(sdl.INIT_EVERYTHING)
gl.Init()
var screen = sdl.SetVideoMode(win.width, win.height, 16, sdl.OPENGL)
if screen == nil {
sdl.Quit()
panic("Couldn't set sdl GL video mode: " + sdl.GetError() + "\n")
}
sdl.WM_SetCaption(win.title, win.tabname)
win.initGL()
win.pixelData = make([]uint8, win.width*win.height*4)
return win
}
func NewWindow(r Renderer) (*Window, error) {
w := &Window{r, time.Now()}
var err error
// Fail if the window is in use, even after its
// finalizer has had a change to run.
if busy {
runtime.GC()
runtime.GC()
if busy {
return nil, err
}
}
if err = glfw.Init(); err != nil {
goto abort_with_nothing
}
if err = glfw.OpenWindow(1024, 1024, 0, 0, 0, 0, 0, 0, glfw.Windowed); err != nil {
goto abort_with_glfw_init
}
if gl.Init() != 0 {
goto abort_with_open_window
}
glfw.SetWindowTitle(os.Args[0])
glfw.SetWindowSizeCallback(reshape)
glInit()
reshape(1024, 1024)
runtime.SetFinalizer(w, finalizeWindow)
busy = true
return w, nil
abort_with_open_window:
glfw.CloseWindow()
abort_with_glfw_init:
glfw.Terminate()
abort_with_nothing:
return nil, error(err)
}
func main() {
flag.Parse()
var done bool
var keys []uint8
sdl.Init(sdl.INIT_VIDEO)
var screen = sdl.SetVideoMode(300, 300, 16, sdl.OPENGL|sdl.RESIZABLE)
if screen == nil {
sdl.Quit()
panic("Couldn't set 300x300 GL video mode: " + sdl.GetError() + "\n")
}
if gl.Init() != 0 {
panic("gl error")
}
sdl.WM_SetCaption("Gears", "gears")
init_()
reshape(int(screen.W), int(screen.H))
done = false
for !done {
idle()
for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
switch e.(type) {
case *sdl.ResizeEvent:
re := e.(*sdl.ResizeEvent)
screen = sdl.SetVideoMode(int(re.W), int(re.H), 16,
sdl.OPENGL|sdl.RESIZABLE)
if screen != nil {
reshape(int(screen.W), int(screen.H))
} else {
panic("we couldn't set the new video mode??")
}
break
case *sdl.QuitEvent:
done = true
break
}
}
keys = sdl.GetKeyState()
if keys[sdl.K_ESCAPE] != 0 {
done = true
}
if keys[sdl.K_UP] != 0 {
view_rotx += 5.0
}
if keys[sdl.K_DOWN] != 0 {
view_rotx -= 5.0
}
if keys[sdl.K_LEFT] != 0 {
view_roty += 5.0
}
if keys[sdl.K_RIGHT] != 0 {
view_roty -= 5.0
}
if keys[sdl.K_z] != 0 {
if (sdl.GetModState() & sdl.KMOD_RSHIFT) != 0 {
view_rotz -= 5.0
} else {
view_rotz += 5.0
}
}
draw()
}
sdl.Quit()
return
}
func main() {
log.SetFlags(log.Lshortfile)
//parse flags
flag.Parse()
if flags.cpuprofile != "" {
f, err := os.Create(flags.cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
loadSettingsFile()
Settings.Paused = flags.startPaused
if flags.buildExamples {
allExamples()
return
}
wx, wy := 800, 600
//initialize opengl & glfw
{
//init glfw
if err := glfw.Init(); err != nil {
log.Printf("Error initializing glfw: %v\n", err)
return
}
defer glfw.Terminate()
//set window hints
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
//create the window
if err := glfw.OpenWindow(wx, wy, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil {
log.Printf("Error opening Window: %v\n", err)
return
}
defer glfw.CloseWindow()
//init opengl
if gl.Init() != 0 {
panic("gl error")
}
//glfw config
{
glfw.SetSwapInterval(1)
glfw.SetWindowTitle("mater test")
}
//set additional opengl stuff
{
gl.ClearColor(0, 0, 0, 0)
gl.Enable(gl.BLEND)
//gl.BlendFunc (gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
gl.Enable(gl.TEXTURE_2D)
}
}
//setup scene related stuff
{
//create empty space
space = collision.NewSpace()
}
//reload settings so they take effect
reloadSettings()
saveSettingsFile()
//set callbacks
{
glfw.SetWindowSizeCallback(OnResize)
glfw.SetKeyCallback(OnKey)
}
//init debug console
console.Init()
//load savefile passed from the commandline if any
if flags.file != "" {
err := loadSpace(flags.file)
Settings.Paused = true
if err != nil {
panic(err)
}
}
//if set to true once a second
printFPS := false
//fix timestep to given fps
const expectedFps = 30.0
const expectedFrameTime = 1.0 / expectedFps
//the time at the start of the last frame
lastTime := 0.0
acc := 0.0
updateAcc := 0.0
frameCount := 0
updateFrameCount := 0
fps := 0
updateFps := 0
Settings.Running = true
for Settings.Running && glfw.WindowParam(glfw.Opened) == 1 {
time := glfw.Time()
//get the time elapsed since the last frame
dt := time - lastTime
lastTime = time
//advance framecount and accumulators
frameCount++
acc += dt
updateAcc += dt
//execute console commands if any
select {
case command := <-console.Command:
console.ExecuteCommand(command)
default:
}
//update the scene at a fixed timestep
for updateAcc >= expectedFrameTime {
updateFrameCount++
//if one second has passed update the fps and reset the framecount
if acc > 1 {
updateFps = updateFrameCount
updateFrameCount = 0
}
//only update if not paused or if set to advance a single frame
if !Settings.Paused || Settings.SingleStep {
space.Step(expectedFrameTime)
Settings.SingleStep = false
}
updateAcc -= expectedFrameTime
}
//draw debug data
Draw()
glfw.SwapBuffers()
//if one second has passed update the fps and reset the framecount
if acc > 1 {
fps = frameCount
frameCount = 0
if printFPS {
fmt.Printf("---\n")
fmt.Printf("FPS: %v\n", fps)
fmt.Printf("Update FPS: %v\n", updateFps)
fmt.Printf("Average frametime: %v\n", acc/float64(fps))
fmt.Printf("---\n")
}
acc -= 1
}
}
}
func main() {
runtime.LockOSThread()
if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
log.Fatal(sdl.GetError())
}
var screen = sdl.SetVideoMode(screenWidth, screenHeight, 32, sdl.OPENGL|sdl.HWSURFACE|sdl.GL_DOUBLEBUFFER|sdl.FULLSCREEN)
if screen == nil {
log.Fatal(sdl.GetError())
}
sdl.WM_SetCaption("Lecture Hall Games", "")
sdl.EnableUNICODE(1)
if gl.Init() != 0 {
log.Fatal("could not initialize OpenGL")
}
gl.Viewport(0, 0, int(screen.W), int(screen.H))
gl.ClearColor(1, 1, 1, 0)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(screen.W), float64(screen.H), 0, -1.0, 1.0)
gl.Disable(gl.LIGHTING)
gl.Disable(gl.DEPTH_TEST)
gl.TexEnvi(gl.TEXTURE_ENV, gl.TEXTURE_ENV_MODE, gl.MODULATE)
if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT,
mixer.DEFAULT_CHANNELS, 4096) != 0 {
log.Fatal(sdl.GetError())
}
if ttf.Init() != 0 {
log.Fatal(sdl.GetError())
}
if p, err := build.Default.Import(basePkg, "", build.FindOnly); err == nil {
os.Chdir(p.Dir)
}
var err error
rand.Seed(time.Now().UnixNano())
levelDir := fmt.Sprintf("data/levels/demolevel%d", 3+rand.Intn(numberLevels))
//carsDir := fmt.Sprintf(" data/cars/car%d/", 1+rand.Intn(numberCars))
if game, err = NewRacer(levelDir); err != nil {
log.Fatal(err)
}
go func() {
listen, err := net.Listen("tcp", ":8001")
if err != nil {
log.Fatal(err)
}
for {
conn, err := listen.Accept()
if err != nil {
log.Println(err)
continue
}
go handleConnection(conn)
}
}()
running := true
last := time.Now()
for running {
select {
case event := <-sdl.Events:
switch e := event.(type) {
case sdl.QuitEvent:
running = false
case sdl.ResizeEvent:
screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE)
case sdl.KeyboardEvent:
if e.Type == sdl.KEYDOWN {
if e.Keysym.Sym == sdl.K_ESCAPE {
running = false
} else {
game.KeyPressed(e.Keysym)
}
}
}
default:
}
current := time.Now()
t := current.Sub(last)
last = current
mu.Lock()
game.Update(t)
game.Render(screen)
mu.Unlock()
sdl.GL_SwapBuffers()
}
sdl.Quit()
}
func initGame() {
viewport.Zoomstd()
viewport.Rotx(25)
viewport.Roty(70)
picker = NewPicker()
sdl.Init(sdl.INIT_VIDEO)
if ttf.Init() != 0 {
panic("Could not initalize fonts")
}
sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
screen := sdl.SetVideoMode(1024, 600, 32, sdl.OPENGL|sdl.RESIZABLE)
if screen == nil {
sdl.Quit()
panic("Couldn't set GL video mode: " + sdl.GetError() + "\n")
}
if gl.Init() != 0 {
panic("gl error")
}
sdl.WM_SetCaption("Amberfell", "amberfell")
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// gl.ShadeModel(gl.FLAT)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ShadeModel(gl.SMOOTH)
gl.Enable(gl.LIGHTING)
gl.Enable(gl.LIGHT0)
gl.Enable(gl.LIGHT1)
gl.Enable(gl.COLOR_MATERIAL)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.ClearDepth(1.0) // Depth Buffer Setup
gl.Enable(gl.DEPTH_TEST) // Enables Depth Testing
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.FASTEST)
gl.Enable(gl.TEXTURE_2D)
// LoadMapTextures()
LoadPlayerTextures()
LoadWolfTextures()
InitItems()
pauseFont = NewFont("res/Jura-DemiBold.ttf", 48, color.RGBA{255, 255, 255, 0})
consoleFont = NewFont("res/Jura-DemiBold.ttf", 16, color.RGBA{255, 255, 255, 0})
inventoryItemFont = NewFont("res/Jura-DemiBold.ttf", 14, color.RGBA{240, 240, 240, 0})
textures[TEXTURE_PICKER] = loadTexture("res/dial.png")
terrainTexture = loadTexture("res/tiles.png")
itemsTexture = loadTexture("res/items.png")
gVertexBuffer = NewVertexBuffer(10000, terrainTexture)
gGuiBuffer = NewVertexBuffer(1000, terrainTexture)
WolfModel = LoadModel("res/wolf.mm3d")
TheWorld = NewWorld()
ThePlayer = new(Player)
ThePlayer.Init(0, PLAYER_START_X, PLAYER_START_Z)
inventory = NewInventory()
viewport.Reshape(int(screen.W), int(screen.H))
PreloadChunks(400)
}
func main() {
runtime.LockOSThread()
flag.Parse()
buildPalette()
sdl.Init(sdl.INIT_VIDEO)
defer sdl.Quit()
sdl.GL_SetAttribute(sdl.GL_SWAP_CONTROL, 1)
if sdl.SetVideoMode(512, 512, 32, sdl.OPENGL) == nil {
panic("sdl error")
}
if gl.Init() != 0 {
panic("gl error")
}
sdl.WM_SetCaption("Gomandel", "Gomandel")
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 dndStart Point
var dndEnd Point
var tex gl.Texture
var tc TexCoords
var lastProgress int
initialRect := Rect{-1.5, -1.5, 3, 3}
rect := initialRect
rc := new(MandelbrotRequest)
rc.MakeRequest(512, 512, rect)
rc.WaitFor(Small, &tex, &tc)
running := true
for running {
for e := sdl.PollEvent(); e != nil; e = sdl.PollEvent() {
switch e.(type) {
case *sdl.QuitEvent:
running = false
case *sdl.MouseButtonEvent:
mbe := e.(*sdl.MouseButtonEvent)
if mbe.Type == sdl.MOUSEBUTTONDOWN {
dndDragging = true
sdl.GetMouseState(&dndStart.X, &dndStart.Y)
dndEnd = dndStart
} else {
dndDragging = false
sdl.GetMouseState(&dndEnd.X, &dndEnd.Y)
if mbe.Which == 3 {
rect = initialRect
} else {
rect = rectFromSelection(dndStart, dndEnd, 512, 512, rect)
tc = texCoordsFromSelection(dndStart, dndEnd, 512, 512, tc)
}
// make request
rc.MakeRequest(512, 512, rect)
}
case *sdl.MouseMotionEvent:
if dndDragging {
sdl.GetMouseState(&dndEnd.X, &dndEnd.Y)
}
}
}
// if we're waiting for a result, check if it's ready
p := rc.Update(&tex, &tc)
if p != -1 {
lastProgress = p
}
gl.Clear(gl.COLOR_BUFFER_BIT)
tex.Bind(gl.TEXTURE_2D)
drawQuad(0, 0, 512, 512, tc.TX, tc.TY, tc.TX2, tc.TY2)
gl.BindTexture(gl.TEXTURE_2D, 0)
if dndDragging {
drawSelection(dndStart, dndEnd)
}
drawProgress(512, 512, lastProgress, rc.Pending)
sdl.GL_SwapBuffers()
}
}
