Golang sdl.GetError函數代碼示例

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 main() {
	if sdl.Init(sdl.INIT_VIDEO) < 0 {
		panic("Video initialization failed: " + sdl.GetError())
	}

	if sdl.EnableKeyRepeat(100, 25) != 0 {
		panic("Setting keyboard repeat failed: " + sdl.GetError())
	}

	videoFlags := sdl.OPENGL    // Enable OpenGL in SDL
	videoFlags |= sdl.DOUBLEBUF // Enable double buffering
	videoFlags |= sdl.HWPALETTE // Store the palette in hardware
	// FIXME: this causes segfault.
	// videoFlags |= sdl.RESIZABLE // Enable window resizing

	surface = sdl.SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, uint32(videoFlags))

	if surface == nil {
		panic("Video mode set failed: " + sdl.GetError())
	}

	sdl.GL_SetAttribute(sdl.GL_DOUBLEBUFFER, 1)
	initGL()
	resizeWindow(SCREEN_WIDTH, SCREEN_HEIGHT)

	SetupWorld("data/world.txt")

	// wait for events
	running := true
	isActive := true
	for running {
		for ev := sdl.PollEvent(); ev != nil; ev = sdl.PollEvent() {
			switch e := ev.(type) {
			case *sdl.ActiveEvent:
				isActive = e.Gain != 0
			case *sdl.ResizeEvent:
				width, height := int(e.W), int(e.H)
				surface = sdl.SetVideoMode(width, height, SCREEN_BPP, uint32(videoFlags))
				if surface == nil {
					fmt.Println("Could not get a surface after resize:", sdl.GetError())
					Quit(1)
				}
				resizeWindow(width, height)
			case *sdl.KeyboardEvent:
				if e.Type == sdl.KEYDOWN {
					handleKeyPress(e.Keysym)
				}
			case *sdl.QuitEvent:
				running = false
			}
		}

		// draw the scene
		if isActive {
			drawGLScene(sector1)
		}
	}
}

func Play() {
	sdl.Init(sdl.INIT_AUDIO)
	if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT,
		mixer.DEFAULT_CHANNELS, 4096) != 0 {
		panic(sdl.GetError())
	}
	var m = mixer.LoadMUS("data/track.ogg")
	if m == nil {
		panic(sdl.GetError())
	}
	m.PlayMusic(-1)
}

func main() {
	if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
		panic(sdl.GetError())
	}

	if ttf.Init() != 0 {
		panic(sdl.GetError())
	}

	var screen = sdl.SetVideoMode(1400, 300, 32, 0)
	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)

	font := ttf.OpenFont("euler.otf", 24)

	if font == nil {
		panic(sdl.GetError())
	}

	black := sdl.Color{0, 0, 0, 0}
	text := ttf.RenderUTF8_Blended(font, "!!", black)
	fmt.Println(text.Bounds())
	sdl.WM_SetCaption("Go-SDL SDL Test", "")
	running := true
	num := NewNumberShower("b+c", "", "euler.otf", 24, 0)
	denom := NewNumberShower("a", "", "euler.otf", 24, 0)
	testy := NewFractionShower(num, denom, "euler.otf", 24, 0)
	testy.CursorPosition = 3
	testy.RenderEmptyIndextxt = true
	str := ""
	for running {
		switch e := sdl.PollEvent().(type) {
		case *sdl.QuitEvent:
			running = false
			break
		case *sdl.KeyboardEvent:

			if e.State == 1 {
				str = handlekeypress2(e.Keysym, str)
				fmt.Println("rendering string", str)
				text = ttf.RenderUTF8_Blended(font, str, black)
			}
		}
		screen.FillRect(nil, 0xFFFFFF)
		screen.Blit(&sdl.Rect{23, 0, 0, 0}, testy.Render(), nil)
		screen.Flip()
		sdl.Delay(5)
	}
}

func NewScreen(w, h int) *Screen {
	if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
		log.Fatal("failed to init sdl", sdl.GetError())
		return nil
	}

	if ttf.Init() != 0 {
		log.Fatal("failed to init ttf", sdl.GetError())
		return nil
	}

	var ctx Screen
	if err := ctx.setSurface(w, h); err != nil {
		log.Fatal(err)
	}

	var vInfo = sdl.GetVideoInfo()
	log.Println("HW_available = ", vInfo.HW_available)
	log.Println("WM_available = ", vInfo.WM_available)
	log.Println("Video_mem = ", vInfo.Video_mem, "kb")

	/* title := "Subtitle Player" */
	title := os.Args[0]
	icon := "" // path/to/icon
	sdl.WM_SetCaption(title, icon)

	sdl.EnableUNICODE(1)

	ctx.fps = opt.fps

	err := ctx.setFont(opt.fontPath, opt.fontSize)
	if err != nil {
		log.Fatal("failed to set default font")
		return nil
	}

	ctx.debugFont = ttf.OpenFont(DFLT_FONT_PATH, 20)
	if ctx.debugFont == nil {
		errMsg := fmt.Sprintf("failed to open debug font: %s",
			sdl.GetError())
		/* return errors.New(errMsg) */
		log.Fatal(errMsg)
	}
	ctx.debugLineHeight = uint16(ctx.debugFont.LineSkip())

	ctx.updateC = make(chan int)

	return &ctx
}

