class Fox::FXMat4f

Public Class Methods

Source

SWIGINTERN VALUE _wrap_new_FXMat4f(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_FXMat4f__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FXMat4f__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FXMat4f__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, SWIG_POINTER_NO_NULL);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec4f, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXVec4f, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_FXMat4f__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v = 0;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_float(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_float(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_float(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_FXMat4f__SWIG_2(nargs, args, self);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 16, "FXMat4f.new", 
    "    FXMat4f.new()\n"
    "    FXMat4f.new(FXfloat w)\n"
    "    FXMat4f.new(FXfloat a00, FXfloat a01, FXfloat a02, FXfloat a03, FXfloat a10, FXfloat a11, FXfloat a12, FXfloat a13, FXfloat a20, FXfloat a21, FXfloat a22, FXfloat a23, FXfloat a30, FXfloat a31, FXfloat a32, FXfloat a33)\n"
    "    FXMat4f.new(FXVec4f const &a, FXVec4f const &b, FXVec4f const &c, FXVec4f const &d)\n"
    "    FXMat4f.new(FXMat4f const &other)\n");
  
  return Qnil;
}

Public Instance Methods

* (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f___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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXMat4f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4f___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4f___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4f___mul____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4f___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
    "    FXMat4f __mul__(FXMat4f const &other)\n"
    "    FXMat4f __mul__(FXfloat x)\n"
    "    FXVec4f __mul__(FXVec4f const &other)\n"
    "    FXVec3f __mul__(FXVec3f const &other)\n");
  
  return Qnil;
}

+(other) → FXMat4f

Source

SWIGINTERN VALUE
_wrap_FXMat4f___add__(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXMat4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXMat4f 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4f const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4f const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXMat4f * >(argp2);
  result = FXMat4f_operator_Sa_((FXMat4f const *)arg1,(FXMat4f const &)*arg2);
  {
    FXMat4f* resultptr = new FXMat4f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
  }
  return vresult;
fail:
  return Qnil;
}

Add operator.

-(other) → FXMat4f

Source

SWIGINTERN VALUE
_wrap_FXMat4f___sub__(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXMat4f *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  FXMat4f 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4f,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4f const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4f const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXMat4f * >(argp2);
  result = FXMat4f_operator_Ss_((FXMat4f const *)arg1,(FXMat4f const &)*arg2);
  {
    FXMat4f* resultptr = new FXMat4f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
  }
  return vresult;
fail:
  return Qnil;
}

Subtraction operator.

-@ → FXMat4f

Source

SWIGINTERN VALUE
_wrap_FXMat4f___neg__(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = FXMat4f_operator_Ss_((FXMat4f const *)arg1);
  {
    FXMat4f* resultptr = new FXMat4f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
  }
  return vresult;
fail:
  return Qnil;
}

Subtraction operator.

/ (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f___div__(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXfloat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  FXMat4f 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< FXfloat >(val2);
  result = FXMat4f_operator_Sd_((FXMat4f const *)arg1,arg2);
  {
    FXMat4f* resultptr = new FXMat4f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
  }
  return vresult;
fail:
  return Qnil;
}

[](i) → FXVec4f

Source

SWIGINTERN VALUE
_wrap_FXMat4f___getitem__(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXVec4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","__getitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  arg2 = NUM2INT(argv[0]);
  result = (FXVec4f *) &FXMat4f___getitem__((FXMat4f const *)arg1,arg2);
  {
    FXVec4f* resultptr = new FXVec4f(*result);
    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
  }
  return vresult;
fail:
  return Qnil;
}

Element accessor/slicing.

[]=(i, other) → FXVec4f

Source

SWIGINTERN VALUE
_wrap_FXMat4f___setitem__(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXint arg2 ;
  FXVec3d *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  FXVec4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","__setitem__", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(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 = (FXVec4f *) &FXMat4f___setitem__(arg1,arg2,(FXVec3d const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4f, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

Element setter/slicing.

det (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_det(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXfloat 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","det", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = (FXfloat)((FXMat4f const *)arg1)->det();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}

eye (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_eye(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","eye", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = (FXMat4f *) &(arg1)->eye();
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  return vresult;
fail:
  return Qnil;
}

frustum (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_frustum(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXfloat arg2 ;
  FXfloat arg3 ;
  FXfloat arg4 ;
  FXfloat arg5 ;
  FXfloat arg6 ;
  FXfloat arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  FXMat4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","frustum", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","frustum", 2, argv[0] ));
  } 
  arg2 = static_cast< FXfloat >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","frustum", 3, argv[1] ));
  } 
  arg3 = static_cast< FXfloat >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","frustum", 4, argv[2] ));
  } 
  arg4 = static_cast< FXfloat >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","frustum", 5, argv[3] ));
  } 
  arg5 = static_cast< FXfloat >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","frustum", 6, argv[4] ));
  } 
  arg6 = static_cast< FXfloat >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXfloat","frustum", 7, argv[5] ));
  } 
  arg7 = static_cast< FXfloat >(val7);
  result = (FXMat4f *) &(arg1)->frustum(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  return vresult;
fail:
  return Qnil;
}

