Class: Snow::Mat3

Inherits:

Data

• Object
• Data
• Snow::Mat3

Includes:

ArraySupport, BaseMarshalSupport, FiddlePointerSupport, InspectSupport

Defined in:

lib/snow-math/mat3.rb,
lib/snow-math/ptr.rb,
lib/snow-math/to_a.rb,
lib/snow-math/inspect.rb,
lib/snow-math/marshal.rb,
ext/snow-math/snow-math.c

Overview

A 3x3 matrix class. Often useful for representation rotations.

Constant Summary

IDENTITY =

self.new.freeze

ONE =

self.new(Array.new(9, 1)).freeze

ZERO =

self.new(Array.new(9, 0)).freeze

Class Method Summary

• .angle_axis(*args) ⇒ Object

  Returns a Mat3 describing a rotation around the given axis.

• .new(*args) ⇒ Object (also: [])

  Allocates a new Mat3.

Instance Method Summary

• #==(sm_other) ⇒ Object

  Tests this Mat3 and another Mat3 for equivalency.

• #address ⇒ Object

  Returns the memory address of the object.

• #adjoint(*args) ⇒ Object

  Returns an ajoint matrix.

• #adjoint! ⇒ Object

  Calls #adjoint(self).

• #cofactor(*args) ⇒ Object

  Returns a cofactor matrix.

• #cofactor! ⇒ Object

  Calls #cofactor(self).

• #copy(*args) ⇒ Object (also: #dup, #clone)

  Returns a copy of self.

• #determinant ⇒ Object

  Returns the matrix determinant.

• #fetch ⇒ Object (also: #[])

  Gets the component of the Mat3 at the given index.

• #get_column3(*args) ⇒ Object

  Returns a Vec3 whose components are that of the column at the given index.

• #get_row3(*args) ⇒ Object

  Returns a Vec3 whose components are that of the row at the given index.

• #initialize(*args) ⇒ Object constructor

  Sets the Mat3’s components.

• #inverse(*args) ⇒ Object

  Returns the matrix inverse on success, nil on failure.

• #inverse! ⇒ Object

  Calls #inverse(self).

• #inverse_rotate_vec3(*args) ⇒ Object

  Convenience function to rotate a Vec3 by an inverse matrix and return the result.

• #length ⇒ Object

  Returns the length of the Mat3 in components.

• #load_identity ⇒ Object

  Sets self to the identity matrix.

• #multiply(rhs, out = nil) ⇒ Object (also: #*)

  Multiplies self and RHS and returns the result.

• #multiply!(rhs) ⇒ Object

  Calls #multiply(rhs, self).

• #multiply_mat3(*args) ⇒ Object

  Multiplies this Mat3 and another and returns the result.

• #multiply_mat3!(rhs) ⇒ Object

  Calls #multiply_mat3(rhs, self).

• #orthogonal(*args) ⇒ Object

  Returns an orthogonal matrix.

• #rotate_vec3(*args) ⇒ Object

  Rotates a Vec3 using self and returns the result.

• #scale(*args) ⇒ Object (also: #**)

  Scales Mat3’s columns by X, Y, and Z and returns the result.

• #scale!(x, y, z) ⇒ Object

  Calls scale(x, y, z, self).

• #set(*args) ⇒ Object

  Sets the Mat3’s components.

• #set_column3(sm_index, sm_value) ⇒ Object

  Sets the matrix’s column at the given index to the given vector.

• #set_row3(sm_index, sm_value) ⇒ Object

  Sets the matrix’s row at the given index to the given vector.

• #size ⇒ Object

  Returns the length in bytes of the Mat3.

• #store ⇒ Object (also: #[]=)

  Sets the Mat3’s component at the index to the value.

• #to_mat4(*args) ⇒ Object

  Returns a Mat4 converted from the Mat3.

• #to_quat ⇒ Object
• #to_s ⇒ Object

  Returns a string representation of self.

• #transpose(*args) ⇒ Object (also: #~)

  Transposes this matrix and returns the result.

• #transpose! ⇒ Object

  Calls #transpose(self).

Methods included from BaseMarshalSupport

#_dump, included

Methods included from InspectSupport

#inspect

Methods included from ArraySupport

#each, #map, #map!, #to_a

