class Fox::FXMat4d

Public Class Methods

Source

SWIGINTERN VALUE _wrap_new_FXMat4d(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[16];
  int ii;
  
  argc = nargs;
  if (argc > 16) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_FXMat4d__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FXMat4d__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FXMat4d__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4d, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec4d, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXVec4d, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FXMat4d__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_FXMat4d__SWIG_2(nargs, args, self);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 16, "FXMat4d.new", 
    "    FXMat4d.new()\n"
    "    FXMat4d.new(FXdouble w)\n"
    "    FXMat4d.new(FXdouble a00, FXdouble a01, FXdouble a02, FXdouble a03, FXdouble a10, FXdouble a11, FXdouble a12, FXdouble a13, FXdouble a20, FXdouble a21, FXdouble a22, FXdouble a23, FXdouble a30, FXdouble a31, FXdouble a32, FXdouble a33)\n"
    "    FXMat4d.new(FXVec4d const &a, FXVec4d const &b, FXVec4d const &c, FXVec4d const &d)\n"
    "    FXMat4d.new(FXMat4d const &other)\n");
  
  return Qnil;
}

Public Instance Methods

* (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d___mul__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 3) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXMat4d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4d___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4d___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4d___mul____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4d___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
    "    FXMat4d __mul__(FXMat4d const &other)\n"
    "    FXMat4d __mul__(FXdouble x)\n"
    "    FXVec4d __mul__(FXVec4d const &other)\n"
    "    FXVec3d __mul__(FXVec3d const &v)\n");
  
  return Qnil;
}

+(other) → FXMat4d

Source

