Math Types & Utilities (mathutils)

Math Types & Utilities (mathutils)#

This module provides access to math operations.

Note

Classes, methods and attributes that accept vectors also accept other numeric sequences, such as tuples, lists.

Submodules:

The mathutils module provides the following classes:

Color,
Euler,
Matrix,
Quaternion,
Vector,

import mathutils
from math import radians

vec = mathutils.Vector((1.0, 2.0, 3.0))

mat_rot = mathutils.Matrix.Rotation(radians(90.0), 4, 'X')
mat_trans = mathutils.Matrix.Translation(vec)

mat = mat_trans * mat_rot
mat.invert()

mat3 = mat.to_3x3()
quat1 = mat.to_quaternion()
quat2 = mat3.to_quaternion()

quat_diff = quat1.rotation_difference(quat2)

print(quat_diff.angle)

Color#

class mathutils.Color(rgb)#

This object gives access to Colors in Blender.

Parameters:: rgb (3d vector) – (r, g, b) color values

import mathutils

# color values are represented as RGB values from 0 - 1, this is blue
col = mathutils.Color((0.0, 0.0, 1.0))

# as well as r/g/b attribute access you can adjust them by h/s/v
col.s *= 0.5

# you can access its components by attribute or index
print("Color R:", col.r)
print("Color G:", col[1])
print("Color B:", col[-1])
print("Color HSV: %.2f, %.2f, %.2f", col[:])


# components of an existing color can be set
col[:] = 0.0, 0.5, 1.0

# components of an existing color can use slice notation to get a tuple
print("Values: %f, %f, %f" % col[:])

# colors can be added and subtracted
col += mathutils.Color((0.25, 0.0, 0.0))

# Color can be multiplied, in this example color is scaled to 0-255
# can printed as integers
print("Color: %d, %d, %d" % (col * 255.0)[:])

# This example prints the color as hexidecimal
print("Hexidecimal: %.2x%.2x%.2x" % (col * 255.0)[:])

copy()#

Returns a copy of this color.

Returns:: A copy of the color.
Return type:: Color

Note

use this to get a copy of a wrapped color with no reference to the original data.

freeze()#

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns:: An instance of this object.

b#

Blue color channel.

Type:: float

g#

Green color channel.

Type:: float

h#

HSV Hue component in [0, 1].

Type:: float

hsv#

HSV Values in [0, 1].

Type:: float triplet

is_frozen#

True when this object has been frozen (read-only).

Type:: boolean

is_wrapped#

True when this object wraps external data (read-only).

Type:: boolean

owner#: The item this is wrapping or None (read-only).

r#

Red color channel.

Type:: float

s#

HSV Saturation component in [0, 1].

Type:: float

v#

HSV Value component in [0, 1].

Type:: float

Euler#

class mathutils.Euler(angles, order='XYZ')#

This object gives access to Eulers in Blender.

Parameters:

angles (3d vector) – Three angles, in radians.
order (str) – Optional order of the angles, a permutation of XYZ.

import mathutils
import math

# create a new euler with default axis rotation order
eul = mathutils.Euler((0.0, math.radians(45.0), 0.0), 'XYZ')

# rotate the euler
eul.rotate_axis('Z', math.radians(10.0))

# you can access its components by attribute or index
print("Euler X", eul.x)
print("Euler Y", eul[1])
print("Euler Z", eul[-1])

# components of an existing euler can be set
eul[:] = 1.0, 2.0, 3.0

# components of an existing euler can use slice notation to get a tuple
print("Values: %f, %f, %f" % eul[:])

# the order can be set at any time too
eul.order = 'ZYX'

# eulers can be used to rotate vectors
vec = mathutils.Vector((0.0, 0.0, 1.0))
vec.rotate(eul)

# often its useful to convert the euler into a matrix so it can be used as
# transformations with more flexibility
mat_rot = eul.to_matrix()
mat_loc = mathutils.Matrix.Translation((2.0, 3.0, 4.0))
mat = mat_loc * mat_rot.to_4x4()

copy()#

Returns a copy of this euler.

Returns:: A copy of the euler.
Return type:: Euler

Note

