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 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 QuickLoad_WAV(mem unsafe.Pointer) (chunk *Chunk, err error) {
_mem := (*C.Uint8)(mem)
chunk = (*Chunk)(unsafe.Pointer(C.Mix_QuickLoad_WAV(_mem)))
if chunk == nil {
err = sdl.GetError()
}
return
}
func SetMusicPosition(position int64) error {
_position := (C.double)(position)
if C.Mix_SetMusicPosition(_position) == -1 {
return sdl.GetError()
} else {
return nil
}
}
func SetReverseStereo(channel int, flip int) error {
_channel := (C.int)(channel)
_flip := (C.int)(flip)
if (C.Mix_SetReverseStereo(_channel, _flip)) == 0 {
return sdl.GetError()
} else {
return nil
}
}
func SetDistance(channel int, distance uint8) error {
_channel := (C.int)(channel)
_distance := (C.Uint8)(distance)
if (C.Mix_SetDistance(_channel, _distance)) == 0 {
return sdl.GetError()
} else {
return nil
}
}
func QuickLoad_RAW(mem *uint8, len_ uint32) (chunk *Chunk, err error) {
_mem := (*C.Uint8)(mem)
_len := (C.Uint32)(len_)
chunk = (*Chunk)(unsafe.Pointer(C.Mix_QuickLoad_RAW(_mem, _len)))
if chunk == nil {
err = sdl.GetError()
}
return
}
func LoadMUS_RW(src *sdl.RWops, freesrc int) (mus *Music, err error) {
_src := (*C.SDL_RWops)(unsafe.Pointer(src))
_freesrc := (C.int)(freesrc)
mus = (*Music)(unsafe.Pointer(C.Mix_LoadMUS_RW(_src, _freesrc)))
if mus == nil {
err = sdl.GetError()
}
return
}
func LoadMUS(file string) (mus *Music, err error) {
_file := C.CString(file)
defer C.free(unsafe.Pointer(_file))
mus = (*Music)(unsafe.Pointer(C.Mix_LoadMUS(_file)))
if mus == nil {
err = sdl.GetError()
}
return
}
func LoadWAV_RW(src *sdl.RWops, freesrc bool) (chunk *Chunk, err error) {
_src := (*C.SDL_RWops)(unsafe.Pointer(src))
_freesrc := cint(freesrc)
chunk = (*Chunk)(unsafe.Pointer(C.Mix_LoadWAV_RW(_src, _freesrc)))
if chunk == nil {
err = sdl.GetError()
}
return
}
func SetMusicCMD(command string) error {
_command := C.CString(command)
defer C.free(unsafe.Pointer(_command))
if C.Mix_SetMusicCMD(_command) == -1 {
return sdl.GetError()
} else {
return nil
}
}
func (music *Music) Play(loops int) error {
_music := (*C.Mix_Music)(unsafe.Pointer(music))
_loops := (C.int)(loops)
if C.Mix_PlayMusic(_music, _loops) == -1 {
return sdl.GetError()
} else {
return nil
}
}
func (chunk *Chunk) PlayChannel(channel, loops int) (channel_ int, err error) {
_channel := (C.int)(channel)
_chunk := (*C.Mix_Chunk)(unsafe.Pointer(chunk))
_loops := (C.int)(loops)
channel_ = int(C.Mix_PlayChannelTimed(_channel, _chunk, _loops, -1))
if channel_ == -1 {
err = sdl.GetError()
}
return
}
func SetPosition(channel int, angle int16, distance uint8) error {
_channel := (C.int)(channel)
_angle := (C.Sint16)(angle)
_distance := (C.Uint8)(distance)
if (C.Mix_SetPosition(_channel, _angle, _distance)) == 0 {
return sdl.GetError()
} else {
return nil
}
}
func (music *Music) FadeIn(loops, ms int) error {
_music := (*C.Mix_Music)(unsafe.Pointer(music))
_loops := (C.int)(loops)
_ms := (C.int)(ms)
if C.Mix_FadeInMusic(_music, _loops, _ms) == -1 {
return sdl.GetError()
} else {
return nil
}
}
func SetPanning(channel int, left, right uint8) error {
_channel := (C.int)(channel)
_left := (C.Uint8)(left)
_right := (C.Uint8)(right)
if C.Mix_SetPanning(_channel, _left, _right) == 0 {
return sdl.GetError()
} else {
return nil
}
}
func OpenAudio(frequency int, format uint16, channels, chunksize int) error {
_frequency := (C.int)(frequency)
_format := (C.Uint16)(format)
_channels := (C.int)(channels)
_chunksize := (C.int)(chunksize)
if C.Mix_OpenAudio(_frequency, _format, _channels, _chunksize) < 0 {
return sdl.GetError()
} else {
return nil
}
}
func (music *Music) FadeInPos(loops, ms int, position float64) error {
_music := (*C.Mix_Music)(unsafe.Pointer(music))
_loops := (C.int)(loops)
_ms := (C.int)(ms)
_position := (C.double)(position)
if C.Mix_FadeInMusicPos(_music, _loops, _ms, _position) == -1 {
return sdl.GetError()
} else {
return nil
}
}
func LoadWAV(file string) (chunk *Chunk, err error) {
_file := C.CString(file)
defer C.free(unsafe.Pointer(_file))
_rb := C.CString("rb")
defer C.free(unsafe.Pointer(_rb))
// why doesn't this call Mix_LoadWAV ?
chunk = (*Chunk)(unsafe.Pointer(C.Mix_LoadWAV_RW(C.SDL_RWFromFile(_file, _rb), 1)))
if chunk == nil {
err = sdl.GetError()
}
return
}
func (chunk *Chunk) FadeInTimed(channel, loops, ms, ticks int) (channel_ int, err error) {
_channel := (C.int)(channel)
_chunk := (*C.Mix_Chunk)(unsafe.Pointer(chunk))
_loops := (C.int)(loops)
_ms := (C.int)(ms)
_ticks := (C.int)(ticks)
channel_ = int(C.Mix_FadeInChannelTimed(_channel, _chunk, _loops, _ms, _ticks))
if channel_ == -1 {
err = sdl.GetError()
}
return
}
// open is number of call to OpenAudio or 0 on error
func QuerySpec() (frequency int, format uint16, channels int, open int, err error) {
var _frequency C.int
var _format C.Uint16
var _channels C.int
open = int(C.Mix_QuerySpec(&_frequency, &_format, &_channels))
if open == 0 {
err = sdl.GetError()
}
frequency = int(_frequency)
format = uint16(_format)
channels = int(_channels)
return
}
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
lastPushTime := sdl.GetTicks()
for running {
// Push a UserEvent every second
if lastPushTime+pushTime < sdl.GetTicks() {
lastPushTime = sdl.GetTicks()
pEvent := &sdl.UserEvent{sdl.USEREVENT, sdl.GetTicks(), window.GetID(), 1331, nil, nil}
retVal := sdl.PushEvent(pEvent) // Here's where the event is actually pushed
switch retVal {
case 1:
fmt.Println("PushEvent returned success")
case 0:
fmt.Println("PushEvent returned filtered")
case -1:
fmt.Printf("PushEvent returned error: %s\n", sdl.GetError)
}
}
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 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()
}
