UnrealXR/raylib-go
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Physics examples

Browse source
This commit is contained in:
Milan Nikolic 2017-03-05 22:54:34 +01:00
parent c7f6376031
commit 39264dc723
2 changed files with 652 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

513
examples/physics/box2d/main.go Normal file
View file

@ -0,0 +1,513 @@
package main
import (
"math"
"math/rand"
"github.com/gen2brain/raylib-go/raylib"
box2d "github.com/neguse/go-box2d-lite/box2dlite"
)
// Game type
type Game struct {
World *box2d.World
TimeStep float64
}
// NewGame - Start new game
func NewGame() (g Game) {
g.Init()
return
}
// Init - Initialize game
func (g *Game) Init() {
gravity := box2d.Vec2{0.0, -10.0}
g.World = box2d.NewWorld(gravity, 10) // 10 iterations
}
// Update - Update game
func (g *Game) Update() {
// Keys 1-9 switch demos
switch raylib.GetKeyPressed() {
case raylib.KeyOne:
g.Demo1()
case raylib.KeyTwo:
g.Demo2()
case raylib.KeyThree:
g.Demo3()
case raylib.KeyFour:
g.Demo4()
case raylib.KeyFive:
g.Demo5()
case raylib.KeySix:
g.Demo6()
case raylib.KeySeven:
g.Demo7()
case raylib.KeyEight:
g.Demo8()
case raylib.KeyNine:
g.Demo9()
}
g.TimeStep = float64(raylib.GetFrameTime())
// Physics steps calculations
g.World.Step(g.TimeStep)
}
// Draw - Draw game
func (g *Game) Draw() {
for _, b := range g.World.Bodies {
g.DrawBody(b)
}
for _, j := range g.World.Joints {
g.DrawJoint(j)
}
raylib.DrawText("Use keys 1-9 to switch current demo", 20, 20, 10, raylib.RayWhite)
}
// DrawBody - Draw body
func (g *Game) DrawBody(b *box2d.Body) {
R := box2d.Mat22ByAngle(b.Rotation)
x := b.Position
h := box2d.MulSV(0.5, b.Width)
o := box2d.Vec2{400, 400}
S := box2d.Mat22{box2d.Vec2{20.0, 0.0}, box2d.Vec2{0.0, -20.0}}
v1 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{-h.X, -h.Y}))))
v2 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{h.X, -h.Y}))))
v3 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{h.X, h.Y}))))
v4 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{-h.X, h.Y}))))
raylib.DrawLine(int32(v1.X), int32(v1.Y), int32(v2.X), int32(v2.Y), raylib.RayWhite)
raylib.DrawLine(int32(v2.X), int32(v2.Y), int32(v3.X), int32(v3.Y), raylib.RayWhite)
raylib.DrawLine(int32(v3.X), int32(v3.Y), int32(v4.X), int32(v4.Y), raylib.RayWhite)
raylib.DrawLine(int32(v4.X), int32(v4.Y), int32(v1.X), int32(v1.Y), raylib.RayWhite)
}
// DrawJoint - Draw joint
func (g *Game) DrawJoint(j *box2d.Joint) {
b1 := j.Body1
b2 := j.Body2
R1 := box2d.Mat22ByAngle(b1.Rotation)
R2 := box2d.Mat22ByAngle(b2.Rotation)
x1 := b1.Position
p1 := x1.Add(R1.MulV(j.LocalAnchor1))
x2 := b2.Position
p2 := x2.Add(R2.MulV(j.LocalAnchor2))
o := box2d.Vec2{400, 400}
S := box2d.Mat22{box2d.Vec2{20.0, 0.0}, box2d.Vec2{0.0, -20.0}}
x1 = o.Add(S.MulV(x1))
p1 = o.Add(S.MulV(p1))
x2 = o.Add(S.MulV(x2))
p2 = o.Add(S.MulV(p2))
raylib.DrawLine(int32(x1.X), int32(x1.Y), int32(p1.X), int32(p1.Y), raylib.RayWhite)
raylib.DrawLine(int32(x2.X), int32(x2.Y), int32(p2.X), int32(p2.Y), raylib.RayWhite)
}
// Demo1 - Single box
func (g *Game) Demo1() {
g.World.Clear()
var b1, b2 box2d.Body
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
g.World.AddBody(&b1)
b2.Set(&box2d.Vec2{1.0, 1.0}, 200.0)
b2.Position = box2d.Vec2{0.0, 4.0}
g.World.AddBody(&b2)
}
// Demo2 - A simple pendulum
func (g *Game) Demo2() {
g.World.Clear()
var b2, b1 box2d.Body
var j box2d.Joint
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b1.Friction = 0.2
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
b1.Rotation = 0.0
g.World.AddBody(&b1)
b2.Set(&box2d.Vec2{1.0, 1.0}, 100.0)
b2.Friction = 0.2
b2.Position = box2d.Vec2{9.0, 11.0}
b2.Rotation = 0.0
g.World.AddBody(&b2)
j.Set(&b1, &b2, &box2d.Vec2{0.0, 11.0})
g.World.AddJoint(&j)
}
// Demo3 - Varying friction coefficients
func (g *Game) Demo3() {
g.World.Clear()
{
var b box2d.Body
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
g.World.AddBody(&b)
}
{
var b box2d.Body
b.Set(&box2d.Vec2{13.0, 0.25}, math.MaxFloat64)
b.Position = box2d.Vec2{-2.0, 11.0}
b.Rotation = -0.25
g.World.AddBody(&b)
}
{
var b box2d.Body
b.Set(&box2d.Vec2{0.25, 1.0}, math.MaxFloat64)
b.Position = box2d.Vec2{5.25, 9.5}
g.World.AddBody(&b)
}
{
var b box2d.Body
b.Set(&box2d.Vec2{13.0, 0.25}, math.MaxFloat64)
b.Position = box2d.Vec2{2.0, 7.0}
b.Rotation = 0.25
g.World.AddBody(&b)
}
{
var b box2d.Body
b.Set(&box2d.Vec2{0.25, 1.0}, math.MaxFloat64)
b.Position = box2d.Vec2{-5.25, 5.5}
g.World.AddBody(&b)
}
frictions := []float64{0.75, 0.5, 0.35, 0.1, 0.0}
for i := 0; i < 5; i++ {
var b box2d.Body
b.Set(&box2d.Vec2{0.5, 0.5}, 25.0)
b.Friction = frictions[i]
b.Position = box2d.Vec2{-7.5 + 2.0*float64(i), 14.0}
g.World.AddBody(&b)
}
}
// Demo4 - A vertical stack
func (g *Game) Demo4() {
g.World.Clear()
{
var b box2d.Body
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b.Friction = 0.2
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
b.Rotation = 0.0
g.World.AddBody(&b)
}
for i := 0; i < 10; i++ {
var b box2d.Body
b.Set(&box2d.Vec2{1.0, 1.0}, 1.0)
b.Friction = 0.2
x := rand.Float64()*0.2 - 0.1
b.Position = box2d.Vec2{x, 0.51 + 1.05*float64(i)}
g.World.AddBody(&b)
}
}
// Demo5 - A pyramid
func (g *Game) Demo5() {
g.World.Clear()
{
var b box2d.Body
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b.Friction = 0.2
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
b.Rotation = 0.0
g.World.AddBody(&b)
}
x := box2d.Vec2{-6.0, 0.75}
for i := 0; i < 12; i++ {
y := x
for j := i; j < 12; j++ {
var b box2d.Body
b.Set(&box2d.Vec2{1.0, 1.0}, 10.0)
b.Friction = 0.2
b.Position = y
g.World.AddBody(&b)
y = y.Add(box2d.Vec2{1.125, 0.0})
}
x = x.Add(box2d.Vec2{0.5625, 2.0})
}
}
// Demo6 - A teeter
func (g *Game) Demo6() {
g.World.Clear()
var b1, b2, b3, b4, b5 box2d.Body
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
g.World.AddBody(&b1)
b2.Set(&box2d.Vec2{12.0, 0.25}, 100)
b2.Position = box2d.Vec2{0.0, 1.0}
g.World.AddBody(&b2)
b3.Set(&box2d.Vec2{0.5, 0.5}, 25.0)
b3.Position = box2d.Vec2{-5.0, 2.0}
g.World.AddBody(&b3)
b4.Set(&box2d.Vec2{0.5, 0.5}, 25.0)
b4.Position = box2d.Vec2{-5.5, 2.0}
g.World.AddBody(&b4)
b5.Set(&box2d.Vec2{1.0, 1.0}, 100)
b5.Position = box2d.Vec2{5.5, 15.0}
g.World.AddBody(&b5)
{
var j box2d.Joint
j.Set(&b1, &b2, &box2d.Vec2{0.0, 1.0})
g.World.AddJoint(&j)
}
}
// Demo7 - A suspension bridge
func (g *Game) Demo7() {
g.World.Clear()
var ba []*box2d.Body
{
var b box2d.Body
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b.Friction = 0.2
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
b.Rotation = 0.0
g.World.AddBody(&b)
ba = append(ba, &b)
}
const numPlunks = 15
const mass = 50.0
for i := 0; i < numPlunks; i++ {
var b box2d.Body
b.Set(&box2d.Vec2{1.0, 0.25}, mass)
b.Friction = 0.2
b.Position = box2d.Vec2{-8.5 + 1.25*float64(i), 5.0}
g.World.AddBody(&b)
ba = append(ba, &b)
}
// Tuning
const frequencyHz = 2.0
const dampingRatio = 0.7
// Frequency in radians
const omega = 2.0 * math.Pi * frequencyHz
// Damping coefficient
const d = 2.0 * mass * dampingRatio * omega
// Spring stifness
const k = mass * omega * omega
// Magic formulas
softness := 1.0 / (d + g.TimeStep*k)
biasFactor := g.TimeStep * k / (d + g.TimeStep*k)
for i := 0; i <= numPlunks; i++ {
var j box2d.Joint
j.Set(ba[i], ba[(i+1)%(numPlunks+1)], &box2d.Vec2{-9.125 + 1.25*float64(i), 5.0})
j.Softness = softness
j.BiasFactor = biasFactor
g.World.AddJoint(&j)
}
}
// Demo8 - Dominos
func (g *Game) Demo8() {
g.World.Clear()
var b1 box2d.Body
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
g.World.AddBody(&b1)
{
var b box2d.Body
b.Set(&box2d.Vec2{12.0, 0.5}, math.MaxFloat64)
b.Position = box2d.Vec2{-1.5, 10.0}
g.World.AddBody(&b)
}
for i := 0; i < 10; i++ {
var b box2d.Body
b.Set(&box2d.Vec2{0.2, 2.0}, 10.0)
b.Position = box2d.Vec2{-6.0 + 1.0*float64(i), 11.125}
b.Friction = 0.1
g.World.AddBody(&b)
}
{
var b box2d.Body
b.Set(&box2d.Vec2{14.0, 0.5}, math.MaxFloat64)
b.Position = box2d.Vec2{1.0, 6.0}
b.Rotation = 0.3
g.World.AddBody(&b)
}
var b2 box2d.Body
b2.Set(&box2d.Vec2{0.5, 3.0}, math.MaxFloat64)
b2.Position = box2d.Vec2{-7.0, 4.0}
g.World.AddBody(&b2)
var b3 box2d.Body
b3.Set(&box2d.Vec2{12.0, 0.25}, 20.0)
b3.Position = box2d.Vec2{-0.9, 1.0}
g.World.AddBody(&b3)
{
var j box2d.Joint
j.Set(&b1, &b3, &box2d.Vec2{-2.0, 1.0})
g.World.AddJoint(&j)
}
var b4 box2d.Body
b4.Set(&box2d.Vec2{0.5, 0.5}, 10.0)
b4.Position = box2d.Vec2{-10.0, 15.0}
g.World.AddBody(&b4)
{
var j box2d.Joint
j.Set(&b2, &b4, &box2d.Vec2{-7.0, 15.0})
g.World.AddJoint(&j)
}
var b5 box2d.Body
b5.Set(&box2d.Vec2{2.0, 2.0}, 20.0)
b5.Position = box2d.Vec2{6.0, 2.5}
b5.Friction = 0.1
g.World.AddBody(&b5)
{
var j box2d.Joint
j.Set(&b1, &b5, &box2d.Vec2{6.0, 2.6})
g.World.AddJoint(&j)
}
var b6 box2d.Body
b6.Set(&box2d.Vec2{2.0, 0.2}, 10.0)
b6.Position = box2d.Vec2{6.0, 3.6}
g.World.AddBody(&b6)
{
var j box2d.Joint
j.Set(&b5, &b6, &box2d.Vec2{7.0, 3.5})
g.World.AddJoint(&j)
}
}
// Demo9 - A multi-pendulum
func (g *Game) Demo9() {
g.World.Clear()
var b1 *box2d.Body
{
var b box2d.Body
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
g.World.AddBody(&b)
b1 = &b
}
const mass = 10.0
// Tuning
const frequencyHz = 4.0
const dampingRatio = 0.7
// Frequency in radians
const omega = 2.0 * math.Pi * frequencyHz
// Damping coefficient
const d = 2.0 * mass * dampingRatio * omega
// Spring stiffness
const k = mass * omega * omega
// Magic formulas
softness := 1.0 / (d + g.TimeStep*k)
biasFactor := g.TimeStep * k / (d + g.TimeStep*k)
const y = 12.0
for i := 0; i < 15; i++ {
x := box2d.Vec2{0.5 + float64(i), y}
var b box2d.Body
b.Set(&box2d.Vec2{0.75, 0.25}, mass)
b.Friction = 0.2
b.Position = x
b.Rotation = 0.0
g.World.AddBody(&b)
var j box2d.Joint
j.Set(b1, &b, &box2d.Vec2{float64(i), y})
j.Softness = softness
j.BiasFactor = biasFactor
g.World.AddJoint(&j)
b1 = &b
}
}
func main() {
raylib.InitWindow(800, 450, "raylib [physics] example - box2d")
raylib.SetTargetFPS(60)
game := NewGame()
game.Demo1()
for !raylib.WindowShouldClose() {
raylib.BeginDrawing()
raylib.ClearBackground(raylib.Black)
game.Update()
game.Draw()
raylib.EndDrawing()
}
raylib.CloseWindow()
}