use this to get a copy of a wrapped euler with no reference to the original data.

freeze()#

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns:: An instance of this object.

make_compatible(other)#: Make this euler compatible with another, so interpolating between them works as intended.

Note

the rotation order is not taken into account for this function.

rotate(other)#

Rotates the euler by another mathutils value.

Parameters:: other (Euler, Quaternion or Matrix) – rotation component of mathutils value

rotate_axis(axis, angle)#

Rotates the euler a certain amount and returning a unique euler rotation (no 720 degree pitches).

Parameters:

axis (string) – single character in [‘X, ‘Y’, ‘Z’].
angle (float) – angle in radians.

to_matrix()#

Return a matrix representation of the euler.

Returns:: A 3x3 roation matrix representation of the euler.
Return type:: Matrix

to_quaternion()#

Return a quaternion representation of the euler.

Returns:: Quaternion representation of the euler.
Return type:: Quaternion

zero()#: Set all values to zero.

is_frozen#

True when this object has been frozen (read-only).

Type:: boolean

is_wrapped#

True when this object wraps external data (read-only).

Type:: boolean

order#

Euler rotation order.

Type:: string in [‘XYZ’, ‘XZY’, ‘YXZ’, ‘YZX’, ‘ZXY’, ‘ZYX’]

owner#: The item this is wrapping or None (read-only).

x#

Euler axis angle in radians.

Type:: float

y#

Euler axis angle in radians.

Type:: float

z#

Euler axis angle in radians.

Type:: float

Matrix#

class mathutils.Matrix([rows])#

This object gives access to Matrices in Blender, supporting square and rectangular matrices from 2x2 up to 4x4.

Parameters:: rows (2d number sequence) – Sequence of rows. When ommitted, a 4x4 identity matrix is constructed.

import mathutils
import math

# create a location matrix
mat_loc = mathutils.Matrix.Translation((2.0, 3.0, 4.0))

# create an identitiy matrix
mat_sca = mathutils.Matrix.Scale(0.5, 4, (0.0, 0.0, 1.0))

# create a rotation matrix
mat_rot = mathutils.Matrix.Rotation(math.radians(45.0), 4, 'X')

# combine transformations
mat_out = mat_loc * mat_rot * mat_sca
print(mat_out)

# extract components back out of the matrix
loc, rot, sca = mat_out.decompose()
print(loc, rot, sca)

# it can also be useful to access components of a matrix directly
mat = mathutils.Matrix()
mat[0][0], mat[1][0], mat[2][0] = 0.0, 1.0, 2.0

mat[0][0:3] = 0.0, 1.0, 2.0

# each item in a matrix is a vector so vector utility functions can be used
mat[0].xyz = 0.0, 1.0, 2.0

classmethod Identity(size)#

Create an identity matrix.

Parameters:: size (int) – The size of the identity matrix to construct [2, 4].
Returns:: A new identity matrix.
Return type:: Matrix

classmethod OrthoProjection(axis, size)#

Create a matrix to represent an orthographic projection.

Parameters:

axis (string or Vector) – Can be any of the following: [‘X’, ‘Y’, ‘XY’, ‘XZ’, ‘YZ’], where a single axis is for a 2D matrix. Or a vector for an arbitrary axis
size (int) – The size of the projection matrix to construct [2, 4].

Returns:

A new projection matrix.

Return type:

Matrix

classmethod Rotation(angle, size, axis)#

Create a matrix representing a rotation.

Parameters:

angle (float) – The angle of rotation desired, in radians.
size (int) – The size of the rotation matrix to construct [2, 4].
axis (string or Vector) – a string in [‘X’, ‘Y’, ‘Z’] or a 3D Vector Object (optional when size is 2).

Returns:

A new rotation matrix.

Return type:

Matrix

classmethod Scale(factor, size, axis)#

Create a matrix representing a scaling.

Parameters:

factor (float) – The factor of scaling to apply.
size (int) – The size of the scale matrix to construct [2, 4].
axis (Vector) – Direction to influence scale. (optional).

Returns:

A new scale matrix.

Return type:

Matrix

classmethod Shear(plane, size, factor)#

Create a matrix to represent an shear transformation.