invert (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_invert(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","invert", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = ((FXMat4f const *)arg1)->invert();
  {
    FXMat4f* resultptr = new FXMat4f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
  }
  return vresult;
fail:
  return Qnil;
}

left (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_left(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","left", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = (FXMat4f *) &(arg1)->left();
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  return vresult;
fail:
  return Qnil;
}

look (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_look(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXVec3f *arg2 = 0 ;
  FXVec3f *arg3 = 0 ;
  FXVec3f *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","look", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  {
    if (TYPE(argv[0]) == T_ARRAY) {
      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
    } else {
      FXVec3f *p;
      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
      arg2 = new FXVec3f(*p);
    }
  }
  {
    if (TYPE(argv[1]) == T_ARRAY) {
      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
    } else {
      FXVec3f *p;
      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
      arg3 = new FXVec3f(*p);
    }
  }
  {
    if (TYPE(argv[2]) == T_ARRAY) {
      arg4 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
    } else {
      FXVec3f *p;
      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
      arg4 = new FXVec3f(*p);
    }
  }
  result = (FXMat4f *) &(arg1)->look((FXVec3f const &)*arg2,(FXVec3f const &)*arg3,(FXVec3f const &)*arg4);
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  delete arg2;
  delete arg3;
  delete arg4;
  return vresult;
fail:
  delete arg2;
  delete arg3;
  delete arg4;
  return Qnil;
}

ortho (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_ortho(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  FXfloat arg2 ;
  FXfloat arg3 ;
  FXfloat arg4 ;
  FXfloat arg5 ;
  FXfloat arg6 ;
  FXfloat arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  FXMat4f *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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","ortho", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","ortho", 2, argv[0] ));
  } 
  arg2 = static_cast< FXfloat >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","ortho", 3, argv[1] ));
  } 
  arg3 = static_cast< FXfloat >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","ortho", 4, argv[2] ));
  } 
  arg4 = static_cast< FXfloat >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","ortho", 5, argv[3] ));
  } 
  arg5 = static_cast< FXfloat >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","ortho", 6, argv[4] ));
  } 
  arg6 = static_cast< FXfloat >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXfloat","ortho", 7, argv[5] ));
  } 
  arg7 = static_cast< FXfloat >(val7);
  result = (FXMat4f *) &(arg1)->ortho(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = FXRbGetRubyObj(result, "FXMat4f *");
  return vresult;
fail:
  return Qnil;
}

rot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f_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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXQuatf, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4f_rot__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4f_rot__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FXMat4f_rot__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FXMat4f.rot", 
    "    FXMat4f FXMat4f.rot(FXQuatf const &q)\n"
    "    FXMat4f FXMat4f.rot(FXVec3f const &v, FXfloat c, FXfloat s)\n"
    "    FXMat4f & FXMat4f.rot(FXVec3f const &v, FXfloat phi)\n");
  
  return Qnil;
}

scale (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f_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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4f_scale__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4f_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FXMat4f_scale__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FXMat4f.scale", 
    "    FXMat4f FXMat4f.scale(FXfloat sx, FXfloat sy, FXfloat sz)\n"
    "    FXMat4f FXMat4f.scale(FXfloat s)\n"
    "    FXMat4f & FXMat4f.scale(FXVec3f const &v)\n");
  
  return Qnil;
}

to_s → FXString

Source

SWIGINTERN VALUE
_wrap_FXMat4f_to_s(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXString 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","to_s", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = FXMat4f_to_s((FXMat4f const *)arg1);
  vresult = to_ruby((&result)->text());
  return vresult;
fail:
  return Qnil;
}

Convert class to a String representation.

trans (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f_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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXMat4f_trans__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FXMat4f_trans__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FXMat4f.trans", 
    "    FXMat4f FXMat4f.trans(FXfloat tx, FXfloat ty, FXfloat tz)\n"
    "    FXMat4f & FXMat4f.trans(FXVec3f const &v)\n");
  
  return Qnil;
}

transpose (*args)

Source

SWIGINTERN VALUE
_wrap_FXMat4f_transpose(int argc, VALUE *argv, VALUE self) {
  FXMat4f *arg1 = (FXMat4f *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXMat4f 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_FXMat4f, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","transpose", 1, self )); 
  }
  arg1 = reinterpret_cast< FXMat4f * >(argp1);
  result = ((FXMat4f const *)arg1)->transpose();
  {
    FXMat4f* resultptr = new FXMat4f(result);
    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
  }
  return vresult;
fail:
  return Qnil;
}

xrot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f_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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4f_xrot__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4f_xrot__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXMat4f.xrot", 
    "    FXMat4f FXMat4f.xrot(FXfloat c, FXfloat s)\n"
    "    FXMat4f & FXMat4f.xrot(FXfloat phi)\n");
  
  return Qnil;
}

yrot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f_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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4f_yrot__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4f_yrot__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXMat4f.yrot", 
    "    FXMat4f FXMat4f.yrot(FXfloat c, FXfloat s)\n"
    "    FXMat4f & FXMat4f.yrot(FXfloat phi)\n");
  
  return Qnil;
}

zrot (*args)

Source

SWIGINTERN VALUE _wrap_FXMat4f_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_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FXMat4f_zrot__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FXMat4f_zrot__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FXMat4f.zrot", 
    "    FXMat4f FXMat4f.zrot(FXfloat c, FXfloat s)\n"
    "    FXMat4f & FXMat4f.zrot(FXfloat phi)\n");
  
  return Qnil;
}