func main() { if sdl.Init(sdl.INIT_VIDEO) != 0 { panic(sdl.GetError()) } defer sdl.Quit() screen := sdl.SetVideoMode(400, 300, 32, 0) if screen == nil { panic(sdl.GetError()) } sdl.WM_SetCaption("Template", "") ticker := time.NewTicker(1e9 / 2 /*2 Hz*/) loop: for { select { case <-ticker.C: // Note: For better efficiency, use UpdateRects instead of Flip screen.FillRect(nil /*color*/, rand.Uint32()) //screen.Blit(&sdl.Rect{x,y, 0, 0}, image, nil) screen.Flip() case event := <-sdl.Events: fmt.Printf("%#v\n", event) switch event.(type) { case sdl.QuitEvent: break loop } } } }
func main() { verbose := flag.Bool("verbose", false, "verbose mode") debug := flag.Bool("debug", false, "debug mode") fullScreen := flag.Bool("fullscreen", false, "go fullscreen") cpuProfile := flag.String("cpuprofile", "", "write cpu profile to file") help := flag.Bool("help", false, "Show usage") flag.Usage = usage flag.Parse() if *help { usage() return } if *cpuProfile != "" { f, err := os.Create(*cpuProfile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } application.Verbose = *verbose application.Debug = *debug if sdl.Init(sdl.INIT_EVERYTHING) != 0 { log.Fatal(sdl.GetError()) } screen := sms.NewSDL2xScreen(*fullScreen) sdlLoop := sms.NewSDLLoop(screen) emulatorLoop := newEmulatorLoop(sdlLoop) if emulatorLoop == nil { usage() return } cpuProfiling := *cpuProfile != "" commandLoop := newCommandLoop(emulatorLoop, sdlLoop, cpuProfiling) inputLoop := sms.NewInputLoop(emulatorLoop.sms) application.Register("Emulator loop", emulatorLoop) application.Register("Command loop", commandLoop) application.Register("SDL render loop", sdlLoop) application.Register("SDL input loop", inputLoop) exitCh := make(chan bool) application.Run(exitCh) <-exitCh sdl.Quit() }
// TODO: Sprite are not free (sdl) func (this *RenderManager) Quit() { // image.Free() sdl.Quit() }
func (v *Video) Close() { sdl.Quit() }
func Main() { var init_waitGroup *sync.WaitGroup init_waitGroup = env.WaitName("init WaitGroup").(*sync.WaitGroup) init_waitGroup.Add(1) var app *spectrum.Application app = env.Wait(reflect.TypeOf(app)).(*spectrum.Application) var speccy *spectrum.Spectrum48k speccy = env.Wait(reflect.TypeOf(speccy)).(*spectrum.Spectrum48k) if !*enableSDL { return } uiSettings = &InitialSettings{ scale2x: Scale2x, fullscreen: Fullscreen, showPaintedRegions: ShowPaintedRegions, audio: Audio, audioFreq: AudioFreq, hqAudio: HQAudio, } composer = NewSDLSurfaceComposer(app) composer.ShowPaintedRegions(*ShowPaintedRegions) // SDL subsystems init if err := initSDLSubSystems(app); err != nil { app.PrintfMsg("%s", err) app.RequestExit() return } // Setup the display r = NewSDLRenderer(app, speccy, *Scale2x, *Fullscreen, *Audio, *HQAudio, *AudioFreq) setUI(r) initCLI() // Setup the audio if *Audio { audio, err := NewSDLAudio(app, *AudioFreq, *HQAudio) if err == nil { speccy.CommandChannel <- spectrum.Cmd_AddAudioReceiver{audio} } else { app.PrintfMsg("%s", err) } } // Start the SDL event loop go sdlEventLoop(app, speccy, *verboseInput) init_waitGroup.Done() hint := "Hint: Press F10 to invoke the built-in console.\n" hint += " Input an empty line in the console to display available commands.\n" fmt.Print(hint) // Wait for all event loops to terminate, and then call 'sdl.Quit()' shutdown.Wait() if r.app.Verbose { r.app.PrintfMsg("SDL: sdl.Quit()") } sdl.Quit() }
func BenchmarkRender(b *testing.B) { b.StopTimer() initSDL() app := spectrum.NewApplication() sdlScreen := &SDLScreen{ screenChannel: make(chan *spectrum.DisplayData), screenSurface: &SDLSurface{newSurface()}, unscaledDisplay: newUnscaledDisplay(), updatedRectsCh: make(chan []sdl.Rect), app: app, } rom, err := spectrum.ReadROM("testdata/48.rom") if err != nil { panic(err) } speccy := spectrum.NewSpectrum48k(app, *rom) speccy.CommandChannel <- spectrum.Cmd_AddDisplay{sdlScreen} snapshot, err := formats.ReadProgram("testdata/fire.z80") if err != nil { panic(err) } errChan := make(chan error) speccy.CommandChannel <- spectrum.Cmd_LoadSnapshot{"<fire>", snapshot.(formats.Snapshot), errChan} err = <-errChan if err != nil { panic(err) } // Capture a number of frames sent from 'speccy' to the rendering backends const numFrames = 1000 var frames [numFrames]*spectrum.DisplayData { go func() { for i := 0; i < numFrames; i++ { speccy.CommandChannel <- spectrum.Cmd_RenderFrame{nil} } }() for i := 0; i < numFrames; i++ { frames[i] = <-sdlScreen.screenChannel } } // The actual benchmark { b.StartTimer() go func() { for { <-sdlScreen.updatedRectsCh sdlScreen.screenSurface.surface.Flip() } }() for i := 0; i < b.N; i++ { sdlScreen.render(frames[i%numFrames]) } b.StopTimer() } app.RequestExit() <-app.HasTerminated sdl.Quit() }