Parameters:

plane (string) – Can be any of the following: [‘X’, ‘Y’, ‘XY’, ‘XZ’, ‘YZ’], where a single axis is for a 2D matrix only.
size (int) – The size of the shear matrix to construct [2, 4].
factor (float or float pair) – The factor of shear to apply. For a 3 or 4 size matrix pass a pair of floats corresponding with the plane axis.

Returns:

A new shear matrix.

Return type:

Matrix

classmethod Translation(vector)#

Create a matrix representing a translation.

Parameters:: vector (Vector) – The translation vector.
Returns:: An identity matrix with a translation.
Return type:: Matrix

adjugate()#: Set the matrix to its adjugate.

Note

When the matrix cannot be adjugated a ValueError exception is raised.

See also

Adjugate matrix <https://en.wikipedia.org/wiki/Adjugate_matrix> on Wikipedia.

adjugated()#

Return an adjugated copy of the matrix.

Returns:: the adjugated matrix.
Return type:: Matrix

Note

When the matrix cant be adjugated a ValueError exception is raised.

copy()#

Returns a copy of this matrix.

Returns:: an instance of itself
Return type:: Matrix

decompose()#

Return the translation, rotation and scale components of this matrix.

Returns:: trans, rot, scale triple.
Return type:: (Vector, Quaternion, Vector)

determinant()#

Return the determinant of a matrix.

Returns:: Return the determinant of a matrix.
Return type:: float

Quaternion#

class mathutils.Quaternion([seq[, angle]])#

This object gives access to Quaternions in Blender.

Parameters:

seq (Vector) – size 3 or 4
angle (float) – rotation angle, in radians

The constructor takes arguments in various forms:

(), no args: Create an identity quaternion
(wxyz): Create a quaternion from a (w, x, y, z) vector.
(exponential_map): Create a quaternion from a 3d exponential map vector.

See also

to_exponential_map()
(axis, angle): Create a quaternion representing a rotation of angle radians over axis.

See also

to_axis_angle()

import mathutils
import math

# a new rotation 90 degrees about the Y axis
quat_a = mathutils.Quaternion((0.7071068, 0.0, 0.7071068, 0.0))

# passing values to Quaternion's directly can be confusing so axis, angle
# is supported for initializing too
quat_b = mathutils.Quaternion((0.0, 1.0, 0.0), math.radians(90.0))

print("Check quaternions match", quat_a == quat_b)

# like matrices, quaternions can be multiplied to accumulate rotational values
quat_a = mathutils.Quaternion((0.0, 1.0, 0.0), math.radians(90.0))
quat_b = mathutils.Quaternion((0.0, 0.0, 1.0), math.radians(45.0))
quat_out = quat_a * quat_b

# print the quat, euler degrees for mear mortals and (axis, angle)
print("Final Rotation:")
print(quat_out)
print("%.2f, %.2f, %.2f" % tuple(math.degrees(a) for a in quat_out.to_euler()))
print("(%.2f, %.2f, %.2f), %.2f" % (quat_out.axis[:] +
                                    (math.degrees(quat_out.angle), )))

# multiple rotations can be interpolated using the exponential map
quat_c = mathutils.Quaternion((1.0, 0.0, 0.0), math.radians(15.0))
exp_avg = (quat_a.to_exponential_map() +
           quat_b.to_exponential_map() +
           quat_c.to_exponential_map()) / 3.0
quat_avg = mathutils.Quaternion(exp_avg)
print("Average rotation:")
print(quat_avg)

conjugate()#: Set the quaternion to its conjugate (negate x, y, z).

conjugated()#

Return a new conjugated quaternion.

Returns:: a new quaternion.
Return type:: Quaternion

copy()#

Returns a copy of this quaternion.

Returns:: A copy of the quaternion.
Return type:: Quaternion

Note

use this to get a copy of a wrapped quaternion with no reference to the original data.

cross(other)#

Return the cross product of this quaternion and another.

Parameters:: other (Quaternion) – The other quaternion to perform the cross product with.
Returns:: The cross product.
Return type:: Quaternion

dot(other)#

Return the dot product of this quaternion and another.

