@spec identity() :: {:ok, t()} | {:error, term()}

Returns the identity transform matrix.

On success, returns {:ok, matrix}.

On failure, returns {:error, reason}.

@spec identity!() :: t()

Same as identity/0, but returns the matrix directly.

On success, returns matrix.

On failure, raises Blendend.Error.

@spec invert(t()) :: {:ok, t()} | {:error, term()}

Inverts the matrix, returning a new matrix.

Examples:

iex> use Blendend.Draw
iex> scale = matrix(do: scale(2, 1))
iex> Blendend.Matrix2D.invert!(scale) |> Blendend.Matrix2D.to_list!
[0.5, -0.0, -0.0, 1.0, -0.0, -0.0]

@spec invert!(t()) :: t()

Same as invert/1, but returns the matrix directly.

@spec make_sin_cos(number(), number(), number(), number()) ::
  {:ok, t()} | {:error, term()}

Constructs a matrix from precomputed sin/cos and optional translation tx/ty.

@spec make_sin_cos!(number(), number(), number(), number()) :: t()

Same as make_sin_cos/4, but returns the matrix directly.

@spec map_point(t(), number(), number()) ::
  {:ok, {number(), number()}} | {:error, term()}

Maps a point {x, y} through the matrix, returning {ok, {x, y}}.

@spec map_point!(t(), number(), number()) :: {number(), number()}

Same as map_point/3, but returns the tuple directly.

@spec map_vector(t(), number(), number()) ::
  {:ok, {number(), number()}} | {:error, term()}

Maps a vector {x, y} through the matrix (ignores translation), returning {ok, {x, y}}.

Examples:

iex> use Blendend.Draw
iex> scale = matrix(do: scale(2, 1))
iex> Blendend.Matrix2D.map_vector!(scale, 2, 3)
{4.0, 3.0}

iex> translate = matrix(do: translate(10, 10))
iex> Blendend.Matrix2D.map_vector!(translate, 2, 3)
{2.0, 3.0}

@spec map_vector!(t(), number(), number()) :: {number(), number()}

Same as map_vector/3, but returns the tuple directly.

@spec new([number()]) :: {:ok, t()} | {:error, term()}

Creates a matrix from a 6-element list [m00, m01, m10, m11, tx, ty].

On success, returns {:ok, matrix} where matrix is a Blendend.Matrix2D.t().

On failure, returns {:error, reason}.

@spec new!([number()]) :: t()

Same as new/1, but returns the matrix directly.

On success, returns matrix.

On failure, raises Blendend.Error.

@spec post_rotate(t(), number(), number(), number()) :: {:ok, t()} | {:error, term()}

Returns rotation * matrix, applying the rotation about {cx, cy} before the existing transform.

@spec post_rotate!(t(), number(), number(), number()) :: t()

Same as post_rotate/4, but returns the rotated matrix directly.

@spec post_scale(t(), number(), number()) :: {:ok, t()} | {:error, term()}

Returns scale * matrix, applying the scale before the existing transform.

@spec post_scale!(t(), number(), number()) :: t()

Same as post_scale/3, but returns the scaled matrix directly.

@spec post_skew(t(), number(), number()) :: {:ok, t()} | {:error, term()}

Returns skew * matrix, applying the shear before the existing transforms.

@spec post_skew!(t(), number(), number()) :: t()

Same as post_skew/3, but returns the skewed matrix directly.

@spec post_transform(t(), t()) :: {:ok, t()} | {:error, term()}

Returns other * matrix, i.e. the other transform is applied before matrix.

Examples:

iex> use Blendend.Draw
iex> translate = matrix(do: translate(10, 0))
iex> scale = matrix(do: scale(2, 1))
iex> {:ok, m} = Blendend.Matrix2D.post_transform(translate, scale)
iex> {:ok, list} = Blendend.Matrix2D.to_list(m)
iex> list
[2.0, 0.0, 0.0, 1.0, 20.0, 0.0]  # scale first, then translate (x translation doubled)

@spec post_transform!(t(), t()) :: t()

Same as post_transform/2, but returns the matrix directly.

@spec post_translate(t(), number(), number()) :: {:ok, t()} | {:error, term()}

Returns translation * matrix, applying (tx, ty) before the existing transforms.

@spec post_translate!(t(), number(), number()) :: t()

Same as post_translate/3, but raises on error and returns the matrix.

@spec rotate(t(), number()) :: {:ok, t()} | {:error, term()}

Rotates the matrix by angle radians around the origin, returning a new matrix.

On success, returns {:ok, matrix}.

On failure, returns {:error, reason}.

@spec rotate!(t(), number()) :: t()

Same as rotate/2, but returns the rotated matrix directly.

On success, returns matrix.

On failure, raises Blendend.Error.

@spec rotate_at(t(), number(), number(), number()) :: {:ok, t()} | {:error, term()}

Rotates the matrix by angle radians about {cx, cy}, returning a new matrix.

@spec rotate_at!(t(), number(), number(), number()) :: t()

Same as rotate_at/4, but returns the rotated matrix directly.

@spec scale(t(), number(), number()) :: {:ok, t()} | {:error, term()}

Scales the matrix by sx and sy, returning a new matrix.

On success, returns {:ok, matrix}.

On failure, returns {:error, reason}.

@spec scale!(t(), number(), number()) :: t()

Same as scale/3, but returns the scaled matrix directly.

On success, returns matrix.

On failure, raises Blendend.Error.

@spec skew(t(), number(), number()) :: {:ok, t()} | {:error, term()}

Skews (shears) the matrix by angles kx and ky (radians) and returns a new matrix.

On success, returns {:ok, matrix}.

On failure, returns {:error, reason}.

@spec skew!(t(), number(), number()) :: t()

Same as skew/3, but returns the skewed matrix directly.

On success, returns matrix.

On failure, raises Blendend.Error.

@spec to_list(t()) :: {:ok, [number()]} | {:error, term()}

Reads the matrix as [m00, m01, m10, m11, tx, ty].

On success, returns {:ok, list}.

On failure, returns {:error, reason}.

Examples:

use Blendend.Draw
m = matrix do
 rotate :math.pi
end

{:ok, ml} = Blendend.Matrix2D.to_list(m)
[-1.0, 0, 0, -1.0, 0.0, 0.0] # floating point noise discarded

@spec to_list!(t()) :: [number()]

Same as to_list/1, but returns the list directly.

On success, returns [m00, m01, m10, m11, tx, ty].

On failure, raises Blendend.Error.

@spec transform(t(), t()) :: {:ok, t()} | {:error, term()}

Returns matrix * other, i.e. the other transform is applied after matrix.

Examples:

iex> use Blendend.Draw
iex> translate = matrix(do: translate(10, 0))
iex> scale = matrix(do: scale(2, 1))
iex> {:ok, m} = Blendend.Matrix2D.transform(translate, scale)
iex> {:ok, list} = Blendend.Matrix2D.to_list(m)
iex> list
[2.0, 0.0, 0.0, 1.0, 10.0, 0.0]  # translate first, then scale (translation unchanged)

@spec transform!(t(), t()) :: t()

Same as transform/2, but returns the matrix directly.

@spec translate(t(), number(), number()) :: {:ok, t()} | {:error, term()}

Translates the matrix by {tx, ty} and returns a new matrix.

On success, returns {:ok, matrix}.

On failure, returns {:error, reason}.

@spec translate!(t(), number(), number()) :: t()

Same as translate/3, but returns the translated matrix directly.

On success, returns matrix.

On failure, raises Blendend.Error.