Methods included from FiddlePointerSupport

#to_ptr

Constructor Details

#initialize(*args) ⇒ Object

Sets the Mat3’s components.

call-seq:

set(m1, m2, ..., m8, m9)   -> new mat3 with components
set([m1, m2, ..., m8, m9]) -> new mat3 with components
set(mat3)                  -> copy of mat3
set(mat4)                  -> new mat3 from mat4's inner 9x9 matrix
set(quat)                  -> quat as mat3
set(Vec3, Vec3, Vec3)      -> new mat3 with given row vectors

# File 'ext/snow-math/snow-math.c', line 6459

static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
{
  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
  size_t arr_index = 0;

  rb_check_frozen(sm_self);

  switch (argc) {

  case 0: {
    /* Identity (handled in _new) */
    break;
  }

  /* Copy Mat3 or provided [Numeric..] */
  case 1: {
    /* Copy Mat3 */
    if (SM_IS_A(argv[0], mat3)) {
      sm_unwrap_mat3(argv[0], *self);
      break;
    }

    /* Copy Mat4 */
    if (SM_IS_A(argv[0], mat4)) {
      mat4_to_mat3(*sm_unwrap_mat4(argv[0], NULL), *self);
      break;
    }

    /* Build from Quaternion */
    if (SM_IS_A(argv[0], quat)) {
      mat3_from_quat(*sm_unwrap_quat(argv[0], NULL), *self);
      break;
    }

    /* Optional offset into array provided */
    if (0) {
      case 2:
      arr_index = NUM2SIZET(argv[1]);
    }

    /* Array of values */
    if (SM_RB_IS_A(argv[0], rb_cArray)) {
      VALUE arrdata = argv[0];
      const size_t arr_end = arr_index + 9;
      s_float_t *mat_elem = *self;
      for (; arr_index < arr_end; ++arr_index, ++mat_elem) {
        *mat_elem = rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
      }
      break;
    }

    rb_raise(rb_eArgError, "Expected either an array of Numerics or a Mat3");
    break;
  }

  /* Mat3(Vec3, Vec3, Vec3) */
  case 3: {
    size_t arg_index;
    s_float_t *mat_elem = *self;
    for (arg_index = 0; arg_index < 3; ++arg_index, mat_elem += 3) {
      if (!SM_IS_A(argv[arg_index], vec3) && !SM_IS_A(argv[arg_index], vec4) && !SM_IS_A(argv[arg_index], quat)) {
        rb_raise(
          rb_eArgError,
          "Argument %d must be a Vec3, Vec4, or Quat when supplying three arguments to initialize/set",
          (int)(arg_index + 1));
      }

      sm_unwrap_vec3(argv[arg_index], mat_elem);
    }
    break;
  }

  /* Mat3(Numeric m00 .. m16) */
  case 9: {
    s_float_t *mat_elem = *self;
    VALUE *argv_p = argv;
    for (; argc; --argc, ++argv_p, ++mat_elem) {
      *mat_elem = (s_float_t)rb_num2dbl(*argv_p);
    }
    break;
  }

  default: {
    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
    break;
  }
  } /* switch (argc) */

  return sm_self;
}

Class Method Details

.angle_axis(*args) ⇒ Object

Returns a Mat3 describing a rotation around the given axis.

call-seq:

angle_axis(angle_degrees, axis_vec3, output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6585

static VALUE sm_mat3_angle_axis(int argc, VALUE *argv, VALUE self)
{
  VALUE sm_angle;
  VALUE sm_axis;
  VALUE sm_out;
  s_float_t angle;
  const vec3_t *axis;

  rb_scan_args(argc, argv, "21", &sm_angle, &sm_axis, &sm_out);
  if (!SM_IS_A(sm_axis, vec3) && !SM_IS_A(sm_axis, vec4) && !SM_IS_A(sm_axis, quat)) {
    rb_raise(rb_eTypeError,
      kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
      rb_obj_classname(sm_axis));
    return Qnil;
  }

  angle = (s_float_t)rb_num2dbl(sm_angle);
  axis = sm_unwrap_vec3(sm_axis, NULL);

  if (SM_IS_A(sm_out, mat3)) {
    rb_check_frozen(sm_out);
    mat3_t *out = sm_unwrap_mat3(sm_out, NULL);
    mat3_rotation(angle, (*axis)[0], (*axis)[1], (*axis)[2], *out);
  } else {
    mat3_t out;
    mat3_rotation(angle, (*axis)[0], (*axis)[1], (*axis)[2], out);
    sm_out = sm_wrap_mat3(out, self);
    rb_obj_call_init(sm_out, 0, 0);
  }

  return sm_out;
}

.new(*args) ⇒ Object Also known as: []

Allocates a new Mat3.

call-seq:

new()                      -> identity mat3
new(m1, m2, ..., m8, m9)   -> new mat3 with components
new([m1, m2, ..., m8, m9]) -> new mat3 with components
new(mat3)                  -> copy of mat3
new(mat4)                  -> new mat3 from mat4's inner 9x9 matrix
new(quat)                  -> quat as mat3
new(Vec3, Vec3, Vec3)      -> new mat3 with given row vectors

# File 'ext/snow-math/snow-math.c', line 6439

static VALUE sm_mat3_new(int argc, VALUE *argv, VALUE self)
{
  VALUE sm_mat = sm_wrap_mat3(g_mat3_identity, self);
  rb_obj_call_init(sm_mat, argc, argv);
  return sm_mat;
}

Instance Method Details

#==(sm_other) ⇒ Object

Tests this Mat3 and another Mat3 for equivalency.

call-seq:

mat3 == other_mat3 -> bool

# File 'ext/snow-math/snow-math.c', line 6872

static VALUE sm_mat3_equals(VALUE sm_self, VALUE sm_other)
{
  if (!RTEST(sm_other) || !SM_IS_A(sm_other, mat3)) {
    return Qfalse;
  }

  return mat3_equals(*sm_unwrap_mat3(sm_self, NULL), *sm_unwrap_mat3(sm_other, NULL)) ? Qtrue : Qfalse;
}

#address ⇒ Object

Returns the memory address of the object.

call-seq: address -> fixnum

# File 'ext/snow-math/snow-math.c', line 6894

static VALUE sm_get_address(VALUE sm_self)
{
  void *data_ptr = NULL;
  Data_Get_Struct(sm_self, void, data_ptr);
  return ULL2NUM((unsigned long long)data_ptr);
}

#adjoint(*args) ⇒ Object

Returns an ajoint matrix.

call-seq:

adjoint(output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6123

static VALUE sm_mat3_adjoint(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  mat3_t *self;
  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (argc == 1) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat3_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    mat3_adjoint (*self, *output);
  }} else if (argc == 0) {
SM_LABEL(skip_output): {
    mat3_t output;
    mat3_adjoint (*self, output);
    sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to adjoint");
  }
  return sm_out;
}

#adjoint! ⇒ Object

Calls #adjoint(self)

call-seq: adjoint! -> self

# File 'lib/snow-math/mat3.rb', line 70

def adjoint!
  adjoint self
end

#cofactor(*args) ⇒ Object

Returns a cofactor matrix.

call-seq:

cofactor(output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6193

static VALUE sm_mat3_cofactor(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  mat3_t *self;
  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (argc == 1) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat3_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    mat3_cofactor (*self, *output);
  }} else if (argc == 0) {
SM_LABEL(skip_output): {
    mat3_t output;
    mat3_cofactor (*self, output);
    sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to cofactor");
  }
  return sm_out;
}

#cofactor! ⇒ Object

Calls #cofactor(self)

call-seq: cofactor! -> self

# File 'lib/snow-math/mat3.rb', line 79

def cofactor!
  cofactor self
end

#copy(*args) ⇒ Object Also known as: dup, clone

Returns a copy of self.

call-seq:

copy(output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6018

static VALUE sm_mat3_copy(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  mat3_t *self;
  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (argc == 1) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat3_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    mat3_copy (*self, *output);
  }} else if (argc == 0) {
SM_LABEL(skip_output): {
    mat3_t output;
    mat3_copy (*self, output);
    sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to copy");
  }
  return sm_out;
}

#determinant ⇒ Object

Returns the matrix determinant.

call-seq:

determinant -> float

# File 'ext/snow-math/snow-math.c', line 6366

static VALUE sm_mat3_determinant(VALUE sm_self)
{
  return mat3_determinant(*sm_unwrap_mat3(sm_self, NULL));
}

#fetch ⇒ Object Also known as: []

Gets the component of the Mat3 at the given index.

call-seq: fetch(index) -> float

# File 'ext/snow-math/snow-math.c', line 5951

static VALUE sm_mat3_fetch (VALUE sm_self, VALUE sm_index)
{
  static const int max_index = sizeof(mat3_t) / sizeof(s_float_t);
  const mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
  int index = NUM2INT(sm_index);
  if (index < 0 || index >= max_index) {
    rb_raise(rb_eRangeError,
      "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
  }
  return rb_float_new(self[0][NUM2INT(sm_index)]);
}

#get_column3(*args) ⇒ Object

Returns a Vec3 whose components are that of the column at the given index.

call-seq:

get_column3(index, output = nil) -> output or new vec3

# File 'ext/snow-math/snow-math.c', line 6690

static VALUE sm_mat3_get_column3(int argc, VALUE *argv, VALUE sm_self)
{
  mat3_t *self;
  int index;
  VALUE sm_out;

  self = sm_unwrap_mat3(sm_self, NULL);
  index = NUM2INT(argv[0]);
  sm_out = Qnil;

  if (index < 0 || index > 2) {
    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 2)", index);
    return Qnil;
  }

  switch (argc) {
  case 2: {
    vec3_t *out;

    sm_out = argv[1];

    if (RTEST(sm_out)) {
      if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
        rb_raise(rb_eTypeError,
          kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
          rb_obj_classname(sm_out));
        return Qnil;
      }
      rb_check_frozen(sm_out);
    } else {
      goto SM_LABEL(no_output);
    }

    out = sm_unwrap_vec3(sm_out, NULL);
    mat3_get_column3(*self, index, *out);

    break;
  }

  case 1: SM_LABEL(no_output): {
    vec3_t out;
    mat3_get_column3(*self, index, out);
    sm_out = sm_wrap_vec3(out, Qnil);
    rb_obj_call_init(sm_out, 0, 0);
    break;
  }

  default: {
    rb_raise(rb_eArgError, "Invalid number of arguments to get_column3 - expected 1 or 2");
    break;
  }
  }

  return sm_out;
}