Parameters:: other (Quaternion) – The other quaternion to perform the dot product with.
Returns:: The dot product.
Return type:: Quaternion

freeze()#

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns:: An instance of this object.

identity()#

Set the quaternion to an identity quaternion.

Return type:: Quaternion

invert()#: Set the quaternion to its inverse.

inverted()#

Return a new, inverted quaternion.

Returns:: the inverted value.
Return type:: Quaternion

negate()#

Set the quaternion to its negative.

Return type:: Quaternion

normalize()#: Normalize the quaternion.

normalized()#

Return a new normalized quaternion.

Returns:: a normalized copy.
Return type:: Quaternion

rotate(other)#

Rotates the quaternion by another mathutils value.

Parameters:: other (Euler, Quaternion or Matrix) – rotation component of mathutils value

rotation_difference(other)#

Returns a quaternion representing the rotational difference.

Parameters:: other (Quaternion) – second quaternion.
Returns:: the rotational difference between the two quat rotations.
Return type:: Quaternion

slerp(other, factor)#

Returns the interpolation of two quaternions.

Parameters:

other (Quaternion) – value to interpolate with.
factor (float) – The interpolation value in [0.0, 1.0].

Returns:

The interpolated rotation.

Return type:

Quaternion

to_axis_angle()#

Return the axis, angle representation of the quaternion.

Returns:: axis, angle.
Return type:: (Vector, float) pair

to_euler(order, euler_compat)#

Return Euler representation of the quaternion.

Parameters:

order (string) – Optional rotation order argument in [‘XYZ’, ‘XZY’, ‘YXZ’, ‘YZX’, ‘ZXY’, ‘ZYX’].
euler_compat (Euler) – Optional euler argument the new euler will be made compatible with (no axis flipping between them). Useful for converting a series of matrices to animation curves.

Returns:

Euler representation of the quaternion.

Return type:

Euler

to_exponential_map()#

Return the exponential map representation of the quaternion.

This representation consist of the rotation axis multiplied by the rotation angle. Such a representation is useful for interpolation between multiple orientations.

Returns:: exponential map.
Return type:: Vector of size 3

To convert back to a quaternion, pass it to the Quaternion constructor.

to_matrix()#

Return a matrix representation of the quaternion.

Returns:: A 3x3 rotation matrix representation of the quaternion.
Return type:: Matrix

angle#

Angle of the quaternion.

Type:: float

axis#

Quaternion axis as a vector.

Type:: Vector

is_frozen#

True when this object has been frozen (read-only).

Type:: boolean

is_wrapped#

True when this object wraps external data (read-only).

Type:: boolean

magnitude#

Size of the quaternion (read-only).

Type:: float

owner#: The item this is wrapping or None (read-only).

w#

Quaternion axis value.

Type:: float

x#

Quaternion axis value.

Type:: float

y#

Quaternion axis value.

Type:: float

z#

Quaternion axis value.

Type:: float

Vector#

class mathutils.Vector(seq)#

This object gives access to Vectors in Blender.

Parameters:: seq (sequence of numbers) – Components of the vector, must be a sequence of at least two

import mathutils

# zero length vector
vec = mathutils.Vector((0.0, 0.0, 1.0))

# unit length vector
vec_a = vec.normalized()

vec_b = mathutils.Vector((0.0, 1.0, 2.0))

vec2d = mathutils.Vector((1.0, 2.0))
vec3d = mathutils.Vector((1.0, 0.0, 0.0))
vec4d = vec_a.to_4d()

# other mathutuls types
quat = mathutils.Quaternion()
matrix = mathutils.Matrix()

# Comparison operators can be done on Vector classes:

# (In)equality operators == and != test component values, e.g. 1,2,3 != 3,2,1
vec_a == vec_b
vec_a != vec_b

# Ordering operators >, >=, > and <= test vector length.
vec_a > vec_b
vec_a >= vec_b
vec_a < vec_b
vec_a <= vec_b


# Math can be performed on Vector classes
vec_a + vec_b
vec_a - vec_b
vec_a * vec_b
vec_a * 10.0
matrix * vec_a
quat * vec_a
vec_a * vec_b
-vec_a


