(index ("print-mat4" 0) ("copy-mat4" 141) ("m*" 768) ("m*s" 1417) ("m+" 2038) ("m-" 2684) ("mat4-identity" 3335) ("translation" 3762) ("translate" 4223) ("x-rotation" 4347) ("rotate-x" 4841) ("y-rotation" 4984) ("rotate-y" 5478) ("z-rotation" 5621) ("rotate-z" 6115) ("axis-angle-rotation" 6258) ("rotate-axis-angle" 6791) ("quaternion-rotation" 6973) ("rotate-quaternion" 7452) ("ypr-rotation" 7594) ("rotate-ypr" 8206) ("2d-scaling" 8469) ("scale-2d" 8979) ("3d-scaling" 9150) ("scale-3d" 9692) ("scaling" 9896) ("scale" 10368) ("flip-x" 10502) ("flip-y" 10613) ("flip-z" 10724) ("translate-rotate-scale-2d" 10835) ("transpose" 11512) ("inverse" 12111) ("fast-inverse-transpose" 12703) ("ortho" 13509) ("ortho-viewport" 14042) ("perspective" 14890) ("frustum" 15489) ("frustum-viewport" 16194) ("look-at" 17058) ("camera-inverse" 17727) ("make-point" 18693) ("point-x" 18693) ("point-y" 18693) ("point-z" 18693) ("point-x-set!" 18693) ("point-y-set!" 18693) ("point-z-set!" 18693) ("v+" 19282) ("v-" 19824) ("v*" 20369) ("cross-product" 20924) ("dot-product" 21502) ("vector-magnitude" 21658) ("normalize!" 21779) ("m*vector!" 21892) ("m*vector-array!" 22029) ("lerp" 22719) ("make-quaternion" 23338) ("quaternion-x" 23338) ("quaternion-y" 23338) ("quaternion-z" 23338) ("quaternion-w" 23338) ("quaternion-x-set!" 23338) ("quaternion-y-set!" 23338) ("quaternion-z-set!" 23338) ("quaternion-w-set!" 23338) ("quaternion-normalize!" 24129) ("quaternion-inverse" 24268) ("quaternion-cross-product" 24824) ("quaternion-axis-angle-rotation" 25413) ("quaternion-rotate-axis-angle" 26059) ("quaternion-x-rotation" 26282) ("quaternion-rotate-x" 26889) ("quaternion-y-rotation" 27073) ("quaternion-rotate-y" 27680) ("quaternion-z-rotation" 27864) ("quaternion-rotate-z" 28471) ("quaternion-ypr-rotation" 28655) ("quaternion-rotate-ypr" 29382) ("quaternion-rotate-point!" 29672) ("slerp" 29847) ("degrees->radians" 30487) ("radians->degrees" 30618) ("pi" 30749) ("pi/2" 30749))
(def (sig (procedure " (print-mat4 MATRIX)" (id print-mat4))) (p "Prints the given " (tt "MATRIX") " to " (tt "(current-output-port)") "."))
(def (sig (procedure " (copy-mat4 MATRIX [RESULT])" (id copy-mat4))) (p "Make a copy of " (tt "MATRIX") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the contents of " (tt "MATRIX") ". If " (tt "RESULT") " is " (tt "#t") ", " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (m* A B [RESULT])" (id m*))) (p "Multiply matrix " (tt "A") " by matrix " (tt "B") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the results of the multiplication. If " (tt "RESULT") " is " (tt "#t") ", " (tt "A") " and " (tt "B") " must be f32vectors and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "A") " and " (tt "B") " must be f32vectors and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (m*s A S [RESULT])" (id m*s))) (p "Multiply matrix " (tt "A") " by scalar " (tt "S") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the results of the multiplication. If " (tt "RESULT") " is " (tt "#t") ", " (tt "A") " must be an f32vector and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "A") " must be an f32vector and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (m+ A B [RESULT])" (id m+))) (p "Add matrix " (tt "A") " with matrix " (tt "B") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the results of the multiplication. If " (tt "RESULT") " is " (tt "#t") ", " (tt "A") " and " (tt "B") " must be f32vectors and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "A") " and " (tt "B") " must be f32vectors and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (m- A B [RESULT])" (id m-))) (p "Subtract matrix " (tt "B") " from matrix " (tt "A") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the results of the multiplication. If " (tt "RESULT") " is " (tt "#t") ", " (tt "A") " and " (tt "B") " must be f32vectors and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "A") " and " (tt "B") " must be f32vectors and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (mat4-identity [RESULT])" (id mat4-identity))) (p "Return an identity matrix. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (translation VECTOR [RESULT])" (id translation))) (p "Return the translation matrix given by " (tt "VECTOR") ". If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (translate VECTOR MATRIX)" (id translate))) (p "Translate " (tt "MATRIX") " by " (tt "VECTOR") "."))
(def (sig (procedure " (x-rotation ANGLE [RESULT])" (id x-rotation))) (p "Return the rotation matrix given by a rotation of " (tt "ANGLE") " radians around the x-axis. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (rotate-x ANGLE MATRIX)" (id rotate-x))) (p "Rotate " (tt "MATRIX") " around the x-axis by " (tt "ANGLE") " radians."))
(def (sig (procedure " (y-rotation ANGLE [RESULT])" (id y-rotation))) (p "Return the rotation matrix given by a rotation of " (tt "ANGLE") " radians around the y-axis. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (rotate-y ANGLE MATRIX)" (id rotate-y))) (p "Rotate " (tt "MATRIX") " around the y-axis by " (tt "ANGLE") " radians."))
(def (sig (procedure " (z-rotation ANGLE [RESULT])" (id z-rotation))) (p "Return the rotation matrix given by a rotation of " (tt "ANGLE") " radians around the z-axis. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (rotate-z ANGLE MATRIX)" (id rotate-z))) (p "Rotate " (tt "MATRIX") " around the z-axis by " (tt "ANGLE") " radians."))
(def (sig (procedure " (axis-angle-rotation AXIS ANGLE [RESULT])" (id axis-angle-rotation))) (p "Return the rotation matrix given by a rotation of " (tt "ANGLE") " radians around the vector " (tt "AXIS") ". If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (rotate-axis-angle AXIS ANGLE MATRIX)" (id rotate-axis-angle))) (p "Rotate " (tt "MATRIX") " around the vector " (tt "AXIS") " by " (tt "ANGLE") " radians."))
(def (sig (procedure " (quaternion-rotation Q [RESULT])" (id quaternion-rotation))) (p "Return the rotation matrix given by the quaternion " (tt "Q") ". If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (rotate-quaternion Q MATRIX)" (id rotate-quaternion))) (p "Rotate " (tt "MATRIX") " by the quaternion " (tt "Q") "."))
(def (sig (procedure " (ypr-rotation YAW PITCH ROLL [RESULT])" (id ypr-rotation))) (p "Return the rotation matrix given by rotating by " (tt "ROLL") " radians around the z-axis followed by " (tt "PITCH") " radians around the x-axis followed by " (tt "YAW") " radians around the y-axis. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (rotate-ypr YAW PITCH ROLL MATRIX)" (id rotate-ypr))) (p "Rotate " (tt "MATRIX") " by " (tt "ROLL") " radians around the z-axis followed by " (tt "PITCH") " radians around the x-axis followed by " (tt "YAW") " radians around the y-axis."))
(def (sig (procedure " (2d-scaling SCALE-X SCALE-Y [RESULT])" (id 2d-scaling))) (p "Return the matrix created by scaling the x and y axes by " (tt "SCALE-X") " and " (tt "SCALE-Y") ". If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (scale-2d SCALE-X SCALE-Y MATRIX)" (id scale-2d))) (p "Scale the x and y axis of " (tt "MATRIX") " by " (tt "SCALE-X") " and " (tt "SCALE-Y") "."))
(def (sig (procedure " (3d-scaling SCALE-X SCALE-Y SCALE-Z [RESULT])" (id 3d-scaling))) (p "Return the matrix created by scaling the x, y and z axes by " (tt "SCALE-X") ", " (tt "SCALE-Y") ", and " (tt "SCALE-Z") ". If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (scale-3d SCALE-X SCALE-Y SCALE-Z MATRIX)" (id scale-3d))) (p "Scale the x, y, and z axis of " (tt "MATRIX") " by " (tt "SCALE-X") ", " (tt "SCALE-Y") ", and " (tt "SCALE-Z") "."))
(def (sig (procedure " (scaling SCALE [RESULT])" (id scaling))) (p "Return the matrix created by scaling the x, y and z axes by " (tt "SCALE") ". If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (scale SCALE MATRIX)" (id scale))) (p "Scale the x, y, and z axis of " (tt "MATRIX") " by " (tt "SCALE") "."))
(def (sig (procedure " (flip-x MATRIX)" (id flip-x))) (p "Flip (mirror) " (tt "MATRIX") " along the x-axis."))
(def (sig (procedure " (flip-y MATRIX)" (id flip-y))) (p "Flip (mirror) " (tt "MATRIX") " along the y-axis."))
(def (sig (procedure " (flip-z MATRIX)" (id flip-z))) (p "Flip (mirror) " (tt "MATRIX") " along the z-axis."))
(def (sig (procedure " (translate-rotate-scale-2d VECTOR ANGLE SCALE [RESULT])" (id translate-rotate-scale-2d))) (p "Efficiently create a matrix translated by " (tt "VECTOR") ", rotated around the z-axis by " (tt "ANGLE") " radians, then scaled by " (tt "SCALE") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (transpose MATRIX [RESULT])" (id transpose))) (p "Transpose " (tt "MATRIX") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (inverse MATRIX [RESULT])" (id inverse))) (p "Invert " (tt "MATRIX") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (fast-inverse-transpose MATRIX [RESULT])" (id fast-inverse-transpose))) (p "Efficiently inverse the transpose the unscaled " (tt "MATRIX") ". If " (tt "MATRIX") " has been scaled, this will produce incorrect results: " (tt "inverse") " then " (tt "transpose") " should be used instead. If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "MATRIX") " must be an f32vector and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (ortho WIDTH HEIGHT NEAR FAR [RESULT])" (id ortho))) (p "Create an orthographic projection matrix. If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (ortho-viewport LEFT RIGHT NEAR FAR VIEWPORT-LEFT VIEWPORT-RIGHT VIEWPORT-BOTTOM VIEWPORT-TOP [RESULT])" (id ortho-viewport))) (p "Create an orthographic projection matrix mapping the " (tt "LEFT") ", " (tt "RIGHT") ", " (tt "TOP") ", " (tt "BOTTOM") ", " (tt "NEAR") ", " (tt "FAR") " cube to a viewport of " (tt "VIEWPORT-LEFT") ", " (tt "VIEWPORT-RIGHT") ", " (tt "VIEWPORT-TOP") ", " (tt "VIEWPORT-BOTTOM") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (perspective WIDTH HEIGHT NEAR FAR ANGLE [RESULT])" (id perspective))) (p "Create an perspective projection matrix with a field of view of " (tt "ANGLE") " degrees. If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (frustum LEFT RIGHT BOTTOM TOP NEAR FAR [RESULT])" (id frustum))) (p "Create a perspective projection matrix defined by a frustum with a near side of " (tt "LEFT") ", " (tt "RIGHT") ", " (tt "TOP") ", " (tt "BOTTOM") ", " (tt "NEAR") ", and a far side at " (tt "FAR") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (frustum-viewport LEFT RIGHT BOTTOM TOP NEAR FAR VIEWPORT-LEFT VIEWPORT-RIGHT VIEWPORT-BOTTOM VIEWPORT-TOP [RESULT])" (id frustum-viewport))) (p "Create a perspective projection matrix mapping the " (tt "LEFT") ", " (tt "RIGHT") ", " (tt "TOP") ", " (tt "BOTTOM") ", " (tt "NEAR") ", " (tt "FAR") " frustum to a viewport of " (tt "VIEWPORT-LEFT") ", " (tt "VIEWPORT-RIGHT") ", " (tt "VIEWPORT-BOTTOM") ", " (tt "VIEWPORT-TOP") ". If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (look-at EYE OBJ UP [RESULT])" (id look-at))) (p "Create a “look-at” style camera matrix. The camera is positioned at point " (tt "EYE") ", pointing towards the point " (tt "OBJ") ". " (tt "UP") " defines the camera’s up vector. If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (camera-inverse CAMERA [RESULT])" (id camera-inverse))) (p "Invert " (tt "CAMERA") " in an efficient fashion. This allows the camera to be constructed in an intuitive fashion by translating and rotating before inverting in order to position the scene properly. This function is far faster than the general " (tt "inverse") " function, but the matrix " (tt "CAMERA") " must only be a matrix representing a translation and a rotation (no scaling). If the matrix " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") ", " (tt "CAMERA") " must be an f32vector and the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, " (tt "CAMERA") " must be an f32vector and the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (make-point X Y Z [NON-GC?])" (id make-point)) (procedure " (point-x POINT)" (id point-x)) (procedure " (point-y POINT)" (id point-y)) (procedure " (point-z POINT)" (id point-z)) (procedure " (point-x-set! POINT)" (id point-x-set!)) (procedure " (point-y-set! POINT)" (id point-y-set!)) (procedure " (point-z-set! POINT)" (id point-z-set!))) (p "Vector constructor, getters, and setters. If " (tt "NON-GC?") " is " (tt "#t") ", the point is created in a non-garbage-collected area (the memory will still be freed when there are no more references to the vector)."))
(def (sig (procedure " (v+ A B [RESULT])" (id v+))) (p "Return the result of the addition of vectors " (tt "A") " and " (tt "B") ". If the vector " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (v- A B [RESULT])" (id v-))) (p "Return the result of the subtraction of vector " (tt "B") " from " (tt "A") ". If the vector " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (v* V S [RESULT])" (id v*))) (p "Return the result of the multiplication of vector " (tt "A") " with scalar " (tt "S") ". If the vector " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (cross-product A B [RESULT])" (id cross-product))) (p "Return the result of the cross product between the vectors " (tt "A") " and " (tt "B") ". If the vector " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (dot-product A B)" (id dot-product))) (p "Return the result of the dot product between the vectors " (tt "A") " and " (tt "B") "."))
(def (sig (procedure " (vector-magnitude V)" (id vector-magnitude))) (p "Return the magnitude of vector " (tt "V") "."))
(def (sig (procedure " (normalize! V)" (id normalize!))) (p "Destructively normalize the vector " (tt "V") "."))
(def (sig (procedure " (m*vector! MATRIX VECTOR)" (id m*vector!))) (p "Destructively multiply " (tt "VECTOR") " by " (tt "MATRIX") "."))
(def (sig (procedure " (m*vector-array! MATRIX VECTORS stride: [STRIDE] length: [LENGTH])" (id m*vector-array!))) (p "Destructively multiply the array of 3 element floats " (tt "VECTORS") " by " (tt "MATRIX") ". " (tt "VECTORS") " may be given as an f32vector, a u8vector or a pointer. The keyword " (tt "STRIDE") " specifies the number of elements between consecutive vectors, given in number of floats (which must be at least 3) when " (tt "VECTORS") " is an f32vector and in bytes when " (tt "VECTORS") " is a u8vector or a pointer. When " (tt "VECTORS") " is given as a pointer, the keyword " (tt "LENGTH") " must be provided, specifying the number of vectors in " (tt "VECTORS") "."))
(def (sig (procedure " (lerp A B T [RESULT])" (id lerp))) (p "Linear interpolation between the points " (tt "A") " and " (tt "B") " with the interpolation parameter " (tt "T") " which must be between 0 and 1. If the vector " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (make-quaternion X Y Z W [NON-GC?])" (id make-quaternion)) (procedure " (quaternion-x POINT)" (id quaternion-x)) (procedure " (quaternion-y POINT)" (id quaternion-y)) (procedure " (quaternion-z POINT)" (id quaternion-z)) (procedure " (quaternion-w POINT)" (id quaternion-w)) (procedure " (quaternion-x-set! POINT)" (id quaternion-x-set!)) (procedure " (quaternion-y-set! POINT)" (id quaternion-y-set!)) (procedure " (quaternion-z-set! POINT)" (id quaternion-z-set!)) (procedure " (quaternion-w-set! POINT)" (id quaternion-w-set!))) (p "Quaternion constructor, getters, and setters. If " (tt "NON-GC") " is " (tt "#t") ", the quaternion is created in a non-garbage-collected area (the memory will still be freed when there are no more references to the quaternion)."))
(def (sig (procedure " (quaternion-normalize! Q)" (id quaternion-normalize!))) (p "Destructively normalize the quaternion " (tt "Q") "."))
(def (sig (procedure " (quaternion-inverse Q [RESULT])" (id quaternion-inverse))) (p "Return the inverse of the unit quaternion " (tt "Q") ". If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-cross-product A B [RESULT])" (id quaternion-cross-product))) (p "Return the cross-product of the quaternions " (tt "A") " and " (tt "B") ". If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-axis-angle-rotation AXIS ANGLE [RESULT])" (id quaternion-axis-angle-rotation))) (p "Return the quaternion corresponding to a rotation of " (tt "ANGLE") " radians around the vector " (tt "AXIS") ". If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-rotate-axis-angle AXIS ANGLE Q)" (id quaternion-rotate-axis-angle))) (p "Rotate the quaternion " (tt "Q") " by a rotation of " (tt "ANGLE") " radians around the vector " (tt "AXIS") "."))
(def (sig (procedure " (quaternion-x-rotation ANGLE [RESULT])" (id quaternion-x-rotation))) (p "Return the quaternion corresponding to a rotation of " (tt "ANGLE") " radians around the x-axis. If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-rotate-x ANGLE Q)" (id quaternion-rotate-x))) (p "Rotate the quaternion " (tt "Q") " by a rotation of " (tt "ANGLE") " radians around the x-axis."))
(def (sig (procedure " (quaternion-y-rotation ANGLE [RESULT])" (id quaternion-y-rotation))) (p "Return the quaternion corresponding to a rotation of " (tt "ANGLE") " radians around the y-axis. If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-rotate-y ANGLE Q)" (id quaternion-rotate-y))) (p "Rotate the quaternion " (tt "Q") " by a rotation of " (tt "ANGLE") " radians around the y-axis."))
(def (sig (procedure " (quaternion-z-rotation ANGLE [RESULT])" (id quaternion-z-rotation))) (p "Return the quaternion corresponding to a rotation of " (tt "ANGLE") " radians around the z-axis. If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-rotate-z ANGLE Q)" (id quaternion-rotate-z))) (p "Rotate the quaternion " (tt "Q") " by a rotation of " (tt "ANGLE") " radians around the z-axis."))
(def (sig (procedure " (quaternion-ypr-rotation YAW PITCH ROLL [RESULT])" (id quaternion-ypr-rotation))) (p "Return the quaternion corresponding to a rotation of " (tt "ROLL") " radians around the z-axis followed by " (tt "PITCH") " radians around the x-axis followed by " (tt "YAW") " radians around the y-axis. If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (quaternion-rotate-ypr YAW PITCH ROLL Q)" (id quaternion-rotate-ypr))) (p "Rotate the quaternion " (tt "Q") " by " (tt "ROLL") " radians around the z-axis followed by " (tt "PITCH") " radians around the x-axis followed by " (tt "YAW") " radians around the y-axis."))
(def (sig (procedure " (quaternion-rotate-point! Q P)" (id quaternion-rotate-point!))) (p "Destructively rotate the point " (tt "P") " by the unit quaternion " (tt "Q") "."))
(def (sig (procedure " (slerp A B T [RESULT])" (id slerp))) (p "Spherical linear interpolation between the quaternions " (tt "A") " and " (tt "B") " with the interpolation parameter " (tt "T") " which must be between 0 and 1. If the quaternion " (tt "RESULT") " is given, it will be modified to contain the result. If " (tt "RESULT") " is " (tt "#t") " the returned value will be an f32vector located in non-garbage-collected memory (the memory will still be freed when there are no more references to the matrix). If " (tt "RESULT") " is not provided, the returned value will be an f32vector located in normal garbage collected memory."))
(def (sig (procedure " (degrees->radians ANGLE)" (id degrees->radians))) (p "Converts " (tt "ANGLE") " from degrees to radians."))
(def (sig (procedure " (radians->degrees ANGLE)" (id radians->degrees))) (p "Converts " (tt "ANGLE") " from radians to degrees."))
(def (sig (constant " pi" (id pi)) (constant " pi/2" (id pi/2))))