#get_row3(*args) ⇒ Object

Returns a Vec3 whose components are that of the row at the given index.

call-seq:

get_row3(index, output = nil) -> output or new vec3

# File 'ext/snow-math/snow-math.c', line 6626

static VALUE sm_mat3_get_row3(int argc, VALUE *argv, VALUE sm_self)
{
  mat3_t *self;
  int index;
  VALUE sm_out;

  self = sm_unwrap_mat3(sm_self, NULL);
  index = NUM2INT(argv[0]);
  sm_out = Qnil;

  if (index < 0 || index > 2) {
    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 2)", index);
    return Qnil;
  }

  switch (argc) {
  case 2: {
    vec3_t *out;

    sm_out = argv[1];

    if (RTEST(sm_out)) {
      if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
        rb_raise(rb_eTypeError,
          kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
          rb_obj_classname(sm_out));
        return Qnil;
      }
      rb_check_frozen(sm_out);
    } else {
      goto SM_LABEL(no_output);
    }

    out = sm_unwrap_vec3(sm_out, NULL);
    mat3_get_row3(*self, index, *out);

    break;
  }

  case 1: SM_LABEL(no_output): {
    vec3_t out;
    mat3_get_row3(*self, index, out);
    sm_out = sm_wrap_vec3(out, Qnil);
    rb_obj_call_init(sm_out, 0, 0);
    break;
  }

  default: {
    rb_raise(rb_eArgError, "Invalid number of arguments to get_row3 - expected 1 or 2");
    break;
  }
  }

  return sm_out;
}

#inverse(*args) ⇒ Object

Returns the matrix inverse on success, nil on failure.

call-seq:

inverse(output = nil) -> output, new mat3, or nil

# File 'ext/snow-math/snow-math.c', line 6379