# You can access a vector object like a sequence
x = vec_a[0]
len(vec)
vec_a[:] = vec_b
vec_a[:] = 1.0, 2.0, 3.0
vec2d[:] = vec3d[:2]


# Vectors support 'swizzle' operations
# See https://en.wikipedia.org/wiki/Swizzling_(computer_graphics)
vec.xyz = vec.zyx
vec.xy = vec4d.zw
vec.xyz = vec4d.wzz
vec4d.wxyz = vec.yxyx

classmethod Fill(size, fill=0.0)#

Create a vector of length size with all values set to fill.

Parameters:

size (int) – The length of the vector to be created.
fill (float) – The value used to fill the vector.

classmethod Linspace(start, stop, size)#

Create a vector of the specified size which is filled with linearly spaced values between start and stop values.

Parameters:

start (int) – The start of the range used to fill the vector.
stop (int) – The end of the range used to fill the vector.
size (int) – The size of the vector to be created.

classmethod Range(start=0, stop, step=1)#

Create a filled with a range of values.

Parameters:

start (int) – The start of the range used to fill the vector.
stop (int) – The end of the range used to fill the vector.
step (int) – The step between successive values in the vector.

classmethod Repeat(vector, size)#

Create a vector by repeating the values in vector until the required size is reached.

Parameters:

tuple (mathutils.Vector) – The vector to draw values from.
size (int) – The size of the vector to be created.

angle(other, fallback=None)#

Return the angle between two vectors.

Parameters:

other (Vector) – another vector to compare the angle with
fallback (any) – return this when the angle can’t be calculated (zero length vector), (instead of raising a ValueError).

Returns:

angle in radians or fallback when given

Return type:

float

angle_signed(other, fallback)#

Return the signed angle between two 2D vectors (clockwise is positive).

Parameters:

other (Vector) – another vector to compare the angle with
fallback (any) – return this when the angle can’t be calculated (zero length vector), (instead of raising a ValueError).

Returns:

angle in radians or fallback when given

Return type:

float

copy()#

Returns a copy of this vector.

Returns:: A copy of the vector.
Return type:: Vector

Note

use this to get a copy of a wrapped vector with no reference to the original data.

cross(other)#

Return the cross product of this vector and another.

Parameters:: other (Vector) – The other vector to perform the cross product with.
Returns:: The cross product.
Return type:: Vector or float when 2D vectors are used

Note

both vectors must be 2D or 3D

dot(other)#

Return the dot product of this vector and another.

Parameters:: other (Vector) – The other vector to perform the dot product with.
Returns:: The dot product.
Return type:: Vector

freeze()#

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns:: An instance of this object.

lerp(other, factor)#

Returns the interpolation of two vectors.

Parameters:

other (Vector) – value to interpolate with.
factor (float) – The interpolation value in [0.0, 1.0].

Returns:

The interpolated vector.

Return type:

Vector

negate()#: Set all values to their negative.

normalize()#: Normalize the vector, making the length of the vector always 1.0.

Warning

Normalizing a vector where all values are zero has no effect.

Note

Normalize works for vectors of all sizes, however 4D Vectors w axis is left untouched.

normalized()#

Return a new, normalized vector.

Returns:: a normalized copy of the vector
Return type:: Vector

orthogonal()#

Return a perpendicular vector.

Returns:: a new vector 90 degrees from this vector.
Return type:: Vector

Note

the axis is undefined, only use when any orthogonal vector is acceptable.

project(other)#

Return the projection of this vector onto the other.

Parameters:: other (Vector) – second vector.
Returns:: the parallel projection vector
Return type:: Vector

reflect(mirror)#

Return the reflection vector from the mirror argument.

Parameters:: mirror (Vector) – This vector could be a normal from the reflecting surface.
Returns:: The reflected vector matching the size of this vector.
Return type:: Vector

resize(size=3)#: Resize the vector to have size number of elements.

resize_2d()#: Resize the vector to 2D (x, y).

resize_3d()#: Resize the vector to 3D (x, y, z).

resize_4d()#: Resize the vector to 4D (x, y, z, w).

resized(size=3)#

