Beispiel #1
0
func main() {
	if sdl.Init(sdl.INIT_VIDEO) != 0 {
		panic(sdl.GetError())
	}

	defer sdl.Quit()

	screen := sdl.SetVideoMode(400, 300, 32, 0)
	if screen == nil {
		panic(sdl.GetError())
	}

	sdl.WM_SetCaption("Template", "")

	ticker := time.NewTicker(1e9 / 2 /*2 Hz*/)

loop:
	for {
		select {
		case <-ticker.C:
			// Note: For better efficiency, use UpdateRects instead of Flip
			screen.FillRect(nil /*color*/, rand.Uint32())
			//screen.Blit(&sdl.Rect{x,y, 0, 0}, image, nil)
			screen.Flip()

		case event := <-sdl.Events:
			fmt.Printf("%#v\n", event)

			switch event.(type) {
			case sdl.QuitEvent:
				break loop
			}
		}
	}
}
Beispiel #2
0
func NewWindow(c *Container, w, h int) (win *Window, err error) {
	win = &Window{Container: c, W: w, H: h}
	win.surface = sdl.SetVideoMode(win.W, win.H, 32, sdl.RESIZABLE)
	if win.surface == nil {
		err = sdlError()
		return
	}
	return
}
Beispiel #3
0
func (gfx *Graphics) setup() error {
	var errno = sdl.Init(sdl.INIT_EVERYTHING)
	if errno != 0 {
		return fmt.Errorf("Init failed: %s", sdl.GetError())
	}

	gfx.display = sdl.SetVideoMode(int(gfx.cfg.ScreenX), int(gfx.cfg.ScreenY), 32, sdl.HWSURFACE|sdl.DOUBLEBUF|sdl.FULLSCREEN)
	if gfx.display == nil {
		return fmt.Errorf("No surface created: %s", sdl.GetError())
	}

	return nil
}
Beispiel #4
0
Datei: cube.go Projekt: aiju/gl
func main() {
	sdl.Init(sdl.INIT_VIDEO)
	sdl.SetVideoMode(800, 600, 32, sdl.OPENGL|sdl.DOUBLEBUF|sdl.HWSURFACE)
	gl.Init()
	gl.Enable(gl.DEPTH_TEST)
	gl.Viewport(0, 0, 800, 600)
	tick := time.Tick(time.Second / 50)
	timer := 0.0
	posbuf := gl.NewBuffer(gl.ARRAY_BUFFER, Vertices, gl.STATIC_DRAW)
	prog, err := gl.MakeProgram([]string{vertexShader}, []string{fragmentShader})
	if err != nil {
		fmt.Println(err)
		return
	}
	f, err := os.Open("glenda.png")
	if err != nil {
		fmt.Println(err)
		return
	}
	img, _, err := image.Decode(f)
	if err != nil {
		fmt.Println(err)
		return
	}
	tex := gl.NewTexture2D(img, 0)
	for {
		select {
		case ev := <-sdl.Events:
			if _, ok := ev.(sdl.QuitEvent); ok {
				return
			}
		case <-tick:
			gl.ClearColor(0, 0, 0, 1)
			gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)

			prog.Use()
			mat := gl.Mul4(gl.Frustum(45, 800./600, 0.01, 100), gl.Translate(0, 0, -8), gl.RotX(timer), gl.RotY(2*timer), gl.RotZ(3*timer))
			prog.EnableAttrib("position", posbuf, 0, 3, 5, false)
			prog.EnableAttrib("texcoord", posbuf, 3, 2, 5, false)
			prog.SetUniform("tex", 0)
			prog.SetUniform("matrix", mat)
			tex.Enable(0, gl.TEXTURE_2D)
			gl.DrawArrays(gl.TRIANGLE_STRIP, 0, len(Vertices)/5)
			prog.DisableAttrib("position")
			prog.Unuse()

			sdl.GL_SwapBuffers()
			timer += 1
		}
	}
}
Beispiel #5
0
func main() {

	var screen = sdl.SetVideoMode(640, 480, 32, sdl.RESIZABLE)

	if screen == nil {
		log.Fatal(sdl.GetError())
	}

	var n int32
	for n = 0; n < 1000000; n++ {

		var y int32 = rand.Int31() % 480
		var x int32 = rand.Int31() % 640
		var value uint32 = rand.Uint32()
		draw_point(x, y, value, screen)

		screen.Flip()
	}
}
Beispiel #6
0
func main() {
	res.WriteResources(ResPath)
	fonts.SetFontsPath(ResPath)

	if sdl.Init(sdl.INIT_VIDEO) != 0 {
		panic(sdl.GetError())
	}
	defer sdl.Quit()
	if ttf.Init() != 0 {
		panic("Error initializing SDL TTF")
	}
	defer ttf.Quit()

	screen := sdl.SetVideoMode(ScreenWidth, ScreenHeight, 32, 0)
	if screen == nil {
		panic(sdl.GetError())
	}
	sdl.WM_SetCaption("Drones", "")

	newLayers := make(chan ui.Layer, 100)
	layerStack := ui.LayerStack{mainmenu.New(newLayers)}
	frameTime := time.Second / time.Duration(FPS)
	tickTimer := time.NewTicker(frameTime)

	for len(layerStack) != 0 {
		select {
		case newLayer := <-newLayers:
			layerStack = append(layerStack, newLayer)
		case <-tickTimer.C:
			if toRemove := layerStack.Tick(frameTime); len(toRemove) != 0 {
				layerStack.RemoveLayers(toRemove)
			}
			layerStack.Draw(screen)
		case event := <-sdl.Events:
			layerStack.HandleEvent(event)
			switch event.(type) {
			case sdl.QuitEvent:
				layerStack = nil
			}
		}
	}
}
Beispiel #7
0
/**
 * The main loop for the pygame interface. The pygame window will be 4
 * times wider and 4 times taller than the width and height of the liquid
 * simulation. It uses a standard double buffered sdl window. With pygame the
 * simulation speed and the framerate are locked together. You can use the
 * mouse to click and drag around the particles.
 */