static VALUE sm_mat3_inverse(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out = Qnil;
  mat3_t *self;

  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);

  if (argc == 1) {
    mat3_t *output;

    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }

    if (!SM_IS_A(sm_out, mat3)) {
      rb_raise(rb_eTypeError,
        "Invalid argument to output of inverse_general: expected %s, got %s",
        rb_class2name(s_sm_mat3_klass),
        rb_obj_classname(sm_out));
      return Qnil;
    }

    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    if (!mat3_inverse(*self, *output)) {
      return Qnil;
    }

  } else if (argc == 0) {
    SM_LABEL(skip_output): {
      mat3_t output;
      if (!mat3_inverse(*self, output)) {
        return Qnil;
      }

      sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
      rb_obj_call_init(sm_out, 0, 0);
    }
  } else {
    rb_raise(rb_eArgError, "Invalid number of arguments to inverse");
  }

  return sm_out;
}

#inverse! ⇒ Object

Calls #inverse(self)

call-seq: inverse! -> self

# File 'lib/snow-math/mat3.rb', line 61

def inverse!
  inverse self
end

#inverse_rotate_vec3(*args) ⇒ Object

Convenience function to rotate a Vec3 by an inverse matrix and return the result.

call-seq:

inv_rotate_vec3(vec3, output = nil) -> output or new vec3

# File 'ext/snow-math/snow-math.c', line 6317

static VALUE sm_mat3_inv_rotate_vec3(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_rhs;
  VALUE sm_out;
  mat3_t *self;
  vec3_t *rhs;
  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (!SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
    rb_raise(rb_eTypeError,
      kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
      rb_obj_classname(sm_rhs));
    return Qnil;
  }
  rhs = sm_unwrap_vec3(sm_rhs, NULL);
  if (argc == 2) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    vec3_t *output;
    if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
      rb_raise(rb_eTypeError,
        kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
        rb_obj_classname(sm_out));
      return Qnil;
    }
    rb_check_frozen(sm_out);
    output = sm_unwrap_vec3(sm_out, NULL);
    mat3_inv_rotate_vec3(*self, *rhs, *output);
  }} else if (argc == 1) {
SM_LABEL(skip_output): {
    vec3_t output;
    mat3_inv_rotate_vec3(*self, *rhs, output);
    sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to inverse_rotate_vec3");
  }
  return sm_out;
}

#length ⇒ Object

Returns the length of the Mat3 in components. Result is always 9.

call-seq: length -> fixnum

# File 'ext/snow-math/snow-math.c', line 6005

static VALUE sm_mat3_length (VALUE self)
{
  return SIZET2NUM(sizeof(mat3_t) / sizeof(s_float_t));
}

#load_identity ⇒ Object

Sets self to the identity matrix.

call-seq:

load_identity -> self

# File 'ext/snow-math/snow-math.c', line 6824

static VALUE sm_mat3_identity(VALUE sm_self)
{
  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
  mat3_identity(*self);
  return sm_self;
}

#multiply(rhs, out = nil) ⇒ Object Also known as: *

Multiplies self and RHS and returns the result. This is a wrapper around other multiply methods. See multiply_mat3, rotate_vec3, and #scale for more reference.

In the third form, the scalar value provided is passed for all three columns when calling scale.

call-seq:

multiply(mat3, output = nil) -> output or new mat3
multiply(vec3, output = nil) -> output or new vec3
multiply(scalar, output = nil) -> output or new mat3

# File 'lib/snow-math/mat3.rb', line 105

def multiply(rhs, out = nil)
  case rhs
  when ::Snow::Mat3 then multiply_mat3(rhs, out)
  when ::Snow::Vec3 then rotate_vec3(rhs, out)
  when Numeric      then scale(rhs, rhs, rhs, out)
  else raise TypeError, "Invalid type for RHS"
  end
end

#multiply!(rhs) ⇒ Object

Calls #multiply(rhs, self).

call-seq:

multiply!(mat3) -> self
multiply!(vec3) -> vec3
multiply!(scalar) -> self

# File 'lib/snow-math/mat3.rb', line 122

def multiply!(rhs)
  multiply rhs, case rhs
    when Mat3, Numeric then self
    when Vec3 then rhs
    else raise TypeError, "Invalid type for RHS"
    end
end

#multiply_mat3(*args) ⇒ Object

Multiplies this Mat3 and another and returns the result.

call-seq:

multiply_mat3(mat3, output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6228

static VALUE sm_mat3_multiply(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_rhs;
  VALUE sm_out;
  mat3_t *self;
  mat3_t *rhs;
  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  SM_RAISE_IF_NOT_TYPE(sm_rhs, mat3);
  rhs = sm_unwrap_mat3(sm_rhs, NULL);
  if (argc == 2) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat3_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    mat3_multiply(*self, *rhs, *output);
  }} else if (argc == 1) {
SM_LABEL(skip_output): {
    mat3_t output;
    mat3_multiply(*self, *rhs, output);
    sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_mat3");
  }
  return sm_out;
}

#multiply_mat3!(rhs) ⇒ Object

Calls #multiply_mat3(rhs, self)

call-seq: multiply_mat3!(rhs) -> self

# File 'lib/snow-math/mat3.rb', line 88

def multiply_mat3!(rhs)
  multiply_mat3 rhs, self
end

#orthogonal(*args) ⇒ Object

Returns an orthogonal matrix.

call-seq:

orthogonal(output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6158

static VALUE sm_mat3_orthogonal(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  mat3_t *self;
  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (argc == 1) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat3_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    mat3_orthogonal (*self, *output);
  }} else if (argc == 0) {
SM_LABEL(skip_output): {
    mat3_t output;
    mat3_orthogonal (*self, output);
    sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to orthogonal");
  }
  return sm_out;
}

#rotate_vec3(*args) ⇒ Object

Rotates a Vec3 using self and returns the result.

call-seq:

rotate_vec3(vec3, output = nil) -> output or new vec3

# File 'ext/snow-math/snow-math.c', line 6267

static VALUE sm_mat3_rotate_vec3(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_rhs;
  VALUE sm_out;
  mat3_t *self;
  vec3_t *rhs;
  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (!SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
    rb_raise(rb_eTypeError,
      kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
      rb_obj_classname(sm_rhs));
    return Qnil;
  }
  rhs = sm_unwrap_vec3(sm_rhs, NULL);
  if (argc == 2) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    vec3_t *output;
    if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
      rb_raise(rb_eTypeError,
        kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
        rb_obj_classname(sm_out));
      return Qnil;
    }
    rb_check_frozen(sm_out);
    output = sm_unwrap_vec3(sm_out, NULL);
    mat3_rotate_vec3(*self, *rhs, *output);
  }} else if (argc == 1) {
SM_LABEL(skip_output): {
    vec3_t output;
    mat3_rotate_vec3(*self, *rhs, output);
    sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to rotate_vec3");
  }
  return sm_out;
}

#scale(*args) ⇒ Object Also known as: **

Scales Mat3’s columns by X, Y, and Z and returns the result.

call-seq:

scale(x, y, z, output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6839

static VALUE sm_mat3_scale(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  VALUE sm_x, sm_y, sm_z;
  s_float_t x, y, z;
  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);

  rb_scan_args(argc, argv, "31", &sm_x, &sm_y, &sm_z, &sm_out);
  x = rb_num2dbl(sm_x);
  y = rb_num2dbl(sm_y);
  z = rb_num2dbl(sm_z);

  if (SM_IS_A(sm_out, mat3)) {
    rb_check_frozen(sm_out);
    mat3_scale(*self, x, y, z, *sm_unwrap_mat3(sm_out, NULL));
  } else {
    mat3_t out;
    mat3_scale(*self, x, y, z, out);
    sm_out = sm_wrap_mat3(out, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }

  return sm_out;
}

#scale!(x, y, z) ⇒ Object

Calls scale(x, y, z, self)

call-seq: scale!(x, y, z) -> self

# File 'lib/snow-math/mat3.rb', line 135

def scale!(x, y, z)
  scale x, y, z, self
end

#set(*args) ⇒ Object

Sets the Mat3’s components.

call-seq:

set(m1, m2, ..., m8, m9)   -> new mat3 with components
set([m1, m2, ..., m8, m9]) -> new mat3 with components
set(mat3)                  -> copy of mat3
set(mat4)                  -> new mat3 from mat4's inner 9x9 matrix
set(quat)                  -> quat as mat3
set(Vec3, Vec3, Vec3)      -> new mat3 with given row vectors

# File 'ext/snow-math/snow-math.c', line 6459

static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
{
  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
  size_t arr_index = 0;

  rb_check_frozen(sm_self);

  switch (argc) {

  case 0: {
    /* Identity (handled in _new) */
    break;
  }

  /* Copy Mat3 or provided [Numeric..] */
  case 1: {
    /* Copy Mat3 */
    if (SM_IS_A(argv[0], mat3)) {
      sm_unwrap_mat3(argv[0], *self);
      break;
    }

    /* Copy Mat4 */
    if (SM_IS_A(argv[0], mat4)) {
      mat4_to_mat3(*sm_unwrap_mat4(argv[0], NULL), *self);
      break;
    }

    /* Build from Quaternion */
    if (SM_IS_A(argv[0], quat)) {
      mat3_from_quat(*sm_unwrap_quat(argv[0], NULL), *self);
      break;
    }

    /* Optional offset into array provided */
    if (0) {
      case 2:
      arr_index = NUM2SIZET(argv[1]);
    }

    /* Array of values */
    if (SM_RB_IS_A(argv[0], rb_cArray)) {
      VALUE arrdata = argv[0];
      const size_t arr_end = arr_index + 9;
      s_float_t *mat_elem = *self;
      for (; arr_index < arr_end; ++arr_index, ++mat_elem) {
        *mat_elem = rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
      }
      break;
    }

    rb_raise(rb_eArgError, "Expected either an array of Numerics or a Mat3");
    break;
  }

  /* Mat3(Vec3, Vec3, Vec3) */
  case 3: {
    size_t arg_index;
    s_float_t *mat_elem = *self;
    for (arg_index = 0; arg_index < 3; ++arg_index, mat_elem += 3) {
      if (!SM_IS_A(argv[arg_index], vec3) && !SM_IS_A(argv[arg_index], vec4) && !SM_IS_A(argv[arg_index], quat)) {
        rb_raise(
          rb_eArgError,
          "Argument %d must be a Vec3, Vec4, or Quat when supplying three arguments to initialize/set",
          (int)(arg_index + 1));
      }

      sm_unwrap_vec3(argv[arg_index], mat_elem);
    }
    break;
  }

  /* Mat3(Numeric m00 .. m16) */
  case 9: {
    s_float_t *mat_elem = *self;
    VALUE *argv_p = argv;
    for (; argc; --argc, ++argv_p, ++mat_elem) {
      *mat_elem = (s_float_t)rb_num2dbl(*argv_p);
    }
    break;
  }

  default: {
    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
    break;
  }
  } /* switch (argc) */

  return sm_self;
}

#set_column3(sm_index, sm_value) ⇒ Object

Sets the matrix’s column at the given index to the given vector.

call-seq:

set_column3(index, value) -> self

# File 'ext/snow-math/snow-math.c', line 6789

static VALUE sm_mat3_set_column3(VALUE sm_self, VALUE sm_index, VALUE sm_value)
{
  const vec3_t *value;
  int index;
  mat3_t *self;

  if (!SM_IS_A(sm_value, vec3) && !SM_IS_A(sm_value, vec4) && !SM_IS_A(sm_value, quat)) {
    rb_raise(rb_eTypeError,
      kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
      rb_obj_classname(sm_value));
    return Qnil;
  }

  self = sm_unwrap_mat3(sm_self, NULL);
  value = sm_unwrap_vec3(sm_value, NULL);
  index = NUM2INT(sm_index);

  if (index < 0 || index > 2) {
    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 2)", index);
    return Qnil;
  }

  mat3_set_column3(index, *value, *self);

  return sm_self;
}

#set_row3(sm_index, sm_value) ⇒ Object

Sets the matrix’s row at the given index to the given vector.

call-seq:

set_row3(index, vec3) -> self

# File 'ext/snow-math/snow-math.c', line 6754

static VALUE sm_mat3_set_row3(VALUE sm_self, VALUE sm_index, VALUE sm_value)
{
  const vec3_t *value;
  int index;
  mat3_t *self;

  if (!SM_IS_A(sm_value, vec3) && !SM_IS_A(sm_value, vec4) && !SM_IS_A(sm_value, quat)) {
    rb_raise(rb_eTypeError,
      kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
      rb_obj_classname(sm_value));
    return Qnil;
  }

  self = sm_unwrap_mat3(sm_self, NULL);
  value = sm_unwrap_vec3(sm_value, NULL);
  index = NUM2INT(sm_index);

  if (index < 0 || index > 2) {
    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 2)", index);
    return Qnil;
  }

  mat3_set_row3(index, *value, *self);

  return sm_self;
}

