Exemple #1
0
func event() {
	for {
		ev := sdl.PollEvent()
		if ev == nil {
			break
		}
		switch ev := ev.(type) {
		case sdl.QuitEvent:
			os.Exit(0)
		case sdl.KeyDownEvent:
			switch ev.Sym {
			case sdl.K_ESCAPE:
				os.Exit(0)
			case sdl.K_UP:
				if dir != 1 {
					dir = 3
				}
			case sdl.K_DOWN:
				if dir != 3 {
					dir = 1
				}
			case sdl.K_LEFT:
				if dir != 2 {
					dir = 4
				}
			case sdl.K_RIGHT:
				if dir != 4 {
					dir = 2
				}
			}
		}
	}
}
func event() {
	const step = 0.1
	for {
		ev := sdl.PollEvent()
		if ev == nil {
			break
		}
		switch e := ev.(type) {
		case sdl.QuitEvent:
			run = false
		case sdl.KeyDownEvent:
			switch e.Sym {
			case sdl.K_ESCAPE:
				run = false
			case sdl.K_LEFT:
				center -= complex(step, 0)
			case sdl.K_RIGHT:
				center += complex(step, 0)
			case sdl.K_DOWN:
				center -= complex(0, step)
			case sdl.K_UP:
				center += complex(0, step)
			case sdl.K_a:
				view += 0.1
			case sdl.K_z:
				view -= 0.1
			}
		}
	}
}
func event() {
	for {
		ev := sdl.PollEvent()
		if ev == nil {
			break
		}
		switch ev := ev.(type) {
		case sdl.QuitEvent:
			os.Exit(0)
		case sdl.KeyDownEvent:
			switch ev.Sym {
			case sdl.K_ESCAPE:
				os.Exit(0)
			}
		}
	}
}
Exemple #4
0
func (c *App) event() {
	for {
		ev := sdl.PollEvent()
		if ev == nil {
			break
		}

		switch ev := ev.(type) {
		case sdl.QuitEvent:
			c.run = false
		case sdl.KeyDownEvent:
			switch ev.Sym {
			case sdl.K_ESCAPE:
				c.run = false
			case sdl.K_SPACE:
				c.ball.Moving = true
			case sdl.K_RETURN:
				c.Reset()
			}
		case sdl.MouseButtonDownEvent:
			switch ev.Button {
			case sdl.BUTTON_LEFT:
				c.ball.Moving = true
			case sdl.BUTTON_RIGHT:
				c.Reset()
			}
		case sdl.MouseWheelEvent:
			switch b := &c.ball; {
			case ev.Y < 0:
				if b.Speed > 1 {
					b.Speed--
				}
			case ev.Y > 0:
				if b.Speed < 10 {
					b.Speed++
				}
			}
		}
	}
}
Exemple #5
0
func main() {
	runtime.LockOSThread()

	var fullscreen bool
	flag.Usage = usage
	flag.Float64Var(&v0, "v", v0, "maximum start velocity")
	flag.Float64Var(&xmin, "x", xmin, "left boundary")
	flag.Float64Var(&xmax, "X", xmax, "right boundary")
	flag.Float64Var(&ymin, "y", ymin, "top boundary")
	flag.Float64Var(&ymax, "Y", ymax, "bottom boundary")
	flag.Float64Var(&dt, "t", dt, "time step")
	flag.IntVar(&refresh, "F", refresh, "clear every number of frames (0: off)")
	flag.IntVar(&N, "N", N, "number of particles")
	flag.IntVar(&size, "s", size, "size of particle (number of pixels)")
	flag.BoolVar(&fullscreen, "fs", false, "fullscreen")
	flag.Parse()

	A = make([]Particle, N)
	B = make([]Particle, N)
	prev = A
	cur = B

	rand.Seed(time.Now().UnixNano())

	err := sdl.Init(sdl.INIT_VIDEO)
	ck(err)

	wflag := sdl.WINDOW_RESIZABLE
	if fullscreen {
		wflag |= sdl.WINDOW_FULLSCREEN_DESKTOP
	}
	screen = NewDisplay(640, 480, wflag)

	screen.SetDrawColor(White)
	screen.Clear()
	screen.Present()
	screen.SetTitle("Molecular Dynamics")
	sdl.ShowCursor(0)

	i := 0
	reset()
	for {
		sw, sh := screen.Size()
		viewport.W = int32(sw)
		viewport.H = int32(sh)

		if refresh != 0 {
			if i++; i == refresh {
				draw(viewport, White)
				i = 0
			}
		}

		for i := range cur {
			cur[i] = Particle{}
		}
		for n := 0; n < N; n++ {
			p := &prev[n]
			for m := 0; m < n; m++ {
				q := &prev[m]
				dx1 := math.Abs(p.x - q.x)
				dx2 := xmax - xmin - dx1
				dx := min(dx1, dx2)
				dy1 := math.Abs(p.y - q.y)
				dy2 := ymax - ymin - dy1
				dy := min(dy1, dy2)
				R := dx*dx + dy*dy
				if R >= 9 || R == 0 {
					continue
				}
				R = 1 / math.Sqrt(R)
				R2 := R * R
				R4 := R2 * R2
				R6 := R4 * R2
				R12 := R6 * R6
				F := 24 * (2*R12 - R6)
				if p.x < q.x {
					dx = -dx
				}
				if p.y < q.y {
					dy = -dy
				}
				if dx1 > dx2 {
					dx = -dx
				}
				if dy1 > dy2 {
					dy = -dy
				}
				dx *= F
				dy *= F
				cur[n].ax += dx
				cur[n].ay += dy
				cur[m].ax -= dx
				cur[m].ay -= dy
			}
		}

		for j := 0; j < N; j++ {
			p := &prev[j]
			q := &cur[j]
			q.x = 2*p.x - p.prevx + q.ax*dt*dt
			q.y = 2*p.y - p.prevy + q.ay*dt*dt
			q.vx = (q.x - p.prevx) / (2 * dt)
			q.vy = (q.y - p.prevy) / (2 * dt)
			q.prevx = p.x
			q.prevy = p.y
			if q.x > xmax {
				q.x -= xmax - xmin
				q.prevx -= xmax - xmin
			}
			if q.x < xmin {
				q.x += xmax - xmin
				q.prevx += xmax - xmin
			}
			if q.y > ymax {
				q.y -= ymax - ymin
				q.prevy -= ymax - ymin
			}
			if q.y < ymin {
				q.y += ymax - ymin
				q.prevy += ymax - ymin
			}
			q.col = p.col

			x := float64(viewport.W)*(q.x-xmin)/(xmax-xmin) + float64(viewport.X)
			y := float64(viewport.H)*(q.y-ymin)/(ymax-ymin) + float64(viewport.Y)
			draw(sdl.Rect{int32(x), int32(y), int32(size), int32(size)}, p.col)
		}

		prev, cur = cur, prev
		screen.Present()

		for {
			ev := sdl.PollEvent()
			if ev == nil {
				break
			}
			switch ev := ev.(type) {
			case sdl.QuitEvent:
				os.Exit(0)
			case sdl.KeyDownEvent:
				switch ev.Sym {
				case sdl.K_q, sdl.K_ESCAPE:
					os.Exit(0)
				case sdl.K_r:
					reset()
				case sdl.K_f:
					draw(viewport, White)
				}
			case sdl.WindowEvent:
				switch ev.Event {
				case sdl.WINDOWEVENT_EXPOSED:
					draw(viewport, White)

				case sdl.WINDOWEVENT_RESIZED:
					sw, sh := screen.Size()
					viewport.W, viewport.H = int32(sw), int32(sh)
					draw(viewport, White)
				}
			}
		}
	}
}
func main() {
	runtime.LockOSThread()
	log.SetFlags(0)
	err := sdl.Init(sdl.INIT_VIDEO)
	ck(err)

	screen := NewDisplay(500, 500, sdl.WINDOW_RESIZABLE)
	screen.SetLogicalSize(500, 500)
	screen.SetTitle("Make It Alive!")

	foo := 3
	bar := 2

	unit := []sdl.Point{
		{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
		{1, 0}, {-1, 1}, {0, 1}, {1, 1},
	}

	var p, z map[sdl.Point]bool
	var q map[sdl.Point]int

	for {
		screen.SetDrawColor(sdlcolor.Black)
		screen.Clear()

		z = make(map[sdl.Point]bool)
		for {
			ev := sdl.PollEvent()
			if ev == nil {
				break
			}
			switch ev := ev.(type) {
			case sdl.QuitEvent:
				os.Exit(0)
			case sdl.KeyDownEvent:
				switch ev.Sym {
				case sdl.K_ESCAPE:
					os.Exit(0)
				}
			case sdl.MouseButtonDownEvent:
				for _, u := range unit {
					n := sdl.Point{ev.X + u.X, ev.Y + u.Y}
					z[n] = true
				}
			}
		}

		for i := range q {
			if q[i] == foo {
				z[i] = true
				if p[i] {
					screen.SetDrawColor(sdl.Color{250, 150, 150, 255})
				} else {
					screen.SetDrawColor(sdl.Color{150, 150, 250, 255})
				}
				screen.DrawPoint(int(i.X), int(i.Y))
			} else if q[i] == bar && p[i] {
				z[i] = true
				screen.SetDrawColor(sdl.Color{250, 150, 150, 255})
				screen.DrawPoint(int(i.X), int(i.Y))
			}
		}

		p = z
		q = make(map[sdl.Point]int)
		for v := range p {
			for _, u := range unit {
				n := sdl.Point{v.X + u.X, v.Y + u.Y}
				q[n] = q[n] + 1
			}
		}

		screen.Present()
	}
}
Exemple #7
0
func main() {
	runtime.LockOSThread()

	err := sdl.Init(sdl.INIT_EVERYTHING)
	if err != nil {
		log.Fatalln(err)
	}

	defer sdl.Quit()

	window, renderer, err := sdl.CreateWindowAndRenderer(W, H, sdl.WINDOW_RESIZABLE)
	if err != nil {
		log.Fatalln(err)
	}
	texture, err := renderer.CreateTexture(sdl.PIXELFORMAT_ARGB8888, sdl.TEXTUREACCESS_STREAMING, W, H)
	if err != nil {
		log.Fatalln(err)
	}
	pixels := make([]uint32, W*H)
	window.SetTitle("Gasket")
	renderer.SetLogicalSize(W, H)

	v := []Vec2{
		{0.5, 0},
		{0, 1},
		{1, 1},
	}
	p := Vec2{0.5, 0.5}

loop:
	for {
		for {
			ev := sdl.PollEvent()
			if ev == nil {
				break
			}
			switch ev := ev.(type) {
			case sdl.QuitEvent:
				break loop
			case sdl.KeyDownEvent:
				switch ev.Sym {
				case sdl.K_ESCAPE:
					break loop
				}
			}
		}
		r, g, b := rand.Intn(256), rand.Intn(256), rand.Intn(256)

		n := rand.Intn(3)
		q := v[n].Add(p).Scale(.5)

		x := int(q[0] * W)
		y := int(q[1] * H)
		if y*W+x < len(pixels) {
			pixels[y*W+x] = 255<<24 | uint32(r)<<16 | uint32(g)<<8 | uint32(b)
		}
		p = q

		renderer.SetDrawColor(sdlcolor.Black)
		renderer.Clear()
		texture.Update(nil, pixels, W*4)
		renderer.Copy(texture, nil, nil)
		renderer.Present()
	}
}