Return a resized copy of the vector with size number of elements.

Returns:: a new vector
Return type:: Vector

rotate(other)#

Rotate the vector by a rotation value.

Parameters:: other (Euler, Quaternion or Matrix) – rotation component of mathutils value

rotation_difference(other)#

Returns a quaternion representing the rotational difference between this vector and another.

Parameters:: other (Vector) – second vector.
Returns:: the rotational difference between the two vectors.
Return type:: Quaternion

Note

2D vectors raise an AttributeError.

slerp(other, factor, fallback=None)#

Returns the interpolation of two non-zero vectors (spherical coordinates).

Parameters:

other (Vector) – value to interpolate with.
factor (float) – The interpolation value typically in [0.0, 1.0].
fallback (any) – return this when the vector can’t be calculated (zero length vector or direct opposites), (instead of raising a ValueError).

Returns:

The interpolated vector.

Return type:

Vector

to_2d()#

Return a 2d copy of the vector.

Returns:: a new vector
Return type:: Vector

to_3d()#

Return a 3d copy of the vector.

Returns:: a new vector
Return type:: Vector

to_4d()#

Return a 4d copy of the vector.

Returns:: a new vector
Return type:: Vector

to_track_quat(track, up)#

Return a quaternion rotation from the vector and the track and up axis.

Parameters:

track (string) – Track axis in [‘X’, ‘Y’, ‘Z’, ‘-X’, ‘-Y’, ‘-Z’].
up (string) – Up axis in [‘X’, ‘Y’, ‘Z’].

Returns:

rotation from the vector and the track and up axis.

Return type:

Quaternion

to_tuple(precision=-1)#

Return this vector as a tuple with.

Parameters:: precision (int) – The number to round the value to in [-1, 21].
Returns:: the values of the vector rounded by precision
Return type:: tuple

zero()#: Set all values to zero.

is_frozen#

True when this object has been frozen (read-only).

Type:: boolean

is_wrapped#

True when this object wraps external data (read-only).

Type:: boolean

length#

Vector Length.

Type:: float

length_squared#

Vector length squared (v.dot(v)).

Type:: float

magnitude#

Vector Length.

Type:: float

owner#: The item this is wrapping or None (read-only).

w#

Vector W axis (4D Vectors only).

Type:: float

ww#: Undocumented

www#: Undocumented

wwww#: Undocumented

wwwx#: Undocumented

wwwy#: Undocumented

wwwz#: Undocumented

wwx#: Undocumented

wwxw#: Undocumented

wwxx#: Undocumented

wwxy#: Undocumented

wwxz#: Undocumented

wwy#: Undocumented

wwyw#: Undocumented

wwyx#: Undocumented

wwyy#: Undocumented

wwyz#: Undocumented

wwz#: Undocumented

wwzw#: Undocumented

wwzx#: Undocumented

wwzy#: Undocumented

wwzz#: Undocumented

wx#: Undocumented

wxw#: Undocumented

wxww#: Undocumented

wxwx#: Undocumented

wxwy#: Undocumented

wxwz#: Undocumented

wxx#: Undocumented

wxxw#: Undocumented

wxxx#: Undocumented

wxxy#: Undocumented

wxxz#: Undocumented

wxy#: Undocumented

wxyw#: Undocumented

wxyx#: Undocumented

wxyy#: Undocumented

wxyz#: Undocumented

wxz#: Undocumented

wxzw#: Undocumented

wxzx#: Undocumented

wxzy#: Undocumented

wxzz#: Undocumented

wy#: Undocumented

wyw#: Undocumented

wyww#: Undocumented

wywx#: Undocumented

wywy#: Undocumented

wywz#: Undocumented

wyx#: Undocumented

wyxw#: Undocumented

wyxx#: Undocumented

wyxy#: Undocumented

wyxz#: Undocumented

wyy#: Undocumented

wyyw#: Undocumented

wyyx#: Undocumented

wyyy#: Undocumented

wyyz#: Undocumented

wyz#: Undocumented

wyzw#: Undocumented

wyzx#: Undocumented

wyzy#: Undocumented

wyzz#: Undocumented

wz#: Undocumented

