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