func SdlMain(l *Liquid) {
	if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
		panic(sdl.GetError())
	}

	defer sdl.Quit()

	canvas := sdl.SetVideoMode(int(l.width)*4, int(l.height)*4, 32, 0)

	if canvas == nil {
		panic(sdl.GetError())
	}

	surf := MakeSurface(canvas)
	mouse := MouseState{false, 0.0, 0.0}
	//mch := make(chan MouseState)
	eventtime := int64(0)
	simulatetime := int64(0)
	drawtime := int64(0)
	start := time.Now()
	t1 := time.Now()
	for frames := 0; ; frames++ {
		t1 = time.Now()
		select {
		case event := <-sdl.Events:
			switch e := event.(type) {
			case sdl.QuitEvent:
				fmt.Printf("%v frames\n", frames)
				fmt.Printf("%v frames/s\n", float64(frames)/time.Since(start).Seconds())
				fmt.Printf("%v time polling events\n", time.Duration(eventtime))
				fmt.Printf("%v time simulating\n", time.Duration(simulatetime))
				fmt.Printf("%v time drawing\n", time.Duration(drawtime))
				return
			case sdl.MouseButtonEvent:
				if e.State == sdl.PRESSED {
					mouse.pressed = true
				}
				if e.State == sdl.RELEASED {
					mouse.pressed = false
				}
			case sdl.MouseMotionEvent:
				mouse.x = float64(e.X / 4)
				mouse.y = float64(e.Y / 4)
			}
		default:
			mouse.pressed = mouse.pressed
		}
		eventtime += time.Since(t1).Nanoseconds()

		t1 = time.Now()
		l.simulate(mouse)
		simulatetime += time.Since(t1).Nanoseconds()

		t1 = time.Now()
		canvas.FillRect(nil, 0x000000)
		//draw simulation state
		surf.surface.Lock()
		for _, p := range l.particles {
			DrawLinePrelocked(
				surf,
				p.color,
				4*p.x, 4*p.y,
				4*(p.x-p.u), 4*(p.y-p.v),
			)
		}
		surf.surface.Unlock()
		canvas.Flip()
		drawtime += time.Since(t1).Nanoseconds()
	}
}
Beispiel #8
0
func main() {
	log.SetFlags(0)

	var resourcePath string
	{
		GOPATH := os.Getenv("GOPATH")
		if GOPATH == "" {
			log.Fatal("No such environment variable: GOPATH")
		}
		for _, gopath := range strings.Split(GOPATH, ":") {
			a := gopath + "/src/github.com/neagix/Go-SDL/examples/completeTest"
			_, err := os.Stat(a)
			if err == nil {
				resourcePath = a
				break
			}
		}
		if resourcePath == "" {
			log.Fatal("Failed to find resource directory")
		}
	}

	var joy *sdl.Joystick
	if sdl.Init(sdl.INIT_EVERYTHING) != 0 {
		log.Fatal(sdl.GetError())
	}

	if ttf.Init() != 0 {
		log.Fatal(sdl.GetError())
	}

	if sdl.NumJoysticks() > 0 {
		// Open joystick
		joy = sdl.JoystickOpen(0)

		if joy != nil {
			println("Opened Joystick 0")
			println("Name: ", sdl.JoystickName(0))
			println("Number of Axes: ", joy.NumAxes())
			println("Number of Buttons: ", joy.NumButtons())
			println("Number of Balls: ", joy.NumBalls())
		} else {
			println("Couldn't open Joystick!")
		}
	}

	if mixer.OpenAudio(mixer.DEFAULT_FREQUENCY, mixer.DEFAULT_FORMAT,
		mixer.DEFAULT_CHANNELS, 4096) != 0 {
		log.Fatal(sdl.GetError())
	}

	var screen = sdl.SetVideoMode(640, 480, 32, sdl.RESIZABLE)

	if screen == nil {
		log.Fatal(sdl.GetError())
	}

	var video_info = sdl.GetVideoInfo()

	println("HW_available = ", video_info.HW_available)
	println("WM_available = ", video_info.WM_available)
	println("Video_mem = ", video_info.Video_mem, "kb")

	sdl.EnableUNICODE(1)

	sdl.WM_SetCaption("Go-SDL SDL Test", "")

	image := sdl.Load(resourcePath + "/test.png")

	if image == nil {
		log.Fatal(sdl.GetError())
	}

	sdl.WM_SetIcon(image, nil)

	running := true

	font := ttf.OpenFont(resourcePath+"/Fontin Sans.otf", 72)

	if font == nil {
		log.Fatal(sdl.GetError())
	}

	font.SetStyle(ttf.STYLE_UNDERLINE)
	white := sdl.Color{255, 255, 255, 0}
	text := ttf.RenderText_Blended(font, "Test (with music)", white)
	music := mixer.LoadMUS(resourcePath + "/test.ogg")

	if music == nil {
		log.Fatal(sdl.GetError())
	}

	music.PlayMusic(-1)

	if sdl.GetKeyName(270) != "[+]" {
		log.Fatal("GetKeyName broken")
	}

	worm_in := make(chan Point)
	draw := make(chan Point, 64)

	var out chan Point
	var in chan Point

	out = worm_in

	in = out
	out = make(chan Point)
	go worm(in, out, draw)

	ticker := time.NewTicker(time.Second / 50) // 50 Hz

	// Note: The following SDL code is highly ineffective.
	//       It is eating too much CPU. If you intend to use Go-SDL,
	//       you should to do better than this.

	for running {
		select {
		case <-ticker.C:
			screen.FillRect(nil, 0x302019)
			screen.Blit(&sdl.Rect{0, 0, 0, 0}, text, nil)

		loop:
			for {
				select {
				case p := <-draw:
					screen.Blit(&sdl.Rect{int16(p.x), int16(p.y), 0, 0}, image, nil)

				case <-out:
				default:
					break loop
				}
			}

			var p Point
			sdl.GetMouseState(&p.x, &p.y)
			worm_in <- p

			screen.Flip()

		case _event := <-sdl.Events:
			switch e := _event.(type) {
			case sdl.QuitEvent:
				running = false

			case sdl.KeyboardEvent:
				println("")
				println(e.Keysym.Sym, ": ", sdl.GetKeyName(sdl.Key(e.Keysym.Sym)))

				if e.Keysym.Sym == sdl.K_ESCAPE {
					running = false
				}

				fmt.Printf("%04x ", e.Type)

				for i := 0; i < len(e.Pad0); i++ {
					fmt.Printf("%02x ", e.Pad0[i])
				}
				println()

				fmt.Printf("Type: %02x Which: %02x State: %02x Pad: %02x\n", e.Type, e.Which, e.State, e.Pad0[0])
				fmt.Printf("Scancode: %02x Sym: %08x Mod: %04x Unicode: %04x\n", e.Keysym.Scancode, e.Keysym.Sym, e.Keysym.Mod, e.Keysym.Unicode)

			case sdl.MouseButtonEvent:
				if e.Type == sdl.MOUSEBUTTONDOWN {
					println("Click:", e.X, e.Y)
					in = out
					out = make(chan Point)
					go worm(in, out, draw)
				}

			case sdl.JoyAxisEvent:
				println("Joystick Axis Event ->", "Type", e.Type, "Axis:", e.Axis, " Value:", e.Value, "Which:", e.Which)

			case sdl.JoyButtonEvent:
				println("Joystick Button Event ->", e.Button)
				println("State of button", e.Button, "->", joy.GetButton(int(e.Button)))

			case sdl.ResizeEvent:
				println("resize screen ", e.W, e.H)

				screen = sdl.SetVideoMode(int(e.W), int(e.H), 32, sdl.RESIZABLE)

				if screen == nil {
					log.Fatal(sdl.GetError())
				}
			}
		}
	}

	// Close if opened
	if sdl.JoystickOpened(0) > 0 {
		joy.Close()
	}

	image.Free()
	music.Free()
	font.Close()

	ttf.Quit()
	sdl.Quit()
}