Common Lisp Package: CL-TUPLES

README:

FUNCTION

Public

AABB-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of AABB's (ie how many AABB's it contains)

ANGLE-AXIS-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of ANGLE-AXIS's (ie how many ANGLE-AXIS's it contains)

COLOUR-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of COLOUR's (ie how many COLOUR's it contains)

MAKE-AABB-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of AABB's

MAKE-ANGLE-AXIS-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of ANGLE-AXIS's

MAKE-COLOUR-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of COLOUR's

MAKE-MATRIX33-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of MATRIX33's

MAKE-MATRIX44-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of MATRIX44's

MAKE-QUATERNION-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of QUATERNION's

MAKE-RECT-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of RECT's

MAKE-TRIANGLE-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of TRIANGLE's

MAKE-TUPLE-SYMBOL (TYPE-NAME TUPLE-ELEMENT-TYPE TUPLE-INITIAL-ELEMENT ELEMENTS)

Makes a symbol used to identify a typle type and interns it in the package used for holding metadata about the tuple types. Information about the tuple type is stored in the property list of the symbol.

MAKE-VECTOR2D-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of VECTOR2D's

MAKE-VECTOR3D-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT 0.0 INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of VECTOR3D's

MAKE-VERTEX3D-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of VERTEX3D's

MATRIX33-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of MATRIX33's (ie how many MATRIX33's it contains)

MATRIX44-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of MATRIX44's (ie how many MATRIX44's it contains)

QUATERNION-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of QUATERNION's (ie how many QUATERNION's it contains)

RECT-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of RECT's (ie how many RECT's it contains)

TRIANGLE-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of TRIANGLE's (ie how many TRIANGLE's it contains)

TUPLE-ELEMENT-TYPE (TYPE-NAME)

Return the size of the type

TUPLE-GENSYMS (TYPE-NAME)

Return a list of gensyms, one for each element of the tuple

TUPLE-SIZE (TYPE-NAME)

Return the size of the type

TUPLE-TYPEP (TYPE-NAME)

Test to see if this symbol represents a tuple type

TUPLE-TYPESPEC (TYPE-NAME)

Return typespec of tuple as multiple value.

TUPLE-TYPESPEC* (TYPE-NAME)

Return typespec of tuple as bounded array

TUPLE-TYPESPEC** (TYPE-NAME)

Return typespec of tuple as unbounded array

VECTOR2D-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of VECTOR2D's (ie how many VECTOR2D's it contains)

VECTOR3D-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of VECTOR3D's (ie how many VECTOR3D's it contains)

VERTEX3D-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of VERTEX3D's (ie how many VERTEX3D's it contains)

Undocumented

AABB-AREF (TUPLE-ARRAY TUPLE-INDEX)

AABB-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

AABB-FILL-POINTER (TUPLE-ARRAY)

SETFAABB-FILL-POINTER (VALUE TUPLE-ARRAY)

AABB-VECTOR-PUSH (TUPLE ARRAY-NAME)

AABB-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

ANGLE-AXIS-AREF (TUPLE-ARRAY TUPLE-INDEX)

ANGLE-AXIS-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

ANGLE-AXIS-FILL-POINTER (TUPLE-ARRAY)

SETFANGLE-AXIS-FILL-POINTER (VALUE TUPLE-ARRAY)

ANGLE-AXIS-VECTOR-PUSH (TUPLE ARRAY-NAME)

ANGLE-AXIS-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

COLOUR-AREF (TUPLE-ARRAY TUPLE-INDEX)

COLOUR-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

COLOUR-FILL-POINTER (TUPLE-ARRAY)

SETFCOLOUR-FILL-POINTER (VALUE TUPLE-ARRAY)

COLOUR-VECTOR-PUSH (TUPLE ARRAY-NAME)

COLOUR-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

MATRIX33-AREF (TUPLE-ARRAY TUPLE-INDEX)

MATRIX33-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

MATRIX33-FILL-POINTER (TUPLE-ARRAY)

SETFMATRIX33-FILL-POINTER (VALUE TUPLE-ARRAY)

MATRIX33-VECTOR-PUSH (TUPLE ARRAY-NAME)

MATRIX33-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

MATRIX44-AREF (TUPLE-ARRAY TUPLE-INDEX)

MATRIX44-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

MATRIX44-FILL-POINTER (TUPLE-ARRAY)

SETFMATRIX44-FILL-POINTER (VALUE TUPLE-ARRAY)

MATRIX44-VECTOR-PUSH (TUPLE ARRAY-NAME)

MATRIX44-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

QUATERNION-AREF (TUPLE-ARRAY TUPLE-INDEX)

QUATERNION-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

QUATERNION-FILL-POINTER (TUPLE-ARRAY)

SETFQUATERNION-FILL-POINTER (VALUE TUPLE-ARRAY)

QUATERNION-VECTOR-PUSH (TUPLE ARRAY-NAME)

QUATERNION-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

RECT-AREF (TUPLE-ARRAY TUPLE-INDEX)

RECT-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

RECT-FILL-POINTER (TUPLE-ARRAY)

SETFRECT-FILL-POINTER (VALUE TUPLE-ARRAY)

RECT-VECTOR-PUSH (TUPLE ARRAY-NAME)

RECT-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

TRIANGLE-AREF (TUPLE-ARRAY TUPLE-INDEX)

TRIANGLE-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

TRIANGLE-FILL-POINTER (TUPLE-ARRAY)

SETFTRIANGLE-FILL-POINTER (VALUE TUPLE-ARRAY)

TRIANGLE-VECTOR-PUSH (TUPLE ARRAY-NAME)

TRIANGLE-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

VECTOR2D-AREF (TUPLE-ARRAY TUPLE-INDEX)

VECTOR2D-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

VECTOR2D-FILL-POINTER (TUPLE-ARRAY)

SETFVECTOR2D-FILL-POINTER (VALUE TUPLE-ARRAY)