#size ⇒ Object

Returns the length in bytes of the Mat3. When compiled to use doubles as the base type, this is always 72. Otherwise, when compiled to use floats, it’s always 36.

call-seq: size -> fixnum

# File 'ext/snow-math/snow-math.c', line 5993

static VALUE sm_mat3_size (VALUE self)
{
  return SIZET2NUM(sizeof(mat3_t));
}

#store ⇒ Object Also known as: []=

Sets the Mat3’s component at the index to the value.

call-seq: store(index, value) -> value

# File 'ext/snow-math/snow-math.c', line 5970

static VALUE sm_mat3_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
{
  static const int max_index = sizeof(mat3_t) / sizeof(s_float_t);
  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
  int index = NUM2INT(sm_index);
  rb_check_frozen(sm_self);
  if (index < 0 || index >= max_index) {
    rb_raise(rb_eRangeError,
      "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
  }
  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
  return sm_value;
}

#to_mat4(*args) ⇒ Object

Returns a Mat4 converted from the Mat3.

call-seq:

to_mat4(output = nil) -> output or new mat4

# File 'ext/snow-math/snow-math.c', line 6053

static VALUE sm_mat3_to_mat4(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  mat3_t *self;
  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (argc == 1) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat4_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat4(sm_out, NULL);
    mat3_to_mat4 (*self, *output);
  }} else if (argc == 0) {
SM_LABEL(skip_output): {
    mat4_t output;
    mat3_to_mat4 (*self, output);
    sm_out = sm_wrap_mat4(output, s_sm_mat3_klass);
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to to_mat4");
  }
  return sm_out;
}

#to_quat ⇒ Object

# File 'lib/snow-math/mat3.rb', line 43

def to_quat
  Quat.new(self)
end

#to_s ⇒ Object

Returns a string representation of self.

Mat3[].to_s     # => "{ 1.0, 0.0, 0.0,\n
                #       0.0, 1.0, 0.0,\n"
                #       0.0, 0.0, 1.0 }"

call-seq:

to_s -> string

# File 'ext/snow-math/snow-math.c', line 6562

static VALUE sm_mat3_to_s(VALUE self)
{
  const s_float_t *v;
  v = (const s_float_t *)*sm_unwrap_mat3(self, NULL);
  return rb_sprintf(
    "{ "
    "%f, %f, %f" ",\n  "
    "%f, %f, %f" ",\n  "
    "%f, %f, %f"
    " }",
    v[0],   v[1],   v[2],
    v[3],   v[4],   v[5],
    v[6],   v[7],   v[8] );
}

#transpose(*args) ⇒ Object Also known as: ~

Transposes this matrix and returns the result.

call-seq:

transpose(output = nil) -> output or new mat3

# File 'ext/snow-math/snow-math.c', line 6088

static VALUE sm_mat3_transpose(int argc, VALUE *argv, VALUE sm_self)
{
  VALUE sm_out;
  mat3_t *self;
  rb_scan_args(argc, argv, "01", &sm_out);
  self = sm_unwrap_mat3(sm_self, NULL);
  if (argc == 1) {
    if (!RTEST(sm_out)) {
      goto SM_LABEL(skip_output);
    }{
    mat3_t *output;
    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
    rb_check_frozen(sm_out);
    output = sm_unwrap_mat3(sm_out, NULL);
    mat3_transpose (*self, *output);
  }} else if (argc == 0) {
SM_LABEL(skip_output): {
    mat3_t output;
    mat3_transpose (*self, output);
    sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
    rb_obj_call_init(sm_out, 0, 0);
  }} else {
    rb_raise(rb_eArgError, "Invalid number of arguments to transpose");
  }
  return sm_out;
}

#transpose! ⇒ Object

Calls #transpose(self)

call-seq: transpose! -> self

# File 'lib/snow-math/mat3.rb', line 52

def transpose!
  transpose self
end