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

Move raymath to raylib package, issue #58

Browse source
This commit is contained in:
Milan Nikolic 2020-09-05 17:38:24 +02:00
parent 97a2104544
commit 5b0944b556
No known key found for this signature in database
GPG key ID: 9229D0EAA3AA4E75
4 changed files with 215 additions and 222 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -1,4 +1,4 @@
PACKAGES= raylib raygui raymath easings physics rres PACKAGES= raylib raygui easings physics rres
GO?= go GO?= go

181
physics/physics.go
View file

@ -7,7 +7,6 @@ import (
"math" "math"
"github.com/gen2brain/raylib-go/raylib" "github.com/gen2brain/raylib-go/raylib"
"github.com/gen2brain/raylib-go/raymath"
) )
// ShapeType type // ShapeType type
@ -196,7 +195,7 @@ func NewBodyRectangle(pos rl.Vector2, width, height, density float32) *Body {
} }
p2 := newBody.Shape.VertexData.Vertices[nextIndex] p2 := newBody.Shape.VertexData.Vertices[nextIndex]
D := raymath.Vector2CrossProduct(p1, p2) D := rl.Vector2CrossProduct(p1, p2)
triangleArea := D / 2 triangleArea := D / 2
area += triangleArea area += triangleArea
@ -276,7 +275,7 @@ func NewBodyPolygon(pos rl.Vector2, radius float32, sides int, density float32)
} }
position2 := newBody.Shape.VertexData.Vertices[nextIndex] position2 := newBody.Shape.VertexData.Vertices[nextIndex]
cross := raymath.Vector2CrossProduct(position1, position2) cross := rl.Vector2CrossProduct(position1, position2)
triangleArea := cross / 2 triangleArea := cross / 2
area += triangleArea area += triangleArea
@ -502,7 +501,7 @@ func Close() {
// AddForce - Adds a force to a physics body // AddForce - Adds a force to a physics body
func (b *Body) AddForce(force rl.Vector2) { func (b *Body) AddForce(force rl.Vector2) {
b.Force = raymath.Vector2Add(b.Force, force) b.Force = rl.Vector2Add(b.Force, force)
} }
// AddTorque - Adds an angular force to a physics body // AddTorque - Adds an angular force to a physics body
@ -521,14 +520,14 @@ func (b *Body) Shatter(position rl.Vector2, force float32) {
for i := 0; i < vertexData.VertexCount; i++ { for i := 0; i < vertexData.VertexCount; i++ {
positionA := b.Position positionA := b.Position
positionB := raymath.Mat2MultiplyVector2(vertexData.Transform, raymath.Vector2Add(b.Position, vertexData.Vertices[i])) positionB := rl.Mat2MultiplyVector2(vertexData.Transform, rl.Vector2Add(b.Position, vertexData.Vertices[i]))
nextIndex := 0 nextIndex := 0
if i+1 < vertexData.VertexCount { if i+1 < vertexData.VertexCount {
nextIndex = i + 1 nextIndex = i + 1
} }
positionC := raymath.Mat2MultiplyVector2(vertexData.Transform, raymath.Vector2Add(b.Position, vertexData.Vertices[nextIndex])) positionC := rl.Mat2MultiplyVector2(vertexData.Transform, rl.Vector2Add(b.Position, vertexData.Vertices[nextIndex]))
// Check collision between each triangle // Check collision between each triangle
alpha := ((positionB.Y-positionC.Y)*(position.X-positionC.X) + (positionC.X-positionB.X)*(position.Y-positionC.Y)) / alpha := ((positionB.Y-positionC.Y)*(position.X-positionC.X) + (positionC.X-positionB.X)*(position.Y-positionC.Y)) /
@ -565,8 +564,8 @@ func (b *Body) Shatter(position rl.Vector2, force float32) {
} }
center := triangleBarycenter(vertices[i], vertices[nextIndex], rl.NewVector2(0, 0)) center := triangleBarycenter(vertices[i], vertices[nextIndex], rl.NewVector2(0, 0))
center = raymath.Vector2Add(bodyPos, center) center = rl.Vector2Add(bodyPos, center)
offset := raymath.Vector2Subtract(center, bodyPos) offset := rl.Vector2Subtract(center, bodyPos)
newBody := NewBodyPolygon(center, 10, 3, 10) // Create polygon physics body with relevant values newBody := NewBodyPolygon(center, 10, 3, 10) // Create polygon physics body with relevant values
@ -574,9 +573,9 @@ func (b *Body) Shatter(position rl.Vector2, force float32) {
newData.VertexCount = 3 newData.VertexCount = 3
newData.Transform = trans newData.Transform = trans
newData.Vertices[0] = raymath.Vector2Subtract(vertices[i], offset) newData.Vertices[0] = rl.Vector2Subtract(vertices[i], offset)
newData.Vertices[1] = raymath.Vector2Subtract(vertices[nextIndex], offset) newData.Vertices[1] = rl.Vector2Subtract(vertices[nextIndex], offset)
newData.Vertices[2] = raymath.Vector2Subtract(position, center) newData.Vertices[2] = rl.Vector2Subtract(position, center)
// Separate vertices to avoid unnecessary physics collisions // Separate vertices to avoid unnecessary physics collisions
newData.Vertices[0].X *= 0.95 newData.Vertices[0].X *= 0.95
@ -593,7 +592,7 @@ func (b *Body) Shatter(position rl.Vector2, force float32) {
nextVertex = j + 1 nextVertex = j + 1
} }
face := raymath.Vector2Subtract(newData.Vertices[nextVertex], newData.Vertices[j]) face := rl.Vector2Subtract(newData.Vertices[nextVertex], newData.Vertices[j])
newData.Normals[j] = rl.NewVector2(face.Y, -face.X) newData.Normals[j] = rl.NewVector2(face.Y, -face.X)
normalize(&newData.Normals[j]) normalize(&newData.Normals[j])
@ -617,7 +616,7 @@ func (b *Body) Shatter(position rl.Vector2, force float32) {
} }
p2 := newBody.Shape.VertexData.Vertices[nextVertex] p2 := newBody.Shape.VertexData.Vertices[nextVertex]
D := raymath.Vector2CrossProduct(p1, p2) D := rl.Vector2CrossProduct(p1, p2)
triangleArea := D / 2 triangleArea := D / 2
area += triangleArea area += triangleArea
@ -647,10 +646,10 @@ func (b *Body) Shatter(position rl.Vector2, force float32) {
// Calculate explosion force direction // Calculate explosion force direction
pointA := newBody.Position pointA := newBody.Position
pointB := raymath.Vector2Subtract(newData.Vertices[1], newData.Vertices[0]) pointB := rl.Vector2Subtract(newData.Vertices[1], newData.Vertices[0])
pointB.X /= 2 pointB.X /= 2
pointB.Y /= 2 pointB.Y /= 2
forceDirection := raymath.Vector2Subtract(raymath.Vector2Add(pointA, raymath.Vector2Add(newData.Vertices[0], pointB)), newBody.Position) forceDirection := rl.Vector2Subtract(rl.Vector2Add(pointA, rl.Vector2Add(newData.Vertices[0], pointB)), newBody.Position)
normalize(&forceDirection) normalize(&forceDirection)
forceDirection.X *= force forceDirection.X *= force
forceDirection.Y *= force forceDirection.Y *= force
@ -671,7 +670,7 @@ func (b *Body) GetShapeVertex(vertex int) rl.Vector2 {
position.Y = b.Position.Y + float32(math.Sin(360/float64(circleVertices)*float64(vertex)*rl.Deg2rad))*b.Shape.Radius position.Y = b.Position.Y + float32(math.Sin(360/float64(circleVertices)*float64(vertex)*rl.Deg2rad))*b.Shape.Radius
break break
case PolygonShape: case PolygonShape:
position = raymath.Vector2Add(b.Position, raymath.Mat2MultiplyVector2(b.Shape.VertexData.Transform, b.Shape.VertexData.Vertices[vertex])) position = rl.Vector2Add(b.Position, rl.Mat2MultiplyVector2(b.Shape.VertexData.Transform, b.Shape.VertexData.Vertices[vertex]))
break break
} }
@ -683,7 +682,7 @@ func (b *Body) SetRotation(radians float32) {
b.Orient = radians b.Orient = radians
if b.Shape.Type == PolygonShape { if b.Shape.Type == PolygonShape {
b.Shape.VertexData.Transform = raymath.Mat2Radians(radians) b.Shape.VertexData.Transform = rl.Mat2Radians(radians)
} }
} }
@ -700,7 +699,7 @@ func (b *Body) integrateVelocity() {
b.Orient += b.AngularVelocity * deltaTime b.Orient += b.AngularVelocity * deltaTime
} }
raymath.Mat2Set(&b.Shape.VertexData.Transform, b.Orient) rl.Mat2Set(&b.Shape.VertexData.Transform, b.Orient)
b.integrateForces() b.integrateForces()
} }
@ -730,7 +729,7 @@ func newRandomPolygon(radius float32, sides int) Polygon {
data.VertexCount = sides data.VertexCount = sides
orient := rl.GetRandomValue(0, 360) orient := rl.GetRandomValue(0, 360)
data.Transform = raymath.Mat2Radians(float32(orient) * rl.Deg2rad) data.Transform = rl.Mat2Radians(float32(orient) * rl.Deg2rad)
// Calculate polygon vertices positions // Calculate polygon vertices positions
for i := 0; i < data.VertexCount; i++ { for i := 0; i < data.VertexCount; i++ {
@ -745,7 +744,7 @@ func newRandomPolygon(radius float32, sides int) Polygon {
nextIndex = i + 1 nextIndex = i + 1
} }
face := raymath.Vector2Subtract(data.Vertices[nextIndex], data.Vertices[i]) face := rl.Vector2Subtract(data.Vertices[nextIndex], data.Vertices[i])
data.Normals[i] = rl.NewVector2(face.Y, -face.X) data.Normals[i] = rl.NewVector2(face.Y, -face.X)
normalize(&data.Normals[i]) normalize(&data.Normals[i])
@ -759,7 +758,7 @@ func newRectanglePolygon(pos, size rl.Vector2) Polygon {
data := Polygon{} data := Polygon{}
data.VertexCount = 4 data.VertexCount = 4
data.Transform = raymath.Mat2Radians(0) data.Transform = rl.Mat2Radians(0)
// Calculate polygon vertices positions // Calculate polygon vertices positions
data.Vertices[0] = rl.NewVector2(pos.X+size.X/2, pos.Y-size.Y/2) data.Vertices[0] = rl.NewVector2(pos.X+size.X/2, pos.Y-size.Y/2)
@ -773,7 +772,7 @@ func newRectanglePolygon(pos, size rl.Vector2) Polygon {
if i+1 < data.VertexCount { if i+1 < data.VertexCount {
nextIndex = i + 1 nextIndex = i + 1
} }
face := raymath.Vector2Subtract(data.Vertices[nextIndex], data.Vertices[i]) face := rl.Vector2Subtract(data.Vertices[nextIndex], data.Vertices[i])
data.Normals[i] = rl.NewVector2(face.Y, -face.X) data.Normals[i] = rl.NewVector2(face.Y, -face.X)
normalize(&data.Normals[i]) normalize(&data.Normals[i])
@ -852,9 +851,9 @@ func (m *manifold) solveCircleToCircle() {
bodyB := m.BodyB bodyB := m.BodyB
// Calculate translational vector, which is normal // Calculate translational vector, which is normal
normal := raymath.Vector2Subtract(bodyB.Position, bodyA.Position) normal := rl.Vector2Subtract(bodyB.Position, bodyA.Position)
distSqr := raymath.Vector2LenSqr(normal) distSqr := rl.Vector2LenSqr(normal)
radius := bodyA.Shape.Radius + bodyB.Shape.Radius radius := bodyA.Shape.Radius + bodyB.Shape.Radius
// Check if circles are not in contact // Check if circles are not in contact
@ -888,7 +887,7 @@ func (m *manifold) solveCircleToPolygon() {
// Transform circle center to polygon transform space // Transform circle center to polygon transform space
center := m.BodyA.Position center := m.BodyA.Position
center = raymath.Mat2MultiplyVector2(raymath.Mat2Transpose(m.BodyB.Shape.VertexData.Transform), raymath.Vector2Subtract(center, m.BodyB.Position)) center = rl.Mat2MultiplyVector2(rl.Mat2Transpose(m.BodyB.Shape.VertexData.Transform), rl.Vector2Subtract(center, m.BodyB.Position))
// Find edge with minimum penetration // Find edge with minimum penetration
// It is the same concept as using support points in solvePolygonToPolygon // It is the same concept as using support points in solvePolygonToPolygon
@ -897,7 +896,7 @@ func (m *manifold) solveCircleToPolygon() {
vertexData := m.BodyB.Shape.VertexData vertexData := m.BodyB.Shape.VertexData
for i := 0; i < vertexData.VertexCount; i++ { for i := 0; i < vertexData.VertexCount; i++ {
currentSeparation := raymath.Vector2DotProduct(vertexData.Normals[i], raymath.Vector2Subtract(center, vertexData.Vertices[i])) currentSeparation := rl.Vector2DotProduct(vertexData.Normals[i], rl.Vector2Subtract(center, vertexData.Vertices[i]))
if currentSeparation > m.BodyA.Shape.Radius { if currentSeparation > m.BodyA.Shape.Radius {
return return
@ -920,7 +919,7 @@ func (m *manifold) solveCircleToPolygon() {
// Check to see if center is within polygon // Check to see if center is within polygon
if separation < epsilon { if separation < epsilon {
m.ContactsCount = 1 m.ContactsCount = 1
normal := raymath.Mat2MultiplyVector2(vertexData.Transform, vertexData.Normals[faceNormal]) normal := rl.Mat2MultiplyVector2(vertexData.Transform, vertexData.Normals[faceNormal])
m.Normal = rl.NewVector2(-normal.X, -normal.Y) m.Normal = rl.NewVector2(-normal.X, -normal.Y)
m.Contacts[0] = rl.NewVector2(m.Normal.X*m.BodyA.Shape.Radius+m.BodyA.Position.X, m.Normal.Y*m.BodyA.Shape.Radius+m.BodyA.Position.Y) m.Contacts[0] = rl.NewVector2(m.Normal.X*m.BodyA.Shape.Radius+m.BodyA.Position.X, m.Normal.Y*m.BodyA.Shape.Radius+m.BodyA.Position.Y)
m.Penetration = m.BodyA.Shape.Radius m.Penetration = m.BodyA.Shape.Radius
@ -928,44 +927,44 @@ func (m *manifold) solveCircleToPolygon() {
} }
// Determine which voronoi region of the edge center of circle lies within // Determine which voronoi region of the edge center of circle lies within
dot1 := raymath.Vector2DotProduct(raymath.Vector2Subtract(center, v1), raymath.Vector2Subtract(v2, v1)) dot1 := rl.Vector2DotProduct(rl.Vector2Subtract(center, v1), rl.Vector2Subtract(v2, v1))
dot2 := raymath.Vector2DotProduct(raymath.Vector2Subtract(center, v2), raymath.Vector2Subtract(v1, v2)) dot2 := rl.Vector2DotProduct(rl.Vector2Subtract(center, v2), rl.Vector2Subtract(v1, v2))
m.Penetration = m.BodyA.Shape.Radius - separation m.Penetration = m.BodyA.Shape.Radius - separation
if dot1 <= 0 { // Closest to v1 if dot1 <= 0 { // Closest to v1
if raymath.Vector2Distance(center, v1) > m.BodyA.Shape.Radius*m.BodyA.Shape.Radius { if rl.Vector2Distance(center, v1) > m.BodyA.Shape.Radius*m.BodyA.Shape.Radius {
return return
} }
m.ContactsCount = 1 m.ContactsCount = 1
normal := raymath.Vector2Subtract(v1, center) normal := rl.Vector2Subtract(v1, center)
normal = raymath.Mat2MultiplyVector2(vertexData.Transform, normal) normal = rl.Mat2MultiplyVector2(vertexData.Transform, normal)
normalize(&normal) normalize(&normal)
m.Normal = normal m.Normal = normal
v1 = raymath.Mat2MultiplyVector2(vertexData.Transform, v1) v1 = rl.Mat2MultiplyVector2(vertexData.Transform, v1)
v1 = raymath.Vector2Add(v1, m.BodyB.Position) v1 = rl.Vector2Add(v1, m.BodyB.Position)
m.Contacts[0] = v1 m.Contacts[0] = v1
} else if dot2 <= 0 { // Closest to v2 } else if dot2 <= 0 { // Closest to v2
if raymath.Vector2Distance(center, v2) > m.BodyA.Shape.Radius*m.BodyA.Shape.Radius { if rl.Vector2Distance(center, v2) > m.BodyA.Shape.Radius*m.BodyA.Shape.Radius {
return return
} }
m.ContactsCount = 1 m.ContactsCount = 1
normal := raymath.Vector2Subtract(v2, center) normal := rl.Vector2Subtract(v2, center)
v2 = raymath.Mat2MultiplyVector2(vertexData.Transform, v2) v2 = rl.Mat2MultiplyVector2(vertexData.Transform, v2)
v2 = raymath.Vector2Add(v2, m.BodyB.Position) v2 = rl.Vector2Add(v2, m.BodyB.Position)
m.Contacts[0] = v2 m.Contacts[0] = v2
normal = raymath.Mat2MultiplyVector2(vertexData.Transform, normal) normal = rl.Mat2MultiplyVector2(vertexData.Transform, normal)
normalize(&normal) normalize(&normal)
m.Normal = normal m.Normal = normal
} else { // Closest to face } else { // Closest to face
normal := vertexData.Normals[faceNormal] normal := vertexData.Normals[faceNormal]
if raymath.Vector2DotProduct(raymath.Vector2Subtract(center, v1), normal) > m.BodyA.Shape.Radius { if rl.Vector2DotProduct(rl.Vector2Subtract(center, v1), normal) > m.BodyA.Shape.Radius {
return return
} }
normal = raymath.Mat2MultiplyVector2(vertexData.Transform, normal) normal = rl.Mat2MultiplyVector2(vertexData.Transform, normal)
m.Normal = rl.NewVector2(-normal.X, -normal.Y) m.Normal = rl.NewVector2(-normal.X, -normal.Y)
m.Contacts[0] = rl.NewVector2(m.Normal.X*m.BodyA.Shape.Radius+m.BodyA.Position.X, m.Normal.Y*m.BodyA.Shape.Radius+m.BodyA.Position.Y) m.Contacts[0] = rl.NewVector2(m.Normal.X*m.BodyA.Shape.Radius+m.BodyA.Position.X, m.Normal.Y*m.BodyA.Shape.Radius+m.BodyA.Position.Y)
m.ContactsCount = 1 m.ContactsCount = 1
@ -1038,20 +1037,20 @@ func (m *manifold) solvePolygonToPolygon() {
v2 := refData.Vertices[referenceIndex] v2 := refData.Vertices[referenceIndex]
// Transform vertices to world space // Transform vertices to world space
v1 = raymath.Mat2MultiplyVector2(refData.Transform, v1) v1 = rl.Mat2MultiplyVector2(refData.Transform, v1)
v1 = raymath.Vector2Add(v1, refPoly.Body.Position) v1 = rl.Vector2Add(v1, refPoly.Body.Position)
v2 = raymath.Mat2MultiplyVector2(refData.Transform, v2) v2 = rl.Mat2MultiplyVector2(refData.Transform, v2)
v2 = raymath.Vector2Add(v2, refPoly.Body.Position) v2 = rl.Vector2Add(v2, refPoly.Body.Position)
// Calculate reference face side normal in world space // Calculate reference face side normal in world space
sidePlaneNormal := raymath.Vector2Subtract(v2, v1) sidePlaneNormal := rl.Vector2Subtract(v2, v1)
normalize(&sidePlaneNormal) normalize(&sidePlaneNormal)
// Orthogonalize // Orthogonalize
refFaceNormal := rl.NewVector2(sidePlaneNormal.Y, -sidePlaneNormal.X) refFaceNormal := rl.NewVector2(sidePlaneNormal.Y, -sidePlaneNormal.X)
refC := raymath.Vector2DotProduct(refFaceNormal, v1) refC := rl.Vector2DotProduct(refFaceNormal, v1)
negSide := raymath.Vector2DotProduct(sidePlaneNormal, v1) * -1 negSide := rl.Vector2DotProduct(sidePlaneNormal, v1) * -1
posSide := raymath.Vector2DotProduct(sidePlaneNormal, v2) posSide := rl.Vector2DotProduct(sidePlaneNormal, v2)
// clip incident face to reference face side planes (due to floating point error, possible to not have required points // clip incident face to reference face side planes (due to floating point error, possible to not have required points
if clip(rl.NewVector2(-sidePlaneNormal.X, -sidePlaneNormal.Y), negSide, &incidentFace0, &incidentFace1) < 2 { if clip(rl.NewVector2(-sidePlaneNormal.X, -sidePlaneNormal.Y), negSide, &incidentFace0, &incidentFace1) < 2 {
@ -1070,7 +1069,7 @@ func (m *manifold) solvePolygonToPolygon() {
// Keep points behind reference face // Keep points behind reference face
currentPoint := 0 // clipped points behind reference face currentPoint := 0 // clipped points behind reference face
separation := raymath.Vector2DotProduct(refFaceNormal, incidentFace0) - refC separation := rl.Vector2DotProduct(refFaceNormal, incidentFace0) - refC
if separation <= 0 { if separation <= 0 {
m.Contacts[currentPoint] = incidentFace0 m.Contacts[currentPoint] = incidentFace0
m.Penetration = -separation m.Penetration = -separation
@ -1079,7 +1078,7 @@ func (m *manifold) solvePolygonToPolygon() {
m.Penetration = 0 m.Penetration = 0
} }
separation = raymath.Vector2DotProduct(refFaceNormal, incidentFace1) - refC separation = rl.Vector2DotProduct(refFaceNormal, incidentFace1) - refC
if separation <= 0 { if separation <= 0 {
m.Contacts[currentPoint] = incidentFace1 m.Contacts[currentPoint] = incidentFace1
@ -1105,11 +1104,11 @@ func (m *manifold) initializeManifolds() {
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
// Caculate radius from center of mass to contact // Caculate radius from center of mass to contact
radiusA := raymath.Vector2Subtract(m.Contacts[i], bodyA.Position) radiusA := rl.Vector2Subtract(m.Contacts[i], bodyA.Position)
radiusB := raymath.Vector2Subtract(m.Contacts[i], bodyB.Position) radiusB := rl.Vector2Subtract(m.Contacts[i], bodyB.Position)
crossA := raymath.Vector2Cross(bodyA.AngularVelocity, radiusA) crossA := rl.Vector2Cross(bodyA.AngularVelocity, radiusA)
crossB := raymath.Vector2Cross(bodyB.AngularVelocity, radiusB) crossB := rl.Vector2Cross(bodyB.AngularVelocity, radiusB)
radiusV := rl.Vector2{} radiusV := rl.Vector2{}
radiusV.X = bodyB.Velocity.X + crossB.X - bodyA.Velocity.X - crossA.X radiusV.X = bodyB.Velocity.X + crossB.X - bodyA.Velocity.X - crossA.X
@ -1117,7 +1116,7 @@ func (m *manifold) initializeManifolds() {
// Determine if we should perform a resting collision or not; // Determine if we should perform a resting collision or not;
// The idea is if the only thing moving this object is gravity, then the collision should be performed without any restitution // The idea is if the only thing moving this object is gravity, then the collision should be performed without any restitution
if raymath.Vector2LenSqr(radiusV) < (raymath.Vector2LenSqr(rl.NewVector2(gravityForce.X*deltaTime/1000, gravityForce.Y*deltaTime/1000)) + epsilon) { if rl.Vector2LenSqr(radiusV) < (rl.Vector2LenSqr(rl.NewVector2(gravityForce.X*deltaTime/1000, gravityForce.Y*deltaTime/1000)) + epsilon) {
m.Restitution = 0 m.Restitution = 0
} }
} }
@ -1137,24 +1136,24 @@ func (m *manifold) integrateImpulses() {
for i := 0; i < m.ContactsCount; i++ { for i := 0; i < m.ContactsCount; i++ {
// Calculate radius from center of mass to contact // Calculate radius from center of mass to contact
radiusA := raymath.Vector2Subtract(m.Contacts[i], bodyA.Position) radiusA := rl.Vector2Subtract(m.Contacts[i], bodyA.Position)
radiusB := raymath.Vector2Subtract(m.Contacts[i], bodyB.Position) radiusB := rl.Vector2Subtract(m.Contacts[i], bodyB.Position)
// Calculate relative velocity // Calculate relative velocity
radiusV := rl.Vector2{} radiusV := rl.Vector2{}
radiusV.X = bodyB.Velocity.X + raymath.Vector2Cross(bodyB.AngularVelocity, radiusB).X - bodyA.Velocity.X - raymath.Vector2Cross(bodyA.AngularVelocity, radiusA).X radiusV.X = bodyB.Velocity.X + rl.Vector2Cross(bodyB.AngularVelocity, radiusB).X - bodyA.Velocity.X - rl.Vector2Cross(bodyA.AngularVelocity, radiusA).X
radiusV.Y = bodyB.Velocity.Y + raymath.Vector2Cross(bodyB.AngularVelocity, radiusB).Y - bodyA.Velocity.Y - raymath.Vector2Cross(bodyA.AngularVelocity, radiusA).Y radiusV.Y = bodyB.Velocity.Y + rl.Vector2Cross(bodyB.AngularVelocity, radiusB).Y - bodyA.Velocity.Y - rl.Vector2Cross(bodyA.AngularVelocity, radiusA).Y
// Relative velocity along the normal // Relative velocity along the normal
contactVelocity := raymath.Vector2DotProduct(radiusV, m.Normal) contactVelocity := rl.Vector2DotProduct(radiusV, m.Normal)
// Do not resolve if velocities are separating // Do not resolve if velocities are separating
if contactVelocity > 0 { if contactVelocity > 0 {
return return
} }
raCrossN := raymath.Vector2CrossProduct(radiusA, m.Normal) raCrossN := rl.Vector2CrossProduct(radiusA, m.Normal)
rbCrossN := raymath.Vector2CrossProduct(radiusB, m.Normal) rbCrossN := rl.Vector2CrossProduct(radiusB, m.Normal)
inverseMassSum := bodyA.InverseMass + bodyB.InverseMass + (raCrossN*raCrossN)*bodyA.InverseInertia + (rbCrossN*rbCrossN)*bodyB.InverseInertia inverseMassSum := bodyA.InverseMass + bodyB.InverseMass + (raCrossN*raCrossN)*bodyA.InverseInertia + (rbCrossN*rbCrossN)*bodyB.InverseInertia
@ -1170,7 +1169,7 @@ func (m *manifold) integrateImpulses() {
bodyA.Velocity.X += bodyA.InverseMass * (-impulseV.X) bodyA.Velocity.X += bodyA.InverseMass * (-impulseV.X)
bodyA.Velocity.Y += bodyA.InverseMass * (-impulseV.Y) bodyA.Velocity.Y += bodyA.InverseMass * (-impulseV.Y)
if !bodyA.FreezeOrient { if !bodyA.FreezeOrient {
bodyA.AngularVelocity += bodyA.InverseInertia * raymath.Vector2CrossProduct(radiusA, rl.NewVector2(-impulseV.X, -impulseV.Y)) bodyA.AngularVelocity += bodyA.InverseInertia * rl.Vector2CrossProduct(radiusA, rl.NewVector2(-impulseV.X, -impulseV.Y))
} }
} }
@ -1178,19 +1177,19 @@ func (m *manifold) integrateImpulses() {
bodyB.Velocity.X += bodyB.InverseMass * (impulseV.X) bodyB.Velocity.X += bodyB.InverseMass * (impulseV.X)
bodyB.Velocity.Y += bodyB.InverseMass * (impulseV.Y) bodyB.Velocity.Y += bodyB.InverseMass * (impulseV.Y)
if !bodyB.FreezeOrient { if !bodyB.FreezeOrient {
bodyB.AngularVelocity += bodyB.InverseInertia * raymath.Vector2CrossProduct(radiusB, impulseV) bodyB.AngularVelocity += bodyB.InverseInertia * rl.Vector2CrossProduct(radiusB, impulseV)
} }
} }
// Apply friction impulse to each physics body // Apply friction impulse to each physics body
radiusV.X = bodyB.Velocity.X + raymath.Vector2Cross(bodyB.AngularVelocity, radiusB).X - bodyA.Velocity.X - raymath.Vector2Cross(bodyA.AngularVelocity, radiusA).X radiusV.X = bodyB.Velocity.X + rl.Vector2Cross(bodyB.AngularVelocity, radiusB).X - bodyA.Velocity.X - rl.Vector2Cross(bodyA.AngularVelocity, radiusA).X
radiusV.Y = bodyB.Velocity.Y + raymath.Vector2Cross(bodyB.AngularVelocity, radiusB).Y - bodyA.Velocity.Y - raymath.Vector2Cross(bodyA.AngularVelocity, radiusA).Y radiusV.Y = bodyB.Velocity.Y + rl.Vector2Cross(bodyB.AngularVelocity, radiusB).Y - bodyA.Velocity.Y - rl.Vector2Cross(bodyA.AngularVelocity, radiusA).Y
tangent := rl.NewVector2(radiusV.X-(m.Normal.X*raymath.Vector2DotProduct(radiusV, m.Normal)), radiusV.Y-(m.Normal.Y*raymath.Vector2DotProduct(radiusV, m.Normal))) tangent := rl.NewVector2(radiusV.X-(m.Normal.X*rl.Vector2DotProduct(radiusV, m.Normal)), radiusV.Y-(m.Normal.Y*rl.Vector2DotProduct(radiusV, m.Normal)))
normalize(&tangent) normalize(&tangent)
// Calculate impulse tangent magnitude // Calculate impulse tangent magnitude
impulseTangent := -(raymath.Vector2DotProduct(radiusV, tangent)) impulseTangent := -(rl.Vector2DotProduct(radiusV, tangent))
impulseTangent /= inverseMassSum impulseTangent /= inverseMassSum
impulseTangent /= float32(m.ContactsCount) impulseTangent /= float32(m.ContactsCount)
@ -1215,7 +1214,7 @@ func (m *manifold) integrateImpulses() {
bodyA.Velocity.Y += bodyA.InverseMass * (-tangentImpulse.Y) bodyA.Velocity.Y += bodyA.InverseMass * (-tangentImpulse.Y)
if !bodyA.FreezeOrient { if !bodyA.FreezeOrient {
bodyA.AngularVelocity += bodyA.InverseInertia * raymath.Vector2CrossProduct(radiusA, rl.NewVector2(-tangentImpulse.X, -tangentImpulse.Y)) bodyA.AngularVelocity += bodyA.InverseInertia * rl.Vector2CrossProduct(radiusA, rl.NewVector2(-tangentImpulse.X, -tangentImpulse.Y))
} }
} }
@ -1224,7 +1223,7 @@ func (m *manifold) integrateImpulses() {
bodyB.Velocity.Y += bodyB.InverseMass * (tangentImpulse.Y) bodyB.Velocity.Y += bodyB.InverseMass * (tangentImpulse.Y)
if !bodyB.FreezeOrient { if !bodyB.FreezeOrient {
bodyB.AngularVelocity += bodyB.InverseInertia * raymath.Vector2CrossProduct(radiusB, tangentImpulse) bodyB.AngularVelocity += bodyB.InverseInertia * rl.Vector2CrossProduct(radiusB, tangentImpulse)
} }
} }
} }
@ -1257,7 +1256,7 @@ func getSupport(shape Shape, dir rl.Vector2) rl.Vector2 {
for i := 0; i < shape.VertexData.VertexCount; i++ { for i := 0; i < shape.VertexData.VertexCount; i++ {
vertex := shape.VertexData.Vertices[i] vertex := shape.VertexData.Vertices[i]
projection := raymath.Vector2DotProduct(vertex, dir) projection := rl.Vector2DotProduct(vertex, dir)
if projection > bestProjection { if projection > bestProjection {
bestVertex = vertex bestVertex = vertex
@ -1279,24 +1278,24 @@ func findAxisLeastPenetration(shapeA, shapeB Shape) (int, float32) {
for i := 0; i < dataA.VertexCount; i++ { for i := 0; i < dataA.VertexCount; i++ {
// Retrieve a face normal from A shape // Retrieve a face normal from A shape
normal := dataA.Normals[i] normal := dataA.Normals[i]
transNormal := raymath.Mat2MultiplyVector2(dataA.Transform, normal) transNormal := rl.Mat2MultiplyVector2(dataA.Transform, normal)
// Transform face normal into B shape's model space // Transform face normal into B shape's model space
buT := raymath.Mat2Transpose(dataB.Transform) buT := rl.Mat2Transpose(dataB.Transform)
normal = raymath.Mat2MultiplyVector2(buT, transNormal) normal = rl.Mat2MultiplyVector2(buT, transNormal)
// Retrieve support point from B shape along -n // Retrieve support point from B shape along -n
support := getSupport(shapeB, rl.NewVector2(-normal.X, -normal.Y)) support := getSupport(shapeB, rl.NewVector2(-normal.X, -normal.Y))
// Retrieve vertex on face from A shape, transform into B shape's model space // Retrieve vertex on face from A shape, transform into B shape's model space
vertex := dataA.Vertices[i] vertex := dataA.Vertices[i]
vertex = raymath.Mat2MultiplyVector2(dataA.Transform, vertex) vertex = rl.Mat2MultiplyVector2(dataA.Transform, vertex)
vertex = raymath.Vector2Add(vertex, shapeA.Body.Position) vertex = rl.Vector2Add(vertex, shapeA.Body.Position)
vertex = raymath.Vector2Subtract(vertex, shapeB.Body.Position) vertex = rl.Vector2Subtract(vertex, shapeB.Body.Position)
vertex = raymath.Mat2MultiplyVector2(buT, vertex) vertex = rl.Mat2MultiplyVector2(buT, vertex)
// Compute penetration distance in B shape's model space // Compute penetration distance in B shape's model space
distance := raymath.Vector2DotProduct(normal, raymath.Vector2Subtract(support, vertex)) distance := rl.Vector2DotProduct(normal, rl.Vector2Subtract(support, vertex))
// Store greatest distance // Store greatest distance
if distance > bestDistance { if distance > bestDistance {
@ -1316,15 +1315,15 @@ func findIncidentFace(v0, v1 *rl.Vector2, ref, inc Shape, index int) {
referenceNormal := refData.Normals[index] referenceNormal := refData.Normals[index]
// Calculate normal in incident's frame of reference // Calculate normal in incident's frame of reference
referenceNormal = raymath.Mat2MultiplyVector2(refData.Transform, referenceNormal) // To world space referenceNormal = rl.Mat2MultiplyVector2(refData.Transform, referenceNormal) // To world space
referenceNormal = raymath.Mat2MultiplyVector2(raymath.Mat2Transpose(incData.Transform), referenceNormal) // To incident's model space referenceNormal = rl.Mat2MultiplyVector2(rl.Mat2Transpose(incData.Transform), referenceNormal) // To incident's model space
// Find most anti-normal face on polygon // Find most anti-normal face on polygon
incidentFace := 0 incidentFace := 0
minDot := float32(fltMax) minDot := float32(fltMax)
for i := 0; i < incData.VertexCount; i++ { for i := 0; i < incData.VertexCount; i++ {
dot := raymath.Vector2DotProduct(referenceNormal, incData.Normals[i]) dot := rl.Vector2DotProduct(referenceNormal, incData.Normals[i])
if dot < minDot { if dot < minDot {
minDot = dot minDot = dot
@ -1333,8 +1332,8 @@ func findIncidentFace(v0, v1 *rl.Vector2, ref, inc Shape, index int) {
} }
// Assign face vertices for incident face // Assign face vertices for incident face
*v0 = raymath.Mat2MultiplyVector2(incData.Transform, incData.Vertices[incidentFace]) *v0 = rl.Mat2MultiplyVector2(incData.Transform, incData.Vertices[incidentFace])
*v0 = raymath.Vector2Add(*v0, inc.Body.Position) *v0 = rl.Vector2Add(*v0, inc.Body.Position)
if incidentFace+1 < incData.VertexCount { if incidentFace+1 < incData.VertexCount {
incidentFace = incidentFace + 1 incidentFace = incidentFace + 1
@ -1342,8 +1341,8 @@ func findIncidentFace(v0, v1 *rl.Vector2, ref, inc Shape, index int) {
incidentFace = 0 incidentFace = 0
} }
*v1 = raymath.Mat2MultiplyVector2(incData.Transform, incData.Vertices[incidentFace]) *v1 = rl.Mat2MultiplyVector2(incData.Transform, incData.Vertices[incidentFace])
*v1 = raymath.Vector2Add(*v1, inc.Body.Position) *v1 = rl.Vector2Add(*v1, inc.Body.Position)
} }
// clip - Calculates clipping based on a normal and two faces // clip - Calculates clipping based on a normal and two faces
@ -1355,8 +1354,8 @@ func clip(normal rl.Vector2, clip float32, faceA, faceB *rl.Vector2) int {
out[1] = *faceB out[1] = *faceB
// Retrieve distances from each endpoint to the line // Retrieve distances from each endpoint to the line
distanceA := raymath.Vector2DotProduct(normal, *faceA) - clip distanceA := rl.Vector2DotProduct(normal, *faceA) - clip
distanceB := raymath.Vector2DotProduct(normal, *faceB) - clip distanceB := rl.Vector2DotProduct(normal, *faceB) - clip
// If negative (behind plane) // If negative (behind plane)
if distanceA <= 0 { if distanceA <= 0 {
@ -1373,10 +1372,10 @@ func clip(normal rl.Vector2, clip float32, faceA, faceB *rl.Vector2) int {
// Push intersection point // Push intersection point
alpha := distanceA / (distanceA - distanceB) alpha := distanceA / (distanceA - distanceB)
out[sp] = *faceA out[sp] = *faceA
delta := raymath.Vector2Subtract(*faceB, *faceA) delta := rl.Vector2Subtract(*faceB, *faceA)
delta.X *= alpha delta.X *= alpha
delta.Y *= alpha delta.Y *= alpha
out[sp] = raymath.Vector2Add(out[sp], delta) out[sp] = rl.Vector2Add(out[sp], delta)
sp++ sp++
} }

251
raymath/raymath.go → raylib/raymath.go
View file

@ -1,50 +1,47 @@
// Package raymath - Some useful functions to work with Vector2, Vector3, Matrix and Quaternions package rl
package raymath
import ( import (
"math" "math"
"github.com/gen2brain/raylib-go/raylib"
) )
// Vector2Zero - Vector with components value 0.0 // Vector2Zero - Vector with components value 0.0
func Vector2Zero() rl.Vector2 { func Vector2Zero() Vector2 {
return rl.NewVector2(0.0, 0.0) return NewVector2(0.0, 0.0)
} }
// Vector2One - Vector with components value 1.0 // Vector2One - Vector with components value 1.0
func Vector2One() rl.Vector2 { func Vector2One() Vector2 {
return rl.NewVector2(1.0, 1.0) return NewVector2(1.0, 1.0)
} }
// Vector2Add - Add two vectors (v1 + v2) // Vector2Add - Add two vectors (v1 + v2)
func Vector2Add(v1, v2 rl.Vector2) rl.Vector2 { func Vector2Add(v1, v2 Vector2) Vector2 {
return rl.NewVector2(v1.X+v2.X, v1.Y+v2.Y) return NewVector2(v1.X+v2.X, v1.Y+v2.Y)
} }
// Vector2Subtract - Subtract two vectors (v1 - v2) // Vector2Subtract - Subtract two vectors (v1 - v2)
func Vector2Subtract(v1, v2 rl.Vector2) rl.Vector2 { func Vector2Subtract(v1, v2 Vector2) Vector2 {
return rl.NewVector2(v1.X-v2.X, v1.Y-v2.Y) return NewVector2(v1.X-v2.X, v1.Y-v2.Y)
} }
// Vector2Length - Calculate vector length // Vector2Length - Calculate vector length
func Vector2Length(v rl.Vector2) float32 { func Vector2Length(v Vector2) float32 {
return float32(math.Sqrt(float64((v.X * v.X) + (v.Y * v.Y)))) return float32(math.Sqrt(float64((v.X * v.X) + (v.Y * v.Y))))
} }
// Vector2DotProduct - Calculate two vectors dot product // Vector2DotProduct - Calculate two vectors dot product
func Vector2DotProduct(v1, v2 rl.Vector2) float32 { func Vector2DotProduct(v1, v2 Vector2) float32 {
return v1.X*v2.X + v1.Y*v2.Y return v1.X*v2.X + v1.Y*v2.Y
} }
// Vector2Distance - Calculate distance between two vectors // Vector2Distance - Calculate distance between two vectors
func Vector2Distance(v1, v2 rl.Vector2) float32 { func Vector2Distance(v1, v2 Vector2) float32 {
return float32(math.Sqrt(float64((v1.X-v2.X)*(v1.X-v2.X) + (v1.Y-v2.Y)*(v1.Y-v2.Y)))) return float32(math.Sqrt(float64((v1.X-v2.X)*(v1.X-v2.X) + (v1.Y-v2.Y)*(v1.Y-v2.Y))))
} }
// Vector2Angle - Calculate angle between two vectors in X-axis // Vector2Angle - Calculate angle between two vectors in X-axis
func Vector2Angle(v1, v2 rl.Vector2) float32 { func Vector2Angle(v1, v2 Vector2) float32 {
angle := float32(math.Atan2(float64(v2.Y-v1.Y), float64(v2.X-v1.X)) * (180.0 / float64(rl.Pi))) angle := float32(math.Atan2(float64(v2.Y-v1.Y), float64(v2.X-v1.X)) * (180.0 / float64(Pi)))
if angle < 0 { if angle < 0 {
angle += 360.0 angle += 360.0
@ -54,60 +51,60 @@ func Vector2Angle(v1, v2 rl.Vector2) float32 {
} }
// Vector2Scale - Scale vector (multiply by value) // Vector2Scale - Scale vector (multiply by value)
func Vector2Scale(v rl.Vector2, scale float32) rl.Vector2 { func Vector2Scale(v Vector2, scale float32) Vector2 {
return rl.NewVector2(v.X*scale, v.Y*scale) return NewVector2(v.X*scale, v.Y*scale)
} }
// Vector2Multiply - Multiply vector by vector // Vector2Multiply - Multiply vector by vector
func Vector2Multiply(v1, v2 rl.Vector2) rl.Vector2 { func Vector2Multiply(v1, v2 Vector2) Vector2 {
return rl.NewVector2(v1.X*v2.X, v1.Y*v2.Y) return NewVector2(v1.X*v2.X, v1.Y*v2.Y)
} }
// Vector2Negate - Negate vector // Vector2Negate - Negate vector
func Vector2Negate(v rl.Vector2) rl.Vector2 { func Vector2Negate(v Vector2) Vector2 {
return rl.NewVector2(-v.X, -v.Y) return NewVector2(-v.X, -v.Y)
} }
// Vector2Divide - Divide vector by vector // Vector2Divide - Divide vector by vector
func Vector2DivideV(v1, v2 rl.Vector2) rl.Vector2 { func Vector2DivideV(v1, v2 Vector2) Vector2 {
return rl.NewVector2(v1.X/v2.X, v1.Y/v2.Y) return NewVector2(v1.X/v2.X, v1.Y/v2.Y)
} }
// Vector2Normalize - Normalize provided vector // Vector2Normalize - Normalize provided vector
func Vector2Normalize(v rl.Vector2) rl.Vector2 { func Vector2Normalize(v Vector2) Vector2 {
return Vector2Scale(v, 1/Vector2Length(v)) return Vector2Scale(v, 1/Vector2Length(v))
} }
// Vector2Lerp - Calculate linear interpolation between two vectors // Vector2Lerp - Calculate linear interpolation between two vectors
func Vector2Lerp(v1, v2 rl.Vector2, amount float32) rl.Vector2 { func Vector2Lerp(v1, v2 Vector2, amount float32) Vector2 {
return rl.NewVector2(v1.X+amount*(v2.X-v1.X), v1.Y+amount*(v2.Y-v1.Y)) return NewVector2(v1.X+amount*(v2.X-v1.X), v1.Y+amount*(v2.Y-v1.Y))
} }
// Vector2CrossProduct - Calculate two vectors cross product // Vector2CrossProduct - Calculate two vectors cross product
func Vector2CrossProduct(v1, v2 rl.Vector2) float32 { func Vector2CrossProduct(v1, v2 Vector2) float32 {
return v1.X*v2.Y - v1.Y*v2.X return v1.X*v2.Y - v1.Y*v2.X
} }
// Vector2Cross - Calculate the cross product of a vector and a value // Vector2Cross - Calculate the cross product of a vector and a value
func Vector2Cross(value float32, vector rl.Vector2) rl.Vector2 { func Vector2Cross(value float32, vector Vector2) Vector2 {
return rl.NewVector2(-value*vector.Y, value*vector.X) return NewVector2(-value*vector.Y, value*vector.X)
} }
// Vector2LenSqr - Returns the len square root of a vector // Vector2LenSqr - Returns the len square root of a vector
func Vector2LenSqr(vector rl.Vector2) float32 { func Vector2LenSqr(vector Vector2) float32 {
return vector.X*vector.X + vector.Y*vector.Y return vector.X*vector.X + vector.Y*vector.Y
} }
// Mat2Radians - Creates a matrix 2x2 from a given radians value // Mat2Radians - Creates a matrix 2x2 from a given radians value
func Mat2Radians(radians float32) rl.Mat2 { func Mat2Radians(radians float32) Mat2 {
c := float32(math.Cos(float64(radians))) c := float32(math.Cos(float64(radians)))
s := float32(math.Sin(float64(radians))) s := float32(math.Sin(float64(radians)))
return rl.NewMat2(c, -s, s, c) return NewMat2(c, -s, s, c)
} }
// Mat2Set - Set values from radians to a created matrix 2x2 // Mat2Set - Set values from radians to a created matrix 2x2
func Mat2Set(matrix *rl.Mat2, radians float32) { func Mat2Set(matrix *Mat2, radians float32) {
cos := float32(math.Cos(float64(radians))) cos := float32(math.Cos(float64(radians)))
sin := float32(math.Sin(float64(radians))) sin := float32(math.Sin(float64(radians)))
@ -118,33 +115,33 @@ func Mat2Set(matrix *rl.Mat2, radians float32) {
} }
// Mat2Transpose - Returns the transpose of a given matrix 2x2 // Mat2Transpose - Returns the transpose of a given matrix 2x2
func Mat2Transpose(matrix rl.Mat2) rl.Mat2 { func Mat2Transpose(matrix Mat2) Mat2 {
return rl.NewMat2(matrix.M00, matrix.M10, matrix.M01, matrix.M11) return NewMat2(matrix.M00, matrix.M10, matrix.M01, matrix.M11)
} }
// Mat2MultiplyVector2 - Multiplies a vector by a matrix 2x2 // Mat2MultiplyVector2 - Multiplies a vector by a matrix 2x2
func Mat2MultiplyVector2(matrix rl.Mat2, vector rl.Vector2) rl.Vector2 { func Mat2MultiplyVector2(matrix Mat2, vector Vector2) Vector2 {
return rl.NewVector2(matrix.M00*vector.X+matrix.M01*vector.Y, matrix.M10*vector.X+matrix.M11*vector.Y) return NewVector2(matrix.M00*vector.X+matrix.M01*vector.Y, matrix.M10*vector.X+matrix.M11*vector.Y)
} }
// Vector3Zero - Vector with components value 0.0 // Vector3Zero - Vector with components value 0.0
func Vector3Zero() rl.Vector3 { func Vector3Zero() Vector3 {
return rl.NewVector3(0.0, 0.0, 0.0) return NewVector3(0.0, 0.0, 0.0)
} }
// Vector3One - Vector with components value 1.0 // Vector3One - Vector with components value 1.0
func Vector3One() rl.Vector3 { func Vector3One() Vector3 {
return rl.NewVector3(1.0, 1.0, 1.0) return NewVector3(1.0, 1.0, 1.0)
} }
// Vector3Add - Add two vectors // Vector3Add - Add two vectors
func Vector3Add(v1, v2 rl.Vector3) rl.Vector3 { func Vector3Add(v1, v2 Vector3) Vector3 {
return rl.NewVector3(v1.X+v2.X, v1.Y+v2.Y, v1.Z+v2.Z) return NewVector3(v1.X+v2.X, v1.Y+v2.Y, v1.Z+v2.Z)
} }
// Vector3Multiply - Multiply vector by scalar // Vector3Multiply - Multiply vector by scalar
func Vector3Multiply(v rl.Vector3, scalar float32) rl.Vector3 { func Vector3Multiply(v Vector3, scalar float32) Vector3 {
result := rl.Vector3{} result := Vector3{}
result.X = v.X * scalar result.X = v.X * scalar
result.Y = v.Y * scalar result.Y = v.Y * scalar
@ -154,8 +151,8 @@ func Vector3Multiply(v rl.Vector3, scalar float32) rl.Vector3 {
} }
// Vector3MultiplyV - Multiply vector by vector // Vector3MultiplyV - Multiply vector by vector
func Vector3MultiplyV(v1, v2 rl.Vector3) rl.Vector3 { func Vector3MultiplyV(v1, v2 Vector3) Vector3 {
result := rl.Vector3{} result := Vector3{}
result.X = v1.X * v2.X result.X = v1.X * v2.X
result.Y = v1.Y * v2.Y result.Y = v1.Y * v2.Y
@ -165,13 +162,13 @@ func Vector3MultiplyV(v1, v2 rl.Vector3) rl.Vector3 {
} }
// Vector3Subtract - Subtract two vectors // Vector3Subtract - Subtract two vectors
func Vector3Subtract(v1, v2 rl.Vector3) rl.Vector3 { func Vector3Subtract(v1, v2 Vector3) Vector3 {
return rl.NewVector3(v1.X-v2.X, v1.Y-v2.Y, v1.Z-v2.Z) return NewVector3(v1.X-v2.X, v1.Y-v2.Y, v1.Z-v2.Z)
} }
// Vector3CrossProduct - Calculate two vectors cross product // Vector3CrossProduct - Calculate two vectors cross product
func Vector3CrossProduct(v1, v2 rl.Vector3) rl.Vector3 { func Vector3CrossProduct(v1, v2 Vector3) Vector3 {
result := rl.Vector3{} result := Vector3{}
result.X = v1.Y*v2.Z - v1.Z*v2.Y result.X = v1.Y*v2.Z - v1.Z*v2.Y
result.Y = v1.Z*v2.X - v1.X*v2.Z result.Y = v1.Z*v2.X - v1.X*v2.Z
@ -181,19 +178,19 @@ func Vector3CrossProduct(v1, v2 rl.Vector3) rl.Vector3 {
} }
// Vector3Perpendicular - Calculate one vector perpendicular vector // Vector3Perpendicular - Calculate one vector perpendicular vector
func Vector3Perpendicular(v rl.Vector3) rl.Vector3 { func Vector3Perpendicular(v Vector3) Vector3 {
result := rl.Vector3{} result := Vector3{}
min := math.Abs(float64(v.X)) min := math.Abs(float64(v.X))
cardinalAxis := rl.NewVector3(1.0, 0.0, 0.0) cardinalAxis := NewVector3(1.0, 0.0, 0.0)
if math.Abs(float64(v.Y)) < min { if math.Abs(float64(v.Y)) < min {
min = math.Abs(float64(v.Y)) min = math.Abs(float64(v.Y))
cardinalAxis = rl.NewVector3(0.0, 1.0, 0.0) cardinalAxis = NewVector3(0.0, 1.0, 0.0)
} }
if math.Abs(float64(v.Z)) < min { if math.Abs(float64(v.Z)) < min {
cardinalAxis = rl.NewVector3(0.0, 0.0, 1.0) cardinalAxis = NewVector3(0.0, 0.0, 1.0)
} }
result = Vector3CrossProduct(v, cardinalAxis) result = Vector3CrossProduct(v, cardinalAxis)
@ -202,17 +199,17 @@ func Vector3Perpendicular(v rl.Vector3) rl.Vector3 {
} }
// Vector3Length - Calculate vector length // Vector3Length - Calculate vector length
func Vector3Length(v rl.Vector3) float32 { func Vector3Length(v Vector3) float32 {
return float32(math.Sqrt(float64(v.X*v.X + v.Y*v.Y + v.Z*v.Z))) return float32(math.Sqrt(float64(v.X*v.X + v.Y*v.Y + v.Z*v.Z)))
} }
// Vector3DotProduct - Calculate two vectors dot product // Vector3DotProduct - Calculate two vectors dot product
func Vector3DotProduct(v1, v2 rl.Vector3) float32 { func Vector3DotProduct(v1, v2 Vector3) float32 {
return v1.X*v2.X + v1.Y*v2.Y + v1.Z*v2.Z return v1.X*v2.X + v1.Y*v2.Y + v1.Z*v2.Z
} }
// Vector3Distance - Calculate distance between two vectors // Vector3Distance - Calculate distance between two vectors
func Vector3Distance(v1, v2 rl.Vector3) float32 { func Vector3Distance(v1, v2 Vector3) float32 {
dx := v2.X - v1.X dx := v2.X - v1.X
dy := v2.Y - v1.Y dy := v2.Y - v1.Y
dz := v2.Z - v1.Z dz := v2.Z - v1.Z
@ -221,17 +218,17 @@ func Vector3Distance(v1, v2 rl.Vector3) float32 {
} }
// Vector3Scale - Scale provided vector // Vector3Scale - Scale provided vector
func Vector3Scale(v rl.Vector3, scale float32) rl.Vector3 { func Vector3Scale(v Vector3, scale float32) Vector3 {
return rl.NewVector3(v.X*scale, v.Y*scale, v.Z*scale) return NewVector3(v.X*scale, v.Y*scale, v.Z*scale)
} }
// Vector3Negate - Negate provided vector (invert direction) // Vector3Negate - Negate provided vector (invert direction)
func Vector3Negate(v rl.Vector3) rl.Vector3 { func Vector3Negate(v Vector3) Vector3 {
return rl.NewVector3(-v.X, -v.Y, -v.Z) return NewVector3(-v.X, -v.Y, -v.Z)
} }
// Vector3Normalize - Normalize provided vector // Vector3Normalize - Normalize provided vector
func Vector3Normalize(v rl.Vector3) rl.Vector3 { func Vector3Normalize(v Vector3) Vector3 {
result := v result := v
var length, ilength float32 var length, ilength float32
@ -252,8 +249,8 @@ func Vector3Normalize(v rl.Vector3) rl.Vector3 {
} }
// Vector3Transform - Transforms a Vector3 by a given Matrix // Vector3Transform - Transforms a Vector3 by a given Matrix
func Vector3Transform(v rl.Vector3, mat rl.Matrix) rl.Vector3 { func Vector3Transform(v Vector3, mat Matrix) Vector3 {
result := rl.Vector3{} result := Vector3{}
x := v.X x := v.X
y := v.Y y := v.Y
@ -267,8 +264,8 @@ func Vector3Transform(v rl.Vector3, mat rl.Matrix) rl.Vector3 {
} }
// Vector3Lerp - Calculate linear interpolation between two vectors // Vector3Lerp - Calculate linear interpolation between two vectors
func Vector3Lerp(v1, v2 rl.Vector3, amount float32) rl.Vector3 { func Vector3Lerp(v1, v2 Vector3, amount float32) Vector3 {
result := rl.Vector3{} result := Vector3{}
result.X = v1.X + amount*(v2.X-v1.X) result.X = v1.X + amount*(v2.X-v1.X)
result.Y = v1.Y + amount*(v2.Y-v1.Y) result.Y = v1.Y + amount*(v2.Y-v1.Y)
@ -278,12 +275,12 @@ func Vector3Lerp(v1, v2 rl.Vector3, amount float32) rl.Vector3 {
} }
// Vector3Reflect - Calculate reflected vector to normal // Vector3Reflect - Calculate reflected vector to normal
func Vector3Reflect(vector, normal rl.Vector3) rl.Vector3 { func Vector3Reflect(vector, normal Vector3) Vector3 {
// I is the original vector // I is the original vector
// N is the normal of the incident plane // N is the normal of the incident plane
// R = I - (2*N*( DotProduct[ I,N] )) // R = I - (2*N*( DotProduct[ I,N] ))
result := rl.Vector3{} result := Vector3{}
dotProduct := Vector3DotProduct(vector, normal) dotProduct := Vector3DotProduct(vector, normal)
@ -295,8 +292,8 @@ func Vector3Reflect(vector, normal rl.Vector3) rl.Vector3 {
} }
// Vector3Min - Return min value for each pair of components // Vector3Min - Return min value for each pair of components
func Vector3Min(vec1, vec2 rl.Vector3) rl.Vector3 { func Vector3Min(vec1, vec2 Vector3) Vector3 {
result := rl.Vector3{} result := Vector3{}
result.X = float32(math.Min(float64(vec1.X), float64(vec2.X))) result.X = float32(math.Min(float64(vec1.X), float64(vec2.X)))
result.Y = float32(math.Min(float64(vec1.Y), float64(vec2.Y))) result.Y = float32(math.Min(float64(vec1.Y), float64(vec2.Y)))
@ -306,8 +303,8 @@ func Vector3Min(vec1, vec2 rl.Vector3) rl.Vector3 {
} }
// Vector3Max - Return max value for each pair of components // Vector3Max - Return max value for each pair of components
func Vector3Max(vec1, vec2 rl.Vector3) rl.Vector3 { func Vector3Max(vec1, vec2 Vector3) Vector3 {
result := rl.Vector3{} result := Vector3{}
result.X = float32(math.Max(float64(vec1.X), float64(vec2.X))) result.X = float32(math.Max(float64(vec1.X), float64(vec2.X)))
result.Y = float32(math.Max(float64(vec1.Y), float64(vec2.Y))) result.Y = float32(math.Max(float64(vec1.Y), float64(vec2.Y)))
@ -317,7 +314,7 @@ func Vector3Max(vec1, vec2 rl.Vector3) rl.Vector3 {
} }
// Vector3Barycenter - Barycenter coords for p in triangle abc // Vector3Barycenter - Barycenter coords for p in triangle abc
func Vector3Barycenter(p, a, b, c rl.Vector3) rl.Vector3 { func Vector3Barycenter(p, a, b, c Vector3) Vector3 {
v0 := Vector3Subtract(b, a) v0 := Vector3Subtract(b, a)
v1 := Vector3Subtract(c, a) v1 := Vector3Subtract(c, a)
v2 := Vector3Subtract(p, a) v2 := Vector3Subtract(p, a)
@ -329,7 +326,7 @@ func Vector3Barycenter(p, a, b, c rl.Vector3) rl.Vector3 {
denom := d00*d11 - d01*d01 denom := d00*d11 - d01*d01
result := rl.Vector3{} result := Vector3{}
result.Y = (d11*d20 - d01*d21) / denom result.Y = (d11*d20 - d01*d21) / denom
result.Z = (d00*d21 - d01*d20) / denom result.Z = (d00*d21 - d01*d20) / denom
@ -339,7 +336,7 @@ func Vector3Barycenter(p, a, b, c rl.Vector3) rl.Vector3 {
} }
// MatrixDeterminant - Compute matrix determinant // MatrixDeterminant - Compute matrix determinant
func MatrixDeterminant(mat rl.Matrix) float32 { func MatrixDeterminant(mat Matrix) float32 {
var result float32 var result float32
a00 := mat.M0 a00 := mat.M0
@ -370,13 +367,13 @@ func MatrixDeterminant(mat rl.Matrix) float32 {
} }
// MatrixTrace - Returns the trace of the matrix (sum of the values along the diagonal) // MatrixTrace - Returns the trace of the matrix (sum of the values along the diagonal)
func MatrixTrace(mat rl.Matrix) float32 { func MatrixTrace(mat Matrix) float32 {
return mat.M0 + mat.M5 + mat.M10 + mat.M15 return mat.M0 + mat.M5 + mat.M10 + mat.M15
} }
// MatrixTranspose - Transposes provided matrix // MatrixTranspose - Transposes provided matrix
func MatrixTranspose(mat rl.Matrix) rl.Matrix { func MatrixTranspose(mat Matrix) Matrix {
var result rl.Matrix var result Matrix
result.M0 = mat.M0 result.M0 = mat.M0
result.M1 = mat.M4 result.M1 = mat.M4
@ -399,8 +396,8 @@ func MatrixTranspose(mat rl.Matrix) rl.Matrix {
} }
// MatrixInvert - Invert provided matrix // MatrixInvert - Invert provided matrix
func MatrixInvert(mat rl.Matrix) rl.Matrix { func MatrixInvert(mat Matrix) Matrix {
var result rl.Matrix var result Matrix
a00 := mat.M0 a00 := mat.M0
a01 := mat.M1 a01 := mat.M1
@ -456,8 +453,8 @@ func MatrixInvert(mat rl.Matrix) rl.Matrix {
} }
// MatrixNormalize - Normalize provided matrix // MatrixNormalize - Normalize provided matrix
func MatrixNormalize(mat rl.Matrix) rl.Matrix { func MatrixNormalize(mat Matrix) Matrix {
var result rl.Matrix var result Matrix
det := MatrixDeterminant(mat) det := MatrixDeterminant(mat)
@ -482,8 +479,8 @@ func MatrixNormalize(mat rl.Matrix) rl.Matrix {
} }
// MatrixIdentity - Returns identity matrix // MatrixIdentity - Returns identity matrix
func MatrixIdentity() rl.Matrix { func MatrixIdentity() Matrix {
return rl.NewMatrix( return NewMatrix(
1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0,
@ -491,7 +488,7 @@ func MatrixIdentity() rl.Matrix {
} }
// MatrixAdd - Add two matrices // MatrixAdd - Add two matrices
func MatrixAdd(left, right rl.Matrix) rl.Matrix { func MatrixAdd(left, right Matrix) Matrix {
result := MatrixIdentity() result := MatrixIdentity()
result.M0 = left.M0 + right.M0 result.M0 = left.M0 + right.M0
@ -515,7 +512,7 @@ func MatrixAdd(left, right rl.Matrix) rl.Matrix {
} }
// MatrixSubtract - Subtract two matrices (left - right) // MatrixSubtract - Subtract two matrices (left - right)
func MatrixSubtract(left, right rl.Matrix) rl.Matrix { func MatrixSubtract(left, right Matrix) Matrix {
result := MatrixIdentity() result := MatrixIdentity()
result.M0 = left.M0 - right.M0 result.M0 = left.M0 - right.M0
@ -539,8 +536,8 @@ func MatrixSubtract(left, right rl.Matrix) rl.Matrix {
} }
// MatrixTranslate - Returns translation matrix // MatrixTranslate - Returns translation matrix
func MatrixTranslate(x, y, z float32) rl.Matrix { func MatrixTranslate(x, y, z float32) Matrix {
return rl.NewMatrix( return NewMatrix(
1.0, 0.0, 0.0, x, 1.0, 0.0, 0.0, x,
0.0, 1.0, 0.0, y, 0.0, 1.0, 0.0, y,
0.0, 0.0, 1.0, z, 0.0, 0.0, 1.0, z,
@ -548,8 +545,8 @@ func MatrixTranslate(x, y, z float32) rl.Matrix {
} }
// MatrixRotate - Returns rotation matrix for an angle around an specified axis (angle in radians) // MatrixRotate - Returns rotation matrix for an angle around an specified axis (angle in radians)
func MatrixRotate(axis rl.Vector3, angle float32) rl.Matrix { func MatrixRotate(axis Vector3, angle float32) Matrix {
var result rl.Matrix var result Matrix
mat := MatrixIdentity() mat := MatrixIdentity()
@ -617,7 +614,7 @@ func MatrixRotate(axis rl.Vector3, angle float32) rl.Matrix {
} }
// MatrixRotateX - Returns x-rotation matrix (angle in radians) // MatrixRotateX - Returns x-rotation matrix (angle in radians)
func MatrixRotateX(angle float32) rl.Matrix { func MatrixRotateX(angle float32) Matrix {
result := MatrixIdentity() result := MatrixIdentity()
cosres := float32(math.Cos(float64(angle))) cosres := float32(math.Cos(float64(angle)))
@ -632,7 +629,7 @@ func MatrixRotateX(angle float32) rl.Matrix {
} }
// MatrixRotateY - Returns y-rotation matrix (angle in radians) // MatrixRotateY - Returns y-rotation matrix (angle in radians)
func MatrixRotateY(angle float32) rl.Matrix { func MatrixRotateY(angle float32) Matrix {
result := MatrixIdentity() result := MatrixIdentity()
cosres := float32(math.Cos(float64(angle))) cosres := float32(math.Cos(float64(angle)))
@ -647,7 +644,7 @@ func MatrixRotateY(angle float32) rl.Matrix {
} }
// MatrixRotateZ - Returns z-rotation matrix (angle in radians) // MatrixRotateZ - Returns z-rotation matrix (angle in radians)
func MatrixRotateZ(angle float32) rl.Matrix { func MatrixRotateZ(angle float32) Matrix {
result := MatrixIdentity() result := MatrixIdentity()
cosres := float32(math.Cos(float64(angle))) cosres := float32(math.Cos(float64(angle)))
@ -662,8 +659,8 @@ func MatrixRotateZ(angle float32) rl.Matrix {
} }
// MatrixScale - Returns scaling matrix // MatrixScale - Returns scaling matrix
func MatrixScale(x, y, z float32) rl.Matrix { func MatrixScale(x, y, z float32) Matrix {
result := rl.NewMatrix( result := NewMatrix(
x, 0.0, 0.0, 0.0, x, 0.0, 0.0, 0.0,
0.0, y, 0.0, 0.0, 0.0, y, 0.0, 0.0,
0.0, 0.0, z, 0.0, 0.0, 0.0, z, 0.0,
@ -673,8 +670,8 @@ func MatrixScale(x, y, z float32) rl.Matrix {
} }
// MatrixMultiply - Returns two matrix multiplication // MatrixMultiply - Returns two matrix multiplication
func MatrixMultiply(left, right rl.Matrix) rl.Matrix { func MatrixMultiply(left, right Matrix) Matrix {
var result rl.Matrix var result Matrix
result.M0 = right.M0*left.M0 + right.M1*left.M4 + right.M2*left.M8 + right.M3*left.M12 result.M0 = right.M0*left.M0 + right.M1*left.M4 + right.M2*left.M8 + right.M3*left.M12
result.M1 = right.M0*left.M1 + right.M1*left.M5 + right.M2*left.M9 + right.M3*left.M13 result.M1 = right.M0*left.M1 + right.M1*left.M5 + right.M2*left.M9 + right.M3*left.M13
@ -697,8 +694,8 @@ func MatrixMultiply(left, right rl.Matrix) rl.Matrix {
} }
// MatrixFrustum - Returns perspective projection matrix // MatrixFrustum - Returns perspective projection matrix
func MatrixFrustum(left, right, bottom, top, near, far float32) rl.Matrix { func MatrixFrustum(left, right, bottom, top, near, far float32) Matrix {
var result rl.Matrix var result Matrix
rl := right - left rl := right - left
tb := top - bottom tb := top - bottom
@ -728,16 +725,16 @@ func MatrixFrustum(left, right, bottom, top, near, far float32) rl.Matrix {
} }
// MatrixPerspective - Returns perspective projection matrix // MatrixPerspective - Returns perspective projection matrix
func MatrixPerspective(fovy, aspect, near, far float32) rl.Matrix { func MatrixPerspective(fovy, aspect, near, far float32) Matrix {
top := near * float32(math.Tan(float64(fovy*rl.Pi)/360.0)) top := near * float32(math.Tan(float64(fovy*Pi)/360.0))
right := top * aspect right := top * aspect
return MatrixFrustum(-right, right, -top, top, near, far) return MatrixFrustum(-right, right, -top, top, near, far)
} }
// MatrixOrtho - Returns orthographic projection matrix // MatrixOrtho - Returns orthographic projection matrix
func MatrixOrtho(left, right, bottom, top, near, far float32) rl.Matrix { func MatrixOrtho(left, right, bottom, top, near, far float32) Matrix {
var result rl.Matrix var result Matrix
rl := right - left rl := right - left
tb := top - bottom tb := top - bottom
@ -764,8 +761,8 @@ func MatrixOrtho(left, right, bottom, top, near, far float32) rl.Matrix {
} }
// MatrixLookAt - Returns camera look-at matrix (view matrix) // MatrixLookAt - Returns camera look-at matrix (view matrix)
func MatrixLookAt(eye, target, up rl.Vector3) rl.Matrix { func MatrixLookAt(eye, target, up Vector3) Matrix {
var result rl.Matrix var result Matrix
z := Vector3Subtract(eye, target) z := Vector3Subtract(eye, target)
z = Vector3Normalize(z) z = Vector3Normalize(z)
@ -795,13 +792,13 @@ func MatrixLookAt(eye, target, up rl.Vector3) rl.Matrix {
} }
// QuaternionLength - Compute the length of a quaternion // QuaternionLength - Compute the length of a quaternion
func QuaternionLength(quat rl.Quaternion) float32 { func QuaternionLength(quat Quaternion) float32 {
return float32(math.Sqrt(float64(quat.X*quat.X + quat.Y*quat.Y + quat.Z*quat.Z + quat.W*quat.W))) return float32(math.Sqrt(float64(quat.X*quat.X + quat.Y*quat.Y + quat.Z*quat.Z + quat.W*quat.W)))
} }
// QuaternionNormalize - Normalize provided quaternion // QuaternionNormalize - Normalize provided quaternion
func QuaternionNormalize(q rl.Quaternion) rl.Quaternion { func QuaternionNormalize(q Quaternion) Quaternion {
var result rl.Quaternion var result Quaternion
var length, ilength float32 var length, ilength float32
@ -822,7 +819,7 @@ func QuaternionNormalize(q rl.Quaternion) rl.Quaternion {
} }
// QuaternionInvert - Invert provided quaternion // QuaternionInvert - Invert provided quaternion
func QuaternionInvert(quat rl.Quaternion) rl.Quaternion { func QuaternionInvert(quat Quaternion) Quaternion {
result := quat result := quat
length := QuaternionLength(quat) length := QuaternionLength(quat)
@ -841,8 +838,8 @@ func QuaternionInvert(quat rl.Quaternion) rl.Quaternion {
} }
// QuaternionMultiply - Calculate two quaternion multiplication // QuaternionMultiply - Calculate two quaternion multiplication
func QuaternionMultiply(q1, q2 rl.Quaternion) rl.Quaternion { func QuaternionMultiply(q1, q2 Quaternion) Quaternion {
var result rl.Quaternion var result Quaternion
qax := q1.X qax := q1.X
qay := q1.Y qay := q1.Y
@ -862,8 +859,8 @@ func QuaternionMultiply(q1, q2 rl.Quaternion) rl.Quaternion {
} }
// QuaternionSlerp - Calculates spherical linear interpolation between two quaternions // QuaternionSlerp - Calculates spherical linear interpolation between two quaternions
func QuaternionSlerp(q1, q2 rl.Quaternion, amount float32) rl.Quaternion { func QuaternionSlerp(q1, q2 Quaternion, amount float32) Quaternion {
var result rl.Quaternion var result Quaternion
cosHalfTheta := q1.X*q2.X + q1.Y*q2.Y + q1.Z*q2.Z + q1.W*q2.W cosHalfTheta := q1.X*q2.X + q1.Y*q2.Y + q1.Z*q2.Z + q1.W*q2.W
@ -893,8 +890,8 @@ func QuaternionSlerp(q1, q2 rl.Quaternion, amount float32) rl.Quaternion {
} }
// QuaternionFromMatrix - Returns a quaternion for a given rotation matrix // QuaternionFromMatrix - Returns a quaternion for a given rotation matrix
func QuaternionFromMatrix(matrix rl.Matrix) rl.Quaternion { func QuaternionFromMatrix(matrix Matrix) Quaternion {
var result rl.Quaternion var result Quaternion
trace := MatrixTrace(matrix) trace := MatrixTrace(matrix)
@ -942,8 +939,8 @@ func QuaternionFromMatrix(matrix rl.Matrix) rl.Quaternion {
} }
// QuaternionToMatrix - Returns a matrix for a given quaternion // QuaternionToMatrix - Returns a matrix for a given quaternion
func QuaternionToMatrix(q rl.Quaternion) rl.Matrix { func QuaternionToMatrix(q Quaternion) Matrix {
var result rl.Matrix var result Matrix
x := q.X x := q.X
y := q.Y y := q.Y
@ -987,8 +984,8 @@ func QuaternionToMatrix(q rl.Quaternion) rl.Matrix {
} }
// QuaternionFromAxisAngle - Returns rotation quaternion for an angle and axis // QuaternionFromAxisAngle - Returns rotation quaternion for an angle and axis
func QuaternionFromAxisAngle(axis rl.Vector3, angle float32) rl.Quaternion { func QuaternionFromAxisAngle(axis Vector3, angle float32) Quaternion {
result := rl.NewQuaternion(0.0, 0.0, 0.0, 1.0) result := NewQuaternion(0.0, 0.0, 0.0, 1.0)
if Vector3Length(axis) != 0.0 { if Vector3Length(axis) != 0.0 {
angle *= 0.5 angle *= 0.5
@ -1010,12 +1007,12 @@ func QuaternionFromAxisAngle(axis rl.Vector3, angle float32) rl.Quaternion {
} }
// QuaternionToAxisAngle - Returns the rotation angle and axis for a given quaternion // QuaternionToAxisAngle - Returns the rotation angle and axis for a given quaternion
func QuaternionToAxisAngle(q rl.Quaternion, outAxis *rl.Vector3, outAngle *float32) { func QuaternionToAxisAngle(q Quaternion, outAxis *Vector3, outAngle *float32) {
if math.Abs(float64(q.W)) > 1.0 { if math.Abs(float64(q.W)) > 1.0 {
q = QuaternionNormalize(q) q = QuaternionNormalize(q)
} }
resAxis := rl.NewVector3(0.0, 0.0, 0.0) resAxis := NewVector3(0.0, 0.0, 0.0)
resAngle := 2.0 * float32(math.Acos(float64(q.W))) resAngle := 2.0 * float32(math.Acos(float64(q.W)))
den := float32(math.Sqrt(float64(1.0 - q.W*q.W))) den := float32(math.Sqrt(float64(1.0 - q.W*q.W)))
@ -1035,8 +1032,8 @@ func QuaternionToAxisAngle(q rl.Quaternion, outAxis *rl.Vector3, outAngle *float
} }
// QuaternionTransform - Transform a quaternion given a transformation matrix // QuaternionTransform - Transform a quaternion given a transformation matrix
func QuaternionTransform(q rl.Quaternion, mat rl.Matrix) rl.Quaternion { func QuaternionTransform(q Quaternion, mat Matrix) Quaternion {
var result rl.Quaternion var result Quaternion
x := q.X x := q.X
y := q.Y y := q.Y

3
raymath/README.md
View file

@ -1,3 +0,0 @@
## raymath [![GoDoc](https://godoc.org/github.com/gen2brain/raylib-go/raymath?status.svg)](https://godoc.org/github.com/gen2brain/raylib-go/raymath)
Some useful functions to work with Vector2, Vector3, Matrix and Quaternions.