139
examples/physics/chipmunk/main.go Normal file
View file

@ -0,0 +1,139 @@
package main
import (
"math"
"math/rand"
"github.com/gen2brain/raylib-go/raylib"
"github.com/vova616/chipmunk"
"github.com/vova616/chipmunk/vect"
)
const (
ballRadius = 25
ballMass = 1
)
// Game type
type Game struct {
Space *chipmunk.Space
Balls []*chipmunk.Shape
StaticLines []*chipmunk.Shape
ticksToNextBall int
}
// NewGame - Start new game
func NewGame() (g Game) {
g.Init()
return
}
// Init - Initialize game
func (g *Game) Init() {
g.createBodies()
g.ticksToNextBall = 10
}
// Update - Update game
func (g *Game) Update() {
g.ticksToNextBall--
if g.ticksToNextBall == 0 {
g.ticksToNextBall = rand.Intn(100) + 1
g.addBall()
}
// Physics steps calculations
g.step(raylib.GetFrameTime())
}
// Draw - Draw game
func (g *Game) Draw() {
for i := range g.StaticLines {
x := g.StaticLines[i].GetAsSegment().A.X
y := g.StaticLines[i].GetAsSegment().A.Y
x2 := g.StaticLines[i].GetAsSegment().B.X
y2 := g.StaticLines[i].GetAsSegment().B.Y
raylib.DrawLine(int32(x), int32(y), int32(x2), int32(y2), raylib.DarkBlue)
}
for _, b := range g.Balls {
pos := b.Body.Position()
raylib.DrawCircleLines(int32(pos.X), int32(pos.Y), float32(ballRadius), raylib.DarkBlue)
}
}
// createBodies sets up the chipmunk space and static bodies
func (g *Game) createBodies() {
g.Space = chipmunk.NewSpace()
g.Space.Gravity = vect.Vect{0, 900}
staticBody := chipmunk.NewBodyStatic()
g.StaticLines = []*chipmunk.Shape{
chipmunk.NewSegment(vect.Vect{250.0, 240.0}, vect.Vect{550.0, 280.0}, 0),
chipmunk.NewSegment(vect.Vect{550.0, 280.0}, vect.Vect{550.0, 180.0}, 0),
}
for _, segment := range g.StaticLines {
segment.SetElasticity(0.6)
staticBody.AddShape(segment)
}
g.Space.AddBody(staticBody)
}
// addBall adds ball to chipmunk space and body
func (g *Game) addBall() {
x := rand.Intn(600-200) + 200
ball := chipmunk.NewCircle(vect.Vector_Zero, float32(ballRadius))
ball.SetElasticity(0.95)
body := chipmunk.NewBody(vect.Float(ballMass), ball.Moment(float32(ballMass)))
body.SetPosition(vect.Vect{vect.Float(x), 0.0})
body.SetAngle(vect.Float(rand.Float32() * 2 * math.Pi))
body.AddShape(ball)
g.Space.AddBody(body)
g.Balls = append(g.Balls, ball)
}
// step advances the physics engine and cleans up any balls that are off-screen
func (g *Game) step(dt float32) {
g.Space.Step(vect.Float(dt))
for i := 0; i < len(g.Balls); i++ {
p := g.Balls[i].Body.Position()
if p.Y < -100 {
g.Space.RemoveBody(g.Balls[i].Body)
g.Balls[i] = nil
g.Balls = append(g.Balls[:i], g.Balls[i+1:]...)
i-- // consider same index again
}
}
}
func main() {
raylib.InitWindow(800, 450, "raylib [physics] example - chipmunk")
raylib.SetTargetFPS(60)
game := NewGame()
for !raylib.WindowShouldClose() {
raylib.BeginDrawing()
raylib.ClearBackground(raylib.RayWhite)
game.Update()
game.Draw()
raylib.EndDrawing()
}
raylib.CloseWindow()
}