func (self *AppStateManager) Destroy() { sdl.Quit() if *FLAG_profile { pprof.StopCPUProfile() } }
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 main() { if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic(sdl.GetError()) } defer sdl.Quit() screen := sdl.SetVideoMode(640, 480, 32, 0) if screen == nil { panic(sdl.GetError()) } sdl.WM_SetCaption("Ohai", "") sdl.EnableKeyRepeat(20, 20) fmt.Println("Launching mainloop") loadTextures() loadLevel() gameloop(screen) }
// Runs everything, calling the methods required to get the game // running, runs the main loop, and then cleanly exits. func (g *game) run() (err error) { err = g.load() if err != nil { return } defer g.quit() if sdl.Init(sdl.INIT_EVERYTHING) < 0 { return errors.New(sdl.GetError()) } defer sdl.Quit() g.screen = sdl.SetVideoMode(640, 480, 32, sdl.DOUBLEBUF) if g.screen == nil { return errors.New(sdl.GetError()) } sdl.WM_SetCaption(WinCap, "") err = g.main() if err != nil { return } return }
func initdec() { initnum-- if initnum == 0 { sdl.Quit() } }
// release/destroy our resources and restoring the old desktop func Quit(status int) { // clean up the window sdl.Quit() // and exit appropriately os.Exit(status) }
// Wrap the SDL into one single thread func (s SdlWrap) wrap() { runtime.LockOSThread() if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic("Unable to init SDL. Cause: " + sdl.GetError()) } sdl.EnableUNICODE(1) s.InitDone <- struct{}{} for { select { case t := <-s.Title: sdl.WM_SetCaption(t, t) case <-s.Quit: close(s.Events) sdl.Quit() case sz := <-s.Size: s.Surface <- sdl.SetVideoMode(int(sz.X), int(sz.Y), 32, sdl.HWSURFACE|sdl.DOUBLEBUF|sdl.RESIZABLE) default: e := sdl.PollEvent() if e != nil { s.Events <- e } } } }
func (self *AppStateManager) Setup(state AppState, caption string) { if *FLAG_profile { pfile, _ := os.Create("gowar.prof") pprof.StartCPUProfile(pfile) } // Lock, so we got no GL-in-wrong-thread foolery sdl.Init(sdl.INIT_VIDEO) self.Screen = sdl.SetVideoMode(800, 600, 32, sdl.OPENGL|sdl.RESIZABLE) gl.Init() if self.Screen == nil { sdl.Quit() panic("Couldn't set 300x300 GL video mode: " + sdl.GetError() + "\n") } sdl.WM_SetCaption(caption, caption) Setup() GetViewport().SetScreenSize(float32(self.Screen.W), float32(self.Screen.H)) self.Push(state) }
func main() { var done bool sdl.Init(sdl.INIT_VIDEO) var screen = sdl.SetVideoMode(300, 300, 18, sdl.OPENGL|sdl.RESIZABLE) if screen == nil { sdl.Quit() panic("Couldn't set 300x300 GL video mode: " + sdl.GetError() + "\n") } gl.Init() //if gl.Init() != nil { //panic("gl error") //} init_() reshape(int32(screen.W), int32(screen.H)) done = false for !done { 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(int32(screen.W), int32(screen.H)) } else { panic("we couldn't set the new video mode??") } break case *sdl.QuitEvent: done = true break } } done = key_handler() draw() } sdl.Quit() return }
func (c *Screen) Release() { if c.font != nil { c.font.Close() } if c.surface != nil { c.surface.Free() } ttf.Quit() sdl.Quit() /* log.Printf("sdl Released...") */ }
func main() { if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic(sdl.GetError()) } defer sdl.Quit() println("unpause with space or p") println("while paused you can place cells with the three mouse buttons") rand.Seed(time.Now().UnixNano()) Screen = NewSurface(Width*Scale, Height*Scale) Setup() HandleEvents() }
func main() { globalState.Mouse = make(map[int]bool) flag.Parse() var err error if sdl.Init(sdl.INIT_VIDEO) != 0 { log.Printf("Unable to init SDL") return } if len(flag.Args()) == 0 { old := flag.Usage flag.Usage = func() { old() fmt.Fprintf(os.Stderr, "You MUST pass the name of the file to view\n") } flag.Usage() return } mesh, err = wfobj.LoadMeshFromFile(flag.Args()[0]) if err != nil { flag.Usage() fmt.Fprintf(os.Stderr, "[e] %v\n", err) return } defer sdl.Quit() screen := sdl.SetVideoMode(1024, 600, 32, sdl.OPENGL|sdl.RESIZABLE) if screen == nil { log.Printf("Unable to init sdl Screen") } sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1) initGL() sdl.WM_SetCaption("sdlviewer", "sdlviewer") running = true for running { handleInput() drawScene() } }
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 main() { if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic(sdl.GetError()) } // The actual resolution (screenspace) W := 800 H := 600 // The virtual resolution (worldspace) MAXX := 400 MAXY := 300 screen := sdl.SetVideoMode(W, H, 32, sdl.FULLSCREEN) if screen == nil { panic(sdl.GetError()) } sdl.EnableUNICODE(1) sdl.ShowCursor(0) sdl.WM_SetCaption("Random Lines", "") red := sdl.Color{255, 0, 0, 255} color := red rand.Seed(time.Now().UnixNano()) for { color = sdl.Color{uint8(rand.Intn(255)), uint8(rand.Intn(255)), uint8(rand.Intn(255)), 255} DoublePixelLine(screen, rand.Intn(MAXX), rand.Intn(MAXY), rand.Intn(MAXX), rand.Intn(MAXY), color) if escPressed() { break } screen.Flip() sdl.PollEvent() //sdl.Delay(10) } sdl.Quit() }
func main() { sdl.Init(sdl.INIT_VIDEO) ttf.Init() screen := sdl.SetVideoMode(480, 560, 16, sdl.OPENGL|sdl.RESIZABLE) sdl.WM_SetCaption("Flappy Bird", "") bg := utils.TextureFromFile("./bg.png") font := utils.LoadFont("/usr/share/fonts/truetype/DroidSans.ttf", 32) reshape(int(screen.W), int(screen.H)) renderBackground(screen, bg) font.Printf(110, 50, "Click to play") sdl.GL_SwapBuffers() for { OuterLoop: for { e := sdl.WaitEvent() switch e.(type) { case *sdl.MouseButtonEvent: if e.(*sdl.MouseButtonEvent).Type == sdl.MOUSEBUTTONUP { break OuterLoop } } } score, quit := playGame(screen, bg, font) if quit { break } quit = gameOverScreen(screen, strconv.Itoa(score), bg, font) if quit { break } } screen.Free() ttf.Quit() sdl.Quit() return }
func ui_main() { if sdl.Init(sdl.INIT_VIDEO) != 0 { panic(sdl.GetError()) } if screen == nil { panic(sdl.GetError()) } sdl.EnableUNICODE(1) sdl.WM_SetCaption("Go-SDL SDL Test", "") running := true for running { for ev := sdl.PollEvent(); ev != nil; ev = sdl.PollEvent() { switch e := ev.(type) { case *sdl.QuitEvent: running = false break case *sdl.ResizeEvent: println("resize screen ", e.W, e.H) screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE) if screen == nil { panic(sdl.GetError()) } } } } ttf.Quit() sdl.Quit() }
func DisplayImage(src image.Image) { // Initialise SDL log.Println("Initialising SDL.") sdl.Init(sdl.INIT_VIDEO) defer sdl.Quit() // Transform the image into an SDL surface. log.Println("Transforming image into SDL surface.") var buf bytes.Buffer png.Encode(&buf, src) sdlRW := sdl.RWFromReader(&buf) sdlSurf := sdl.Load_RW(sdlRW, false) // Set the display up. log.Println("Setting up screen.") sdlScreen := sdl.SetVideoMode(int(sdlSurf.W), int(sdlSurf.H), 32, sdl.SWSURFACE) sdlScreen.Blit(nil, sdlSurf, nil) // Loop until exit. log.Println("Displaying image.") loop(sdlScreen) }
func main() { if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic(sdl.GetError()) } defer sdl.Quit() var screen = sdl.SetVideoMode(640, 480, 32, 0) if screen == nil { panic(sdl.GetError()) } sdl.WM_SetCaption("Template", "") for true { e := &sdl.Event{} for e.Poll() { switch e.Type { case sdl.QUIT: return default: } } screen.FillRect(nil, 0x000000) //screen.Blit(&sdl.Rect{x,y, 0, 0}, image, nil) screen.Flip() sdl.Delay(25) } }
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") } sdl.EnableKeyRepeat(200, 20) if err := gl.Init(); err != 0 { panic("gl error") } cam.Yaw(3.14) initGl() initShaders() initVoxels() mainLoop() }
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 }
// Call to clean up after you're done. func (s *Sound) Terminate() { sdl.Quit() }
func (this *Window) Close() { this.pixelData = nil sdl.Quit() }
func main() { var running bool = true var width int = 800 var height int = 600 var t float32 if sdl.Init(sdl.INIT_VIDEO) != 0 { panic(sdl.GetError()) } sdl.WM_SetCaption("Horde3d Go SDL Example", "") //set sdl video mode if sdl.SetVideoMode(width, height, 32, sdl.OPENGL) == nil { panic(sdl.GetError()) } if !horde3d.Init() { fmt.Println("Error initializing Horde3D") horde3d.DumpMessages() return } //horde3d.SetOption(horde3d.Options_DebugViewMode, 1) //horde3d.SetOption(horde3d.Options_WireframeMode, 1) fmt.Println("Version: ", horde3d.VersionString()) //pipeline pipeRes := horde3d.AddResource(horde3d.ResTypes_Pipeline, "forward.pipeline.xml", 0) modelRes := horde3d.AddResource(horde3d.ResTypes_SceneGraph, "platform.scene.xml", 0) horde3d.LoadResourcesFromDisk("../content|" + "../content/pipelines|" + "../content/models|" + "../content/materials|" + "../content/shaders|" + "../content/textures|" + "../content/animations|" + "../content/particles|" + "../content/models/platform|" + "../content/effects") //add camera cam := horde3d.RootNode.AddCameraNode("Camera", pipeRes) //Setup Camera Viewport cam.SetNodeParamI(horde3d.Camera_ViewportXI, 0) cam.SetNodeParamI(horde3d.Camera_ViewportYI, 0) cam.SetNodeParamI(horde3d.Camera_ViewportWidthI, width) cam.SetNodeParamI(horde3d.Camera_ViewportHeightI, height) //add model model := horde3d.RootNode.AddNodes(modelRes) model.SetTransform(0, -30, -150, 0, 0, 0, 1, 1, 1) //add light light := horde3d.RootNode.AddLightNode("Light1", 0, "LIGHTING", "SHADOWMAP") light.SetTransform(0, 20, 0, 0, 0, 0, 1, 1, 1) light.SetNodeParamF(horde3d.Light_RadiusF, 0, 150) light.SetNodeParamF(horde3d.Light_FovF, 0, 90) //horde3d.SetNodeParamI(light, horde3d.Light_ShadowMapCountI, 3) light.SetNodeParamF(horde3d.Light_ShadowSplitLambdaF, 0, 0.9) //horde3d.SetNodeParamF(light, horde3d.Light_ShadowMapBiasF, 0, 0.001) light.SetNodeParamF(horde3d.Light_ColorF3, 0, 1.9) light.SetNodeParamF(horde3d.Light_ColorF3, 1, 1.7) light.SetNodeParamF(horde3d.Light_ColorF3, 2, 1.75) for running { t = 0 //increase anim time t = t + 10.0*(1/60) //process SDL events / input switch event := sdl.PollEvent(); event.(type) { case *sdl.QuitEvent: running = false break } //horde3d.SetNodeTransform(model, //t*10, 0, 0, //0, 0, 0, //1, 1, 1) horde3d.Render(cam) horde3d.FinalizeFrame() horde3d.DumpMessages() sdl.GL_SwapBuffers() } horde3d.Release() sdl.Quit() }
func quit() { ttf.Quit() sdl.Quit() println("Thanks for playing.") }
func Quit(world *World) { sdl.Quit() }
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) tex.Unbind(gl.TEXTURE_2D) if dndDragging { drawSelection(dndStart, dndEnd) } drawProgress(512, 512, lastProgress, rc.Pending) sdl.GL_SwapBuffers() } }
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() { if sdl.Init(sdl.INIT_EVERYTHING) != 0 { panic(sdl.GetError()) } if ttf.Init() != 0 { panic(sdl.GetError()) } if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT, mixer.DEFAULT_CHANNELS, 4096) != 0 { panic(sdl.GetError()) } var screen = sdl.SetVideoMode(640, 480, 32, sdl.RESIZABLE) if screen == nil { panic(sdl.GetError()) } var video_info = sdl.GetVideoInfo() println("HW_available = ", video_info.HW_available) println("WM_available = ", video_info.WM_available) println("Video_mem = ", video_info.Video_mem, "kb") sdl.EnableUNICODE(1) sdl.WM_SetCaption("Go-SDL SDL Test", "") image := sdl.Load("test.png") if image == nil { panic(sdl.GetError()) } sdl.WM_SetIcon(image, nil) running := true font := ttf.OpenFont("Fontin Sans.otf", 72) if font == nil { panic(sdl.GetError()) } font.SetStyle(ttf.STYLE_UNDERLINE) white := sdl.Color{255, 255, 255, 0} text := ttf.RenderText_Blended(font, "Test (with music)", white) music := mixer.LoadMUS("test.ogg") sound := mixer.LoadWAV("sound.ogg") if music == nil || sound == nil { panic(sdl.GetError()) } music.PlayMusic(-1) if sdl.GetKeyName(270) != "[+]" { panic("GetKeyName broken") } worm_in := make(chan Point) draw := make(chan Point, 64) var out chan Point var in chan Point out = worm_in in = out out = make(chan Point) go worm(in, out, draw) for running { for ev := sdl.PollEvent(); ev != nil; ev = sdl.PollEvent() { switch e := ev.(type) { case *sdl.QuitEvent: running = false break case *sdl.KeyboardEvent: println("") println(e.Keysym.Sym, ": ", sdl.GetKeyName(sdl.Key(e.Keysym.Sym))) if e.Keysym.Sym == 27 { running = false } fmt.Printf("%04x ", e.Type) for i := 0; i < len(e.Pad0); i++ { fmt.Printf("%02x ", e.Pad0[i]) } println() fmt.Printf("Type: %02x Which: %02x State: %02x Pad: %02x\n", e.Type, e.Which, e.State, e.Pad0[0]) fmt.Printf("Scancode: %02x Sym: %08x Mod: %04x Unicode: %04x\n", e.Keysym.Scancode, e.Keysym.Sym, e.Keysym.Mod, e.Keysym.Unicode) case *sdl.MouseButtonEvent: if e.Type == sdl.MOUSEBUTTONDOWN { println("Click:", e.X, e.Y) in = out out = make(chan Point) go worm(in, out, draw) sound.PlayChannel(-1, 0) } case *sdl.ResizeEvent: println("resize screen ", e.W, e.H) screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE) if screen == nil { panic(sdl.GetError()) } } } screen.FillRect(nil, 0x302019) screen.Blit(&sdl.Rect{0, 0, 0, 0}, text, nil) loop := true for loop { select { case p := <-draw: screen.Blit(&sdl.Rect{int16(p.x), int16(p.y), 0, 0}, image, nil) case <-out: default: loop = false } } var p Point sdl.GetMouseState(&p.x, &p.y) worm_in <- p screen.Flip() sdl.Delay(25) } image.Free() music.Free() font.Close() ttf.Quit() sdl.Quit() }
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() { 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") } gl.MatrixMode(gl.PROJECTION) gl.Viewport(0, 0, int(screen.W), int(screen.H)) gl.LoadIdentity() gl.Ortho(-5, 5, -2.5, 2.5, -1.0, 1.0) gl.ClearColor(0, 0, 0, 0) gl.Clear(gl.COLOR_BUFFER_BIT) gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE) tess := glu.NewTess() tess.SetBeginCallback(tessBeginHandler) tess.SetVertexCallback(tessVertexHandler) tess.SetEndCallback(tessEndHandler) tess.SetErrorCallback(tessErrorHandler) tess.SetEdgeFlagCallback(tessEdgeFlagHandler) tess.SetCombineCallback(tessCombineHandler) tess.Normal(0, 0, 1) var running = true for running { gl.MatrixMode(gl.MODELVIEW) gl.LoadIdentity() gl.Translated(-2.5, 0, 0) tess.BeginPolygon(nil) tess.BeginContour() for v := range OuterContour { tess.Vertex(OuterContour[v], &OuterContour[v]) } tess.EndContour() tess.BeginContour() for v := range InnerContour { tess.Vertex(InnerContour[v], &InnerContour[v]) } tess.EndContour() tess.EndPolygon() gl.Translated(5, 0, 0) tess.BeginPolygon(nil) tess.BeginContour() for v := range StarContour { tess.Vertex(StarContour[v], &StarContour[v]) } tess.EndContour() tess.EndPolygon() sdl.GL_SwapBuffers() sdl.Delay(25) } tess.Delete() sdl.Quit() }