VECTOR2D-VECTOR-PUSH (TUPLE ARRAY-NAME)

VECTOR2D-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

VECTOR3D-AREF (TUPLE-ARRAY TUPLE-INDEX)

VECTOR3D-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

VECTOR3D-FILL-POINTER (TUPLE-ARRAY)

SETFVECTOR3D-FILL-POINTER (VALUE TUPLE-ARRAY)

VECTOR3D-VECTOR-PUSH (TUPLE ARRAY-NAME)

VECTOR3D-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

VERTEX3D-AREF (TUPLE-ARRAY TUPLE-INDEX)

VERTEX3D-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

VERTEX3D-FILL-POINTER (TUPLE-ARRAY)

SETFVERTEX3D-FILL-POINTER (VALUE TUPLE-ARRAY)

VERTEX3D-VECTOR-PUSH (TUPLE ARRAY-NAME)

VERTEX3D-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

Private

ARG-EXPANDER-FN

Helper function for def-tuple-op. Expands the arguments into a series of WITH-* forms so that symbols are bound to tuple elements in the body of the operator.

ARG-EXPANDER-FN-AUX

Handle the expansion of the n-th parameter in a def-tuple-op call list

BODY-EXPANDER-FN

Expand the declarations and return type wrapper round a def-tuple-op. form

CONSTRUCT-TUPLE-ARRAY-REFERENCE

Given a tuple type and an array index, return a form for returnign the array index

CONSTRUCT-TUPLE-SLOTS

Given a tuple type return a list of slots sutable for the body of a defstruct body eg: ((A 0.0 :TYPE SINGLE-FLOAT) (B 0.0 :TYPE SINGLE-FLOAT))

CONSTRUCT-TUPLE-VALUE-TYPE

Given a tuple name construct the for of a value typespec for it eg (values single-float single-float)