wzw#: Undocumented

wzww#: Undocumented

wzwx#: Undocumented

wzwy#: Undocumented

wzwz#: Undocumented

wzx#: Undocumented

wzxw#: Undocumented

wzxx#: Undocumented

wzxy#: Undocumented

wzxz#: Undocumented

wzy#: Undocumented

wzyw#: Undocumented

wzyx#: Undocumented

wzyy#: Undocumented

wzyz#: Undocumented

wzz#: Undocumented

wzzw#: Undocumented

wzzx#: Undocumented

wzzy#: Undocumented

wzzz#: Undocumented

x#

Vector X axis.

Type:: float

xw#: Undocumented

xww#: Undocumented

xwww#: Undocumented

xwwx#: Undocumented

xwwy#: Undocumented

xwwz#: Undocumented

xwx#: Undocumented

xwxw#: Undocumented

xwxx#: Undocumented

xwxy#: Undocumented

xwxz#: Undocumented

xwy#: Undocumented

xwyw#: Undocumented

xwyx#: Undocumented

xwyy#: Undocumented

xwyz#: Undocumented

xwz#: Undocumented

xwzw#: Undocumented

xwzx#: Undocumented

xwzy#: Undocumented

xwzz#: Undocumented

xx#: Undocumented

xxw#: Undocumented

xxww#: Undocumented

xxwx#: Undocumented

xxwy#: Undocumented

xxwz#: Undocumented

xxx#: Undocumented

xxxw#: Undocumented

xxxx#: Undocumented

xxxy#: Undocumented

xxxz#: Undocumented

xxy#: Undocumented

xxyw#: Undocumented

xxyx#: Undocumented

xxyy#: Undocumented

xxyz#: Undocumented

xxz#: Undocumented

xxzw#: Undocumented

xxzx#: Undocumented

xxzy#: Undocumented

xxzz#: Undocumented

xy#: Undocumented

xyw#: Undocumented

xyww#: Undocumented

xywx#: Undocumented

xywy#: Undocumented

xywz#: Undocumented

xyx#: Undocumented

xyxw#: Undocumented

xyxx#: Undocumented

xyxy#: Undocumented

xyxz#: Undocumented

xyy#: Undocumented

xyyw#: Undocumented

xyyx#: Undocumented

xyyy#: Undocumented

xyyz#: Undocumented

xyz#: Undocumented

xyzw#: Undocumented

xyzx#: Undocumented

xyzy#: Undocumented

xyzz#: Undocumented

xz#: Undocumented

xzw#: Undocumented

xzww#: Undocumented

xzwx#: Undocumented

xzwy#: Undocumented

xzwz#: Undocumented

xzx#: Undocumented

xzxw#: Undocumented

xzxx#: Undocumented

xzxy#: Undocumented

xzxz#: Undocumented

xzy#: Undocumented

xzyw#: Undocumented

xzyx#: Undocumented

xzyy#: Undocumented

xzyz#: Undocumented

xzz#: Undocumented

xzzw#: Undocumented

xzzx#: Undocumented

xzzy#: Undocumented

xzzz#: Undocumented

y#

Vector Y axis.

Type:: float

yw#: Undocumented

yww#: Undocumented

ywww#: Undocumented

ywwx#: Undocumented

ywwy#: Undocumented

ywwz#: Undocumented

ywx#: Undocumented

ywxw#: Undocumented

ywxx#: Undocumented

ywxy#: Undocumented

ywxz#: Undocumented

ywy#: Undocumented

ywyw#: Undocumented

ywyx#: Undocumented

ywyy#: Undocumented

ywyz#: Undocumented

ywz#: Undocumented

ywzw#: Undocumented

ywzx#: Undocumented

ywzy#: Undocumented

ywzz#: Undocumented

yx#: Undocumented

yxw#: Undocumented

yxww#: Undocumented

yxwx#: Undocumented

yxwy#: Undocumented

yxwz#: Undocumented

yxx#: Undocumented

yxxw#: Undocumented

yxxx#: Undocumented

yxxy#: Undocumented

yxxz#: Undocumented

yxy#: Undocumented

yxyw#: Undocumented