SWIGINTERN VALUE
_wrap_FXMat4d___add__(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXMat4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXMat4d result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4d const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4d const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXMat4d * >(argp2);
  result = FXMat4d_operator_Sa_((FXMat4d const *)arg1,(FXMat4d const &)*arg2);
  vresult = SWIG_NewPointerObj((new FXMat4d(result)), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

Add operator.

-(other) → FXMat4d

Source

SWIGINTERN VALUE
_wrap_FXMat4d___sub__(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXMat4d *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXMat4d result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4d const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4d const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXMat4d * >(argp2);
  result = FXMat4d_operator_Ss_((FXMat4d const *)arg1,(FXMat4d const &)*arg2);
  vresult = SWIG_NewPointerObj((new FXMat4d(result)), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

Subtraction operator.

-@ → FXMat4d

Source

SWIGINTERN VALUE
_wrap_FXMat4d___neg__(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4d result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  result = FXMat4d_operator_Ss_((FXMat4d const *)arg1);
  vresult = SWIG_NewPointerObj((new FXMat4d(result)), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

Subtraction operator.

/ (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d___div__(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXdouble arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  FXMat4d result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  result = FXMat4d_operator_Sd_((FXMat4d const *)arg1,arg2);
  vresult = SWIG_NewPointerObj((new FXMat4d(result)), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

[](i) → FXVec4d

Source

SWIGINTERN VALUE
_wrap_FXMat4d___getitem__(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXVec4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","__getitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXVec4d *) &FXMat4d___getitem__((FXMat4d const *)arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

Element accessor/slicing.

[]=(i, other) → FXVec4d

Source

SWIGINTERN VALUE
_wrap_FXMat4d___setitem__(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXint arg2 ;
  FXVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FXVec4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","__setitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  arg2 = NUM2INT(argv[0]);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","__setitem__", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","__setitem__", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FXVec3d * >(argp3);
  result = (FXVec4d *) &FXMat4d___setitem__(arg1,arg2,(FXVec3d const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

Element setter/slicing.

det (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_det(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXdouble result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","det", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  result = (FXdouble)((FXMat4d const *)arg1)->det();
  vresult = SWIG_From_double(static_cast< double >(result));
  return vresult;
fail:
  return Qnil;
}

eye (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_eye(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","eye", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  result = (FXMat4d *) &(arg1)->eye();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

frustum (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_frustum(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXdouble arg2 ;
  FXdouble arg3 ;
  FXdouble arg4 ;
  FXdouble arg5 ;
  FXdouble arg6 ;
  FXdouble arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FXMat4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","frustum", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","frustum", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","frustum", 3, argv[1] ));
  } 
  arg3 = static_cast< FXdouble >(val3);
  ecode4 = SWIG_AsVal_double(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","frustum", 4, argv[2] ));
  } 
  arg4 = static_cast< FXdouble >(val4);
  ecode5 = SWIG_AsVal_double(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","frustum", 5, argv[3] ));
  } 
  arg5 = static_cast< FXdouble >(val5);
  ecode6 = SWIG_AsVal_double(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","frustum", 6, argv[4] ));
  } 
  arg6 = static_cast< FXdouble >(val6);
  ecode7 = SWIG_AsVal_double(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","frustum", 7, argv[5] ));
  } 
  arg7 = static_cast< FXdouble >(val7);
  result = (FXMat4d *) &(arg1)->frustum(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

invert (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_invert(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4d result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","invert", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  result = ((FXMat4d const *)arg1)->invert();
  vresult = SWIG_NewPointerObj((new FXMat4d(result)), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

left (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_left(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","left", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  result = (FXMat4d *) &(arg1)->left();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

look (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_look(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXVec3d *arg2 = 0 ;
  FXVec3d *arg3 = 0 ;
  FXVec3d *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  FXMat4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","look", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","look", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","look", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXVec3d * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","look", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","look", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< FXVec3d * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FXVec3d,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXVec3d const &","look", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","look", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< FXVec3d * >(argp4);
  result = (FXMat4d *) &(arg1)->look((FXVec3d const &)*arg2,(FXVec3d const &)*arg3,(FXVec3d const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

ortho (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_ortho(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  FXdouble arg2 ;
  FXdouble arg3 ;
  FXdouble arg4 ;
  FXdouble arg5 ;
  FXdouble arg6 ;
  FXdouble arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  FXMat4d *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","ortho", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","ortho", 2, argv[0] ));
  } 
  arg2 = static_cast< FXdouble >(val2);
  ecode3 = SWIG_AsVal_double(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","ortho", 3, argv[1] ));
  } 
  arg3 = static_cast< FXdouble >(val3);
  ecode4 = SWIG_AsVal_double(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","ortho", 4, argv[2] ));
  } 
  arg4 = static_cast< FXdouble >(val4);
  ecode5 = SWIG_AsVal_double(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","ortho", 5, argv[3] ));
  } 
  arg5 = static_cast< FXdouble >(val5);
  ecode6 = SWIG_AsVal_double(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","ortho", 6, argv[4] ));
  } 
  arg6 = static_cast< FXdouble >(val6);
  ecode7 = SWIG_AsVal_double(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","ortho", 7, argv[5] ));
  } 
  arg7 = static_cast< FXdouble >(val7);
  result = (FXMat4d *) &(arg1)->ortho(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

rot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d_rot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXQuatd, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4d_rot__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4d_rot__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FXMat4d_rot__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FXMat4d.rot", 
    "    FXMat4d FXMat4d.rot(FXQuatd const &q)\n"
    "    FXMat4d FXMat4d.rot(FXVec3d const &v, FXdouble c, FXdouble s)\n"
    "    FXMat4d & FXMat4d.rot(FXVec3d const &v, FXdouble phi)\n");
  
  return Qnil;
}

scale (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d_scale(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4d_scale__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4d_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FXMat4d_scale__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FXMat4d.scale", 
    "    FXMat4d FXMat4d.scale(FXdouble sx, FXdouble sy, FXdouble sz)\n"
    "    FXMat4d FXMat4d.scale(FXdouble s)\n"
    "    FXMat4d & FXMat4d.scale(FXVec3d const &v)\n");
  
  return Qnil;
}

trans (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d_trans(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4d_trans__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FXMat4d_trans__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FXMat4d.trans", 
    "    FXMat4d FXMat4d.trans(FXdouble tx, FXdouble ty, FXdouble tz)\n"
    "    FXMat4d & FXMat4d.trans(FXVec3d const &v)\n");
  
  return Qnil;
}

transpose (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4d_transpose(int argc, VALUE *argv, VALUE self) {
  FXMat4d *arg1 = (FXMat4d *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4d result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","transpose", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4d * >(argp1);
  result = ((FXMat4d const *)arg1)->transpose();
  vresult = SWIG_NewPointerObj((new FXMat4d(result)), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

xrot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d_xrot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4d_xrot__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4d_xrot__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXMat4d.xrot", 
    "    FXMat4d FXMat4d.xrot(FXdouble c, FXdouble s)\n"
    "    FXMat4d & FXMat4d.xrot(FXdouble phi)\n");
  
  return Qnil;
}

yrot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d_yrot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4d_yrot__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4d_yrot__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXMat4d.yrot", 
    "    FXMat4d FXMat4d.yrot(FXdouble c, FXdouble s)\n"
    "    FXMat4d & FXMat4d.yrot(FXdouble phi)\n");
  
  return Qnil;
}

zrot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4d_zrot(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4d_zrot__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4d_zrot__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXMat4d.zrot", 
    "    FXMat4d FXMat4d.zrot(FXdouble c, FXdouble s)\n"
    "    FXMat4d & FXMat4d.zrot(FXdouble phi)\n");
  
  return Qnil;
}