Golang C.SDL_SetVideoMode函數代碼示例

func SetVideoMode(width int, height int, bpp int, flags int) {
	screen := C.SDL_SetVideoMode(C.int(width), C.int(height), C.int(bpp), C.Uint32(flags))

	if screen == nil {
		panic("unable to set video mode")
	}
}

// Sets up a video mode with the specified width, height, bits-per-pixel and
// returns a corresponding surface.  You don't need to call the Free method
// of the returned surface, as it will be done automatically by sdl.Quit.
func SetVideoMode(w int, h int, bpp int, flags uint32) *Surface {
	GlobalMutex.Lock()
	var screen = C.SDL_SetVideoMode(C.int(w), C.int(h), C.int(bpp), C.Uint32(flags))
	currentVideoSurface = wrap(screen)
	GlobalMutex.Unlock()
	return currentVideoSurface
}

func mainLoop(width, height int) {
	// SDL window must be created in the same thread where the events are
	// polled. Hence this stuff must be in a separate goroutine along with the
	// event loop.

	initFlags := int64(C.SDL_INIT_VIDEO) | int64(C.SDL_INIT_AUDIO)
	screenFlags := 0

	if C.SDL_Init(C.Uint32(initFlags)) == C.int(-1) {
		panic(getError())
	}

	screen := C.SDL_SetVideoMode(
		C.int(width), C.int(height), 32, C.Uint32(screenFlags))
	if screen == nil {
		panic(getError())
	}
	C.SDL_EnableUNICODE(1)
	C.SDL_EnableKeyRepeat(C.SDL_DEFAULT_REPEAT_DELAY, C.SDL_DEFAULT_REPEAT_INTERVAL)

	initAudio()

	// Synchronize with Run function.
	coord <- true

	eventLoop()
	C.SDL_Quit()

	// Synchronize with Stop function.
	coord <- true
	runLevel = off
}

func SetVideoMode(width, height, bitsPerPixel int, flags SurfaceFlags) (Surface, error) {
	c_width := C.int(width)
	c_height := C.int(height)
	c_bpp := C.int(bitsPerPixel)
	c_flags := C.Uint32(flags)
	ret := C.SDL_SetVideoMode(c_width, c_height, c_bpp, c_flags)
	if ret == nil {
		return Surface{}, GetError()
	}
	return Surface{unsafe.Pointer(ret)}, nil
}

func NewDisplay(title string, width, height int) (*Display, error) {
	d := Display{frame: make(chan *C.AVFrame)}
	d.width = C.int(width)
	d.height = C.int(height)
	d.screen = C.SDL_SetVideoMode(d.width, d.height, 0, 0)
	d.overlay = C.SDL_CreateYUVOverlay(d.width, d.height, C.SDL_IYUV_OVERLAY, d.screen)
	t := C.CString(title)
	C.SDL_WM_SetCaption(t, (*C.char)(null))
	C.free(unsafe.Pointer(t))
	return &d, nil
}

// Sets up a video mode with the specified width, height, bits-per-pixel and
// returns a corresponding surface.  You don't need to call the Free method
// of the returned surface, as it will be done automatically by sdl.Quit.
func SetVideoMode(w int, h int, bpp int, flags uint32) *Surface {
	var screen = C.SDL_SetVideoMode(C.int(w), C.int(h), C.int(bpp), C.Uint32(flags))
	return (*Surface)(cast(screen))
}

// Set up a video mode with the specified width, height and bits-per-pixel.
//
// If 'bpp' is 0, it is treated as the current display bits per pixel.
//
// If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
// requested bits-per-pixel, but will return whatever video pixel format is
// available.  The default is to emulate the requested pixel format if it
// is not natively available.
//
// If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
// video memory, if possible, and you may have to call SDL_LockSurface()
// in order to access the raw framebuffer.  Otherwise, the video surface
// will be created in system memory.
//
// If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
// updates asynchronously, but you must always lock before accessing pixels.
// SDL will wait for updates to complete before returning from the lock.
//
// If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
// that the colors set by SDL_SetColors() will be the colors you get.
// Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
// of the colors exactly the way they are requested, and you should look
// at the video surface structure to determine the actual palette.
// If SDL cannot guarantee that the colors you request can be set,
// i.e. if the colormap is shared, then the video surface may be created
// under emulation in system memory, overriding the SDL_HWSURFACE flag.
//
// If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
// a fullscreen video mode.  The default is to create a windowed mode
// if the current graphics system has a window manager.
// If the SDL library is able to set a fullscreen video mode, this flag
// will be set in the surface that is returned.
//
// If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
// two surfaces in video memory and swap between them when you call
// SDL_Flip().  This is usually slower than the normal single-buffering
// scheme, but prevents "tearing" artifacts caused by modifying video
// memory while the monitor is refreshing.  It should only be used by
// applications that redraw the entire screen on every update.
//
// If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
// window manager, if any, to resize the window at runtime.  When this
// occurs, SDL will send a SDL_VIDEORESIZE event to you application,
// and you must respond to the event by re-calling SDL_SetVideoMode()
// with the requested size (or another size that suits the application).
//
// If SDL_NOFRAME is set in 'flags', the SDL library will create a window
// without any title bar or frame decoration.  Fullscreen video modes have
// this flag set automatically.
//
// This function returns the video framebuffer surface, or NULL if it fails.
//
// If you rely on functionality provided by certain video flags, check the
// flags of the returned surface to make sure that functionality is available.
// SDL will fall back to reduced functionality if the exact flags you wanted
// are not available.
func setVideoMode(width, height, bpp int, flags uint32) *C.SDL_Surface {
	return C.SDL_SetVideoMode(C.int(width), C.int(height),
		C.int(bpp), C.Uint32(flags))
}