yxyx#: Undocumented

yxyy#: Undocumented

yxyz#: Undocumented

yxz#: Undocumented

yxzw#: Undocumented

yxzx#: Undocumented

yxzy#: Undocumented

yxzz#: Undocumented

yy#: Undocumented

yyw#: Undocumented

yyww#: Undocumented

yywx#: Undocumented

yywy#: Undocumented

yywz#: Undocumented

yyx#: Undocumented

yyxw#: Undocumented

yyxx#: Undocumented

yyxy#: Undocumented

yyxz#: Undocumented

yyy#: Undocumented

yyyw#: Undocumented

yyyx#: Undocumented

yyyy#: Undocumented

yyyz#: Undocumented

yyz#: Undocumented

yyzw#: Undocumented

yyzx#: Undocumented

yyzy#: Undocumented

yyzz#: Undocumented

yz#: Undocumented

yzw#: Undocumented

yzww#: Undocumented

yzwx#: Undocumented

yzwy#: Undocumented

yzwz#: Undocumented

yzx#: Undocumented

yzxw#: Undocumented

yzxx#: Undocumented

yzxy#: Undocumented

yzxz#: Undocumented

yzy#: Undocumented

yzyw#: Undocumented

yzyx#: Undocumented

yzyy#: Undocumented

yzyz#: Undocumented

yzz#: Undocumented

yzzw#: Undocumented

yzzx#: Undocumented

yzzy#: Undocumented

yzzz#: Undocumented

z#

Vector Z axis (3D Vectors only).

Type:: float

zw#: Undocumented

zww#: Undocumented

zwww#: Undocumented

zwwx#: Undocumented

zwwy#: Undocumented

zwwz#: Undocumented

zwx#: Undocumented

zwxw#: Undocumented

zwxx#: Undocumented

zwxy#: Undocumented

zwxz#: Undocumented

zwy#: Undocumented

zwyw#: Undocumented

zwyx#: Undocumented

zwyy#: Undocumented

zwyz#: Undocumented

zwz#: Undocumented

zwzw#: Undocumented

zwzx#: Undocumented

zwzy#: Undocumented

zwzz#: Undocumented

zx#: Undocumented

zxw#: Undocumented

zxww#: Undocumented

zxwx#: Undocumented

zxwy#: Undocumented

zxwz#: Undocumented

zxx#: Undocumented

zxxw#: Undocumented

zxxx#: Undocumented

zxxy#: Undocumented

zxxz#: Undocumented

zxy#: Undocumented

zxyw#: Undocumented

zxyx#: Undocumented

zxyy#: Undocumented

zxyz#: Undocumented

zxz#: Undocumented

zxzw#: Undocumented

zxzx#: Undocumented

zxzy#: Undocumented

zxzz#: Undocumented

zy#: Undocumented

zyw#: Undocumented

zyww#: Undocumented

zywx#: Undocumented

zywy#: Undocumented

zywz#: Undocumented

zyx#: Undocumented

zyxw#: Undocumented

zyxx#: Undocumented

zyxy#: Undocumented

zyxz#: Undocumented

zyy#: Undocumented

zyyw#: Undocumented

zyyx#: Undocumented

zyyy#: Undocumented

zyyz#: Undocumented

zyz#: Undocumented

zyzw#: Undocumented

zyzx#: Undocumented

zyzy#: Undocumented

zyzz#: Undocumented

zz#: Undocumented

zzw#: Undocumented

zzww#: Undocumented

zzwx#: Undocumented

zzwy#: Undocumented

zzwz#: Undocumented

zzx#: Undocumented

zzxw#: Undocumented

zzxx#: Undocumented

zzxy#: Undocumented

zzxz#: Undocumented

zzy#: Undocumented

zzyw#: Undocumented

zzyx#: Undocumented

zzyy#: Undocumented

zzyz#: Undocumented

zzz#: Undocumented

zzzw#: Undocumented

zzzx#: Undocumented

zzzy#: Undocumented

zzzz#: Undocumented

Math Types & Utilities (mathutils)

Contents

Math Types & Utilities (mathutils)#

Color#

Euler#

Matrix#

Quaternion#

Vector#