use advanced physics

README.md

@@ -80,3 +80,4 @@ The following projects and individuals have contributed significantly to the pro
 
 * **[GLFW for Go](https://github.com/go-gl/glfw)** for making it possible to use GLFW and OpenGL in Go.
 * **[Bo0mer](https://github.com/Bo0mer)** for the panoramic image that was used to generate the individual `city` skybox images.
+* **[Erin Catto](https://github.com/erincatto)** for all the presentations and articles that were used as reference.

cmd/rallymka/internal/ecs/car.go

@@ -0,0 +1,106 @@
+package ecs
+
+import (
+	"time"
+
+	"github.com/mokiat/gomath/sprec"
+)
+
+const (
+	// TODO: Move constants as part of car descriptor
+	carMaxSteeringAngle     = 40
+	carSteeringSpeed        = 80
+	carSteeringRestoreSpeed = 150
+
+	carFrontAcceleration        = 160
+	carRearAcceleration         = 80
+	carReverseAccelerationRatio = 0.75
+
+	carFrontBrakeRatio = 0.1
+	carRearBrakeRatio  = 0.1
+)
+
+func NewCarSystem(ecsManager *Manager) *CarSystem {
+	return &CarSystem{
+		ecsManager: ecsManager,
+	}
+}
+
+type CarSystem struct {
+	ecsManager *Manager
+}
+
+func (s *CarSystem) Update(elapsedTime time.Duration, input CarInput) {
+	elapsedSeconds := float32(elapsedTime.Seconds())
+
+	for _, entity := range s.ecsManager.Entities() {
+		if car := entity.Car; car != nil && entity.HumanInput {
+			s.updateCarSteering(car, elapsedSeconds, input)
+			s.updateCarAcceleration(car, elapsedSeconds, input)
+		}
+	}
+}
+
+func (s *CarSystem) updateCarSteering(car *Car, elapsedSeconds float32, input CarInput) {
+	actualSteeringAngle := carMaxSteeringAngle / (1.0 + 0.03*car.Chassis.Velocity.Length())
+	switch {
+	case input.TurnLeft == input.TurnRight:
+		if car.SteeringAngle > 0.001 {
+			if car.SteeringAngle -= sprec.Degrees(elapsedSeconds * carSteeringRestoreSpeed); car.SteeringAngle < 0.0 {
+				car.SteeringAngle = 0.0
+			}
+		}
+		if car.SteeringAngle < -0.001 {
+			if car.SteeringAngle += sprec.Degrees(elapsedSeconds * carSteeringRestoreSpeed); car.SteeringAngle > 0.0 {
+				car.SteeringAngle = 0.0
+			}
+		}
+	case input.TurnLeft:
+		if car.SteeringAngle += sprec.Degrees(elapsedSeconds * carSteeringSpeed); car.SteeringAngle > sprec.Degrees(actualSteeringAngle) {
+			car.SteeringAngle = sprec.Degrees(actualSteeringAngle)
+		}
+	case input.TurnRight:
+		if car.SteeringAngle -= sprec.Degrees(elapsedSeconds * carSteeringSpeed); car.SteeringAngle < -sprec.Degrees(actualSteeringAngle) {
+			car.SteeringAngle = -sprec.Degrees(actualSteeringAngle)
+		}
+	}
+
+	rotationQuat := sprec.RotationQuat(car.SteeringAngle, sprec.BasisYVec3())
+	car.FLWheelRotation.FirstBodyAxis = sprec.QuatVec3Rotation(rotationQuat, sprec.BasisXVec3())
+	car.FRWheelRotation.FirstBodyAxis = sprec.QuatVec3Rotation(rotationQuat, sprec.BasisXVec3())
+}
+
+func (s *CarSystem) updateCarAcceleration(car *Car, elapsedSeconds float32, input CarInput) {
+	// TODO: Remove, just for debugging
+	if input.Handbrake {
+		car.Chassis.AngularVelocity = sprec.Vec3Sum(car.Chassis.AngularVelocity, sprec.NewVec3(0.0, 0.0, 0.1))
+		car.Chassis.Velocity = sprec.Vec3Sum(car.Chassis.Velocity, sprec.NewVec3(0.0, 0.2, 0.0))
+	}
+
+	if input.Forward {
+		if sprec.Vec3Dot(car.Chassis.Velocity, car.Chassis.Orientation.OrientationZ()) < -5.0 {
+			car.FLWheel.AngularVelocity = sprec.Vec3Prod(car.FLWheel.AngularVelocity, 1.0-carFrontBrakeRatio)
+			car.FRWheel.AngularVelocity = sprec.Vec3Prod(car.FRWheel.AngularVelocity, 1.0-carFrontBrakeRatio)
+			car.BLWheel.AngularVelocity = sprec.Vec3Prod(car.BLWheel.AngularVelocity, 1.0-carRearBrakeRatio)
+			car.BRWheel.AngularVelocity = sprec.Vec3Prod(car.BRWheel.AngularVelocity, 1.0-carRearBrakeRatio)
+		} else {
+			car.FLWheel.AngularVelocity = sprec.Vec3Sum(car.FLWheel.AngularVelocity, sprec.Vec3Prod(car.FLWheel.Orientation.OrientationX(), carFrontAcceleration*elapsedSeconds))
+			car.FRWheel.AngularVelocity = sprec.Vec3Sum(car.FRWheel.AngularVelocity, sprec.Vec3Prod(car.FRWheel.Orientation.OrientationX(), carFrontAcceleration*elapsedSeconds))
+			car.BLWheel.AngularVelocity = sprec.Vec3Sum(car.BLWheel.AngularVelocity, sprec.Vec3Prod(car.BLWheel.Orientation.OrientationX(), carRearAcceleration*elapsedSeconds))
+			car.BRWheel.AngularVelocity = sprec.Vec3Sum(car.BRWheel.AngularVelocity, sprec.Vec3Prod(car.BRWheel.Orientation.OrientationX(), carRearAcceleration*elapsedSeconds))
+		}
+	}
+	if input.Backward {
+		if sprec.Vec3Dot(car.Chassis.Velocity, car.Chassis.Orientation.OrientationZ()) > 5.0 {
+			car.FLWheel.AngularVelocity = sprec.Vec3Prod(car.FLWheel.AngularVelocity, 1.0-carFrontBrakeRatio)
+			car.FRWheel.AngularVelocity = sprec.Vec3Prod(car.FRWheel.AngularVelocity, 1.0-carFrontBrakeRatio)
+			car.BLWheel.AngularVelocity = sprec.Vec3Prod(car.BLWheel.AngularVelocity, 1.0-carRearBrakeRatio)
+			car.BRWheel.AngularVelocity = sprec.Vec3Prod(car.BRWheel.AngularVelocity, 1.0-carRearBrakeRatio)
+		} else {
+			car.FLWheel.AngularVelocity = sprec.Vec3Sum(car.FLWheel.AngularVelocity, sprec.Vec3Prod(car.FLWheel.Orientation.OrientationX(), -carFrontAcceleration*carReverseAccelerationRatio*elapsedSeconds))
+			car.FRWheel.AngularVelocity = sprec.Vec3Sum(car.FRWheel.AngularVelocity, sprec.Vec3Prod(car.FRWheel.Orientation.OrientationX(), -carFrontAcceleration*carReverseAccelerationRatio*elapsedSeconds))
+			car.BLWheel.AngularVelocity = sprec.Vec3Sum(car.BLWheel.AngularVelocity, sprec.Vec3Prod(car.BLWheel.Orientation.OrientationX(), -carRearAcceleration*carReverseAccelerationRatio*elapsedSeconds))
+			car.BRWheel.AngularVelocity = sprec.Vec3Sum(car.BRWheel.AngularVelocity, sprec.Vec3Prod(car.BRWheel.Orientation.OrientationX(), -carRearAcceleration*carReverseAccelerationRatio*elapsedSeconds))
+		}
+	}
+}

cmd/rallymka/internal/ecs/entity.go

@@ -4,27 +4,27 @@ import (
 	"github.com/mokiat/gomath/sprec"
 	"github.com/mokiat/rally-mka/cmd/rallymka/internal/stream"
 	"github.com/mokiat/rally-mka/internal/engine/graphics"
+	"github.com/mokiat/rally-mka/internal/engine/physics"
 )
 
 type Entity struct {
-	Transform    *TransformComponent
-	RenderMesh   *RenderMesh
-	RenderModel  *RenderModel
+	Physics      *PhysicsComponent
+	Render       *RenderComponent
 	RenderSkybox *RenderSkybox
-	Vehicle      *Vehicle
-	Wheel        *Wheel
-	Input        *Input
+	Car          *Car
 	CameraStand  *CameraStand
+	HumanInput   bool
 }
 
-type RenderModel struct {
-	Model       *stream.Model
-	GeomProgram *graphics.Program
+type PhysicsComponent struct {
+	Body *physics.Body
 }
 
-type RenderMesh struct {
-	Mesh        *stream.Mesh
+type RenderComponent struct {
 	GeomProgram *graphics.Program
+	Model       *stream.Model
+	Mesh        *stream.Mesh
+	Matrix      sprec.Mat4
 }
 
 type RenderSkybox struct {
@@ -33,39 +33,25 @@ type RenderSkybox struct {
 	Mesh    *stream.Mesh
 }
 
-type Vehicle struct {
-	SteeringAngle   sprec.Angle
-	Acceleration    float32
-	HandbrakePulled bool
-
-	Position        sprec.Vec3
-	Orientation     Orientation
-	Velocity        sprec.Vec3
-	AngularVelocity sprec.Vec3
-
-	FLWheel *Entity
-	FRWheel *Entity
-	BLWheel *Entity
-	BRWheel *Entity
+type CarInput struct {
+	Forward   bool
+	Backward  bool
+	TurnLeft  bool
+	TurnRight bool
+	Handbrake bool
 }
 
-type Wheel struct {
-	SteeringAngle sprec.Angle
-	RotationAngle sprec.Angle
-
-	AnchorPosition sprec.Vec3
-
-	IsDriven bool
-
-	Length float32
-	Radius float32
-
-	SuspensionLength float32
-	IsGrounded       bool
+type Car struct {
+	SteeringAngle   sprec.Angle
+	Chassis         *physics.Body
+	FLWheelRotation *physics.MatchAxisConstraint
+	FRWheelRotation *physics.MatchAxisConstraint
+	FLWheel         *physics.Body
+	FRWheel         *physics.Body
+	BLWheel         *physics.Body
+	BRWheel         *physics.Body
 }
 
-type Input struct{}
-
 type CameraStand struct {
 	Target         *Entity
 	AnchorPosition sprec.Vec3

cmd/rallymka/internal/ecs/renderer.go

@@ -17,31 +17,32 @@ type Renderer struct {
 }
 
 func (r *Renderer) Render(sequence *graphics.Sequence) {
-	r.renderRenderMeshes(sequence)
-	r.renderRenderModels(sequence)
+	r.renderRender(sequence)
 	r.renderRenderSkyboxes(sequence)
 }
 
-func (r *Renderer) renderRenderMeshes(sequence *graphics.Sequence) {
+func (r *Renderer) renderRender(sequence *graphics.Sequence) {
 	for _, entity := range r.ecsManager.Entities() {
-		transformComp := entity.Transform
-		renderMeshComp := entity.RenderMesh
-		if transformComp == nil || renderMeshComp == nil {
+		render := entity.Render
+		if render == nil {
 			continue
 		}
-		r.renderMesh(sequence, renderMeshComp.GeomProgram, transformComp.Matrix(), renderMeshComp.Mesh)
-	}
-}
-
-func (r *Renderer) renderRenderModels(sequence *graphics.Sequence) {
-	for _, entity := range r.ecsManager.Entities() {
-		transformComp := entity.Transform
-		renderModelComp := entity.RenderModel
-		if transformComp == nil || renderModelComp == nil {
-			continue
+		if entity.Physics != nil {
+			body := entity.Physics.Body
+			render.Matrix = sprec.TransformationMat4(
+				body.Orientation.OrientationX(),
+				body.Orientation.OrientationY(),
+				body.Orientation.OrientationZ(),
+				body.Position,
+			)
+		}
+		if render.Model != nil {
+			for _, node := range render.Model.Nodes {
+				r.renderModelNode(sequence, render.GeomProgram, render.Matrix, node)
+			}
 		}
-		for _, node := range renderModelComp.Model.Nodes {
-			r.renderModelNode(sequence, renderModelComp.GeomProgram, transformComp.Matrix(), node)
+		if render.Mesh != nil {
+			r.renderMesh(sequence, render.GeomProgram, render.Matrix, render.Mesh)
 		}
 	}
 }

cmd/rallymka/internal/ecs/stand.go

@@ -20,10 +20,18 @@ func (s *CameraStandSystem) Update() {
 	}
 }
 
+var angleSpeed sprec.Angle = sprec.Degrees(0.0)
+var angle sprec.Angle = sprec.Degrees(0)
+
 func (s *CameraStandSystem) updateCameraStand(cameraStand *CameraStand) {
+	angle += angleSpeed
+
 	var targetPosition sprec.Vec3
-	if cameraStand.Target.Vehicle != nil {
-		targetPosition = cameraStand.Target.Vehicle.Position
+	switch {
+	case cameraStand.Target.Physics != nil:
+		targetPosition = cameraStand.Target.Physics.Body.Position
+	case cameraStand.Target.Render != nil:
+		targetPosition = cameraStand.Target.Render.Matrix.Translation()
 	}
 	// we use a camera anchor to achieve the smooth effect of a
 	// camera following the target
@@ -45,6 +53,7 @@ func (s *CameraStandSystem) updateCameraStand(cameraStand *CameraStand) {
 			sprec.UnitVec3(cameraVectorZ),
 			sprec.ZeroVec3(),
 		),
+		sprec.RotationMat4(angle, 0.0, 1.0, 0.0),
 		sprec.RotationMat4(sprec.Degrees(-25.0), 1.0, 0.0, 0.0),
 		sprec.TranslationMat4(0.0, 0.0, cameraStand.CameraDistance),
 	))