func writeSDLstr(newStr string) {

	if ttf.Init() != 0 {
		panic(sdl.GetError())
	}
	var font = ttf.OpenFont("FontinSans.otf", int(fontsize))

	blue := sdl.Color{185, 230, 255, 0}
	white := sdl.Color{255, 255, 255, 0}
	text0 := ttf.RenderText_Blended(font, previousStr, blue)
	font.SetStyle(ttf.STYLE_UNDERLINE)
	text1 := ttf.RenderText_Blended(font, newStr, white)

	introw = introw - fontsize - fontsize/2
	screen.FillRect(&sdl.Rect{3, introw, uint16(winWidth - 3), uint16(fontsize + fontsize/2)}, bgcolor)
	screen.Blit(&sdl.Rect{3, introw, 0, 0}, text0, nil)
	introw = introw + fontsize + fontsize/2
	screen.Blit(&sdl.Rect{3, introw, 0, 0}, text1, nil)
	introw = introw + fontsize + fontsize/2
	if introw > (int16(winHeight) - fontsize) {
		introw = 0
	}
	screen.FillRect(&sdl.Rect{3, introw, uint16(winWidth - 3), uint16(fontsize + fontsize/2)}, bgcolor)

	screen.Flip()
	previousStr = newStr

}

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 NewSurface(height int, width int) (surface *sdl.Surface) {
	surface = sdl.SetVideoMode(height, width, 32, 0)
	if surface == nil {
		panic(sdl.GetError())
	}
	return
}

func NewFont(name string, size int) (font *ttf.Font) {
	font = ttf.OpenFont("/usr/share/fonts/TTF/"+name, size)
	if font == nil {
		panic(sdl.GetError())
	}
	return font
}

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)
}

// Draws everything.
func (g *game) draw() (err error) {
	if g.screen.Blit(nil, g.board.Image(), nil) < 0 {
		return errors.New(sdl.GetError())
	}

	if (g.selX >= 0) || (g.selY >= 0) {
		sx, sy := g.board.CoordToXY(g.selX, g.selY)
		//timg := g.turn.Image()
		//sx -= int(timg.W / 2)
		//sy -= int(timg.H / 2)
		//timg.SetAlpha(sdl.SRCALPHA, 128)
		//g.screen.Blit(&sdl.Rect{X: int16(sx), Y: int16(sy)}, timg, nil)
		//timg.SetAlpha(sdl.SRCALPHA, 255)
		switch g.turn {
		case g.pieces["black"]:
			g.screen.FillRect(&sdl.Rect{int16(sx - 10), int16(sy - 10), 20, 20},
				sdl.MapRGBA(g.screen.Format, 0, 0, 0, 128),
			)
		case g.pieces["white"]:
			g.screen.FillRect(&sdl.Rect{int16(sx - 10), int16(sy - 10), 20, 20},
				sdl.MapRGBA(g.screen.Format, 255, 255, 255, 128),
			)
		}
	}

	return
}

// 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 CreateRGBSurface(width, height int) *Surface {
	var rmask, gmask, bmask, amask uint32

	byteorder := 0
	bigendian := 0

	if byteorder == bigendian {
		rmask = 0xff000000
		gmask = 0x00ff0000
		bmask = 0x0000ff00
		amask = 0x000000ff
	} else {
		rmask = 0x000000ff
		gmask = 0x0000ff00
		bmask = 0x00ff0000
		amask = 0xff000000
	}

	inner := sdl.CreateRGBSurface(
		sdl.SRCALPHA, // flags
		width, height,
		32, // depth
		rmask, gmask, bmask, amask,
	)

	if inner == nil {
		panic(sdl.GetError())
	}

	return &Surface{inner}
}

func (s *Sound) GetEffect(path string) (c *mixer.Chunk, err error) {
	c = mixer.LoadWAV(path)
	if c == nil {
		err = fmt.Errorf(sdl.GetError())
		return
	}
	return
}