fxrubi 1.6.22.pre1-x86-mingw32

data/swig-interfaces/FXVec2f.i

@@ -0,0 +1,87 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+/// Single-precision 2-element vector
+class FXVec2f {
+public:
+  FXfloat x;
+  FXfloat y;
+public:
+
+	/// Initialize with components
+	FXVec2f(FXfloat xx=0.0f,FXfloat yy=0.0f);
+
+  /// Copy constructor
+  FXVec2f(const FXVec2f& v);
+
+  // Initialize from array of floats
+  FXVec2f(const FXfloat v[]);
+
+  /// Length and square of length
+  FXfloat length2() const;
+  FXfloat length() const;
+
+  %extend {
+    /// Indexing
+    FXfloat __getitem__(FXint i) const {
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+    FXfloat __setitem__(FXint i,FXfloat f){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=f;
+      return f;
+      }
+
+    /// Unary
+    FXVec2f operator-() const { return -(*self); }
+
+    /// Adding
+    FXVec2f operator+(const FXVec2f& other) const { return (*self)+other; }
+    FXVec2f operator-(const FXVec2f& other) const { return (*self)-other; }
+
+    /// Scaling
+    FXVec2f operator*(FXfloat n) const { return (*self)*n; }
+    FXVec2f operator/(FXfloat n) const {
+      if(n==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+
+    /// Dot product
+    FXfloat operator*(const FXVec2f& other) const { return (*self)*other; }
+    FXfloat dot(const FXVec2f& other) const { return (*self)*other; }
+
+    /// Equality tests
+    bool operator==(const FXVec2f& other) const { return (*self)==other; }
+
+    /// Normalize vector
+    FXVec2f normalize() const { return normalize(*self); }
+
+    /// Lowest or highest components
+    FXVec2f lo(const FXVec2f& other) const { return lo(*self,other); }
+    FXVec2f hi(const FXVec2f& other) const { return hi(*self,other); }
+    }
+
+    /// Clamp values of vector between limits
+    FXVec2f& clamp(FXfloat lo,FXfloat hi);
+  };
+

data/swig-interfaces/FXVec3d.i

@@ -0,0 +1,111 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+/// Double-precision 3-element vector
+class FXVec3d {
+public:
+  FXdouble x;
+  FXdouble y;
+  FXdouble z;
+public:
+
+  /// Default constructor
+  %extend {
+		FXVec3d() {
+			return new FXVec3d(0.0, 0.0, 0.0);
+		}
+	}
+
+  /// Copy constructor
+  FXVec3d(const FXVec3d& v);
+
+  /// Initialize with components
+  FXVec3d(FXdouble xx,FXdouble yy,FXdouble zz=1.0);
+
+  /// Initialize with color
+  FXVec3d(FXColor color);
+
+  /// Length and square of length
+  FXdouble length2() const;
+  FXdouble length() const;
+
+  %extend {
+    /// Indexing
+    FXdouble __getitem__(FXint i) const {
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+    FXdouble __setitem__(FXint i,FXdouble d){
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=d;
+      return d;
+      }
+
+    /// Unary
+    FXVec3d operator-() const { return -(*self); }
+
+    /// Adding
+    FXVec3d operator+(const FXVec3d& other) const { return (*self)+other; }
+
+    /// Subtracting
+    FXVec3d operator-(const FXVec3d& other) const { return (*self)-other; }
+
+    /// Scaling
+    FXVec3d operator*(FXdouble n) const { return (*self)*n; }
+    FXVec3d operator/(FXdouble n) const {
+      if(n==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+  
+    /// Dot product
+    FXdouble operator*(const FXVec3d& other) const { return (*self)*other; }
+    FXdouble dot(const FXVec3d& other) const { return (*self)*other; }
+
+    /// Cross product
+    FXVec3d operator^(const FXVec3d& other) const  { return (*self)^other; }
+    FXVec3d cross(const FXVec3d& other) const  { return (*self)^other; }
+  
+    /// Equality tests
+    bool operator==(const FXVec3d& other) const { return (*self)==other; }
+
+    /// Normalize vector
+    FXVec3d normalize() const { return normalize(*self); }
+
+    /// Lowest or highest components
+    FXVec3d lo(const FXVec3d& other) const { return lo(*self,other); }
+    FXVec3d hi(const FXVec3d& other) const { return hi(*self,other); }
+
+    /// Compute normal from three points a,b,c
+    static FXVec3d normal(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c){
+      return FX::normal(a,b,c);
+      }
+
+    /// Compute approximate normal from four points a,b,c,d
+    static FXVec3d normal(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c,const FXVec3d& d){
+      return FX::normal(a,b,c,d);
+      }
+    }
+
+    /// Clamp values of vector between limits
+    FXVec3d& clamp(FXdouble lo,FXdouble hi);
+  };
+

data/swig-interfaces/FXVec3f.i

@@ -0,0 +1,109 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+/// Single-precision 3-element vector
+class FXVec3f {
+public:
+  FXfloat x;
+  FXfloat y;
+  FXfloat z;
+public:
+
+  /// Default constructor
+  %extend {
+		FXVec3f() {
+			return new FXVec3f(0.0f, 0.0f, 0.0f);
+		}
+	}
+
+  /// Copy constructor
+  FXVec3f(const FXVec3f& v);
+
+  /// Initialize with components
+  FXVec3f(FXfloat xx,FXfloat yy,FXfloat zz=1.0f);
+
+  /// Initialize with color
+  FXVec3f(FXColor color);
+
+  /// Length and square of length
+  FXfloat length2() const;
+  FXfloat length() const;
+
+  %extend {
+    /// Indexing
+    FXfloat __getitem__(FXint i) const {
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+    FXfloat __setitem__(FXint i,FXfloat f){
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=f;
+      return f;
+      }
+
+    /// Unary
+    FXVec3f operator-() const { return -(*self); }
+
+    /// Adding
+    FXVec3f operator+(const FXVec3f& other) const { return (*self)+other; }
+
+    /// Subtracting
+    FXVec3f operator-(const FXVec3f& other) const { return (*self)-other; }
+
+    /// Scaling
+    FXVec3f operator*(FXfloat n) const { return (*self)*n; }
+    FXVec3f operator/(FXfloat n) const {
+      if(n==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+  
+    /// Dot and cross products
+    FXfloat operator*(const FXVec3f& other) const { return (*self)*other; }
+    FXfloat dot(const FXVec3f& other) const { return (*self)*other; }
+    FXVec3f operator^(const FXVec3f& other) const  { return (*self)^other; }
+    FXVec3f cross(const FXVec3f& other) const  { return (*self)^other; }
+  
+    /// Equality tests
+    bool operator==(const FXVec3f& other) const { return (*self)==other; }
+
+    /// Normalize vector
+    FXVec3f normalize() const { return normalize(*self); }
+
+    /// Lowest or highest components
+    FXVec3f lo(const FXVec3f& other) const { return lo(*self,other); }
+    FXVec3f hi(const FXVec3f& other) const { return hi(*self,other); }
+
+    /// Compute normal from three points a,b,c
+    static FXVec3f normal(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c){
+      return FX::normal(a,b,c);
+      }
+
+    /// Compute approximate normal from four points a,b,c,d
+    static FXVec3f normal(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c,const FXVec3f& d){
+      return FX::normal(a,b,c,d);
+      }
+    }
+
+   /// Clamp values of vector between limits
+   FXVec3f& clamp(FXfloat lo,FXfloat hi);
+  };
+

data/swig-interfaces/FXVec4d.i

@@ -0,0 +1,115 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+%rename("crosses?") FXVec4d::crosses(const FXVec3d& a,const FXVec3d& b) const;
+
+/// Double-precision 4-element vector
+class FXVec4d {
+public:
+  FXdouble x;
+  FXdouble y;
+  FXdouble z;
+  FXdouble w;
+public:
+
+  /// Default constructor
+  %extend {
+		FXVec4d() {
+			return new FXVec4d(0.0, 0.0, 0.0, 0.0);
+		}
+	}
+
+  /// Copy constructor
+  FXVec4d(const FXVec4d& v);
+
+  /// Initialize with 3-vector and optional scalar
+  FXVec4d(const FXVec3d& v,FXdouble ww=1.0);
+
+  /// Initialize with components
+  FXVec4d(FXdouble xx,FXdouble yy,FXdouble zz,FXdouble ww=1.0);
+
+  /// Initialize with color
+  FXVec4d(FXColor color);
+
+  /// Signed distance normalized plane and point
+  FXdouble distance(const FXVec3d& p) const;
+
+  /// Return true if edge a-b crosses plane
+  bool crosses(const FXVec3d& a,const FXVec3d& b) const;
+  
+  /// Length and square of length
+  FXdouble length2() const;
+  FXdouble length() const;
+
+  %extend {
+    /// Indexing
+    FXdouble __getitem__(FXint i) const {
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+    FXdouble __setitem__(FXint i,FXdouble d){
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=d;
+      return d;
+      }
+
+    /// Unary
+    FXVec4d operator-() const { return -(*self); }
+
+    /// Adding
+    FXVec4d operator+(const FXVec4d& other) const { return (*self)+other; }
+
+    /// Subtracting
+    FXVec4d operator-(const FXVec4d& other) const { return (*self)-other; }
+
+    /// Scaling
+    FXVec4d operator*(FXdouble n) const { return (*self)*n; }
+    FXVec4d operator/(FXdouble n) const {
+      if(n==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+
+    /// Dot product
+    FXdouble operator*(const FXVec4d& other) const { return (*self)*other; }
+    FXdouble dot(const FXVec4d& other) const { return (*self)*other; }
+
+    /// Equality tests
+    bool operator==(const FXVec4d& other) const { return (*self)==other; }
+
+    /// Normalize vector
+    FXVec4d normalize() const { return normalize(*self); }
+
+    /// Lowest or highest components
+    FXVec4d lo(const FXVec4d& other) const { return lo(*self,other); }
+    FXVec4d hi(const FXVec4d& other) const { return hi(*self,other); }
+
+    /// Compute normalized plane equation ax+by+cz+d=0
+    static FXVec4d plane(const FXVec4d& vec){ return FX::plane(vec); }
+    static FXVec4d plane(const FXVec3d& vec,FXdouble dist){ return FX::plane(vec,dist); }
+    static FXVec4d plane(const FXVec3d& vec,const FXVec3d& p){ return FX::plane(vec,p); }
+    static FXVec4d plane(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c){ return FX::plane(a,b,c); }
+    }
+
+    /// Clamp values of vector between limits
+    FXVec4d& clamp(FXdouble lo,FXdouble hi);
+  };
+

data/swig-interfaces/FXVec4f.i

@@ -0,0 +1,115 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+%rename("crosses?") FXVec4f::crosses(const FXVec3f& a,const FXVec3f& b) const;
+
+/// Single-precision 4-element vector
+class FXVec4f {
+public:
+  FXfloat x;
+  FXfloat y;
+  FXfloat z;
+  FXfloat w;
+public:
+
+  /// Default constructor
+  %extend {
+		FXVec4f() {
+			return new FXVec4f(0.0f, 0.0f, 0.0f, 0.0f);
+		}
+	}
+
+  /// Copy constructor
+  FXVec4f(const FXVec4f& w);
+
+  /// Initialize with 3-vector and optional scalar
+  FXVec4f(const FXVec3f& w,FXfloat ww=1.0f);
+
+  /// Initialize with components
+  FXVec4f(FXfloat x,FXfloat y,FXfloat z,FXfloat w=1.0f);
+
+  /// Initialize with color
+  FXVec4f(FXColor color);
+
+  /// Signed distance normalized plane and point
+  FXfloat distance(const FXVec3f& p) const;
+
+  /// Return true if edge a-b crosses plane
+  bool crosses(const FXVec3f& a,const FXVec3f& b) const;
+  
+  FXfloat length() const;
+  FXfloat length2() const;
+
+  %extend {
+    /// Indexing
+    FXfloat __getitem__(FXint i) const {
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+    FXfloat __setitem__(FXint i,FXfloat f){
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=f;
+      return f;
+      }
+    
+    // Negation
+    FXVec4f operator-() const { return -(*self); }
+    
+    // Addition
+    FXVec4f operator+(const FXVec4f& b) const { return (*self)+b; }
+    
+    // Subtraction
+    FXVec4f operator-(const FXVec4f& b) const { return (*self)-b; }
+    
+    // Multiply by a scalar
+    FXVec4f operator*(FXfloat n) const { return (*self)*n; }
+    
+    // Divide by a scalar
+    FXVec4f operator/(FXfloat n) const {
+      if(n==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+    
+    /// Dot product
+    FXfloat operator*(const FXVec4f& a) const { return (*self)*a; }
+    FXfloat dot(const FXVec4f& a) const { return (*self)*a; }
+    
+    /// Equality tests
+    bool operator==(const FXVec4f& b) const { return (*self == b); }
+    bool operator==(FXfloat n) const { return (*self == n); }
+    
+    // Other functions
+    FXVec4f normalize() const { return normalize(*self); }
+    FXVec4f lo(const FXVec4f& other) const { return lo(*self,other); }
+    FXVec4f hi(const FXVec4f& other) const { return hi(*self,other); }
+
+    /// Compute normalized plane equation ax+by+cz+d=0
+    static FXVec4f plane(const FXVec4f& vec){ return FX::plane(vec); }
+    static FXVec4f plane(const FXVec3f& vec,FXfloat dist){ return FX::plane(vec,dist); }
+    static FXVec4f plane(const FXVec3f& vec,const FXVec3f& p){ return FX::plane(vec,p); }
+    static FXVec4f plane(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c){ return FX::plane(a,b,c); }
+    }
+
+    /// Clamp values of vector between limits
+    FXVec4f& clamp(FXfloat lo,FXfloat hi);
+  };
+