// Run runs renderLoop. The loop renders a frame and swaps the buffer
// at each tick received.
func renderLoopFunc(control *renderLoopControl) loop.LoopFunc {
return func(loop loop.Loop) error {
var window mandala.Window
// Lock/unlock the loop to the current OS thread. This is
// necessary because OpenGL functions should be called from
// the same thread.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// Create an instance of ticker and immediately stop
// it because we don't want to swap buffers before
// initializing a rendering state.
ticker := time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
ticker.Stop()
for {
select {
case window = <-control.window:
ticker.Stop()
window.MakeContextCurrent()
width, height := window.GetSize()
gl.Viewport(0, 0, width, height)
mandala.Logf("Restarting rendering loop...")
ticker = time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
// Compute window radius
windowRadius = math.Sqrt(math.Pow(float64(height), 2) + math.Pow(float64(width), 2))
//gl.Init()
gl.Disable(gl.DEPTH_TEST)
// antialiasing
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
//gl.Enable(gl.LINE_SMOOTH)
// At each tick render a frame and swap buffers.
case <-ticker.C:
draw()
window.SwapBuffers()
case event := <-control.pause:
ticker.Stop()
event.Paused <- true
case <-control.resume:
case <-loop.ShallStop():
ticker.Stop()
return nil
}
}
}
}
// Run runs renderLoop. The loop renders a frame and swaps the buffer
// at each tick received.
func renderLoopFunc(control *renderLoopControl) loop.LoopFunc {
return func(loop loop.Loop) error {
var state *gameState
// Lock/unlock the loop to the current OS thread. This is
// necessary because OpenGL functions should be called from
// the same thread.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// Create an instance of ticker and immediately stop
// it because we don't want to swap buffers before
// initializing a rendering state.
ticker := time.NewTicker(time.Duration(1e9 / int(FramesPerSecond)))
ticker.Stop()
for {
select {
case window := <-control.window:
ticker.Stop()
state = newGameState(window)
width, height := window.GetSize()
gl.Viewport(0, 0, gl.Sizei(width), gl.Sizei(height))
ticker = time.NewTicker(time.Duration(time.Second / time.Duration(FramesPerSecond)))
case tap := <-control.tapEvent:
state.world.explosion(tap[0], tap[1])
// At each tick render a frame and swap buffers.
case <-ticker.C:
state.draw()
state.window.SwapBuffers()
case event := <-control.pause:
ticker.Stop()
state.world.destroy()
event.Paused <- true
case <-control.resume:
case <-loop.ShallStop():
ticker.Stop()
return nil
}
}
}
}
// Run runs renderLoop. The loop renders a frame and swaps the buffer
// at each tick received.
func renderLoopFunc(controlCh *controlCh) loop.LoopFunc {
return func(loop loop.Loop) error {
var state renderState
// Lock/unlock the loop to the current OS thread. This is
// necessary because OpenGL functions should be called from
// the same thread.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// We don't have yet a proper rendering state so the
// ticker should be stopped as soon as it is created.
ticker := time.NewTicker(time.Duration(int(time.Second) / int(FRAMES_PER_SECOND)))
ticker.Stop()
for {
select {
// At each tick render a frame and swap buffers.
case <-ticker.C:
state.angle += 0.05
state.cube.Rotate(state.angle, [3]float32{0, 1, 0})
state.world.Draw()
egl.SwapBuffers(state.eglState.Display, state.eglState.Surface)
// Receive an EGL state from the
// native graphics subsystem and
// initialize a rendering state.
case eglState := <-controlCh.eglState:
if err := state.init(eglState); err != nil {
panic(err)
}
// Now that we have a proper rendering
// state we can start the ticker.
ticker = time.NewTicker(time.Duration(int(time.Second) / int(FRAMES_PER_SECOND)))
case <-controlCh.exit:
go loop.Stop()
case <-loop.ShallStop():
ticker.Stop()
egl.DestroySurface(state.eglState.Display, state.eglState.Surface)
egl.DestroyContext(state.eglState.Display, state.eglState.Context)
egl.Terminate(state.eglState.Display)
return nil
}
}
}
}
// Run runs renderLoop. The loop renders a frame and swaps the buffer
// at each tick received.
func (t *TestSuite) renderLoopFunc(control *renderLoopControl) loop.LoopFunc {
return func(loop loop.Loop) error {
// renderState stores rendering state variables such
// as the EGL state
renderState := new(renderState)
// Lock/unlock the loop to the current OS thread. This is
// necessary because OpenGL functions should be called from
// the same thread.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// Create an instance of ticker and immediately stop
// it because we don't want to swap buffers before
// initializing a rendering state.
ticker := time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
ticker.Stop()
for {
select {
case window := <-control.window:
ticker.Stop()
renderState.init(window)
ticker = time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
// At each tick render a frame and swap buffers.
case <-ticker.C:
renderState.draw()
renderState.window.SwapBuffers()
t.testDraw <- true
case <-control.resizeViewport:
case <-control.pause:
// store something
ticker.Stop()
case <-control.resume:
// resume something
case <-loop.ShallStop():
ticker.Stop()
return nil
}
}
}
}
// Run runs renderLoop. The loop renders a frame and swaps the buffer
// at each tick received.
func renderLoopFunc(control *renderLoopControl) loop.LoopFunc {
return func(loop loop.Loop) error {
var window mandala.Window
// Lock/unlock the loop to the current OS thread. This is
// necessary because OpenGL functions should be called from
// the same thread.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// Create an instance of ticker and immediately stop
// it because we don't want to swap buffers before
// initializing a rendering state.
ticker := time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
ticker.Stop()
for {
select {
case window = <-control.window:
ticker.Stop()
window.MakeContextCurrent()
width, height := window.GetSize()
gl.Viewport(0, 0, gl.Sizei(width), gl.Sizei(height))
mandala.Logf("Restarting rendering loop...")
ticker = time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
// At each tick render a frame and swap buffers.
case <-ticker.C:
draw()
window.SwapBuffers()
case event := <-control.pause:
ticker.Stop()
event.Paused <- true
case <-control.resume:
case <-loop.ShallStop():
ticker.Stop()
return nil
}
}
}
}
// Run runs renderLoop. The loop renders a frame and swaps the buffer
// at each tick received.
func renderLoopFunc(control *renderLoopControl) loop.LoopFunc {
return func(loop loop.Loop) error {
// renderState keeps the rendering state variables
// such as the EGL status
renderState := new(renderState)
// Lock/unlock the loop to the current OS thread. This is
// necessary because OpenGL functions should be called from
// the same thread.
runtime.LockOSThread()
defer runtime.UnlockOSThread()
// Create an instance of ticker and immediately stop
// it because we don't want to swap buffers before
// initializing a rendering state.
ticker := time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
ticker.Stop()
for {
select {
case window := <-control.window:
ticker.Stop()
renderState.init(window)
mandala.Logf("Restarting rendering loop...")
ticker = time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
// At each tick render a frame and swap buffers.
case <-ticker.C:
renderState.angle += 0.05
renderState.cube.Rotate(renderState.angle, [3]float32{0, 1, 0})
renderState.world.Draw()
renderState.window.SwapBuffers()
case viewport := <-control.resizeViewport:
if renderState.world != nil {
if viewport.width != renderState.world.Width || viewport.height != renderState.world.Height {
mandala.Logf("Resize native window W:%v H:%v\n", viewport.width, viewport.height)
ticker.Stop()
renderState.world.Resize(viewport.width, viewport.height)
ticker = time.NewTicker(time.Duration(1e9 / int(FRAMES_PER_SECOND)))
}
}
case event := <-control.pause:
renderState.savedAngle = renderState.angle
mandala.Logf("Save an angle value of %f", renderState.savedAngle)
ticker.Stop()
event.Paused <- true
case <-control.resume:
renderState.angle = renderState.savedAngle
mandala.Logf("Restore an angle value of %f", renderState.angle)
case <-loop.ShallStop():
ticker.Stop()
return nil
}
}
}
}