ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-07 16:18:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Enforce linalg

Browse Source
This commit is contained in:
gingerBill
2024-03-08 13:28:15 +00:00
parent 032e193d0d
commit 51d12acab3
2 changed files with 33 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/raylib/raylib.odin
Vendored
+1 -22
View File
@@ -86,7 +86,6 @@ import "core:fmt"
import "core:mem" import "core:mem"
import "core:strings" import "core:strings"
USE_LINALG :: #config(RAYLIB_USE_LINALG, true)
import "core:math/linalg" import "core:math/linalg"
_ :: linalg _ :: linalg
@@ -213,8 +212,6 @@ BLANK :: Color{ 0, 0, 0, 0 } // Blank (Transparent)
MAGENTA :: Color{ 255, 0, 255, 255 } // Magenta MAGENTA :: Color{ 255, 0, 255, 255 } // Magenta
RAYWHITE :: Color{ 245, 245, 245, 255 } // My own White (raylib logo) RAYWHITE :: Color{ 245, 245, 245, 255 } // My own White (raylib logo)
when USE_LINALG {
// Vector2 type // Vector2 type
Vector2 :: linalg.Vector2f32 Vector2 :: linalg.Vector2f32
// Vector3 type // Vector3 type
@@ -225,27 +222,9 @@ when USE_LINALG {
// Quaternion type // Quaternion type
Quaternion :: linalg.Quaternionf32 Quaternion :: linalg.Quaternionf32
// Matrix type (OpenGL style 4x4 - right handed, column major) // Matrix type (OpenGL style 4x4 - right handed, stored column major)
Matrix :: linalg.Matrix4x4f32 Matrix :: linalg.Matrix4x4f32
} else {
// Vector2 type
Vector2 :: distinct [2]f32
// Vector3 type
Vector3 :: distinct [3]f32
// Vector4 type
Vector4 :: distinct [4]f32
// Quaternion type
Quaternion :: distinct quaternion128
// Matrix, 4x4 components, column major, OpenGL style, right handed
Matrix :: struct {
m0, m4, m8, m12: f32, // Matrix first row (4 components)
m1, m5, m9, m13: f32, // Matrix second row (4 components)
m2, m6, m10, m14: f32, // Matrix third row (4 components)
m3, m7, m11, m15: f32, // Matrix fourth row (4 components)
}
}
// Color, 4 components, R8G8B8A8 (32bit) // Color, 4 components, R8G8B8A8 (32bit)
// //
vendor/raylib/raymath.odin
Vendored
+23 -23
View File
@@ -85,33 +85,33 @@ Vector2SubtractValue :: proc "c" (v: Vector2, value: f32) -> Vector2 {
return v - value return v - value
} }
// Calculate vector length // Calculate vector length
@(require_results, deprecated="Prefer linalg.length(v)") @(require_results)
Vector2Length :: proc "c" (v: Vector2) -> f32 { Vector2Length :: proc "c" (v: Vector2) -> f32 {
return linalg.length(v) return linalg.length(v)
} }
// Calculate vector square length // Calculate vector square length
@(require_results, deprecated="Prefer linalg.length2(v)") @(require_results)
Vector2LengthSqr :: proc "c" (v: Vector2) -> f32 { Vector2LengthSqr :: proc "c" (v: Vector2) -> f32 {
return linalg.length2(v) return linalg.length2(v)
} }
// Calculate two vectors dot product // Calculate two vectors dot product
@(require_results, deprecated="Prefer linalg.dot(v1, v2)") @(require_results)
Vector2DotProduct :: proc "c" (v1, v2: Vector2) -> f32 { Vector2DotProduct :: proc "c" (v1, v2: Vector2) -> f32 {
return linalg.dot(v1, v2) return linalg.dot(v1, v2)
} }
// Calculate distance between two vectors // Calculate distance between two vectors
@(require_results, deprecated="Prefer linalg.distance(v1, v2)") @(require_results)
Vector2Distance :: proc "c" (v1, v2: Vector2) -> f32 { Vector2Distance :: proc "c" (v1, v2: Vector2) -> f32 {
return linalg.distance(v1, v2) return linalg.distance(v1, v2)
} }
// Calculate square distance between two vectors // Calculate square distance between two vectors
@(require_results, deprecated="Prefer linalg.length2(v2-v1)") @(require_results)
Vector2DistanceSqrt :: proc "c" (v1, v2: Vector2) -> f32 { Vector2DistanceSqrt :: proc "c" (v1, v2: Vector2) -> f32 {
return linalg.length2(v2-v1) return linalg.length2(v2-v1)
} }
// Calculate angle between two vectors // Calculate angle between two vectors
// NOTE: Angle is calculated from origin point (0, 0) // NOTE: Angle is calculated from origin point (0, 0)
@(require_results, deprecated="Prefer linalg.angle_between(v1, v2)") @(require_results)
Vector2Angle :: proc "c" (v1, v2: Vector2) -> f32 { Vector2Angle :: proc "c" (v1, v2: Vector2) -> f32 {
return linalg.angle_between(v1, v2) return linalg.angle_between(v1, v2)
} }
@@ -146,7 +146,7 @@ Vector2Divide :: proc "c" (v1, v2: Vector2) -> Vector2 {
return v1 / v2 return v1 / v2
} }
// Normalize provided vector // Normalize provided vector
@(require_results, deprecated="Prefer linalg.normalize0(v)") @(require_results)
Vector2Normalize :: proc "c" (v: Vector2) -> Vector2 { Vector2Normalize :: proc "c" (v: Vector2) -> Vector2 {
return linalg.normalize0(v) return linalg.normalize0(v)
} }
@@ -270,38 +270,38 @@ Vector3SubtractValue :: proc "c" (v: Vector3, value: f32) -> Vector3 {
return v - value return v - value
} }
// Calculate vector length // Calculate vector length
@(require_results, deprecated="Prefer linalg.length(v)") @(require_results)
Vector3Length :: proc "c" (v: Vector3) -> f32 { Vector3Length :: proc "c" (v: Vector3) -> f32 {
return linalg.length(v) return linalg.length(v)
} }
// Calculate vector square length // Calculate vector square length
@(require_results, deprecated="Prefer linalg.length2(v)") @(require_results)
Vector3LengthSqr :: proc "c" (v: Vector3) -> f32 { Vector3LengthSqr :: proc "c" (v: Vector3) -> f32 {
return linalg.length2(v) return linalg.length2(v)
} }
// Calculate two vectors dot product // Calculate two vectors dot product
@(require_results, deprecated="Prefer linalg.dot(v1, v2)") @(require_results)
Vector3DotProduct :: proc "c" (v1, v2: Vector3) -> f32 { Vector3DotProduct :: proc "c" (v1, v2: Vector3) -> f32 {
return linalg.dot(v1, v2) return linalg.dot(v1, v2)
} }
// Calculate two vectors dot product // Calculate two vectors dot product
@(require_results, deprecated="Prefer linalg.cross(v1, v2)") @(require_results)
Vector3CrossProduct :: proc "c" (v1, v2: Vector3) -> Vector3 { Vector3CrossProduct :: proc "c" (v1, v2: Vector3) -> Vector3 {
return linalg.cross(v1, v2) return linalg.cross(v1, v2)
} }
// Calculate distance between two vectors // Calculate distance between two vectors
@(require_results, deprecated="Prefer linalg.distance(v1, v2)") @(require_results)
Vector3Distance :: proc "c" (v1, v2: Vector3) -> f32 { Vector3Distance :: proc "c" (v1, v2: Vector3) -> f32 {
return linalg.distance(v1, v2) return linalg.distance(v1, v2)
} }
// Calculate square distance between two vectors // Calculate square distance between two vectors
@(require_results, deprecated="Prefer linalg.length2(v2-v1)") @(require_results)
Vector3DistanceSqrt :: proc "c" (v1, v2: Vector3) -> f32 { Vector3DistanceSqrt :: proc "c" (v1, v2: Vector3) -> f32 {
return linalg.length2(v2-v1) return linalg.length2(v2-v1)
} }
// Calculate angle between two vectors // Calculate angle between two vectors
// NOTE: Angle is calculated from origin point (0, 0) // NOTE: Angle is calculated from origin point (0, 0)
@(require_results, deprecated="Prefer linalg.angle_between(v1, v2)") @(require_results)
Vector3Angle :: proc "c" (v1, v2: Vector3) -> f32 { Vector3Angle :: proc "c" (v1, v2: Vector3) -> f32 {
return linalg.angle_between(v1, v2) return linalg.angle_between(v1, v2)
} }
@@ -336,7 +336,7 @@ Vector3Divide :: proc "c" (v1, v2: Vector3) -> Vector3 {
return v1 / v2 return v1 / v2
} }
// Normalize provided vector // Normalize provided vector
@(require_results, deprecated="Prefer linalg.normalize0(v)") @(require_results)
Vector3Normalize :: proc "c" (v: Vector3) -> Vector3 { Vector3Normalize :: proc "c" (v: Vector3) -> Vector3 {
return linalg.normalize0(v) return linalg.normalize0(v)
} }
@@ -364,7 +364,7 @@ Vector3OrthoNormalize :: proc "c" (v1, v2: ^Vector3) {
} }
// Transform a vector by quaternion rotation // Transform a vector by quaternion rotation
@(require_results, deprecated="Prefer linalg.mul(q, v") @(require_results)
Vector3RotateByQuaternion :: proc "c" (v: Vector3, q: Quaternion) -> Vector3 { Vector3RotateByQuaternion :: proc "c" (v: Vector3, q: Quaternion) -> Vector3 {
return linalg.mul(q, v) return linalg.mul(q, v)
} }
@@ -480,12 +480,12 @@ Vector3Equals :: proc "c" (p, q: Vector3) -> bool {
} }
@(require_results, deprecated="Prefer linalg.min(v1, v2)") @(require_results)
Vector3Min :: proc "c" (v1, v2: Vector3) -> Vector3 { Vector3Min :: proc "c" (v1, v2: Vector3) -> Vector3 {
return linalg.min(v1, v2) return linalg.min(v1, v2)
} }
@(require_results, deprecated="Prefer linalg.max(v1, v2)") @(require_results)
Vector3Max :: proc "c" (v1, v2: Vector3) -> Vector3 { Vector3Max :: proc "c" (v1, v2: Vector3) -> Vector3 {
return linalg.max(v1, v2) return linalg.max(v1, v2)
} }
@@ -539,25 +539,25 @@ Vector3Unproject :: proc "c" (source: Vector3, projection: Matrix, view: Matrix)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Compute matrix determinant // Compute matrix determinant
@(require_results, deprecated="Prefer linalg.determinant(mat)") @(require_results)
MatrixDeterminant :: proc "c" (mat: Matrix) -> f32 { MatrixDeterminant :: proc "c" (mat: Matrix) -> f32 {
return linalg.determinant(mat) return linalg.determinant(mat)
} }
// Get the trace of the matrix (sum of the values along the diagonal) // Get the trace of the matrix (sum of the values along the diagonal)
@(require_results, deprecated="Prefer linalg.trace(mat)") @(require_results)
MatrixTrace :: proc "c" (mat: Matrix) -> f32 { MatrixTrace :: proc "c" (mat: Matrix) -> f32 {
return linalg.trace(mat) return linalg.trace(mat)
} }
// Transposes provided matrix // Transposes provided matrix
@(require_results, deprecated="Prefer linalg.transpose(mat)") @(require_results)
MatrixTranspose :: proc "c" (mat: Matrix) -> Matrix { MatrixTranspose :: proc "c" (mat: Matrix) -> Matrix {
return linalg.transpose(mat) return linalg.transpose(mat)
} }
// Invert provided matrix // Invert provided matrix
@(require_results, deprecated="Prefer linalg.inverse(mat)") @(require_results)
MatrixInvert :: proc "c" (mat: Matrix) -> Matrix { MatrixInvert :: proc "c" (mat: Matrix) -> Matrix {
return linalg.inverse(mat) return linalg.inverse(mat)
} }
@@ -704,7 +704,7 @@ QuaternionLength :: proc "c" (q: Quaternion) -> f32 {
return abs(q) return abs(q)
} }
// Normalize provided quaternion // Normalize provided quaternion
@(require_results, deprecated="Prefer linalg.normalize0(q)") @(require_results)
QuaternionNormalize :: proc "c" (q: Quaternion) -> Quaternion { QuaternionNormalize :: proc "c" (q: Quaternion) -> Quaternion {
return linalg.normalize0(q) return linalg.normalize0(q)
} }