func SetDrawColor(r *sdl.Renderer, color [4]uint8) { r.SetDrawColor( color[0], color[1], color[2], color[3]) }
//TODO Make sdl_tff work! func (menuGeneratorInfo *MenuGeneratorInfo) GenerateMenuShellOneColumn(renderer *sdl.Renderer, x, y, dx, dy int32) Menu { background, err := renderer.CreateTextureFromSurface(menuGeneratorInfo.menuBackground) if err != nil { panic(err) } buttonCount := len(menuGeneratorInfo.buttonTexts) menuItems := make([]*MenuItem, buttonCount) highlightedBackground, notHighlightedBackground, srcRects, FrameLength := menuGeneratorInfo.menuItemAnimation.Generate(renderer) TEXTSURFACE := sdl.Texture{} TEXTRECT := sdl.Rect{0, 0, 0, 0} for i := 0; i < buttonCount; i++ { currentRect := sdl.Rect{x, y + dy*int32(i), dx, dy} currentRects := make([]*sdl.Rect, len(srcRects)) for j := 0; j < len(srcRects); j++ { currentRects[j] = ¤tRect } previous := (i - 1 + buttonCount) % buttonCount next := (i + 1) % buttonCount menuAction := MenuAction{nil, func(menuInfo *MenuInfo, menuItem *MenuItem) int { return previous }, func(menuInfo *MenuInfo, menuItem *MenuItem) int { return next }, nil, nil} menuItems[i] = &MenuItem{notHighlightedBackground, highlightedBackground, srcRects, currentRects, &TEXTSURFACE, &TEXTRECT, menuAction, FrameLength} } return Menu{background, menuItems, nil} }
func (t *TextEl) Bake(renderer *sdl.Renderer) (*sdl.Texture, int32, int32) { surface, _ := t.Font.RenderUTF8_Solid(t.Content, t.Color) defer surface.Free() txtr, _ := renderer.CreateTextureFromSurface(surface) //defer txtr.Destroy() return txtr, surface.W, surface.H }
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() }
func (d *drawable) Draw(r *sdl.Renderer) { // Fill if d.fill { SetDrawColor(r, d.fill_color) r.FillRect(&sdl.Rect{d.X, d.Y, d.W, d.H}) } // Draw bounds SetDrawColor(r, d.border_color) r.DrawRect(&sdl.Rect{d.X, d.Y, d.W, d.H}) }
func (s *AnimatedSprite) Draw(renderer *sdl.Renderer) { src_rect := s.Src_rects[s.current_frame] dest_rect := &sdl.Rect{ int32(s.X), int32(s.Y), src_rect.W, src_rect.H, } renderer.Copy(s.Texture, src_rect, dest_rect) }
func (d *RectDrawer) Draw(r *sdl.Renderer, offsetX, offsetY int32) error { if err := r.SetDrawColor(d.r, d.g, d.b, d.a); err != nil { return err } rect := &sdl.Rect{ X: d.x + offsetX, Y: d.y + offsetY, W: d.w, H: d.h, } return r.FillRect(rect) }
func LoadText(renderer *sdl.Renderer, font *ttf.Font, text string, textColor sdl.Color) *sdl.Texture { bmp := font.RenderText_Solid(text, textColor) if bmp == nil { fmt.Fprintf(os.Stderr, "Unable to load text %s! SDL Error: %s\n", ttf.GetError()) } else { texture, err := renderer.CreateTextureFromSurface(bmp) if err != nil { fmt.Fprintf(os.Stderr, "Unable to create texture %s! SDL Error: %s\n", sdl.GetError()) } bmp.Free() return texture } return nil }
func LoadTexture(renderer *sdl.Renderer, path string) *sdl.Texture { bmp, err := img.Load(path) if err != nil { fmt.Fprintf(os.Stderr, "Unable to load image %s! SDL Error: %s\n", path, img.GetError()) } else { texture, err := renderer.CreateTextureFromSurface(bmp) if err != nil { fmt.Fprintf(os.Stderr, "Unable to create texture %s! SDL Error: %s\n", path, sdl.GetError()) } bmp.Free() return texture } return nil }
func Draw(r *sdl.Renderer, g *grid.Grid) { g.EachRoom(func(room *grid.Room) { x := int32(room.X) * pixelSize * roomSize y := int32(room.Y) * pixelSize * roomSize width := roomSize * pixelSize height := roomSize * pixelSize rect := &sdl.Rect{x, y, width, height} if room.Blocked { r.FillRect(rect) } else { r.DrawRect(rect) } }) }
func (g gameObject) Draw(r *sdl.Renderer) { tGeometry := make([]sdl.Rect, cap(g.geometry)) copy(tGeometry, g.geometry) for index := range g.geometry { tGeometry[index].X += int32(g.location.X) * roomSize tGeometry[index].Y += int32(g.location.Y) * roomSize } for index := range tGeometry { tGeometry[index].X *= pixelSize tGeometry[index].Y *= pixelSize tGeometry[index].H *= pixelSize tGeometry[index].W *= pixelSize } r.FillRects(tGeometry) }
func DrawPath(r *sdl.Renderer, nodes []graph.Node) { for index, node := range nodes { if index != 0 { previousNode := nodes[index-1] startRoom := previousNode.(*grid.Room) endRoom := node.(*grid.Room) x1 := int32(startRoom.X) * pixelSize * roomSize y1 := int32(startRoom.Y) * pixelSize * roomSize x2 := int32(endRoom.X) * roomSize * pixelSize y2 := int32(endRoom.Y) * roomSize * pixelSize r.DrawLine(int(x1), int(y1), int(x2), int(y2)) } } }
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 LoadTextureTransparent(renderer *sdl.Renderer, path string, r, g, b uint8) *sdl.Texture { bmp, err := img.Load(path) if err != nil { fmt.Fprintf(os.Stderr, "Unable to load image %s! SDL Error: %s\n", path, img.GetError()) } else { if bmp.SetColorKey(1, sdl.MapRGB(bmp.Format, r, g, b)) != 0 { fmt.Fprintf(os.Stderr, "Unable to set Color Key %s! SDL Error: %s\n", path, sdl.GetError()) } texture, err := renderer.CreateTextureFromSurface(bmp) if err != nil { fmt.Fprintf(os.Stderr, "Unable to create texture %s! SDL Error: %s\n", path, sdl.GetError()) } bmp.Free() return texture } return nil }
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 }
// Load loads the image into a Texture func Load(renderer *sdl.Renderer, fileName, id string) error { tempSurface, err := img.Load(fileName) if err != nil { return err } defer tempSurface.Free() texture, err := renderer.CreateTextureFromSurface(tempSurface) if err != nil { return err } textureMap[id] = texture return nil }
func (t *Label) Draw(renderer *sdl.Renderer) { surface, err := t.font.RenderUTF8_Solid(t.text, sdl.Color{255, 255, 255, 255}) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create surface: %s\n", err) os.Exit(1) } texture, err := renderer.CreateTextureFromSurface(surface) if err != nil { fmt.Fprintf(os.Stderr, "Failed to create texture: %s\n", err) os.Exit(1) } src := &sdl.Rect{0, 0, surface.W, surface.H} dst := &sdl.Rect{t.rect.X, t.rect.Y, src.W, src.H} renderer.Copy(texture, src, dst) surface.Free() }
func DrawGraph(r *sdl.Renderer, g *graph.Graph) { nodesDrawn := make(map[graph.Node]struct{}) g.EachAdjacencyList(func(n graph.Node, l []graph.Node) { for _, d := range l { _, drawn := nodesDrawn[d] if !drawn { startRoom := n.(*grid.Room) endRoom := d.(*grid.Room) x1 := int32(startRoom.X) * pixelSize * roomSize y1 := int32(startRoom.Y) * pixelSize * roomSize x2 := int32(endRoom.X) * roomSize * pixelSize y2 := int32(endRoom.Y) * roomSize * pixelSize r.DrawLine(int(x1), int(y1), int(x2), int(y2)) } } nodesDrawn[n] = struct{}{} }) }
func (m *Menu) DrawItem(renderer *sdl.Renderer, index int) { var text_surface *sdl.Surface var text_texture *sdl.Texture var text_width, text_height int32 var text_rect sdl.Rect var screen_width, _, _ int = renderer.GetRendererOutputSize() for index, menu_item := range m.menu_items { if index == m.selected_item { text_surface = m.font.RenderText_Solid(menu_item.text, *m.selected_color) } else { text_surface = m.font.RenderText_Solid(menu_item.text, *m.unselected_color) } text_width = text_surface.W text_height = text_surface.H text_texture = renderer.CreateTextureFromSurface(text_surface) text_rect = sdl.Rect{ int32(screen_width) - 10 - text_width, //X position (m.font_size_32 * int32(index)), text_width, text_height, } renderer.Copy(text_texture, nil, &text_rect) } }
func (animation *MenuItemAnimation) Generate(renderer *sdl.Renderer) (*sdl.Texture, *sdl.Texture, []*sdl.Rect, uint64) { highlightedTexture, err := renderer.CreateTextureFromSurface(animation.highlightedAnimation) if err != nil { panic(err) } notHighlightedTexture, err := renderer.CreateTextureFromSurface(animation.notHighlightedAnimation) rows := animation.highlightedAnimation.W / animation.dx columns := animation.highlightedAnimation.H / animation.dy rects := make([]*sdl.Rect, rows*columns) xMult := columns * int32((animation.AnimationDirection>>YX)%2) if xMult == 0 { xMult = 1 } yMult := rows * int32(1-(animation.AnimationDirection>>YX)%2) if yMult == 0 { yMult = 1 } xDir := int32(1) xPluss := int32(0) yDir := int32(1) yPluss := int32(0) if (animation.AnimationDirection>>LeftRight)%2 == 0 { xDir = -1 xPluss = rows } if (animation.AnimationDirection>>UpDown)%2 == 0 { yDir = -1 yPluss = columns } for y := int32(0); y < columns; y++ { for x := int32(0); x < rows; x++ { currentRect := sdl.Rect{animation.dx * x, animation.dy * y, animation.dx, animation.dy} rects[((xPluss+x*xDir)*xMult + (yPluss+y*yDir)*yMult)] = ¤tRect } } return highlightedTexture, notHighlightedTexture, rects, animation.FrameLength }
func main() { var window *sdl.Window var renderer *sdl.Renderer sdl.Init(sdl.INIT_EVERYTHING) window = createWindow(winTitle, winHeight, winWidth) defer window.Destroy() renderer = createRenderer(window) defer renderer.Destroy() var secTickChan = time.Tick(time.Second) var events = &Events{} var fps = 0 var view = NewGameView() for { // Pump events events.GetEvents() // Pass events and renderer to view view.Render(renderer, events) // This structure logs the fps select { case <-secTickChan: log.Println("fps:", fps) fps = 0 default: fps++ } // Delay the next frame rendering to free up CPU sdl.Delay(13) } }
func (m *Menu) DrawTitle(renderer *sdl.Renderer) { var text_surface *sdl.Surface var text_texture *sdl.Texture var text_width, text_height int32 var title_rect sdl.Rect var _, screen_height, _ int = renderer.GetRendererOutputSize() text_surface = m.title_font.RenderText_Solid(m.menu_title, *m.title_color) text_width = text_surface.W text_height = text_surface.H text_texture = renderer.CreateTextureFromSurface(text_surface) title_rect = sdl.Rect{ 20, //X position int32(screen_height) - 20 - text_height, //Y position text_width, text_height, } renderer.Copy(text_texture, nil, &title_rect) }
func main() { var window *sdl.Window var renderer *sdl.Renderer var image *sdl.Surface 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 = sdl.LoadBMP(imageName) if image == nil { fmt.Fprintf(os.Stderr, "Failed to load BMP: %s", 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.Copy(texture, &src, &dst) renderer.Present() sdl.Delay(2000) image.Free() texture.Destroy() renderer.Destroy() window.Destroy() }
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 run() int { 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) 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 = sdl.LoadBMP(imageName) if err != nil { fmt.Fprintf(os.Stderr, "Failed to load BMP: %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.Copy(texture, &src, &dst) renderer.Present() sdl.Delay(2000) return 0 }
func (t *TitleState) Draw(renderer *sdl.Renderer) { renderer.Copy(t.currentTexture(), &t.src, &t.dest) }
func (t *Rect) Draw(renderer *sdl.Renderer) { renderer.SetDrawColor(t.r, t.g, t.b, t.a) renderer.FillRect(t.Rect) renderer.DrawRect(t.Rect) }
func (gb *GUIBlock) Bake(renderer *sdl.Renderer) *sdl.Texture { finalTxtr, _ := renderer.CreateTexture(sdl.PIXELFORMAT_RGBA8888, sdl.TEXTUREACCESS_TARGET, 800, 600) originalTarget := renderer.GetRenderTarget() renderer.SetRenderTarget(finalTxtr) defer renderer.SetRenderTarget(originalTarget) renderer.SetDrawColor(1, 1, 1, 0) renderer.FillRect(gb.Pos) for _, el := range gb.Elements { println("Baking: ") println(el.Layer, el.Pos.X, el.Pos.Y) renderer.SetDrawColor(el.BGColor.R, el.BGColor.G, el.BGColor.B, el.BGColor.A) renderer.FillRect(el.Pos) for _, txt := range el.Texts { texture, W, H := txt.Bake(renderer) renderer.Copy( texture, &sdl.Rect{0, 0, W, H}, &sdl.Rect{el.Pos.X + txt.RelPos.X, el.Pos.Y + txt.RelPos.Y, W, H}) } } finalTxtr.SetBlendMode(sdl.BLENDMODE_BLEND) finalTxtr.SetAlphaMod(216) return finalTxtr }
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() }
func main() { 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) 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 := img.Load(imageName) if err != nil { fmt.Fprintf(os.Stderr, "Failed to load PNG: %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.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) }