/* Build creates a Controller struct. NOTE: locks the OS thread. Make sure to call all Controller.func from the exact same goroutine, otherwise the SDL context may crash! */ func Build() (*Controller, error) { // MUST guarantee controller always runs in same OS thread runtime.LockOSThread() sdl.Init(sdl.INIT_EVERYTHING) // prepare basic Controller stuff c := &Controller{} c.renderable = makeOrdered() c.entities = make(map[string]interface{}) c.keyreceivers = make(map[string][]*keyReceive) c.textCache = make(map[string]*sdl.Texture) // window window, err := sdl.CreateWindow("Orbiting", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 800, 600, sdl.WINDOW_SHOWN) if err != nil { return nil, err } c.window = window // create renderer (reference kept by window, no need to do it ourselves) renderer, err := sdl.CreateRenderer(c.window, -1, 0) if err != nil { return nil, err } // however, we DO want to keep just a single instance of the wrapper c.wrapped = &Renderer{renderer: renderer} return c, nil }
func Init(width, height int32) *Engine { window, err := sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, int(width), int(height), sdl.WINDOW_SHOWN) if err != nil { fmt.Fprint(os.Stderr, "Failed to create window", sdl.GetError()) os.Exit(1) } renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED|sdl.RENDERER_PRESENTVSYNC) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(2) } img.Init(0) ttf.Init() return &Engine{ Window: window, Renderer: renderer, Running: true, width: width, height: height, entities: make([]Drawable, 0), } }
// Initializes SDL func (e *Engine) Init() (err error) { err = sdl.Init(sdl.INIT_VIDEO | sdl.INIT_AUDIO) if err != nil { return } err = mix.Init(mix.INIT_OGG) if err != nil { return } err = ttf.Init() if err != nil { return } err = mix.OpenAudio(mix.DEFAULT_FREQUENCY, mix.DEFAULT_FORMAT, mix.DEFAULT_CHANNELS, 3072) if err != nil { return } e.Window, err = sdl.CreateWindow(WinTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, WinWidth, WinHeight, sdl.WINDOW_SHOWN) if err != nil { return } e.Renderer, err = sdl.CreateRenderer(e.Window, -1, sdl.RENDERER_ACCELERATED) if err != nil { return } return }
func Init() *MissionControl { mc := new(MissionControl) var err error // Create a new window with a default size mc.sdl_window, err = sdl.CreateWindow("Mission Control", sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, 640, 480, sdl.WINDOW_SHOWN) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err) os.Exit(1) } // Set window to fullscreen var disp_rect sdl.Rect sdl.GetDisplayBounds(mc.Display, &disp_rect) mc.sdl_window.SetPosition(int(disp_rect.X), int(disp_rect.Y)) mc.sdl_window.SetSize(int(disp_rect.W), int(disp_rect.H)) mc.sdl_window.SetFullscreen(sdl.WINDOW_FULLSCREEN) mc.renderer, err = sdl.CreateRenderer(mc.sdl_window, -1, sdl.RENDERER_ACCELERATED) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err) os.Exit(2) } mc.renderer.Clear() mc.SetBackgroundColor(0, 0, 0, 255) return mc }
func start() { if sdl.Init(sdl.INIT_AUDIO) < 0 { fmt.Fprintf(os.Stderr, "Failed to init:", sdl.GetError()) os.Exit(1) } window = sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, int(W), int(H), sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED|sdl.RENDERER_PRESENTVSYNC) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(1) } mix.SetSoundFonts("resources/") if !mix.OpenAudio(44100, mix.DEFAULT_FORMAT, 2, 2048) { fmt.Fprintf(os.Stderr, "Failed to open audio:%s\n", sdl.GetError()) os.Exit(1) } }
func main() { var window *sdl.Window var renderer *sdl.Renderer var event sdl.Event var running bool window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(2) } var peepArray []sdl.Event = make([]sdl.Event, 5) running = true for running { sdl.PumpEvents() numEventsRetrieved := sdl.PeepEvents(peepArray, sdl.PEEKEVENT, sdl.FIRSTEVENT, sdl.LASTEVENT) if numEventsRetrieved < 0 { fmt.Printf("PeepEvents error: %s\n", sdl.GetError()) } else { for i := 0; i < numEventsRetrieved; i++ { fmt.Printf("Event Peeked Value: %v\n", peepArray[i]) // primitive printing of event } } for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() { switch t := event.(type) { case *sdl.QuitEvent: running = false case *sdl.MouseMotionEvent: fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel) case *sdl.MouseButtonEvent: fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State) case *sdl.MouseWheelEvent: fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y) case *sdl.KeyUpEvent: fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n", t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat) } } sdl.Delay(1000 / 30) } renderer.Destroy() window.Destroy() }
// Create the graphics renderer or crash trying func createRenderer(w *sdl.Window) *sdl.Renderer { var r *sdl.Renderer var err error r, err = sdl.CreateRenderer(w, -1, sdl.RENDERER_ACCELERATED) if err != nil { panic(err) } return r }
func createRenderer(window *sdl.Window) *sdl.Renderer { renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { panic(fmt.Sprintf("Failed to create renderer: %s\n", err)) } return renderer }
func run() int { var window *sdl.Window var renderer *sdl.Renderer var points []sdl.Point var rect sdl.Rect var rects []sdl.Rect window, err := sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err) return 1 } defer window.Destroy() renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err) return 2 } defer renderer.Destroy() renderer.Clear() renderer.SetDrawColor(255, 255, 255, 255) renderer.DrawPoint(150, 300) renderer.SetDrawColor(0, 0, 255, 255) renderer.DrawLine(0, 0, 200, 200) points = []sdl.Point{{0, 0}, {100, 300}, {100, 300}, {200, 0}} renderer.SetDrawColor(255, 255, 0, 255) renderer.DrawLines(points) rect = sdl.Rect{300, 0, 200, 200} renderer.SetDrawColor(255, 0, 0, 255) renderer.DrawRect(&rect) rects = []sdl.Rect{{400, 400, 100, 100}, {550, 350, 200, 200}} renderer.SetDrawColor(0, 255, 255, 255) renderer.DrawRects(rects) rect = sdl.Rect{250, 250, 200, 200} renderer.SetDrawColor(0, 255, 0, 255) renderer.FillRect(&rect) rects = []sdl.Rect{{500, 300, 100, 100}, {200, 300, 200, 200}} renderer.SetDrawColor(255, 0, 255, 255) renderer.FillRects(rects) renderer.Present() sdl.Delay(2000) return 0 }
func CreateWindow(width, height int, title string) (*Window, error) { var g Window var err error g.win, err = sdl.CreateWindow(title, sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, width, height, 0) if err != nil { return nil, err } g.rend, err = sdl.CreateRenderer(g.win, -1, 0) return &g, err }
func createRenderer(window *sdl.Window) *sdl.Renderer { renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { log.Println("Failed to create renderer, exiting") os.Exit(1) } return renderer }
func main() { var window *sdl.Window var renderer *sdl.Renderer var points []sdl.Point var rect sdl.Rect var rects []sdl.Rect window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(2) } renderer.SetDrawColor(255, 255, 255, 255) renderer.DrawPoint(150, 300) renderer.SetDrawColor(0, 0, 255, 255) renderer.DrawLine(0, 0, 200, 200) points = []sdl.Point{{0, 0}, {100, 300}, {100, 300}, {200, 0}} renderer.SetDrawColor(255, 255, 0, 255) renderer.DrawLines(points) rect = sdl.Rect{300, 0, 200, 200} renderer.SetDrawColor(255, 0, 0, 255) renderer.DrawRect(&rect) rects = []sdl.Rect{{400, 400, 100, 100}, {550, 350, 200, 200}} renderer.SetDrawColor(0, 255, 255, 255) renderer.DrawRects(rects) rect = sdl.Rect{250, 250, 200, 200} renderer.SetDrawColor(0, 255, 0, 255) renderer.FillRect(&rect) rects = []sdl.Rect{{500, 300, 100, 100}, {200, 300, 200, 200}} renderer.SetDrawColor(255, 0, 255, 255) renderer.FillRects(rects) renderer.Present() sdl.Delay(2000) renderer.Destroy() window.Destroy() }
func Start(windowText string, W, H int) (*sdl.Window, *sdl.Renderer) { window, err := sdl.CreateWindow(windowText, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, W, H, sdl.WINDOW_SHOWN) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED|sdl.RENDERER_PRESENTVSYNC) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(1) } return window, renderer }
func run() int { var window *sdl.Window var renderer *sdl.Renderer var texture *sdl.Texture var src, dst sdl.Rect var err error window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err) return 1 } defer window.Destroy() renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err) return 2 } defer renderer.Destroy() image, err := img.Load(imageName) if err != nil { fmt.Fprintf(os.Stderr, "Failed to load PNG: %s\n", err) return 3 } defer image.Free() texture, err = renderer.CreateTextureFromSurface(image) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err) return 4 } defer texture.Destroy() src = sdl.Rect{0, 0, 512, 512} dst = sdl.Rect{100, 50, 512, 512} renderer.Clear() renderer.SetDrawColor(255, 0, 0, 255) renderer.FillRect(&sdl.Rect{0, 0, int32(winWidth), int32(winHeight)}) renderer.Copy(texture, &src, &dst) renderer.Present() sdl.Delay(2000) return 0 }
func (engine *GameEngine) Init(name string) { sdl.Init(sdl.INIT_EVERYTHING) ttf.Init() engine.window = sdl.CreateWindow(name, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 800, 600, sdl.WINDOW_SHOWN) engine.renderer = sdl.CreateRenderer(engine.window, -1, sdl.RENDERER_ACCELERATED|sdl.RENDERER_PRESENTVSYNC) engine.Input = &InputHandler{} engine.Assets = &AssetsManager{} engine.Input.Init() engine.Assets.Init(engine) engine.Running = true engine.states = NewStack() }
func main() { flag.Parse() // go doesMyCodeWork() // go doesMyCodeWork2() var x, y int if len(os.Args) < 3 { fmt.Println("No size was specified, using defaults") x = int(640 * 1.5) y = int(480 * 1.5) } else { var err error x, err = strconv.Atoi(os.Args[1]) if err != nil { fmt.Println("Could not parse " + os.Args[1] + " to int!") return } y, err = strconv.Atoi(os.Args[2]) if err != nil { fmt.Println("Could not parse " + os.Args[2] + " to int!") return } } window, err := sdl.CreateWindow("Campus Fighter I", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, x, y, sdl.WINDOWPOS_UNDEFINED) if err != nil { panic(err) } defer window.Destroy() //sdl.ShowCursor(0) window.UpdateSurface() renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { panic(err) } surface, err := window.GetSurface() if err != nil { panic(err) } controlManager := inputManager.GetControlManager() updateFunctionsToStartWith := make([]inputManager.Update, 1) updateFunctionsToStartWith[0] = menus.CreateMenus(window, surface, renderer, &controlManager) inputManager.StateMachine(controlManager.ReadInput(), updateFunctionsToStartWith) sdl.Quit() }
func main() { var window *sdl.Window var renderer *sdl.Renderer var event sdl.Event var running bool window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(2) } running = true for running { event = sdl.WaitEventTimeout(1000) // wait here until an event is in the event queue if event == nil { fmt.Println("WaitEventTimeout timed out") continue } switch t := event.(type) { case *sdl.QuitEvent: running = false case *sdl.MouseMotionEvent: fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel) case *sdl.MouseButtonEvent: fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State) case *sdl.MouseWheelEvent: fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y) case *sdl.KeyUpEvent: fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n", t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat) } } renderer.Destroy() window.Destroy() }
func main() { window, err := sdl.CreateWindow("Monster Path", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 640, 480, sdl.WINDOW_SHOWN) if err != nil { os.Exit(1) } defer window.Destroy() renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { os.Exit(2) } defer renderer.Destroy() var event sdl.Event running := true myGrid := grid.New(17, 12) setupMap(myGrid) gunner.location, _ = myGrid.RoomAt(15, 7) alien.location, _ = myGrid.RoomAt(1, 1) graph := graph.NewFromGrid(myGrid) path := graph.Path(gunner.location, alien.location) for running { for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() { switch event.(type) { case *sdl.QuitEvent: running = false } } renderer.SetDrawColor(205, 201, 201, 255) renderer.Clear() renderer.SetDrawColor(10, 10, 10, 255) Draw(renderer, myGrid) DrawGraph(renderer, graph) renderer.SetDrawColor(200, 0, 0, 255) DrawPath(renderer, path) renderer.SetDrawColor(0, 100, 0, 255) alien.Draw(renderer) gunner.Draw(renderer) renderer.Present() } }
func main() { var window *sdl.Window var renderer *sdl.Renderer var texture *sdl.Texture var src, dst sdl.Rect window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(2) } image := img.Load(imageName) if image == nil { fmt.Fprintf(os.Stderr, "Failed to load PNG: %s\n", sdl.GetError()) os.Exit(3) } texture = renderer.CreateTextureFromSurface(image) if texture == nil { fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", sdl.GetError()) os.Exit(4) } src = sdl.Rect{0, 0, 512, 512} dst = sdl.Rect{100, 50, 512, 512} renderer.Clear() renderer.SetDrawColor(255, 0, 0, 255) renderer.FillRect(&sdl.Rect{0, 0, int32(winWidth), int32(winHeight)}) renderer.Copy(texture, &src, &dst) renderer.Present() sdl.Delay(2000) image.Free() texture.Destroy() renderer.Destroy() window.Destroy() }
// Init is used for a starting procedure of the game which will do things // such as creating the SDL Window, creating the SDL Renderer, Start the Scene, etc. func Init(title string, x, y, width, height int, fullscreen bool) { var flags uint32 if fullscreen { flags = sdl.WINDOW_FULLSCREEN } err := sdl.Init(sdl.INIT_EVERYTHING) if err != nil { log.Fatalln("Game // Error whie initialising SDL") log.Panic(err) } log.Println("Game // SDL Initialised") win, err := sdl.CreateWindow(title, x, y, width, height, flags) if err != nil { log.Fatalln("Game // Error while creating window") log.Panic(err) } log.Println("Game // Created Window") ren, err := sdl.CreateRenderer(win, -1, 0) if err != nil { log.Fatalln("Game // Error while creating renderer") log.Panic(err) } ren.SetDrawColor(255, 255, 255, 255) log.Println("Game // Created Renderer") log.Println("Game // Init Success") window = win renderer = ren input.InitJoystick() running = true currentScene.Enter() }
func run() int { var window *sdl.Window var renderer *sdl.Renderer var event sdl.Event var running bool var err error window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err) return 1 } defer window.Destroy() renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err) return 2 } defer renderer.Destroy() running = true for running { for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() { switch t := event.(type) { case *sdl.QuitEvent: running = false case *sdl.MouseMotionEvent: fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel) case *sdl.MouseButtonEvent: fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State) case *sdl.MouseWheelEvent: fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y) case *sdl.KeyUpEvent: fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n", t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat) } } } return 0 }
func main() { var window *sdl.Window var renderer *sdl.Renderer var image *sdl.Surface var texture *sdl.Texture var src, dst sdl.Rect var err error window, err = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", err) os.Exit(1) } defer window.Destroy() renderer, err = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", err) os.Exit(2) } defer renderer.Destroy() image, err = sdl.LoadBMP(imageName) if err != nil { fmt.Fprintf(os.Stderr, "Failed to load BMP: %s\n", err) os.Exit(3) } defer image.Free() texture, err = renderer.CreateTextureFromSurface(image) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err) os.Exit(4) } defer texture.Destroy() src = sdl.Rect{0, 0, 512, 512} dst = sdl.Rect{100, 50, 512, 512} renderer.Clear() renderer.Copy(texture, &src, &dst) renderer.Present() sdl.Delay(2000) }
func NewWindow(title string, width, height int) (*Window, error) { pos := sdl.WINDOWPOS_UNDEFINED w, err := sdl.CreateWindow(title, pos, pos, width, height, sdl.WINDOW_SHOWN) if err != nil { return nil, err } r, err := sdl.CreateRenderer(w, -1 /* first driver */, sdl.RENDERER_ACCELERATED) if err != nil { return nil, err } renderer := newRenderer(r) return &Window{ Renderer: renderer, w: w, }, nil }
func (d *Display) init() (err error) { err = sdl.Init(sdl.INIT_VIDEO) if err != nil { return err } d.window, err = sdl.CreateWindow("anna", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, 1400, 500, sdl.WINDOW_SHOWN) if err != nil { return err } d.renderer, err = sdl.CreateRenderer(d.window, -1, sdl.RENDERER_ACCELERATED) if err != nil { return err } return nil }
func start() { window = sdl.CreateWindow("test", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, int(W), int(H), sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED|sdl.RENDERER_PRESENTVSYNC) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(1) } ttf.Init() font, _ = ttf.OpenFont("resources/lazy.ttf", 28) if font == nil { fmt.Fprintf(os.Stderr, "Failed to create font: %s\n", ttf.GetError()) os.Exit(1) } }
func TestRender(t *testing.T) { window, err := sdl.CreateWindow("Test123", sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, 800, 600, sdl.WINDOW_SHOWN) if err != nil { t.Error("Окно не созданно: ", err) } renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if err != nil { t.Error("Рендер не создан: ", err) } renderer.Clear() renderer.SetDrawColor(255, 255, 255, 255) renderer.DrawPoint(150, 300) renderer.SetDrawColor(0, 0, 255, 255) renderer.DrawLine(0, 0, 200, 200) renderer.Present() }
func init() { window, _ = sdl.CreateWindow("?", sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, win_size, win_size, sdl.WINDOW_SHOWN) renderer, _ = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) cpu := runtime.NumCPU() runtime.GOMAXPROCS(cpu) switch runtime.GOOS { case "linux": slash = "/" case "windows": slash = "\\" } tracklist = []string{"music" + slash + "2.wav", "music" + slash + "3.wav"} storage.init() if file_exists(".player") { storage.load_player() } else { game.first_run = true storage.highscore = "0" } rand.Seed(time.Now().UnixNano()) device := openal.OpenDevice("") context := device.CreateContext() context.Activate() ttf.Init() lines.init() plane.init() bg.init() pause_menu.init() text.init() field.init() bonus.init() logo.init() options.init() menu.init() }
func init() { window, _ = sdl.CreateWindow("?", sdl.WINDOWPOS_CENTERED, sdl.WINDOWPOS_CENTERED, win_size, win_size, sdl.WINDOW_SHOWN) renderer, _ = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) cpu := runtime.NumCPU() runtime.GOMAXPROCS(cpu) switch runtime.GOOS { case "linux": slash = "/" case "windows": slash = "\\" } storage.init() if file_exists(".player") { storage.load_player() } else { game.first_run = true storage.highscore = "0" } rand.Seed(time.Now().UnixNano()) ttf.Init() lines.init() plane.init() bg.init() pause_menu.init() text.init() field.init() bonus.init() logo.init() options.init() menu.init() }
func main() { var window *sdl.Window var renderer *sdl.Renderer var event sdl.Event var running bool window = sdl.CreateWindow(winTitle, sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED, winWidth, winHeight, sdl.WINDOW_SHOWN) if window == nil { fmt.Fprintf(os.Stderr, "Failed to create window: %s\n", sdl.GetError()) os.Exit(1) } renderer = sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED) if renderer == nil { fmt.Fprintf(os.Stderr, "Failed to create renderer: %s\n", sdl.GetError()) os.Exit(2) } var peepArray []sdl.Event = make([]sdl.Event, 2) peepArray[0] = &sdl.UserEvent{sdl.USEREVENT, sdl.GetTicks(), window.GetID(), 1331, nil, nil} peepArray[1] = &sdl.UserEvent{sdl.USEREVENT, sdl.GetTicks(), window.GetID(), 10101, nil, nil} running = true lastPushTime := sdl.GetTicks() for running { if lastPushTime+pushTime < sdl.GetTicks() { lastPushTime = sdl.GetTicks() sdl.PumpEvents() numEventsHandled := sdl.PeepEvents(peepArray, sdl.ADDEVENT, sdl.FIRSTEVENT, sdl.LASTEVENT) if numEventsHandled < 0 { fmt.Printf("PeepEvents error: %s\n", sdl.GetError()) } else { fmt.Printf("Successful push of %d events\n", numEventsHandled) } } for event = sdl.PollEvent(); event != nil; event = sdl.PollEvent() { switch t := event.(type) { case *sdl.QuitEvent: running = false case *sdl.MouseMotionEvent: fmt.Printf("[%d ms] MouseMotion\ttype:%d\tid:%d\tx:%d\ty:%d\txrel:%d\tyrel:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.XRel, t.YRel) case *sdl.MouseButtonEvent: fmt.Printf("[%d ms] MouseButton\ttype:%d\tid:%d\tx:%d\ty:%d\tbutton:%d\tstate:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y, t.Button, t.State) case *sdl.MouseWheelEvent: fmt.Printf("[%d ms] MouseWheel\ttype:%d\tid:%d\tx:%d\ty:%d\n", t.Timestamp, t.Type, t.Which, t.X, t.Y) case *sdl.KeyUpEvent: fmt.Printf("[%d ms] Keyboard\ttype:%d\tsym:%c\tmodifiers:%d\tstate:%d\trepeat:%d\n", t.Timestamp, t.Type, t.Keysym.Sym, t.Keysym.Mod, t.State, t.Repeat) case *sdl.UserEvent: fmt.Printf("[%d ms] UserEvent\tcode:%d\n", t.Timestamp, t.Code) } } sdl.Delay(1000 / 30) } renderer.Destroy() window.Destroy() }
// Create the graphics renderer func createRenderer(w *sdl.Window) (*sdl.Renderer, error) { var r *sdl.Renderer var err error r, err = sdl.CreateRenderer(w, -1, sdl.RENDERER_ACCELERATED) return r, err }