Enforce linalg

vendor/raylib/raylib.odin

@@ -86,7 +86,6 @@ import "core:fmt"
 import "core:mem"
 import "core:strings"
 
-USE_LINALG :: #config(RAYLIB_USE_LINALG, true)
 import "core:math/linalg"
 _ :: linalg
 
@@ -213,39 +212,19 @@ BLANK      :: Color{ 0, 0, 0, 0 }           // Blank (Transparent)
 MAGENTA    :: Color{ 255, 0, 255, 255 }     // Magenta
 RAYWHITE   :: Color{ 245, 245, 245, 255 }   // My own White (raylib logo)
 
+// Vector2 type
+Vector2 :: linalg.Vector2f32
+// Vector3 type
+Vector3 :: linalg.Vector3f32
+// Vector4 type
+Vector4 :: linalg.Vector4f32
 
-when USE_LINALG {
-	// Vector2 type
-	Vector2 :: linalg.Vector2f32
-	// Vector3 type
-	Vector3 :: linalg.Vector3f32
-	// Vector4 type
-	Vector4 :: linalg.Vector4f32
+// Quaternion type
+Quaternion :: linalg.Quaternionf32
 
-	// Quaternion type
-	Quaternion :: linalg.Quaternionf32
+// Matrix type (OpenGL style 4x4 - right handed, stored column major)
+Matrix :: linalg.Matrix4x4f32
 
-	// Matrix type (OpenGL style 4x4 - right handed, column major)
-	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)
 //

vendor/raylib/raymath.odin

@@ -85,33 +85,33 @@ Vector2SubtractValue :: proc "c" (v: Vector2, value: f32) -> Vector2 {
 	return v - value
 }
 // Calculate vector length
-@(require_results, deprecated="Prefer linalg.length(v)")
+@(require_results)
 Vector2Length :: proc "c" (v: Vector2) -> f32 {
 	return linalg.length(v)
 }
 // Calculate vector square length
-@(require_results, deprecated="Prefer linalg.length2(v)")
+@(require_results)
 Vector2LengthSqr :: proc "c" (v: Vector2) -> f32 {
 	return linalg.length2(v)
 }
 // Calculate two vectors dot product
-@(require_results, deprecated="Prefer linalg.dot(v1, v2)")
+@(require_results)
 Vector2DotProduct :: proc "c" (v1, v2: Vector2) -> f32 {
 	return linalg.dot(v1, v2)
 }
 // Calculate distance between two vectors
-@(require_results, deprecated="Prefer linalg.distance(v1, v2)")
+@(require_results)
 Vector2Distance :: proc "c" (v1, v2: Vector2) -> f32 {
 	return linalg.distance(v1, v2)
 }
 // Calculate square distance between two vectors
-@(require_results, deprecated="Prefer linalg.length2(v2-v1)")
+@(require_results)
 Vector2DistanceSqrt :: proc "c" (v1, v2: Vector2) -> f32 {
 	return linalg.length2(v2-v1)
 }
 // Calculate angle between two vectors
 // 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 {
 	return linalg.angle_between(v1, v2)
 }
@@ -146,7 +146,7 @@ Vector2Divide :: proc "c" (v1, v2: Vector2) -> Vector2 {
 	return v1 / v2
 }
 // Normalize provided vector
-@(require_results, deprecated="Prefer linalg.normalize0(v)")
+@(require_results)
 Vector2Normalize :: proc "c" (v: Vector2) -> Vector2 {
 	return linalg.normalize0(v)
 }
@@ -270,38 +270,38 @@ Vector3SubtractValue :: proc "c" (v: Vector3, value: f32) -> Vector3 {
 	return v - value
 }
 // Calculate vector length
-@(require_results, deprecated="Prefer linalg.length(v)")
+@(require_results)
 Vector3Length :: proc "c" (v: Vector3) -> f32 {
 	return linalg.length(v)
 }
 // Calculate vector square length