COPY-AABB (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-ANGLE-AXIS (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-COLOUR (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-MATRIX33 (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-MATRIX44 (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-QUATERNION (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-RECT (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-TRIANGLE (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-VECTOR2D (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-VECTOR3D (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-VERTEX2D (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

COPY-VERTEX3D (SEQUENCE)

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

GENSYM-LIST (N)

Give us a list of gensyms n elements long

MAKE-ELEMENT-NAMES (ELEMENTS TYPE-NAME)

Given a list of element names form a set of symbols of the form <type-name>-<element-name> as used in struct elements.

MAKE-VERTEX2D-ARRAY (DIMENSIONS &KEY ADJUSTABLE (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (FILL-POINTER NIL FILL-POINTER-P))

Create an array suitable for holding a number of VERTEX2D's

SIMPLE-TUPLE-TYPESPEC* (TYPE-NAME)

Return typespec of tuple as bounded array

SYMBOL-MACRO-EXPANDER-FN

Wrap the body of def tuple op in symbol macros mapped to gensyms to prevent name capture.

SYMBOL-TO-STRING (X)

If the argument is a symbol or string, return it as a string.

TUPLE-ELEMENTS (TYPE-NAME)

Return a list of element names

TUPLE-INITIAL-ELEMENT (TYPE-NAME)

Return the inital element type of a tuple array

TUPLE-PLACES (TYPE-NAME ARRAY-NAME)

Return a list of (aref *) forms to turn at tuple represeted and array into individual places.

VERTEX2D-ARRAY-DIMENSIONS (TUPLE-ARRAY)

Return the size of a vector of VERTEX2D's (ie how many VERTEX2D's it contains)

Undocumented

#{-reader (STREAM CHAR ARG)

AABB-MAXX (STRUCTURE)

SETFAABB-MAXX (NEW-VALUE STRUCTURE)

AABB-MAXY (STRUCTURE)

SETFAABB-MAXY (NEW-VALUE STRUCTURE)

AABB-MAXZ (STRUCTURE)

SETFAABB-MAXZ (NEW-VALUE STRUCTURE)

AABB-MINX (STRUCTURE)

SETFAABB-MINX (NEW-VALUE STRUCTURE)

AABB-MINY (STRUCTURE)

SETFAABB-MINY (NEW-VALUE STRUCTURE)

AABB-MINZ (STRUCTURE)

SETFAABB-MINZ (NEW-VALUE STRUCTURE)

ANGLE-AXIS-A (STRUCTURE)

SETFANGLE-AXIS-A (NEW-VALUE STRUCTURE)

ANGLE-AXIS-X (STRUCTURE)

SETFANGLE-AXIS-X (NEW-VALUE STRUCTURE)

ANGLE-AXIS-Y (STRUCTURE)

SETFANGLE-AXIS-Y (NEW-VALUE STRUCTURE)

ANGLE-AXIS-Z (STRUCTURE)

SETFANGLE-AXIS-Z (NEW-VALUE STRUCTURE)

COLOUR-A (STRUCTURE)

SETFCOLOUR-A (NEW-VALUE STRUCTURE)

COLOUR-B (STRUCTURE)

SETFCOLOUR-B (NEW-VALUE STRUCTURE)

COLOUR-G (STRUCTURE)

SETFCOLOUR-G (NEW-VALUE STRUCTURE)

COLOUR-R (STRUCTURE)

SETFCOLOUR-R (NEW-VALUE STRUCTURE)

CONSTRUCT-TUPLE-ARRAY-MAKER

CONSTRUCT-TUPLE-SET-AREF

DOCUMENT-TUPLE-TYPE (TYPE-NAME)

IS-ASTERISK-SYMBOL (S)

MAKE-ADORNED-SYMBOL (NAME &KEY PREFIX SUFFIX ASTERISK PACKAGE)

MAKE-PREFIXED-SYMBOL (NAME PREFIX)

MAKE-SUFFIXED-SYMBOL (NAME SUFFIX)

MATRIX33-E00 (STRUCTURE)

SETFMATRIX33-E00 (NEW-VALUE STRUCTURE)

MATRIX33-E01 (STRUCTURE)

SETFMATRIX33-E01 (NEW-VALUE STRUCTURE)

MATRIX33-E02 (STRUCTURE)

SETFMATRIX33-E02 (NEW-VALUE STRUCTURE)

MATRIX33-E10 (STRUCTURE)

SETFMATRIX33-E10 (NEW-VALUE STRUCTURE)

MATRIX33-E11 (STRUCTURE)

SETFMATRIX33-E11 (NEW-VALUE STRUCTURE)

MATRIX33-E12 (STRUCTURE)

SETFMATRIX33-E12 (NEW-VALUE STRUCTURE)

MATRIX33-E20 (STRUCTURE)

SETFMATRIX33-E20 (NEW-VALUE STRUCTURE)

MATRIX33-E21 (STRUCTURE)

SETFMATRIX33-E21 (NEW-VALUE STRUCTURE)

MATRIX33-E22 (STRUCTURE)

SETFMATRIX33-E22 (NEW-VALUE STRUCTURE)

MATRIX44-E00 (STRUCTURE)

SETFMATRIX44-E00 (NEW-VALUE STRUCTURE)

MATRIX44-E01 (STRUCTURE)

SETFMATRIX44-E01 (NEW-VALUE STRUCTURE)

MATRIX44-E02 (STRUCTURE)

SETFMATRIX44-E02 (NEW-VALUE STRUCTURE)

MATRIX44-E03 (STRUCTURE)

SETFMATRIX44-E03 (NEW-VALUE STRUCTURE)

MATRIX44-E10 (STRUCTURE)

SETFMATRIX44-E10 (NEW-VALUE STRUCTURE)

MATRIX44-E11 (STRUCTURE)

SETFMATRIX44-E11 (NEW-VALUE STRUCTURE)

MATRIX44-E12 (STRUCTURE)

SETFMATRIX44-E12 (NEW-VALUE STRUCTURE)

MATRIX44-E13 (STRUCTURE)

SETFMATRIX44-E13 (NEW-VALUE STRUCTURE)

MATRIX44-E20 (STRUCTURE)

SETFMATRIX44-E20 (NEW-VALUE STRUCTURE)

MATRIX44-E21 (STRUCTURE)

SETFMATRIX44-E21 (NEW-VALUE STRUCTURE)

MATRIX44-E22 (STRUCTURE)

SETFMATRIX44-E22 (NEW-VALUE STRUCTURE)

MATRIX44-E23 (STRUCTURE)

SETFMATRIX44-E23 (NEW-VALUE STRUCTURE)

MATRIX44-E30 (STRUCTURE)

SETFMATRIX44-E30 (NEW-VALUE STRUCTURE)

MATRIX44-E31 (STRUCTURE)

SETFMATRIX44-E31 (NEW-VALUE STRUCTURE)

MATRIX44-E32 (STRUCTURE)

SETFMATRIX44-E32 (NEW-VALUE STRUCTURE)

MATRIX44-E33 (STRUCTURE)

SETFMATRIX44-E33 (NEW-VALUE STRUCTURE)

QUATERNION-W (STRUCTURE)

SETFQUATERNION-W (NEW-VALUE STRUCTURE)

QUATERNION-X (STRUCTURE)

SETFQUATERNION-X (NEW-VALUE STRUCTURE)

QUATERNION-Y (STRUCTURE)

SETFQUATERNION-Y (NEW-VALUE STRUCTURE)

QUATERNION-Z (STRUCTURE)

SETFQUATERNION-Z (NEW-VALUE STRUCTURE)

RECT-BOTTOM (STRUCTURE)

SETFRECT-BOTTOM (NEW-VALUE STRUCTURE)

RECT-LEFT (STRUCTURE)

SETFRECT-LEFT (NEW-VALUE STRUCTURE)

RECT-RIGHT (STRUCTURE)

SETFRECT-RIGHT (NEW-VALUE STRUCTURE)

RECT-TOP (STRUCTURE)

SETFRECT-TOP (NEW-VALUE STRUCTURE)

TRIANGLE-A (STRUCTURE)

SETFTRIANGLE-A (NEW-VALUE STRUCTURE)

TRIANGLE-B (STRUCTURE)

SETFTRIANGLE-B (NEW-VALUE STRUCTURE)

TRIANGLE-C (STRUCTURE)

SETFTRIANGLE-C (NEW-VALUE STRUCTURE)

VECTOR2D-X (STRUCTURE)

SETFVECTOR2D-X (NEW-VALUE STRUCTURE)

VECTOR2D-Y (STRUCTURE)

SETFVECTOR2D-Y (NEW-VALUE STRUCTURE)

VECTOR3D-X (STRUCTURE)

SETFVECTOR3D-X (NEW-VALUE STRUCTURE)

VECTOR3D-Y (STRUCTURE)

SETFVECTOR3D-Y (NEW-VALUE STRUCTURE)

VECTOR3D-Z (STRUCTURE)

SETFVECTOR3D-Z (NEW-VALUE STRUCTURE)

VERTEX2D-AREF (TUPLE-ARRAY TUPLE-INDEX)

VERTEX2D-AREF-SETTER (TUPLE-NAME TUPLE-INDEX TUPLE)

VERTEX2D-FILL-POINTER (TUPLE-ARRAY)

SETFVERTEX2D-FILL-POINTER (VALUE TUPLE-ARRAY)

VERTEX2D-VECTOR-PUSH (TUPLE ARRAY-NAME)

VERTEX2D-VECTOR-PUSH-EXTEND (TUPLE ARRAY-NAME)

VERTEX2D-W (STRUCTURE)

SETFVERTEX2D-W (NEW-VALUE STRUCTURE)

VERTEX2D-X (STRUCTURE)

SETFVERTEX2D-X (NEW-VALUE STRUCTURE)

VERTEX2D-Y (STRUCTURE)

SETFVERTEX2D-Y (NEW-VALUE STRUCTURE)

VERTEX3D-W (STRUCTURE)

SETFVERTEX3D-W (NEW-VALUE STRUCTURE)

VERTEX3D-X (STRUCTURE)

SETFVERTEX3D-X (NEW-VALUE STRUCTURE)

VERTEX3D-Y (STRUCTURE)

SETFVERTEX3D-Y (NEW-VALUE STRUCTURE)

VERTEX3D-Z (STRUCTURE)

SETFVERTEX3D-Z (NEW-VALUE STRUCTURE)

MACRO

Public

AABB* (TUPLE-ARRAY-NAME)

Unpack array representation of an AABB and convert to multiple values.

AABB-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual AABB to multiple values from an array of AABBs.

AABB-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an AABB vector in a vector of AABBs from a multiple values AABB

AABB-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an AABB vector from a multiple values AABB

AABB-VALUES* (&REST ELEMENTS)

Convert AABB forms to multiple values.

AABB-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a AABB multiple value onto the end of a vector of AABB's

AABB-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a AABB multiple value onto the end of a vector of AABB's with the possibility of extension

ANGLE-AXIS* (TUPLE-ARRAY-NAME)

Unpack array representation of an ANGLE-AXIS and convert to multiple values.

ANGLE-AXIS-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual ANGLE-AXIS to multiple values from an array of ANGLE-AXISs.

ANGLE-AXIS-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an ANGLE-AXIS vector in a vector of ANGLE-AXISs from a multiple values ANGLE-AXIS

ANGLE-AXIS-QUATERNION* (AA)

Convert an angle-axis tuple to a quaternion tuple

ANGLE-AXIS-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an ANGLE-AXIS vector from a multiple values ANGLE-AXIS

ANGLE-AXIS-VALUES* (&REST ELEMENTS)

Convert ANGLE-AXIS forms to multiple values.

ANGLE-AXIS-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a ANGLE-AXIS multiple value onto the end of a vector of ANGLE-AXIS's

ANGLE-AXIS-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a ANGLE-AXIS multiple value onto the end of a vector of ANGLE-AXIS's with the possibility of extension

COLOUR* (TUPLE-ARRAY-NAME)

Unpack array representation of an COLOUR and convert to multiple values.

COLOUR-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual COLOUR to multiple values from an array of COLOURs.

COLOUR-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an COLOUR vector in a vector of COLOURs from a multiple values COLOUR

COLOUR-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an COLOUR vector from a multiple values COLOUR

COLOUR-VALUES* (&REST ELEMENTS)

Convert COLOUR forms to multiple values.

COLOUR-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a COLOUR multiple value onto the end of a vector of COLOUR's

COLOUR-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a COLOUR multiple value onto the end of a vector of COLOUR's with the possibility of extension

DEF-TUPLE-OP (NAME PARAM-LIST &BODY FORMS)

Macro to define a tuple operator. The name of the operator is name. The operator arguments are determined by args, which is a list of the form ((argument-name argument-type (elements) ..)). Within the forms the tuple value form is bound to the argument-name and the tuple elements are bound to the symbols in the element list

DEF-TUPLE-TYPE (TUPLE-TYPE-NAME &KEY TUPLE-ELEMENT-TYPE INITIAL-ELEMENT ELEMENTS)

Create a tuple type. To be used from the top level. For example (def-tuple-type vector3d single-float (x y z)) will create several macros and functions. Firstly, the accessor functions (vector3d array) (vector3d-aref array index). Secondly, the context macros (with-vector3d tuple (element-symbols) forms..) and (with-vector3d-array tuple (element-symbols) index forms..), Thirdly the constructors (new-vector3d) and (make-vector3d tuple), (make-vector3d-array dimensions &key adjustable fill-pointer), Forthly generalised access as in (setf (vector3d array) tuple) and (setf (vector3d-aref array) index tuple),

DELTA-VECTOR3D* (START END)

DEF-TUPLE-OP DELTA-VECTOR3D* (VERTEX3D VERTEX3D)

IDENTITY-MATRIX44*

DEF-TUPLE-OP IDENTITY-MATRIX44* NIL

MAKE-AABB (&REST ELEMENTS)

Create an array sutable for holding a single AABB and initialize it from a multiple-values form

MAKE-AABB* (TUPLE-VALUES)

Create an array sutable for holding a single AABB and initialize it from a form

MAKE-ANGLE-AXIS (&REST ELEMENTS)

Create an array sutable for holding a single ANGLE-AXIS and initialize it from a multiple-values form

MAKE-ANGLE-AXIS* (TUPLE-VALUES)

Create an array sutable for holding a single ANGLE-AXIS and initialize it from a form

MAKE-COLOUR (&REST ELEMENTS)

Create an array sutable for holding a single COLOUR and initialize it from a multiple-values form

MAKE-COLOUR* (TUPLE-VALUES)

Create an array sutable for holding a single COLOUR and initialize it from a form

MAKE-MATRIX33 (&REST ELEMENTS)

Create an array sutable for holding a single MATRIX33 and initialize it from a multiple-values form

MAKE-MATRIX33* (TUPLE-VALUES)

Create an array sutable for holding a single MATRIX33 and initialize it from a form

MAKE-MATRIX44 (&REST ELEMENTS)

Create an array sutable for holding a single MATRIX44 and initialize it from a multiple-values form

MAKE-MATRIX44* (TUPLE-VALUES)

Create an array sutable for holding a single MATRIX44 and initialize it from a form

MAKE-QUATERNION (&REST ELEMENTS)

Create an array sutable for holding a single QUATERNION and initialize it from a multiple-values form

MAKE-QUATERNION* (TUPLE-VALUES)

Create an array sutable for holding a single QUATERNION and initialize it from a form

MAKE-RECT (&REST ELEMENTS)

Create an array sutable for holding a single RECT and initialize it from a multiple-values form

MAKE-RECT* (TUPLE-VALUES)

Create an array sutable for holding a single RECT and initialize it from a form

MAKE-TRIANGLE (&REST ELEMENTS)

Create an array sutable for holding a single TRIANGLE and initialize it from a multiple-values form

MAKE-TRIANGLE* (TUPLE-VALUES)

Create an array sutable for holding a single TRIANGLE and initialize it from a form

MAKE-VECTOR2D (&REST ELEMENTS)

Create an array sutable for holding a single VECTOR2D and initialize it from a multiple-values form

MAKE-VECTOR2D* (TUPLE-VALUES)

Create an array sutable for holding a single VECTOR2D and initialize it from a form

MAKE-VECTOR3D (&REST ELEMENTS)

Create an array sutable for holding a single VECTOR3D and initialize it from a multiple-values form

MAKE-VECTOR3D* (TUPLE-VALUES)

Create an array sutable for holding a single VECTOR3D and initialize it from a form

MAKE-VERTEX3D (&REST ELEMENTS)

Create an array sutable for holding a single VERTEX3D and initialize it from a multiple-values form

MAKE-VERTEX3D* (TUPLE-VALUES)

Create an array sutable for holding a single VERTEX3D and initialize it from a form

MATRIX33* (TUPLE-ARRAY-NAME)

Unpack array representation of an MATRIX33 and convert to multiple values.

MATRIX33-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual MATRIX33 to multiple values from an array of MATRIX33s.

MATRIX33-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an MATRIX33 vector in a vector of MATRIX33s from a multiple values MATRIX33

MATRIX33-MATRIX44* (MAT3)

Convert a 3x3 matrix to a 4x4 matrix

MATRIX33-PRODUCT* (M0 M1)

DEF-TUPLE-OP MATRIX33-PRODUCT* (MATRIX33 MATRIX33)

MATRIX33-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an MATRIX33 vector from a multiple values MATRIX33

MATRIX33-VALUES* (&REST ELEMENTS)

Convert MATRIX33 forms to multiple values.

MATRIX33-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a MATRIX33 multiple value onto the end of a vector of MATRIX33's

MATRIX33-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a MATRIX33 multiple value onto the end of a vector of MATRIX33's with the possibility of extension

MATRIX44* (TUPLE-ARRAY-NAME)

Unpack array representation of an MATRIX44 and convert to multiple values.

MATRIX44-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual MATRIX44 to multiple values from an array of MATRIX44s.

MATRIX44-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an MATRIX44 vector in a vector of MATRIX44s from a multiple values MATRIX44

MATRIX44-MATRIX33* (MAT44)

Convert a 4x4 matrix to a 3x3 matrix

MATRIX44-PRODUCT* (M0 M1)

DEF-TUPLE-OP MATRIX44-PRODUCT* (MATRIX44 MATRIX44)

MATRIX44-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an MATRIX44 vector from a multiple values MATRIX44

MATRIX44-VALUES* (&REST ELEMENTS)

Convert MATRIX44 forms to multiple values.

MATRIX44-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a MATRIX44 multiple value onto the end of a vector of MATRIX44's

MATRIX44-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a MATRIX44 multiple value onto the end of a vector of MATRIX44's with the possibility of extension

NEW-AABB

Create an array suitable for holding a single AABB

NEW-ANGLE-AXIS

Create an array suitable for holding a single ANGLE-AXIS

NEW-COLOUR

Create an array suitable for holding a single COLOUR

NEW-MATRIX33

Create an array suitable for holding a single MATRIX33

NEW-MATRIX44

Create an array suitable for holding a single MATRIX44

NEW-QUATERNION

Create an array suitable for holding a single QUATERNION

NEW-RECT

Create an array suitable for holding a single RECT

NEW-TRIANGLE

Create an array suitable for holding a single TRIANGLE

NEW-VECTOR2D

Create an array suitable for holding a single VECTOR2D

NEW-VECTOR3D

Create an array suitable for holding a single VECTOR3D

NEW-VERTEX3D

Create an array suitable for holding a single VERTEX3D

QUATERNION* (TUPLE-ARRAY-NAME)

Unpack array representation of an QUATERNION and convert to multiple values.

QUATERNION-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual QUATERNION to multiple values from an array of QUATERNIONs.

QUATERNION-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an QUATERNION vector in a vector of QUATERNIONs from a multiple values QUATERNION

QUATERNION-CONJUGATE* (Q)

DEF-TUPLE-OP QUATERNION-CONJUGATE* (QUATERNION)

QUATERNION-DOT* (QUATERNION-LHS QUATERNION-RHS)

Dot product of two quaternions.

QUATERNION-INVERSE* (Q)

Inverse of quaternion

QUATERNION-MATRIX33* (Q)

Convert a quaternion to a 3x3 rotation matrix.

QUATERNION-NORM* (Q)

DEF-TUPLE-OP QUATERNION-NORM* (QUATERNION)

QUATERNION-PRODUCT* (Q-LHS Q-RHS)

Multiple of two quaternions

QUATERNION-SCALE* (Q S)

Multiply a quat by a scalar

QUATERNION-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an QUATERNION vector from a multiple values QUATERNION

QUATERNION-SUM* (Q0 Q1)

Sum the components of two quaternions

QUATERNION-TRANSFORM-VECTOR3D* (VECTOR QUAT)

Transform a 3d vector with a quaternion

QUATERNION-UNITIZE* (Q)

Ensure a quaternion is a unit

QUATERNION-VALUES* (&REST ELEMENTS)

Convert QUATERNION forms to multiple values.

QUATERNION-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a QUATERNION multiple value onto the end of a vector of QUATERNION's

QUATERNION-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a QUATERNION multiple value onto the end of a vector of QUATERNION's with the possibility of extension

RECT* (TUPLE-ARRAY-NAME)

Unpack array representation of an RECT and convert to multiple values.

RECT-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual RECT to multiple values from an array of RECTs.

RECT-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an RECT vector in a vector of RECTs from a multiple values RECT

RECT-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an RECT vector from a multiple values RECT

RECT-VALUES* (&REST ELEMENTS)

Convert RECT forms to multiple values.

RECT-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a RECT multiple value onto the end of a vector of RECT's

RECT-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a RECT multiple value onto the end of a vector of RECT's with the possibility of extension

ROTATEX-MATRIX44* (ROTATION)

Return a matrix for rotating around the x axis.

ROTATEY-MATRIX44* (ROTATION)

Return a matrix for rotating around the y axis.

ROTATEZ-MATRIX44* (ROTATION)

Return a matrix for rotating around the z axis.

TRANSFORM-VECTOR2D* (MATRIX33 VECTOR2D)

DEF-TUPLE-OP TRANSFORM-VECTOR2D* (MAT VEC)

TRANSFORM-VECTOR3D* (MAT VECT)

DEF-TUPLE-OP TRANSFORM-VECTOR3D* (MATRIX33 VECTOR3D)

TRANSFORM-VERTEX2D* (MATRIX33 VERTEX2D)

DEF-TUPLE-OP TRANSFORM-VERTEX2D* (MAT VERT)

TRANSFORM-VERTEX3D* (MAT VERT)

DEF-TUPLE-OP TRANSFORM-VERTEX3D* (MATRIX44 VERTEX3D)

TRANSLATION-MATRIX44* (TX TY TZ)

Return a matrix that represents a translation transformation

TRANSPOSE-MATRIX33* (MAT33)

Return the transpose of the matrix

TRANSPOSE-MATRIX44* (MAT44)

Return the transpose of the matrix

TRIANGLE* (TUPLE-ARRAY-NAME)

Unpack array representation of an TRIANGLE and convert to multiple values.

TRIANGLE-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual TRIANGLE to multiple values from an array of TRIANGLEs.

TRIANGLE-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an TRIANGLE vector in a vector of TRIANGLEs from a multiple values TRIANGLE

TRIANGLE-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an TRIANGLE vector from a multiple values TRIANGLE

TRIANGLE-VALUES* (&REST ELEMENTS)

Convert TRIANGLE forms to multiple values.

TRIANGLE-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a TRIANGLE multiple value onto the end of a vector of TRIANGLE's

TRIANGLE-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a TRIANGLE multiple value onto the end of a vector of TRIANGLE's with the possibility of extension

VECTOR2D* (TUPLE-ARRAY-NAME)

Unpack array representation of an VECTOR2D and convert to multiple values.

VECTOR2D-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual VECTOR2D to multiple values from an array of VECTOR2Ds.

VECTOR2D-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an VECTOR2D vector in a vector of VECTOR2Ds from a multiple values VECTOR2D

VECTOR2D-DOT* (VECA VECB)

DEF-TUPLE-OP VECTOR2D-DOT* (VECTOR2D VECTOR2D)

VECTOR2D-LENGTH* (VEC)

DEF-TUPLE-OP VECTOR2D-LENGTH* (VECTOR2D)

VECTOR2D-NORMAL* (VEC)

DEF-TUPLE-OP VECTOR2D-NORMAL* (VECTOR2D)

VECTOR2D-SCALE* (VEC S)

DEF-TUPLE-OP VECTOR2D-SCALE* (VECTOR2D FAST-FLOAT)

VECTOR2D-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an VECTOR2D vector from a multiple values VECTOR2D

VECTOR2D-VALUES* (&REST ELEMENTS)

Convert VECTOR2D forms to multiple values.

VECTOR2D-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a VECTOR2D multiple value onto the end of a vector of VECTOR2D's

VECTOR2D-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a VECTOR2D multiple value onto the end of a vector of VECTOR2D's with the possibility of extension

VECTOR2D-VERTEX2D* (VEC)

DEF-TUPLE-OP VECTOR2D-VERTEX2D* (VECTOR2D)

VECTOR3D* (TUPLE-ARRAY-NAME)

Unpack array representation of an VECTOR3D and convert to multiple values.

VECTOR3D-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual VECTOR3D to multiple values from an array of VECTOR3Ds.

VECTOR3D-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an VECTOR3D vector in a vector of VECTOR3Ds from a multiple values VECTOR3D

VECTOR3D-CROSS* (LHS RHS)

DEF-TUPLE-OP VECTOR3D-CROSS* (VECTOR3D VECTOR3D)

VECTOR3D-DIFFERENCE* (VECA VECB)

DEF-TUPLE-OP VECTOR3D-DIFFERENCE* (VECTOR3D VECTOR3D)

VECTOR3D-DOT* (VECA VECB)

DEF-TUPLE-OP VECTOR3D-DOT* (VECTOR3D VECTOR3D)

VECTOR3D-LENGTH* (VEC)

DEF-TUPLE-OP VECTOR3D-LENGTH* (VECTOR3D)

VECTOR3D-NORMAL* (VEC)

DEF-TUPLE-OP VECTOR3D-NORMAL* (VECTOR3D)

VECTOR3D-QUATERNION* (VECTOR)

Convert a 3d vector into q auqt for angular velocity purposes

VECTOR3D-SCALE* (VEC S)

DEF-TUPLE-OP VECTOR3D-SCALE* (VECTOR3D FAST-FLOAT)

VECTOR3D-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an VECTOR3D vector from a multiple values VECTOR3D

VECTOR3D-SUM* (VECA VECB)

DEF-TUPLE-OP VECTOR3D-SUM* (VECTOR3D VECTOR3D)

VECTOR3D-VALUES* (&REST ELEMENTS)

Convert VECTOR3D forms to multiple values.

VECTOR3D-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a VECTOR3D multiple value onto the end of a vector of VECTOR3D's

VECTOR3D-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a VECTOR3D multiple value onto the end of a vector of VECTOR3D's with the possibility of extension

VECTOR3D-VERTEX3D* (VEC)

DEF-TUPLE-OP VECTOR3D-VERTEX3D* (VECTOR3D)

VERTEX2D-VECTOR2D* (VERT)

DEF-TUPLE-OP VERTEX2D-VECTOR2D* (VERTEX2D)

VERTEX3D* (TUPLE-ARRAY-NAME)

Unpack array representation of an VERTEX3D and convert to multiple values.

VERTEX3D-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual VERTEX3D to multiple values from an array of VERTEX3Ds.

VERTEX3D-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an VERTEX3D vector in a vector of VERTEX3Ds from a multiple values VERTEX3D

VERTEX3D-DISTANCE* (START END)

DEF-TUPLE-OP VERTEX3D-DISTANCE* (VERTEX3D VERTEX3D)

VERTEX3D-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an VERTEX3D vector from a multiple values VERTEX3D

VERTEX3D-TRANSLATION-MATRIX44* (VERT)

Return a matrix that represents a translation transformation

VERTEX3D-VALUES* (&REST ELEMENTS)

Convert VERTEX3D forms to multiple values.

VERTEX3D-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a VERTEX3D multiple value onto the end of a vector of VERTEX3D's

VERTEX3D-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a VERTEX3D multiple value onto the end of a vector of VERTEX3D's with the possibility of extension

VERTEX3D-VECTOR3D* (VERT)

DEF-TUPLE-OP VERTEX3D-VECTOR3D* (VERTEX3D)

WITH-AABB (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a AABB multiple value to symbols.

WITH-AABB* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a AABB vector to symbols.

WITH-AABB-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a AABB from vector of AABB's to symbols

WITH-ANGLE-AXIS (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a ANGLE-AXIS multiple value to symbols.

WITH-ANGLE-AXIS* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a ANGLE-AXIS vector to symbols.

WITH-ANGLE-AXIS-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a ANGLE-AXIS from vector of ANGLE-AXIS's to symbols

WITH-COLOUR (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a COLOUR multiple value to symbols.

WITH-COLOUR* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a COLOUR vector to symbols.

WITH-COLOUR-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a COLOUR from vector of COLOUR's to symbols

WITH-MATRIX33 (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a MATRIX33 multiple value to symbols.

WITH-MATRIX33* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a MATRIX33 vector to symbols.

WITH-MATRIX33-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a MATRIX33 from vector of MATRIX33's to symbols

WITH-MATRIX44 (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a MATRIX44 multiple value to symbols.

WITH-MATRIX44* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a MATRIX44 vector to symbols.

WITH-MATRIX44-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a MATRIX44 from vector of MATRIX44's to symbols

WITH-QUATERNION (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a QUATERNION multiple value to symbols.

WITH-QUATERNION* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a QUATERNION vector to symbols.

WITH-QUATERNION-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a QUATERNION from vector of QUATERNION's to symbols

WITH-RECT (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a RECT multiple value to symbols.

WITH-RECT* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a RECT vector to symbols.

WITH-RECT-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a RECT from vector of RECT's to symbols

WITH-TRIANGLE (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a TRIANGLE multiple value to symbols.

WITH-TRIANGLE* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a TRIANGLE vector to symbols.

WITH-TRIANGLE-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a TRIANGLE from vector of TRIANGLE's to symbols

WITH-VECTOR2D (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VECTOR2D multiple value to symbols.

WITH-VECTOR2D* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VECTOR2D vector to symbols.

WITH-VECTOR2D-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a VECTOR2D from vector of VECTOR2D's to symbols

WITH-VECTOR3D (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VECTOR3D multiple value to symbols.

WITH-VECTOR3D* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VECTOR3D vector to symbols.

WITH-VECTOR3D-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a VECTOR3D from vector of VECTOR3D's to symbols

WITH-VERTEX3D (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VERTEX3D multiple value to symbols.

WITH-VERTEX3D* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VERTEX3D vector to symbols.

WITH-VERTEX3D-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a VERTEX3D from vector of VERTEX3D's to symbols

Private

DEF-NEW-TUPLE (TYPE-NAME)

Create a function to create a place suitable for holding an individual tuple. eg (new-vector3d)

DEF-TUPLE (TYPE-NAME)

Create an alias for values for this tuple.eg (vector3d-values 1.0 0.0 0.0) => #{ 1.0 0.0 0.0 }

DEF-TUPLE-AREF (TYPE-NAME)

Create a tuple aref macro for unpacking individual tuple from an array of tuples. eg (vector3d-aref up 5) => #(0.0 1.0 0.0)

DEF-TUPLE-AREF* (TYPE-NAME)

Create a tuple aref macro for unpacking individual tuple from an array of tuples. eg (vector3d-aref up 5) => (values 0.0 1.0 0.0)

DEF-TUPLE-AREF-SETTER (TYPE-NAME)

Create an aref-setter macro for setting an element in an array of tuples from a multiple-value tuple. eg (vector3d-aref-setter up 2 #( 0.0 1.0 0.0 ))

DEF-TUPLE-AREF-SETTER* (TYPE-NAME)

Create an aref-setter macro for setting an element in an array of tuples from a multiple-value tuple. eg (vector3d-aref-setter up 2 #{ 0.0 1.0 0.0 })

DEF-TUPLE-ARRAY-DIMENSIONS (TYPE-NAME)

Create a function that will return the number of tuples in the array of tuple places.

DEF-TUPLE-ARRAY-MAKER (TYPE-NAME)

Create a function to create an array suitable for holding an number of individual tuples. ie an array of tuple places. eg (make-vector3d-array 5 :adjustable t)

DEF-TUPLE-ARRAY-SETF (TYPE-NAME)

Create generalised variable macros for an array of tuples of type-name with the given elements.

DEF-TUPLE-ARRAY-SETF* (TYPE-NAME)

Create generalised variable macros for an array of tuples of type-name with the given elements.

DEF-TUPLE-FILL-POINTER (TYPE-NAME)

Create a function that will return a vector fill pointer in terms of tuple size

DEF-TUPLE-GETTER (TYPE-NAME)

Create an access macro such as (vector3d vec) that takes a tuple place and unpacks it to tuples (aka multiple values)

DEF-TUPLE-MAKER (TYPE-NAME)

Create a function to create an place suitable for holding an individual tuple, and initialise elements from multiple-value tuple. eg (make-vector3d (values 1.0 2.0 2.0 ))

DEF-TUPLE-MAKER* (TYPE-NAME)

Create a function to create an place suitable for holding an individual tuple, and initialise elements from array tuple. eg (make-vector3d* #( 1.0 2.0 2.0 ))

DEF-TUPLE-SETF* (TYPE-NAME)

Create generalised variable macros for tuple of type-name with the given elements.

DEF-TUPLE-SETF-FILL-POINTER (TYPE-NAME)

Create a function that will adjust a vector fill pointer in terms of tuple size

DEF-TUPLE-SETTER (TYPE-NAME)

Creates a tuple-setter for setting a tuple place from a mutiple-value tuple. eg (vector3d-setter up #{ 0.0 1.0 0.0 })

DEF-TUPLE-TYPESPEC (TYPE-NAME)

Create an alias typespec eg. (deftype vector3d* () `(values 'single-float 'single-float 'single-float))

DEF-WITH-TUPLE (TYPE-NAME)

Create a macro that can be used to bind members of a value tuple to symbols to symbols e-g (with-vector thing-vec (x y z w) &body forms)

DEF-WITH-TUPLE* (TYPE-NAME)

Create a macro that can be used to bind members of the tuples place to symbols to symbols e-g (with-vector* thing-vec #(x y z w) &body forms)

DEF-WITH-TUPLE-AREF (TYPE-NAME)

Create a macro that can be used to bind elements of an array of tuples to symbols e-g (with-vector3d-aref (thing-vec 5 (x y z w)) (+ x y z w))

INTERSECT-AABB* (AABB0 AABB1)

DEF-TUPLE-OP INTERSECT-AABB* (AABB AABB)

MAKE-TEST-MATRIX44*

Return a matrix for testing purposes

MAKE-VERTEX2D (&REST ELEMENTS)

Create an array sutable for holding a single VERTEX2D and initialize it from a multiple-values form

MAKE-VERTEX2D* (TUPLE-VALUES)

Create an array sutable for holding a single VERTEX2D and initialize it from a form

MATRIX-DOT (DIMENSION ROW COL)

Generate the symbols required for a dot product between the row and column of a matrix

NEW-VERTEX2D

Create an array suitable for holding a single VERTEX2D

ONCE-ONLY ((&REST NAMES) &BODY BODY)

Evaluate arguments once only in macro form body

RECT-HEIGHT* (R)

DEF-TUPLE-OP RECT-HEIGHT* (RECT)

RECT-WIDTH* (R)

DEF-TUPLE-OP RECT-WIDTH* (RECT)

TRANSFORM-AABB* (MAT BOX)

DEF-TUPLE-OP TRANSFORM-AABB* (MATRIX44 AABB)

VECTOR3D-MATRIX3D* (ZVEC YVEC)

Construct a rotation matrix from 2 vectors

VERTEX2D* (TUPLE-ARRAY-NAME)

Unpack array representation of an VERTEX2D and convert to multiple values.

VERTEX2D-AREF* (TUPLE-ARRAY ARRAY-INDEX)

Unpack individual VERTEX2D to multiple values from an array of VERTEX2Ds.

VERTEX2D-AREF-SETTER* (ARRAY-NAME ARRAY-INDEX TUPLE-VALUES)

Creates a macro for setting an VERTEX2D vector in a vector of VERTEX2Ds from a multiple values VERTEX2D

VERTEX2D-SETTER* (TUPLE-PLACE TUPLE-VALUES)

Creates a macro for setting an VERTEX2D vector from a multiple values VERTEX2D

VERTEX2D-VALUES* (&REST ELEMENTS)

Convert VERTEX2D forms to multiple values.

VERTEX2D-VECTOR-PUSH* (TUPLE-VALUES ARRAY-NAME)

Push a VERTEX2D multiple value onto the end of a vector of VERTEX2D's

VERTEX2D-VECTOR-PUSH-EXTEND* (TUPLE-VALUES ARRAY-NAME)

Push a VERTEX2D multiple value onto the end of a vector of VERTEX2D's with the possibility of extension

WITH-GENSYMS ((&REST NAMES) &BODY BODY)

Classic macro for creating named unique symbols.

WITH-VERTEX2D (TUPLE-PLACE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VERTEX2D multiple value to symbols.

WITH-VERTEX2D* (TUPLE ELEMENT-SYMS &BODY FORMS)

Bind elements of a VERTEX2D vector to symbols.

WITH-VERTEX2D-AREF ((ARRAY-NAME INDEX ELEMENT-SYMS) &BODY FORMS)

Bind the elements of a VERTEX2D from vector of VERTEX2D's to symbols

Undocumented

DEF-TUPLE-ARRAY-TYPESPEC (TYPE-NAME)

DEF-TUPLE-DOCUMENTATION (TYPE-NAME)

DEF-TUPLE-SET (TYPE-NAME)

DEF-TUPLE-STRUCT (TYPE-NAME)

DEF-TUPLE-VECTOR-PUSH (TYPE-NAME)

DEF-TUPLE-VECTOR-PUSH* (TYPE-NAME)

DEF-TUPLE-VECTOR-PUSH-EXTEND (TYPE-NAME)

DEF-TUPLE-VECTOR-PUSH-EXTEND* (TYPE-NAME)

EXPORT-TUPLE-OPERATIONS (TYPE-NAME)

MAKE-TUPLE-OPERATIONS (TYPE-NAME)

GENERIC-FUNCTION

Private

Undocumented

TUPLE-EXPANSION-FN (TYPE-NAME EXPANSION)

TUPLE-SYMBOL (TYPE-NAME EXPANSION)

VARIABLE

Private

Undocumented

*TUPLE-EXPANDER-KEYWORDS*