-@(require_results, deprecated="Prefer linalg.length2(v)")
+@(require_results)
 Vector3LengthSqr :: proc "c" (v: Vector3) -> f32 {
 	return linalg.length2(v)
 }
 // Calculate two vectors dot product
-@(require_results, deprecated="Prefer linalg.dot(v1, v2)")
+@(require_results)
 Vector3DotProduct :: proc "c" (v1, v2: Vector3) -> f32 {
 	return linalg.dot(v1, v2)
 }
 // Calculate two vectors dot product
-@(require_results, deprecated="Prefer linalg.cross(v1, v2)")
+@(require_results)
 Vector3CrossProduct :: proc "c" (v1, v2: Vector3) -> Vector3 {
 	return linalg.cross(v1, v2)
 }
 // Calculate distance between two vectors
-@(require_results, deprecated="Prefer linalg.distance(v1, v2)")
+@(require_results)
 Vector3Distance :: proc "c" (v1, v2: Vector3) -> f32 {
 	return linalg.distance(v1, v2)
 }
 // Calculate square distance between two vectors
-@(require_results, deprecated="Prefer linalg.length2(v2-v1)")
+@(require_results)
 Vector3DistanceSqrt :: proc "c" (v1, v2: Vector3) -> f32 {
 	return linalg.length2(v2-v1)
 }
 // Calculate angle between two vectors
 // 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 {
 	return linalg.angle_between(v1, v2)
 }
@@ -336,7 +336,7 @@ Vector3Divide :: proc "c" (v1, v2: Vector3) -> Vector3 {
 	return v1 / v2
 }
 // Normalize provided vector
-@(require_results, deprecated="Prefer linalg.normalize0(v)")
+@(require_results)
 Vector3Normalize :: proc "c" (v: Vector3) -> Vector3 {
 	return linalg.normalize0(v)
 }
@@ -364,7 +364,7 @@ Vector3OrthoNormalize :: proc "c" (v1, v2: ^Vector3) {
 }
 
 // Transform a vector by quaternion rotation
-@(require_results, deprecated="Prefer linalg.mul(q, v")
+@(require_results)
 Vector3RotateByQuaternion :: proc "c" (v: Vector3, q: Quaternion) -> Vector3 {
 	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 {
 	return linalg.min(v1, v2)
 }
 
-@(require_results, deprecated="Prefer linalg.max(v1, v2)")
+@(require_results)
 Vector3Max :: proc "c" (v1, v2: Vector3) -> Vector3 {
 	return linalg.max(v1, v2)
 }
@@ -539,25 +539,25 @@ Vector3Unproject :: proc "c" (source: Vector3, projection: Matrix, view: Matrix)
 //----------------------------------------------------------------------------------
 
 // Compute matrix determinant
-@(require_results, deprecated="Prefer linalg.determinant(mat)")
+@(require_results)
 MatrixDeterminant :: proc "c" (mat: Matrix) -> f32 {
 	return linalg.determinant(mat)
 }
 
 // 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 {
 	return linalg.trace(mat)
 }
 
 // Transposes provided matrix
-@(require_results, deprecated="Prefer linalg.transpose(mat)")
+@(require_results)
 MatrixTranspose :: proc "c" (mat: Matrix) -> Matrix {
 	return linalg.transpose(mat)
 }
 
 // Invert provided matrix
-@(require_results, deprecated="Prefer linalg.inverse(mat)")
+@(require_results)
 MatrixInvert :: proc "c" (mat: Matrix) -> Matrix {
 	return linalg.inverse(mat)
 }
@@ -704,7 +704,7 @@ QuaternionLength :: proc "c" (q: Quaternion) -> f32 {
 	return abs(q)
 }
 // Normalize provided quaternion
-@(require_results, deprecated="Prefer linalg.normalize0(q)")
+@(require_results)
 QuaternionNormalize :: proc "c" (q: Quaternion) -> Quaternion {
 	return linalg.normalize0(q)
 }