;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; LUSH Lisp Universal Shell
;;;   Copyright (C) 2002 Leon Bottou, Yann Le Cun, AT&T Corp, NECI.
;;; Includes parts of TL3:
;;;   Copyright (C) 1987-1999 Leon Bottou and Neuristique.
;;; Includes selected parts of SN3.2:
;;;   Copyright (C) 1991-2001 AT&T Corp.
;;;
;;; Includes information derived from the GSL (Gnu Scientific Library)
;;;   header files which are copyrighted and distributed under the GPL
;;;   by their respective authors.
;;;
;;; This program is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2 of the License, or
;;; (at your option) any later version.
;;;
;;; This program 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 General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program; if not, write to the Free Software
;;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(libload "inventor/inventor-config")



#? *** sb

;; dummy function that adds inventor header files in C file
(eval `(de |dummy_sb| () ,inventor-cpheader-cmd ()))

#? * sbvec3f
;;.TYPE CLASS
#? (==> <sbvec3f> cross <v>)
#? (==> <sbvec3f> dot <v>)
#? (==> <sbvec3f> getvalue)
#? (==> <sbvec3f> length)
#? (==> <sbvec3f> normalize)
#? (==> <sbvec3f> negate)
#? (==> <sbvec3f> setvalue <x> <y> <z>)
#? (==> <sbvec3f> equals <v> <tolerance>)
#? (==> <sbvec3f> getclosestaxis)
#? (new sbvec3f <flag>>

#? * sbvec2f
;;.TYPE CLASS
#? (new sbvec2f <flag>>
#? (==> <sbvec2f> dot <v>)
#? (==> <sbvec2f> getvalue)
#? (==> <sbvec2f> length)
#? (==> <sbvec2f> negate)
#? (==> <sbvec2f> normalize)
#? (==> <sbvec2f> setvalue <x> <y>)
#? (==> <sbvec2f> equals <v> <tolerance>)

#? * sbvec2s
;;.TYPE CLASS
#? (new sbvec2s <flag>>
#? (==> <sbvec2s> dot <v>)
#? (==> <sbvec2s> getvalue)
#? (==> <sbvec2s> negate)
#? (==> <sbvec2s> setvalue <x> <y>)

#? * sbvec4f
;;.TYPE CLASS
#? (new sbvec4f <flag>>
#? (==> <sbvec4f> dot <v>)
#? (==> <sbvec4f> getreal <v>)
#? (==> <sbvec4f> getvalue)
#? (==> <sbvec4f> length)
#? (==> <sbvec4f> negate)
#? (==> <sbvec4f> normalize)
#? (==> <sbvec4f> setvalue <x> <y> <z> <w>)
#? (==> <sbvec4f> equals <v> <tolerance>)

#? * sbrotation
;;.TYPE CLASS
#? (==> <sbrotation> getvalue)
#? (==> <sbrotation> invert)
#? (==> <sbrotation> inverse)
#? (==> <sbrotation> setvalue <q0> <q1> <q2> <q3>)
#? (==> <sbrotation> equals <r> <tolerance>)
#? (==> <sbrotation> multvec <src> <dst>)
#? (==> <sbrotation> scaleangle <scalefactor>)
#? (new sbrotation <flag>>

#? * sbmatrix
;;.TYPE CLASS
#? (==> <sbmatrix> setvalue <m>)
#? (==> <sbmatrix> makeidentity)
#? (==> <sbmatrix> setrotate <q>)
#? (==> <sbmatrix> setscale <s>)
#? (==> <sbmatrix> settranslate <s>)
#? (==> <sbmatrix> settransform <translation> <rotation> <scalefactor> <scaleorientation> <center>)
#? (==> <sbmatrix> gettransform <translation> <rotation> <scalefactor> <scaleorientation> <center>)
#? (==> <sbmatrix> getvalue)
#? (==> <sbmatrix> det3 <r1> <r2> <r3> <c1> <c2> <c3>)
#? (==> <sbmatrix> det4)
#? (==> <sbmatrix> factor <r> <s> <u> <p> <proj>)
#? (==> <sbmatrix> inverse)
#? (==> <sbmatrix> ludecomposition <index> <d>)
#? (==> <sbmatrix> lubacksubstitution <index> <b>)
#? (==> <sbmatrix> transpose)
#? (==> <sbmatrix> multright <m>)
#? (==> <sbmatrix> multleft <m>)
#? (==> <sbmatrix> multmatrixvec <src> <dst>)
#? (==> <sbmatrix> multvecmatrix <src> <dst>)
#? (==> <sbmatrix> multdirmatrix <src> <dst>)
#? (==> <sbmatrix> multlinematrix <src> <dst>)
#? (==> <sbmatrix> print <fp>)
#? (==> <sbmatrix> equals <m> <tolerance>)
#? (new sbmatrix <flag>>

#? * sbbox3f
;;.TYPE CLASS
#? (new sbbox3f <flag>>
#? (==> <sbbox3f> -destructor)
#? (==> <sbbox3f> getmin)
#? (==> <sbbox3f> getmax)
#? (==> <sbbox3f> getcenter)
#? (==> <sbbox3f> extendby <pt>)
#? (==> <sbbox3f> intersect <pt>)
#? (==> <sbbox3f> outside <mvp> <cullbits>)
#? (==> <sbbox3f> setbounds <xmin> <ymin> <zmin> <xmax> <ymax> <zmax>)
#? (==> <sbbox3f> getbounds <min> <max>)
#? (==> <sbbox3f> getclosestpoint <point>)
#? (==> <sbbox3f> getorigin <originx> <originy> <originz>)
#? (==> <sbbox3f> getsize <sizex> <sizey> <sizez>)
#? (==> <sbbox3f> makeempty)
#? (==> <sbbox3f> isempty)
#? (==> <sbbox3f> hasvolume)
#? (==> <sbbox3f> getspan <direction> <dmin> <dmax>)
#? (==> <sbbox3f> transform <m>)
#? (==> <sbbox3f> getvolume)

#? * sbxfbox3f
;;.TYPE CLASS
#? (new sbxfbox3f <flag>>
#? (==> <sbxfbox3f> -destructor)
#? (==> <sbxfbox3f> settransform <m>)
#? (==> <sbxfbox3f> gettransform)
#? (==> <sbxfbox3f> getinverse)
#? (==> <sbxfbox3f> getcenter)
#? (==> <sbxfbox3f> extendby <pt>)
#? (==> <sbxfbox3f> intersect <pt>)
#? (==> <sbxfbox3f> setbounds <xmin> <ymin> <zmin> <xmax> <ymax> <zmax>)
#? (==> <sbxfbox3f> getbounds <min> <max>)
#? (==> <sbxfbox3f> getorigin <originx> <originy> <originz>)
#? (==> <sbxfbox3f> getsize <sizex> <sizey> <sizez>)
#? (==> <sbxfbox3f> getvolume)
#? (==> <sbxfbox3f> makeempty)
#? (==> <sbxfbox3f> isempty)
#? (==> <sbxfbox3f> hasvolume)
#? (==> <sbxfbox3f> getspan <direction> <dmin> <dmax>)
#? (==> <sbxfbox3f> transform <m>)
#? (==> <sbxfbox3f> project)

#? * sbbox2f
;;.TYPE CLASS
#? (new sbbox2f <flag>>
#? (==> <sbbox2f> -destructor)
#? (==> <sbbox2f> getmin)
#? (==> <sbbox2f> getmax)
#? (==> <sbbox2f> getcenter)
#? (==> <sbbox2f> extendby <pt>)
#? (==> <sbbox2f> intersect <pt>)
#? (==> <sbbox2f> setbounds <xmin> <ymin> <xmax> <ymax>)
#? (==> <sbbox2f> getbounds <min> <max>)
#? (==> <sbbox2f> getclosestpoint <point>)
#? (==> <sbbox2f> getorigin <originx> <originy>)
#? (==> <sbbox2f> getsize <sizex> <sizey>)
#? (==> <sbbox2f> getaspectratio)
#? (==> <sbbox2f> makeempty)
#? (==> <sbbox2f> isempty)
#? (==> <sbbox2f> hasarea)

#? * sbbox2s
;;.TYPE CLASS
#? (new sbbox2s <flag>>
#? (==> <sbbox2s> -destructor)
#? (==> <sbbox2s> getmin)
#? (==> <sbbox2s> getmax)
#? (==> <sbbox2s> extendby <pt>)
#? (==> <sbbox2s> intersect <pt>)
#? (==> <sbbox2s> setbounds <xmin> <ymin> <xmax> <ymax>)
#? (==> <sbbox2s> getbounds <min> <max>)
#? (==> <sbbox2s> getorigin <originx> <originy>)
#? (==> <sbbox2s> getsize <sizex> <sizey>)
#? (==> <sbbox2s> getaspectratio)
#? (==> <sbbox2s> makeempty)

#? * sbcolor
;;.TYPE CLASS
#? (new sbcolor <flag>>
#? (==> <sbcolor> sethsvvalue <h> <s> <v>)
#? (==> <sbcolor> gethsvvalue <hsv>)
#? (==> <sbcolor> setpackedvalue <orderedrgba> <transparency>)
#? (==> <sbcolor> getpackedvalue <transparency>)

#? * sbline
;;.TYPE CLASS
#? (new sbline <flag>>
#? (==> <sbline> setvalue <p0> <p1>)
#? (==> <sbline> getclosestpoints <line2> <ptonthis> <ptonline2>)
#? (==> <sbline> getclosestpoint <point>)
#? (==> <sbline> getposition)
#? (==> <sbline> getdirection)

#? * sbplane
;;.TYPE CLASS
#? (new sbplane <flag>>
#? (==> <sbplane> offset <d>)
#? (==> <sbplane> intersect <l> <intersection>)
#? (==> <sbplane> transform <matrix>)
#? (==> <sbplane> isinhalfspace <point>)
#? (==> <sbplane> getnormal)
#? (==> <sbplane> getdistancefromorigin)

#? * sbcylinder
;;.TYPE CLASS
#? (new sbcylinder <flag>>
#? (==> <sbcylinder> setvalue <a> <r>)
#? (==> <sbcylinder> setaxis <a>)
#? (==> <sbcylinder> setradius <r>)
#? (==> <sbcylinder> getaxis)
#? (==> <sbcylinder> getradius)
#? (==> <sbcylinder> intersect <l> <intersection>)

#? * sbsphere
;;.TYPE CLASS
#? (new sbsphere <flag>>
#? (==> <sbsphere> setvalue <c> <r>)
#? (==> <sbsphere> setcenter <c>)
#? (==> <sbsphere> setradius <r>)
#? (==> <sbsphere> getcenter)
#? (==> <sbsphere> getradius)
#? (==> <sbsphere> circumscribe <box>)
#? (==> <sbsphere> intersect <l> <intersection>)

#? * sbviewvolume
;;.TYPE CLASS
#? (==> <sbviewvolume> -destructor)
#? (==> <sbviewvolume> getmatrices <affine> <proj>)
#? (==> <sbviewvolume> getmatrix)
#? (==> <sbviewvolume> getcameraspacematrix)
#? (==> <sbviewvolume> projectpointtoline <pt> <line>)
#? (==> <sbviewvolume> projecttoscreen <src> <dst>)
#? (==> <sbviewvolume> getplane <distfromeye>)
#? (==> <sbviewvolume> getsightpoint <distfromeye>)
#? (==> <sbviewvolume> getplanepoint <distfromeye> <normpoint>)
#? (==> <sbviewvolume> getalignrotation <rightangleonly>)
#? (==> <sbviewvolume> getworldtoscreenscale <worldcenter> <normradius>)
#? (==> <sbviewvolume> projectbox <box>)
#? (==> <sbviewvolume> narrow <left> <bottom> <right> <top>)
#? (==> <sbviewvolume> ortho <left> <right> <bottom> <top> <near> <far>)
#? (==> <sbviewvolume> perspective <fovy> <aspect> <near> <far>)
#? (==> <sbviewvolume> rotatecamera <q>)
#? (==> <sbviewvolume> translatecamera <v>)
#? (==> <sbviewvolume> zvector)
#? (==> <sbviewvolume> znarrow <near> <far>)
#? (==> <sbviewvolume> scale <factor>)
#? (==> <sbviewvolume> scalewidth <ratio>)
#? (==> <sbviewvolume> scaleheight <ratio>)
#? (==> <sbviewvolume> getprojectiontype)
#? (==> <sbviewvolume> getprojectionpoint)
#? (==> <sbviewvolume> getprojectiondirection)
#? (==> <sbviewvolume> getneardist)
#? (==> <sbviewvolume> getwidth)
#? (==> <sbviewvolume> getheight)
#? (==> <sbviewvolume> getdepth)
#? (new sbviewvolume <flag>>

#? * sbplist
;;.TYPE CLASS
#? (new sbplist <flag>>
#? (==> <sbplist> -destructor)
#? (==> <sbplist> append <ptr>)
#? (==> <sbplist> find <ptr>)
#? (==> <sbplist> insert <ptr> <addbefore>)
#? (==> <sbplist> remove <which>)
#? (==> <sbplist> getlength)
#? (==> <sbplist> truncate <start>)
#? (==> <sbplist> copy <pl>)

#? * sbstring
;;.TYPE CLASS
#? (==> <sbstring> -destructor)
#? (==> <sbstring> hash)
#? (==> <sbstring> getlength)
#? (==> <sbstring> makeempty <freeold>)
#? (==> <sbstring> getstring)
#? (==> <sbstring> getsubstring <startchar> <endchar>)
#? (==> <sbstring> deletesubstring <startchar> <endchar>)
#? (new sbstring <flag>>

#? * sbname
;;.TYPE CLASS
#? (new sbname <flag>>
#? (==> <sbname> -destructor)
#? (==> <sbname> getstring)
#? (==> <sbname> getlength)

#? * sbtime
;;.TYPE CLASS
#? (new sbtime <flag>>
#? (==> <sbtime> settotimeofday)
#? (==> <sbtime> setvalue <sec>)
#? (==> <sbtime> setmsecvalue <msec>)
#? (==> <sbtime> getvalue)
#? (==> <sbtime> getmsecvalue)
#? (==> <sbtime> format <fmt>)
#? (==> <sbtime> formatdate <fmt>)

#? * sbviewportregion
;;.TYPE CLASS
#? (new sbviewportregion <flag>>
#? (==> <sbviewportregion> setwindowsize <width> <height>)
#? (==> <sbviewportregion> setviewport <left> <bottom> <width> <height>)
#? (==> <sbviewportregion> setviewportpixels <left> <bottom> <width> <height>)
#? (==> <sbviewportregion> getwindowsize)
#? (==> <sbviewportregion> getviewportorigin)
#? (==> <sbviewportregion> getviewportoriginpixels)
#? (==> <sbviewportregion> getviewportsize)
#? (==> <sbviewportregion> getviewportsizepixels)
#? (==> <sbviewportregion> getviewportaspectratio)
#? (==> <sbviewportregion> scalewidth <ratio>)
#? (==> <sbviewportregion> scaleheight <ratio>)
#? (==> <sbviewportregion> setpixelsperinch <ppi>)
#? (==> <sbviewportregion> getpixelsperinch)
#? (==> <sbviewportregion> getpixelsperpoint)

#? * (|dummy_sb|)

;; ********************************************************


(libload "inventor/inventorobject")

;;class SbVec3f : public InventorObject
(defclass SbVec3f  InventorObject)

(defmethod  SbVec3f  cross (v)
  
  ((-gptr- "const SbVec3f *") v)     ;; reference -> gptr
  (let* ((retobj (new SbVec3f ()))
	 (retobjp :retobj:p))
    #{    *((SbVec3f *)$retobjp) = ((SbVec3f *)$p)->cross(*$v);  #} 
    retobj))

(defmethod  SbVec3f  dot (v)
  
  ((-gptr- "const SbVec3f *") v)     ;; reference -> gptr
  (float #{ ((SbVec3f *)$p)->dot(*$v)  #} ))

(defmethod  SbVec3f  getValue ()
  
  (gptr #{ ((SbVec3f *)$p)->getValue()  #} ))  ;; const float	*  -> gptr

;; (defmethod  SbVec3f  getValue (x  y  z)
;;   
;;   ((-gptr- "float *") x)     ;; reference -> gptr
;;   ((-gptr- "float *") y)     ;; reference -> gptr
;;   ((-gptr- "float *") z)     ;; reference -> gptr
;;   #{ ((SbVec3f *)$p)->getValue(*$x ,*$y ,*$z);  #} 
;;   ())

(defmethod  SbVec3f  length ()
  
  (float #{ ((SbVec3f *)$p)->length()  #} ))

(defmethod  SbVec3f  normalize ()
  
  (float #{ ((SbVec3f *)$p)->normalize()  #} ))

(defmethod  SbVec3f  negate ()
  
  #{ ((SbVec3f *)$p)->negate();  #} 
  ())

;; (defmethod  SbVec3f  setValue (v)
;;   
;;   ((-gptr- "const float *") v)
;;   (gptr #{ &(((SbVec3f *)$p)->setValue($v))  #} ))   ;; SbVec3f & -> gptr

(defmethod  SbVec3f  setValue (x  y  z)
  
  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  (gptr #{ &(((SbVec3f *)$p)->setValue($x ,$y ,$z))  #} ))   ;; SbVec3f & -> gptr

;; (defmethod  SbVec3f  setValue (barycentic  v0  v1  v2)
;;   
;;   ((-gptr- "const SbVec3f *") barycentic)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") v0)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") v1)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") v2)     ;; reference -> gptr
;;   (gptr #{ &(((SbVec3f *)$p)->setValue(*$barycentic ,*$v0 ,*$v1 ,*$v2))  #} ))   ;; SbVec3f & -> gptr
;; 
(defmethod  SbVec3f  equals (v  tolerance)
  
  ((-gptr- "const SbVec3f *") v)    ;; object -> gptr
  ((-float-) tolerance)
  (int #{ ((SbVec3f *)$p)->equals(*$v ,$tolerance)  #} ))  ;; SbBool(int) -> int

(defmethod  SbVec3f  getClosestAxis ()
  
  (let* ((retobj (new SbVec3f ()))
	 (retobjp :retobj:p))
    #{  *((SbVec3f *)$retobjp)  = ((SbVec3f *)$p)->getClosestAxis();  #} 
    retobj))


(defmethod  SbVec3f  SbVec3f  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbVec3f; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbVec3f  SbVec3f (v)
;;   
;;   ((-gptr- "const float *") v)
;;   ( #{ ((SbVec3f *)$p)->SbVec3f($v)  #} ))
;; 
;; (defmethod  SbVec3f  SbVec3f (x  y  z)
;;   
;;   ((-float-) x)
;;   ((-float-) y)
;;   ((-float-) z)
;;   ( #{ ((SbVec3f *)$p)->SbVec3f($x ,$y ,$z)  #} ))
;; 
;; (defmethod  SbVec3f  SbVec3f (p0  p1  p2)
;;   
;;   ((-gptr- "SbPlane *") p0)     ;; reference -> gptr
;;   ((-gptr- "SbPlane *") p1)     ;; reference -> gptr
;;   ((-gptr- "SbPlane *") p2)     ;; reference -> gptr
;;   ( #{ ((SbVec3f *)$p)->SbVec3f(*$p0 ,*$p1 ,*$p2)  #} ))



;;class SbVec2f : public InventorObject
(defclass SbVec2f  InventorObject)

(defmethod  SbVec2f  SbVec2f  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbVec2f; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbVec2f  SbVec2f (v)
;;   
;;   ((-gptr- "const float*") v)
;;   ( #{ ((SbVec2f *)$p)->SbVec2f($v)  #} ))
;; 
;; (defmethod  SbVec2f  SbVec2f (x  y)
;;   
;;   ((-float-) x)
;;   ((-float-) y)
;;   ( #{ ((SbVec2f *)$p)->SbVec2f($x ,$y)  #} ))

(defmethod  SbVec2f  dot (v)
  
  ((-gptr- "const SbVec2f *") v)     ;; reference -> gptr
  (float #{ ((SbVec2f *)$p)->dot(*$v)  #} ))

(defmethod  SbVec2f  getValue ()
  
  (gptr #{ ((SbVec2f *)$p)->getValue()  #} ))  ;; const float	*  -> gptr

;; (defmethod  SbVec2f  getValue (x  y)
;;   
;;   ((-gptr- "float *") x)     ;; reference -> gptr
;;   ((-gptr- "float *") y)     ;; reference -> gptr
;;   #{ ((SbVec2f *)$p)->getValue(*$x ,*$y);  #} 
;;   ())

(defmethod  SbVec2f  length ()
  
  (float #{ ((SbVec2f *)$p)->length()  #} ))

(defmethod  SbVec2f  negate ()
  
  #{ ((SbVec2f *)$p)->negate();  #} 
  ())

(defmethod  SbVec2f  normalize ()
  
  (float #{ ((SbVec2f *)$p)->normalize()  #} ))

;; (defmethod  SbVec2f  setValue (v)
;;   
;;   ((-gptr- "const float*") v)
;;   (gptr #{ &(((SbVec2f *)$p)->setValue($v))  #} ))   ;; SbVec2f & -> gptr

(defmethod  SbVec2f  setValue (x  y)
  
  ((-float-) x)
  ((-float-) y)
  (gptr #{ &(((SbVec2f *)$p)->setValue($x ,$y))  #} ))   ;; SbVec2f & -> gptr

(defmethod  SbVec2f  equals (v  tolerance)
  
  ((-gptr- "const SbVec2f *") v)   ;; object -> gptr
  ((-float-) tolerance)
  (int #{ ((SbVec2f *)$p)->equals(*$v ,$tolerance)  #} ))  ;; SbBool(int) -> int





;;class SbVec2s : public InventorObject
(defclass SbVec2s  InventorObject)

(defmethod  SbVec2s  SbVec2s  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbVec2s; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbVec2s  SbVec2s (v)
;;   
;;   ((-gptr- "const short*") v)
;;   ( #{ ((SbVec2s *)$p)->SbVec2s($v)  #} ))
;; 
;; (defmethod  SbVec2s  SbVec2s (x  y)
;;   
;;   ((-int-) x)   ;; short -> int
;;   ((-int-) y)   ;; short -> int
;;   ( #{ ((SbVec2s *)$p)->SbVec2s($x ,$y)  #} ))

(defmethod  SbVec2s  dot (v)
  
  ((-gptr- "const SbVec2s *") v)     ;; reference -> gptr
  (int #{ ((SbVec2s *)$p)->dot(*$v)  #} ))  ;; int32_t -> int

(defmethod  SbVec2s  getValue ()
  
  (gptr #{ ((SbVec2s *)$p)->getValue()  #} ))  ;; const short	*  -> gptr

;; (defmethod  SbVec2s  getValue (x  y)
;;   
;;   ((-gptr- "short *") x)     ;; reference -> gptr
;;   ((-gptr- "short *") y)     ;; reference -> gptr
;;   #{ ((SbVec2s *)$p)->getValue(*$x ,*$y);  #} 
;;   ())

(defmethod  SbVec2s  negate ()
  
  #{ ((SbVec2s *)$p)->negate();  #} 
  ())

;; (defmethod  SbVec2s  setValue (v)
;;   
;;   ((-gptr- "const short*") v)
;;   (gptr #{ &(((SbVec2s *)$p)->setValue($v))  #} ))   ;; SbVec2s & -> gptr

(defmethod  SbVec2s  setValue (x  y)
  
  ((-int-) x)   ;; short -> int
  ((-int-) y)   ;; short -> int
  (gptr #{ &(((SbVec2s *)$p)->setValue($x ,$y))  #} ))   ;; SbVec2s & -> gptr




;;class SbVec4f : public InventorObject
(defclass SbVec4f  InventorObject)

(defmethod  SbVec4f  SbVec4f  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbVec4f; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbVec4f  SbVec4f (v)
;;   
;;   ((-gptr- "const float*") v)
;;   ( #{ ((SbVec4f *)$p)->SbVec4f($v)  #} ))
;; 
;; (defmethod  SbVec4f  SbVec4f (x  y  z  w)
;;   
;;   ((-float-) x)
;;   ((-float-) y)
;;   ((-float-) z)
;;   ((-float-) w)
;;   ( #{ ((SbVec4f *)$p)->SbVec4f($x ,$y ,$z ,$w)  #} ))

(defmethod  SbVec4f  dot (v)
  
  ((-gptr- "const SbVec4f *") v)     ;; reference -> gptr
  (float #{ ((SbVec4f *)$p)->dot(*$v)  #} ))

(defmethod  SbVec4f  getReal (v)
  
  ((-gptr- "SbVec3f *") v)     ;; reference -> gptr
  #{ ((SbVec4f *)$p)->getReal(*$v);  #} 
  ())

(defmethod  SbVec4f  getValue ()
  
  (gptr #{ ((SbVec4f *)$p)->getValue()  #} ))  ;; const float	*  -> gptr

;; (defmethod  SbVec4f  getValue (x  y  z  w)
;;   
;;   ((-gptr- "float *") x)     ;; reference -> gptr
;;   ((-gptr- "float *") y)     ;; reference -> gptr
;;   ((-gptr- "float *") z)     ;; reference -> gptr
;;   ((-gptr- "float *") w)     ;; reference -> gptr
;;   #{ ((SbVec4f *)$p)->getValue(*$x ,*$y ,*$z ,*$w);  #} 
;;   ())

(defmethod  SbVec4f  length ()
  
  (float #{ ((SbVec4f *)$p)->length()  #} ))

(defmethod  SbVec4f  negate ()
  
  #{ ((SbVec4f *)$p)->negate();  #} 
  ())

(defmethod  SbVec4f  normalize ()
  
  (float #{ ((SbVec4f *)$p)->normalize()  #} ))

;; (defmethod  SbVec4f  setValue (v)
;;   
;;   ((-gptr- "const float*") v)
;;   (gptr #{ &(((SbVec4f *)$p)->setValue($v))  #} ))   ;; SbVec4f & -> gptr

(defmethod  SbVec4f  setValue (x  y  z  w)
  
  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  ((-float-) w)
  (gptr #{ &(((SbVec4f *)$p)->setValue($x ,$y ,$z ,$w))  #} ))   ;; SbVec4f & -> gptr

(defmethod  SbVec4f  equals (v  tolerance)
  
  ((-gptr- "const SbVec4f *") v)   ;; object -> gptr
  ((-float-) tolerance)
  (int #{ ((SbVec4f *)$p)->equals(*$v ,$tolerance)  #} ))  ;; SbBool(int) -> int



;;class SbRotation : public InventorObject
(defclass SbRotation  InventorObject)
(defmethod  SbRotation  getValue ()
  
  (gptr #{ ((SbRotation *)$p)->getValue()  #} ))  ;; const float *  -> gptr

;; (defmethod  SbRotation  getValue (q0  q1  q2  q3)
;;   
;;   ((-gptr- "float *") q0)     ;; reference -> gptr
;;   ((-gptr- "float *") q1)     ;; reference -> gptr
;;   ((-gptr- "float *") q2)     ;; reference -> gptr
;;   ((-gptr- "float *") q3)     ;; reference -> gptr
;;   #{ ((SbRotation *)$p)->getValue(*$q0 ,*$q1 ,*$q2 ,*$q3);  #} 
;;   ())
;; 
;; (defmethod  SbRotation  getValue (axis  radians)
;;   
;;   ((-gptr- "SbVec3f *") axis)     ;; reference -> gptr
;;   ((-gptr- "float *") radians)     ;; reference -> gptr
;;   #{ ((SbRotation *)$p)->getValue(*$axis ,*$radians);  #} 
;;   ())
;; 
;; (defmethod  SbRotation  getValue (matrix)
;;   
;;   ((-gptr- "SbMatrix *") matrix)     ;; reference -> gptr
;;   #{ ((SbRotation *)$p)->getValue(*$matrix);  #} 
;;   ())

(defmethod  SbRotation  invert ()
  
  (gptr #{ &(((SbRotation *)$p)->invert())  #} ))   ;; SbRotation & -> gptr

(defmethod  SbRotation  inverse ()
  
  (let* ((retobj (new SbRotation ()))
	 (retobjp :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbRotation *)$p)->inverse();  #} 
    retobj))

;; (defmethod  SbRotation  setValue (q)
;;   
;;   ((-gptr- "const float*") q)
;;   (gptr #{ &(((SbRotation *)$p)->setValue($q))  #} ))   ;; SbRotation & -> gptr

(defmethod  SbRotation  setValue (q0  q1  q2  q3)
  
  ((-float-) q0)
  ((-float-) q1)
  ((-float-) q2)
  ((-float-) q3)
  (gptr #{ &(((SbRotation *)$p)->setValue($q0 ,$q1 ,$q2 ,$q3))  #} ))   ;; SbRotation & -> gptr

;; (defmethod  SbRotation  setValue (m)
;;   
;;   ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
;;   (gptr #{ &(((SbRotation *)$p)->setValue(*$m))  #} ))   ;; SbRotation & -> gptr
;; 
;; (defmethod  SbRotation  setValue (axis  radians)
;;   
;;   ((-gptr- "const SbVec3f *") axis)     ;; reference -> gptr
;;   ((-float-) radians)
;;   (gptr #{ &(((SbRotation *)$p)->setValue(*$axis ,$radians))  #} ))   ;; SbRotation & -> gptr
;; 
;; (defmethod  SbRotation  setValue (rotateFrom  rotateTo)
;;   
;;   ((-gptr- "const SbVec3f *") rotateFrom)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") rotateTo)     ;; reference -> gptr
;;   (gptr #{ &(((SbRotation *)$p)->setValue(*$rotateFrom ,*$rotateTo))  #} ))   ;; SbRotation & -> gptr

(defmethod  SbRotation  equals (r  tolerance)
  
  ((-gptr- "const SbRotation *") r)     ;; reference -> gptr
  ((-float-) tolerance)
  (int #{ ((SbRotation *)$p)->equals(*$r ,$tolerance)  #} ))  ;; SbBool(int) -> int

(defmethod  SbRotation  multVec (src  dst)
  
  ((-gptr- "const SbVec3f *") src)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") dst)     ;; reference -> gptr
  #{ ((SbRotation *)$p)->multVec(*$src ,*$dst);  #} 
  ())

(defmethod  SbRotation  scaleAngle (scaleFactor)
  
  ((-float-) scaleFactor)
  #{ ((SbRotation *)$p)->scaleAngle($scaleFactor);  #} 
  ())


(defmethod  SbRotation  SbRotation  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbRotation; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())


;; (defmethod  SbRotation  SbRotation (v)
;;   
;;   ((-gptr- "const float*") v)
;;   ( #{ ((SbRotation *)$p)->SbRotation($v)  #} ))
;; 
;; (defmethod  SbRotation  SbRotation (q0  q1  q2  q3)
;;   
;;   ((-float-) q0)
;;   ((-float-) q1)
;;   ((-float-) q2)
;;   ((-float-) q3)
;;   ( #{ ((SbRotation *)$p)->SbRotation($q0 ,$q1 ,$q2 ,$q3)  #} ))
;; 
;; (defmethod  SbRotation  SbRotation (m)
;;   
;;   ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
;;   ( #{ ((SbRotation *)$p)->SbRotation(*$m)  #} ))
;; 
;; (defmethod  SbRotation  SbRotation (axis  radians)
;;   
;;   ((-gptr- "const SbVec3f *") axis)     ;; reference -> gptr
;;   ((-float-) radians)
;;   ( #{ ((SbRotation *)$p)->SbRotation(*$axis ,$radians)  #} ))
;; 
;; (defmethod  SbRotation  SbRotation (rotateFrom  rotateTo)
;;   
;;   ((-gptr- "const SbVec3f *") rotateFrom)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") rotateTo)     ;; reference -> gptr
;;   ( #{ ((SbRotation *)$p)->SbRotation(*$rotateFrom ,*$rotateTo)  #} ))




;;class SbMatrix : public InventorObject
(defclass SbMatrix  InventorObject)

(defmethod  SbMatrix  setValue (m)
  
  ((-gptr- "const SbMat *") m)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->setValue(*$m);  #} 
  ())

(defmethod  SbMatrix  makeIdentity ()
  
  #{ ((SbMatrix *)$p)->makeIdentity();  #} 
  ())


(defmethod  SbMatrix  setRotate (q)
  
  ((-gptr- "const SbRotation *") q)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->setRotate(*$q);  #} 
  ())

(defmethod  SbMatrix  setScale (s)
  
  ((-float-) s)
  #{ ((SbMatrix *)$p)->setScale($s);  #} 
  ())

;; (defmethod  SbMatrix  setScale (s)
;;   
;;   ((-gptr- "const SbVec3f *") s)     ;; reference -> gptr
;;   #{ ((SbMatrix *)$p)->setScale(*$s);  #} 
;;   ())

(defmethod  SbMatrix  setTranslate (s)
  
  ((-gptr- "const SbVec3f *") s)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->setTranslate(*$s);  #} 
  ())

(defmethod  SbMatrix  setTransform (translation  rotation  scaleFactor  scaleOrientation  center)
  
  ((-gptr- "const SbVec3f *") translation)     ;; reference -> gptr
  ((-gptr- "const SbRotation *") rotation)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") scaleFactor)     ;; reference -> gptr
  ((-gptr- "const SbRotation *") scaleOrientation)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") center)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->setTransform(*$translation ,*$rotation ,*$scaleFactor ,*$scaleOrientation ,*$center);  #} 
  ())

;; (defmethod  SbMatrix  setTransform (t  r  s)
;;   
;;   ((-gptr- "const SbVec3f *") t)     ;; reference -> gptr
;;   ((-gptr- "const SbRotation *") r)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") s)     ;; reference -> gptr
;;   #{ ((SbMatrix *)$p)->setTransform(*$t ,*$r ,*$s);  #} 
;;   ())
;; 
;; (defmethod  SbMatrix  setTransform (t  r  s  so)
;;   
;;   ((-gptr- "const SbVec3f *") t)     ;; reference -> gptr
;;   ((-gptr- "const SbRotation *") r)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") s)     ;; reference -> gptr
;;   ((-gptr- "const SbRotation *") so)     ;; reference -> gptr
;;   #{ ((SbMatrix *)$p)->setTransform(*$t ,*$r ,*$s ,*$so);  #} 
;;   ())

(defmethod  SbMatrix  getTransform (translation  rotation  scaleFactor  scaleOrientation  center)
  
  ((-gptr- "SbVec3f *") translation)     ;; reference -> gptr
  ((-gptr- "SbRotation *") rotation)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") scaleFactor)     ;; reference -> gptr
  ((-gptr- "SbRotation *") scaleOrientation)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") center)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->getTransform(*$translation ,*$rotation ,*$scaleFactor ,*$scaleOrientation ,*$center);  #} 
  ())

;; (defmethod  SbMatrix  getTransform (t  r  s  so)
;;   
;;   ((-gptr- "SbVec3f *") t)     ;; reference -> gptr
;;   ((-gptr- "SbRotation *") r)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") s)     ;; reference -> gptr
;;   ((-gptr- "SbRotation *") so)     ;; reference -> gptr
;;   #{ ((SbMatrix *)$p)->getTransform(*$t ,*$r ,*$s ,*$so);  #} 
;;   ())

;; (defmethod  SbMatrix  getValue (m)
;;   
;;   ((-gptr- "SbMat *") m)     ;; reference -> gptr
;;   #{ ((SbMatrix *)$p)->getValue(*$m);  #} 
;;   ())

(defmethod  SbMatrix  getValue ()
  
  (gptr #{ &(((SbMatrix *)$p)->getValue())  #} ))   ;; const SbMat & -> gptr

(defmethod  SbMatrix  det3 (r1  r2  r3  c1  c2  c3)
  
  ((-int-) r1)
  ((-int-) r2)
  ((-int-) r3)
  ((-int-) c1)
  ((-int-) c2)
  ((-int-) c3)
  (float #{ ((SbMatrix *)$p)->det3($r1 ,$r2 ,$r3 ,$c1 ,$c2 ,$c3)  #} ))

;; (defmethod  SbMatrix  det3 ()
;;   
;;   (float #{ ((SbMatrix *)$p)->det3()  #} ))

(defmethod  SbMatrix  det4 ()
  
  (float #{ ((SbMatrix *)$p)->det4()  #} ))

(defmethod  SbMatrix  factor (r  s  u  p  proj)
  
  ((-gptr- "SbMatrix *") r)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") s)     ;; reference -> gptr
  ((-gptr- "SbMatrix *") u)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") p)     ;; reference -> gptr
  ((-gptr- "SbMatrix *") proj)     ;; reference -> gptr
  (int #{ ((SbMatrix *)$p)->factor(*$r ,*$s ,*$u ,*$p ,*$proj)  #} ))  ;; SbBool(int) -> int

(defmethod  SbMatrix  inverse ()
  
  (let* ((retobj (new SbMatrix ()))
	 (retobjp :retobj:p))
    #{ *((SbMatrix *)$retobj) = ((SbMatrix *)$p)->inverse();  #} 
    retobj))

(defmethod  SbMatrix  LUDecomposition (index  d)
  
  ((-gptr- "int*") index)
  ((-gptr- "float *") d)     ;; reference -> gptr
  (int #{ ((SbMatrix *)$p)->LUDecomposition($index ,*$d)  #} ))  ;; SbBool(int) -> int

(defmethod  SbMatrix  LUBackSubstitution (index  b)
  
  ((-gptr- "int*") index)
  ((-gptr- "float*") b)
  #{ ((SbMatrix *)$p)->LUBackSubstitution($index ,$b);  #} 
  ())

(defmethod  SbMatrix  transpose ()
  
  (let* ((retobj (new SbMatrix ()))
	 (retobjp :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SbMatrix *)$p)->transpose();  #} 
    retobj))

(defmethod  SbMatrix  multRight (m)
  
  ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
  (gptr #{ &(((SbMatrix *)$p)->multRight(*$m))  #} ))   ;; SbMatrix & -> gptr

(defmethod  SbMatrix  multLeft (m)
  
  ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
  (gptr #{ &(((SbMatrix *)$p)->multLeft(*$m))  #} ))   ;; SbMatrix & -> gptr

(defmethod  SbMatrix  multMatrixVec (src  dst)
  
  ((-gptr- "const SbVec3f *") src)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") dst)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->multMatrixVec(*$src ,*$dst);  #} 
  ())

(defmethod  SbMatrix  multVecMatrix (src  dst)
  
  ((-gptr- "const SbVec3f *") src)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") dst)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->multVecMatrix(*$src ,*$dst);  #} 
  ())

(defmethod  SbMatrix  multDirMatrix (src  dst)
  
  ((-gptr- "const SbVec3f *") src)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") dst)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->multDirMatrix(*$src ,*$dst);  #} 
  ())

(defmethod  SbMatrix  multLineMatrix (src  dst)
  
  ((-gptr- "const SbLine *") src)     ;; reference -> gptr
  ((-gptr- "SbLine *") dst)     ;; reference -> gptr
  #{ ((SbMatrix *)$p)->multLineMatrix(*$src ,*$dst);  #} 
  ())

(defmethod  SbMatrix  print (fp)
  
  ((-gptr- "FILE *") fp)
  #{ ((SbMatrix *)$p)->print($fp);  #} 
  ())

(defmethod  SbMatrix  equals (m  tolerance)
  
  ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
  ((-float-) tolerance)
  (int #{ ((SbMatrix *)$p)->equals(*$m ,$tolerance)  #} ))  ;; SbBool(int) -> int


(defmethod  SbMatrix  SbMatrix  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbMatrix; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbMatrix  SbMatrix (a11  a12  a13  a14  a21  a22  a23  a24  a31  a32  a33  a34  a41  a42  a43  a44)
;;   
;;   ((-float-) a11)
;;   ((-float-) a12)
;;   ((-float-) a13)
;;   ((-float-) a14)
;;   ((-float-) a21)
;;   ((-float-) a22)
;;   ((-float-) a23)
;;   ((-float-) a24)
;;   ((-float-) a31)
;;   ((-float-) a32)
;;   ((-float-) a33)
;;   ((-float-) a34)
;;   ((-float-) a41)
;;   ((-float-) a42)
;;   ((-float-) a43)
;;   ((-float-) a44)
;;   ( #{ ((SbMatrix *)$p)->SbMatrix($a11 ,$a12 ,$a13 ,$a14 ,$a21 ,$a22 ,$a23 ,$a24 ,$a31 ,$a32 ,$a33 ,$a34 ,$a41 ,$a42 ,$a43 ,$a44)  #} ))
;; 
;; (defmethod  SbMatrix  SbMatrix (m)
;;   
;;   ((-gptr- "const SbMat *") m)     ;; reference -> gptr
;;   ( #{ ((SbMatrix *)$p)->SbMatrix(*$m)  #} ))


;;class SbBox3f : public InventorObject
(defclass SbBox3f InventorObject)

(defmethod SbBox3f SbBox3f  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbBox3f; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbBox3f  SbBox3f (xmin  ymin  zmin  xmax  ymax  zmax )
;;   
;;   ((-float-) xmin)
;;   ((-float-) ymin)
;;   ((-float-) zmin)
;;   ((-float-) xmax)
;;   ((-float-) ymax)
;;   ((-float-) zmax)
;;   ( #{ ((SbBox3f *)$p)->SbBox3f($xmin ,$ymin ,$zmin ,$xmax ,$ymax ,$zmax)  #} ))
;; 
;; (defmethod  SbBox3f  SbBox3f (min  max )
;;   
;;   ((-gptr- "const SbVec3f *") min)       ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") max)       ;; reference -> gptr
;;   ( #{ ((SbBox3f *)$p)->SbBox3f(*$min ,*$max)  #} ))

(defmethod  SbBox3f  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbBox3f *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

;; (defmethod  SbBox3f  getMin ()
;;   
;;   (gptr #{ &(((SbBox3f *)$p)->getMin())  #} ))   ;; const SbVec3f & -> gptr
;; 
;; (defmethod  SbBox3f  getMax ()
;;   
;;   (gptr #{ &(((SbBox3f *)$p)->getMax())  #} ))   ;; const SbVec3f & -> gptr

(defmethod  SbBox3f  getMin ()
  
  (gptr #{ &(((SbBox3f *)$p)->getMin())  #} ))   ;; SbVec3f & -> gptr

(defmethod  SbBox3f  getMax ()
  
  (gptr #{ &(((SbBox3f *)$p)->getMax())  #} ))   ;; SbVec3f & -> gptr

(defmethod  SbBox3f  getCenter ()
  
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbBox3f *)$p)->getCenter();  #} 
    retobj))

(defmethod  SbBox3f  extendBy (pt )
  
  ((-gptr- "const SbVec3f *") pt)     ;; reference -> gptr
  #{ ((SbBox3f *)$p)->extendBy(*$pt);  #} 
  ())

;; (defmethod  SbBox3f  extendBy (bb )
;;   
;;   ((-gptr- "const SbBox3f *") bb)     ;; reference -> gptr
;;   #{ ((SbBox3f *)$p)->extendBy(*$bb);  #} 
;;   ())

(defmethod  SbBox3f  intersect (pt )
  
  ((-gptr- "const SbVec3f *") pt)     ;; reference -> gptr
  (int #{ ((SbBox3f *)$p)->intersect(*$pt)  #} ))  ;; SbBool(int) -> int

;; (defmethod  SbBox3f  intersect (bb )
;;   
;;   ((-gptr- "const SbBox3f *") bb)     ;; reference -> gptr
;;   (int #{ ((SbBox3f *)$p)->intersect(*$bb)  #} ))  ;; SbBool(int) -> int

(defmethod  SbBox3f  outside (MVP  cullBits )
  
  ((-gptr- "const SbMatrix *") MVP)     ;; reference -> gptr
  ((-gptr- "int *") cullBits)     ;; reference -> gptr
  (int #{ ((SbBox3f *)$p)->outside(*$MVP ,*$cullBits)  #} ))  ;; SbBool(int) -> int

(defmethod  SbBox3f  setBounds (xmin  ymin  zmin  xmax  ymax  zmax )
  
  ((-float-) xmin)
  ((-float-) ymin)
  ((-float-) zmin)
  ((-float-) xmax)
  ((-float-) ymax)
  ((-float-) zmax)
  #{ ((SbBox3f *)$p)->setBounds($xmin ,$ymin ,$zmin ,$xmax ,$ymax ,$zmax);  #} 
  ())

;; (defmethod  SbBox3f  setBounds (min  max )
;;   
;;   ((-gptr- "const SbVec3f *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") max)     ;; reference -> gptr
;;   #{ ((SbBox3f *)$p)->setBounds(*$min ,*$max);  #} 
;;   ())

;; (defmethod  SbBox3f  getBounds (xmin  ymin  zmin  xmax  ymax  zmax )
;;   
;;   ((-gptr- "float *") xmin)     ;; reference -> gptr
;;   ((-gptr- "float *") ymin)     ;; reference -> gptr
;;   ((-gptr- "float *") zmin)     ;; reference -> gptr
;;   ((-gptr- "float *") xmax)     ;; reference -> gptr
;;   ((-gptr- "float *") ymax)     ;; reference -> gptr
;;   ((-gptr- "float *") zmax)     ;; reference -> gptr
;;   #{ ((SbBox3f *)$p)->getBounds(*$xmin ,*$ymin ,*$zmin ,*$xmax ,*$ymax ,*$zmax);  #} 
;;   ())

(defmethod  SbBox3f  getBounds (min  max )
  
  ((-gptr- "SbVec3f *") min)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") max)     ;; reference -> gptr
  #{ ((SbBox3f *)$p)->getBounds(*$min ,*$max);  #} 
  ())

(defmethod  SbBox3f  getClosestPoint (point )
  
  ((-gptr- "const SbVec3f *") point)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbBox3f *)$p)->getClosestPoint(*$point);  #} 
    retobj))

(defmethod  SbBox3f  getOrigin (originX  originY  originZ )
  
  ((-gptr- "float *") originX)     ;; reference -> gptr
  ((-gptr- "float *") originY)     ;; reference -> gptr
  ((-gptr- "float *") originZ)     ;; reference -> gptr
  #{ ((SbBox3f *)$p)->getOrigin(*$originX ,*$originY ,*$originZ);  #} 
  ())

(defmethod  SbBox3f  getSize (sizeX  sizeY  sizeZ )
  
  ((-gptr- "float *") sizeX)     ;; reference -> gptr
  ((-gptr- "float *") sizeY)     ;; reference -> gptr
  ((-gptr- "float *") sizeZ)     ;; reference -> gptr
  #{ ((SbBox3f *)$p)->getSize(*$sizeX ,*$sizeY ,*$sizeZ);  #} 
  ())

(defmethod  SbBox3f  makeEmpty ()
  
  #{ ((SbBox3f *)$p)->makeEmpty();  #} 
  ())

(defmethod  SbBox3f  isEmpty ()
  
  (int #{ ((SbBox3f *)$p)->isEmpty()  #} ))    ;; SbBool(int) -> int

(defmethod  SbBox3f  hasVolume ()
  
  (int #{ ((SbBox3f *)$p)->hasVolume()  #} ))  ;; SbBool(int) -> int

(defmethod  SbBox3f  getSpan (direction  dMin  dMax )
  
  ((-gptr- "const SbVec3f *") direction)     ;; reference -> gptr
  ((-gptr- "float *") dMin)     ;; reference -> gptr
  ((-gptr- "float *") dMax)     ;; reference -> gptr
  #{ ((SbBox3f *)$p)->getSpan(*$direction ,*$dMin ,*$dMax);  #} 
  ())

(defmethod  SbBox3f  transform (m )
  
  ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
  #{ ((SbBox3f *)$p)->transform(*$m);  #} 
  ())

(defmethod  SbBox3f  getVolume ()
  
  (float #{ ((SbBox3f *)$p)->getVolume()  #} ))





;;class SbXfBox3f : private SbBox3f
(defclass SbXfBox3f  SbBox3f)

(defmethod  SbXfBox3f  SbXfBox3f  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbXfBox3f; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbXfBox3f  SbXfBox3f (min  max )
;;   
;;   ((-gptr- "const SbVec3f *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") max)     ;; reference -> gptr
;;   ( #{ ((SbXfBox3f *)$p)->SbXfBox3f(*$min ,*$max)  #} ))
;; 
;; (defmethod  SbXfBox3f  SbXfBox3f (box )
;;   
;;   ((-gptr- "const SbBox3f *") box)     ;; reference -> gptr
;;   ( #{ ((SbXfBox3f *)$p)->SbXfBox3f(*$box)  #} ))

(defmethod  SbXfBox3f  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbXfBox3f *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

(defmethod  SbXfBox3f  setTransform (m )
  
  ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->setTransform(*$m);  #} 
  ())

(defmethod  SbXfBox3f  getTransform ()
  
  (gptr #{ &(((SbXfBox3f *)$p)->getTransform())  #} ))   ;; const SbMatrix & -> gptr

(defmethod  SbXfBox3f  getInverse ()
  
  (gptr #{ &(((SbXfBox3f *)$p)->getInverse())  #} ))   ;; const SbMatrix & -> gptr

(defmethod  SbXfBox3f  getCenter ()
  
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbXfBox3f *)$p)->getCenter();  #} 
    retobj))

(defmethod  SbXfBox3f  extendBy (pt )
  
  ((-gptr- "const SbVec3f *") pt)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->extendBy(*$pt);  #} 
  ())

;; (defmethod  SbXfBox3f  extendBy (bb )
;;   
;;   ((-gptr- "const SbBox3f *") bb)     ;; reference -> gptr
;;   #{ ((SbXfBox3f *)$p)->extendBy(*$bb);  #} 
;;   ())
;; 
;; (defmethod  SbXfBox3f  extendBy (bb )
;;   
;;   ((-gptr- "const SbXfBox3f *") bb)     ;; reference -> gptr
;;   #{ ((SbXfBox3f *)$p)->extendBy(*$bb);  #} 
;;   ())

(defmethod  SbXfBox3f  intersect (pt )
  
  ((-gptr- "const SbVec3f *") pt)     ;; reference -> gptr
  (int #{ ((SbXfBox3f *)$p)->intersect(*$pt)  #} ))  ;; SbBool(int) -> int

;; (defmethod  SbXfBox3f  intersect (bb )
;;   
;;   ((-gptr- "const SbBox3f *") bb)     ;; reference -> gptr
;;   (int #{ ((SbXfBox3f *)$p)->intersect(*$bb)  #} ))  ;; SbBool(int) -> int

(defmethod  SbXfBox3f  setBounds (xmin  ymin  zmin  xmax  ymax  zmax )
  
  ((-float-) xmin)
  ((-float-) ymin)
  ((-float-) zmin)
  ((-float-) xmax)
  ((-float-) ymax)
  ((-float-) zmax)
  #{ ((SbXfBox3f *)$p)->setBounds($xmin ,$ymin ,$zmin ,$xmax ,$ymax ,$zmax);  #} 
  ())

;; (defmethod  SbXfBox3f  setBounds (min  max )
;;   
;;   ((-gptr- "const SbVec3f *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") max)     ;; reference -> gptr
;;   #{ ((SbXfBox3f *)$p)->setBounds(*$min ,*$max);  #} 
;;   ())
;; 
;; (defmethod  SbXfBox3f  getBounds (xmin  ymin  zmin  xmax  ymax  zmax )
;;   
;;   ((-gptr- "float *") xmin)     ;; reference -> gptr
;;   ((-gptr- "float *") ymin)     ;; reference -> gptr
;;   ((-gptr- "float *") zmin)     ;; reference -> gptr
;;   ((-gptr- "float *") xmax)     ;; reference -> gptr
;;   ((-gptr- "float *") ymax)     ;; reference -> gptr
;;   ((-gptr- "float *") zmax)     ;; reference -> gptr
;;   #{ ((SbXfBox3f *)$p)->getBounds(*$xmin ,*$ymin ,*$zmin ,*$xmax ,*$ymax ,*$zmax);  #} 
;;   ())

(defmethod  SbXfBox3f  getBounds (min  max )
  
  ((-gptr- "SbVec3f *") min)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") max)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->getBounds(*$min ,*$max);  #} 
  ())

(defmethod  SbXfBox3f  getOrigin (originX  originY  originZ )
  
  ((-gptr- "float *") originX)     ;; reference -> gptr
  ((-gptr- "float *") originY)     ;; reference -> gptr
  ((-gptr- "float *") originZ)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->getOrigin(*$originX ,*$originY ,*$originZ);  #} 
  ())

(defmethod  SbXfBox3f  getSize (sizeX  sizeY  sizeZ )
  
  ((-gptr- "float *") sizeX)     ;; reference -> gptr
  ((-gptr- "float *") sizeY)     ;; reference -> gptr
  ((-gptr- "float *") sizeZ)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->getSize(*$sizeX ,*$sizeY ,*$sizeZ);  #} 
  ())

(defmethod  SbXfBox3f  getVolume ()
  
  (float #{ ((SbXfBox3f *)$p)->getVolume()  #} ))

(defmethod  SbXfBox3f  makeEmpty ()
  
  #{ ((SbXfBox3f *)$p)->makeEmpty();  #} 
  ())

(defmethod  SbXfBox3f  isEmpty ()
  
  (int #{ ((SbXfBox3f *)$p)->isEmpty()  #} ))  ;; SbBool(int) -> int

(defmethod  SbXfBox3f  hasVolume ()
  
  (int #{ ((SbXfBox3f *)$p)->hasVolume()  #} ))  ;; SbBool(int) -> int

(defmethod  SbXfBox3f  getSpan (direction  dMin  dMax )
  
  ((-gptr- "const SbVec3f *") direction)     ;; reference -> gptr
  ((-gptr- "float *") dMin)     ;; reference -> gptr
  ((-gptr- "float *") dMax)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->getSpan(*$direction ,*$dMin ,*$dMax);  #} 
  ())

(defmethod  SbXfBox3f  transform (m )
  
  ((-gptr- "const SbMatrix *") m)     ;; reference -> gptr
  #{ ((SbXfBox3f *)$p)->transform(*$m);  #} 
  ())

(defmethod  SbXfBox3f  project ()
  
  (let*  ((retobj (new SbBox3f ()))
	  (retobjp :retobj:p))
    #{ *((SbBox3f *)$retobjp) = ((SbXfBox3f *)$p)->project();  #} 
    retobj))





;;class SbBox2f : public InventorObject
(defclass SbBox2f  InventorObject)

(defmethod  SbBox2f  SbBox2f  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbBox2f; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbBox2f  SbBox2f (xmin  ymin  xmax  ymax )
;;   
;;   ((-float-) xmin)
;;   ((-float-) ymin)
;;   ((-float-) xmax)
;;   ((-float-) ymax)
;;   ( #{ ((SbBox2f *)$p)->SbBox2f($xmin ,$ymin ,$xmax ,$ymax)  #} ))
;; 
;; (defmethod  SbBox2f  SbBox2f (min  max )
;;   
;;   ((-gptr- "const SbVec2f *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec2f *") max)     ;; reference -> gptr
;;   ( #{ ((SbBox2f *)$p)->SbBox2f(*$min ,*$max)  #} ))

(defmethod  SbBox2f  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbBox2f *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

(defmethod  SbBox2f  getMin ()
  
  (gptr #{ &(((SbBox2f *)$p)->getMin())  #} ))   ;; const SbVec2f & -> gptr

(defmethod  SbBox2f  getMax ()
  
  (gptr #{ &(((SbBox2f *)$p)->getMax())  #} ))   ;; const SbVec2f & -> gptr

(defmethod  SbBox2f  getCenter ()
  
  (let*  ((retobj (new SbVec2f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec2f *)$retobjp) = ((SbBox2f *)$p)->getCenter();  #} 
    retobj))

(defmethod  SbBox2f  extendBy (pt )
  
  ((-gptr- "const SbVec2f *") pt)     ;; reference -> gptr
  #{ ((SbBox2f *)$p)->extendBy(*$pt);  #} 
  ())

;; (defmethod  SbBox2f  extendBy (r )
;;   
;;   ((-gptr- "const SbBox2f *") r)     ;; reference -> gptr
;;   #{ ((SbBox2f *)$p)->extendBy(*$r);  #} 
;;   ())

(defmethod  SbBox2f  intersect (pt )
  
  ((-gptr- "const SbVec2f *") pt)     ;; reference -> gptr
  (int #{ ((SbBox2f *)$p)->intersect(*$pt)  #} ))  ;; SbBool(int) -> int

;; (defmethod  SbBox2f  intersect (bb )
;;   
;;   ((-gptr- "const SbBox2f *") bb)     ;; reference -> gptr
;;   (int #{ ((SbBox2f *)$p)->intersect(*$bb)  #} ))  ;; SbBool(int) -> int

(defmethod  SbBox2f  setBounds (xmin  ymin  xmax  ymax )
  
  ((-float-) xmin)
  ((-float-) ymin)
  ((-float-) xmax)
  ((-float-) ymax)
  #{ ((SbBox2f *)$p)->setBounds($xmin ,$ymin ,$xmax ,$ymax);  #} 
  ())

;; (defmethod  SbBox2f  setBounds (min  max )
;;   
;;   ((-gptr- "const SbVec2f *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec2f *") max)     ;; reference -> gptr
;;   #{ ((SbBox2f *)$p)->setBounds(*$min ,*$max);  #} 
;;   ())
;; 
;; (defmethod  SbBox2f  getBounds (xmin  ymin  xmax  ymax )
;;   
;;   ((-gptr- "float *") xmin)     ;; reference -> gptr
;;   ((-gptr- "float *") ymin)     ;; reference -> gptr
;;   ((-gptr- "float *") xmax)     ;; reference -> gptr
;;   ((-gptr- "float *") ymax)     ;; reference -> gptr
;;   #{ ((SbBox2f *)$p)->getBounds(*$xmin ,*$ymin ,*$xmax ,*$ymax);  #} 
;;   ())

(defmethod  SbBox2f  getBounds (min  max )
  
  ((-gptr- "SbVec2f *") min)     ;; reference -> gptr
  ((-gptr- "SbVec2f *") max)     ;; reference -> gptr
  #{ ((SbBox2f *)$p)->getBounds(*$min ,*$max);  #} 
  ())

(defmethod  SbBox2f  getClosestPoint (point )
  
  ((-gptr- "const SbVec2f *") point)     ;; reference -> gptr
  (let*  ((retobj (new SbVec2f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec2f *)$retobjp) = ((SbBox2f *)$p)->getClosestPoint(*$point);  #} 
    retobj))

(defmethod  SbBox2f  getOrigin (originX  originY )
  
  ((-gptr- "float *") originX)     ;; reference -> gptr
  ((-gptr- "float *") originY)     ;; reference -> gptr
  #{ ((SbBox2f *)$p)->getOrigin(*$originX ,*$originY);  #} 
  ())

(defmethod  SbBox2f  getSize (sizeX  sizeY )
  
  ((-gptr- "float *") sizeX)     ;; reference -> gptr
  ((-gptr- "float *") sizeY)     ;; reference -> gptr
  #{ ((SbBox2f *)$p)->getSize(*$sizeX ,*$sizeY);  #} 
  ())

(defmethod  SbBox2f  getAspectRatio ()
  
  (float #{ ((SbBox2f *)$p)->getAspectRatio()  #} ))

(defmethod  SbBox2f  makeEmpty ()
  
  #{ ((SbBox2f *)$p)->makeEmpty();  #} 
  ())

(defmethod  SbBox2f  isEmpty ()
  
  (int #{ ((SbBox2f *)$p)->isEmpty()  #} ))  ;; SbBool(int) -> int

(defmethod  SbBox2f  hasArea ()
  
  (int #{ ((SbBox2f *)$p)->hasArea()  #} ))  ;; SbBool(int) -> int



;;class SbBox2s : public InventorObject
(defclass SbBox2s  InventorObject)

(defmethod  SbBox2s  SbBox2s  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbBox2s; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbBox2s  SbBox2s (xmin  ymin  xmax  ymax )
;;   
;;   ((-int-) xmin)   ;; short -> int
;;   ((-int-) ymin)   ;; short -> int
;;   ((-int-) xmax)   ;; short -> int
;;   ((-int-) ymax)   ;; short -> int
;;   ( #{ ((SbBox2s *)$p)->SbBox2s($xmin ,$ymin ,$xmax ,$ymax)  #} ))
;; 
;; (defmethod  SbBox2s  SbBox2s (min  max )
;;   
;;   ((-gptr- "const SbVec2s *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec2s *") max)     ;; reference -> gptr
;;   ( #{ ((SbBox2s *)$p)->SbBox2s(*$min ,*$max)  #} ))

(defmethod  SbBox2s  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbBox2s *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

(defmethod  SbBox2s  getMin ()
  
  (gptr #{ &(((SbBox2s *)$p)->getMin())  #} ))   ;; const SbVec2s & -> gptr

(defmethod  SbBox2s  getMax ()
  
  (gptr #{ &(((SbBox2s *)$p)->getMax())  #} ))   ;; const SbVec2s & -> gptr

(defmethod  SbBox2s  extendBy (pt )
  
  ((-gptr- "const SbVec2s *") pt)     ;; reference -> gptr
  #{ ((SbBox2s *)$p)->extendBy(*$pt);  #} 
  ())

;; (defmethod  SbBox2s  extendBy (r )
;;   
;;   ((-gptr- "const SbBox2s *") r)     ;; reference -> gptr
;;   #{ ((SbBox2s *)$p)->extendBy(*$r);  #} 
;;   ())

(defmethod  SbBox2s  intersect (pt )
  
  ((-gptr- "const SbVec2s *") pt)     ;; reference -> gptr
  (int #{ ((SbBox2s *)$p)->intersect(*$pt)  #} ))  ;; SbBool(int) -> int

;; (defmethod  SbBox2s  intersect (bb )
;;   
;;   ((-gptr- "const SbBox2s *") bb)     ;; reference -> gptr
;;   (int #{ ((SbBox2s *)$p)->intersect(*$bb)  #} ))  ;; SbBool(int) -> int

(defmethod  SbBox2s  setBounds (xmin  ymin  xmax  ymax )
  
  ((-int-) xmin)   ;; short -> int
  ((-int-) ymin)   ;; short -> int
  ((-int-) xmax)   ;; short -> int
  ((-int-) ymax)   ;; short -> int
  #{ ((SbBox2s *)$p)->setBounds($xmin ,$ymin ,$xmax ,$ymax);  #} 
  ())

;; (defmethod  SbBox2s  setBounds (min  max )
;;   
;;   ((-gptr- "const SbVec2s *") min)     ;; reference -> gptr
;;   ((-gptr- "const SbVec2s *") max)     ;; reference -> gptr
;;   #{ ((SbBox2s *)$p)->setBounds(*$min ,*$max);  #} 
;;   ())
;; 
;; (defmethod  SbBox2s  getBounds (xmin  ymin  xmax  ymax )
;;   
;;   ((-gptr- "short *") xmin)     ;; reference -> gptr
;;   ((-gptr- "short *") ymin)     ;; reference -> gptr
;;   ((-gptr- "short *") xmax)     ;; reference -> gptr
;;   ((-gptr- "short *") ymax)     ;; reference -> gptr
;;   #{ ((SbBox2s *)$p)->getBounds(*$xmin ,*$ymin ,*$xmax ,*$ymax);  #} 
;;   ())

(defmethod  SbBox2s  getBounds (min  max )
  
  ((-gptr- "SbVec2s *") min)     ;; reference -> gptr
  ((-gptr- "SbVec2s *") max)     ;; reference -> gptr
  #{ ((SbBox2s *)$p)->getBounds(*$min ,*$max);  #} 
  ())

(defmethod  SbBox2s  getOrigin (originX  originY )
  
  ((-gptr- "short *") originX)     ;; reference -> gptr
  ((-gptr- "short *") originY)     ;; reference -> gptr
  #{ ((SbBox2s *)$p)->getOrigin(*$originX ,*$originY);  #} 
  ())

(defmethod  SbBox2s  getSize (sizeX  sizeY )
  
  ((-gptr- "short *") sizeX)     ;; reference -> gptr
  ((-gptr- "short *") sizeY)     ;; reference -> gptr
  #{ ((SbBox2s *)$p)->getSize(*$sizeX ,*$sizeY);  #} 
  ())

(defmethod  SbBox2s  getAspectRatio ()
  
  (float #{ ((SbBox2s *)$p)->getAspectRatio()  #} ))

(defmethod  SbBox2s  makeEmpty ()
  
  #{ ((SbBox2s *)$p)->makeEmpty();  #} 
  ())



;;class SbColor : public SbVec3f
(defclass SbColor  SbVec3f)

(defmethod  SbColor  SbColor  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbColor; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbColor  SbColor (vec3f )
;;   
;;   ((-const SbVec3f-) vec3f)
;;   ( #{ ((SbColor *)$p)->SbColor($vec3f)  #} ))
;; 
;; (defmethod  SbColor  SbColor (rgb )
;;   
;;   ((-gptr- "const float *") rgb)
;;   ( #{ ((SbColor *)$p)->SbColor($rgb)  #} ))
;; 
;; (defmethod  SbColor  SbColor (r  g  b )
;;   
;;   ((-float-) r)
;;   ((-float-) g)
;;   ((-float-) b)
;;   ( #{ ((SbColor *)$p)->SbColor($r ,$g ,$b)  #} ))

(defmethod  SbColor  setHSVValue (h  s  v )
  
  ((-float-) h)
  ((-float-) s)
  ((-float-) v)
  (gptr #{ &(((SbColor *)$p)->setHSVValue($h ,$s ,$v))  #} ))   ;; SbColor & -> gptr

;; (defmethod  SbColor  setHSVValue (hsv )
;;   
;;   ((-gptr- "const float *") hsv)
;;   (gptr #{ &(((SbColor *)$p)->setHSVValue($hsv))  #} ))   ;; SbColor & -> gptr

;; (defmethod  SbColor  getHSVValue (h  s  v )
;;   
;;   ((-gptr- "float *") h)     ;; reference -> gptr
;;   ((-gptr- "float *") s)     ;; reference -> gptr
;;   ((-gptr- "float *") v)     ;; reference -> gptr
;;   #{ ((SbColor *)$p)->getHSVValue(*$h ,*$s ,*$v);  #} 
;;   ())

(defmethod  SbColor  getHSVValue (hsv )
  
  ((-gptr- "float*") hsv)
  #{ ((SbColor *)$p)->getHSVValue($hsv);  #} 
  ())

(defmethod  SbColor  setPackedValue (orderedRGBA  transparency )
  
  ((-int-) orderedRGBA)  ;; uint32_t -> int
  ((-gptr- "float*") transparency)     ;; reference -> gptr
  (gptr #{ &(((SbColor *)$p)->setPackedValue($orderedRGBA ,*$transparency))  #} ))   ;; SbColor & -> gptr

(defmethod  SbColor  getPackedValue (transparency )
  
  ((-float-) transparency)
  (int  #{ ((SbColor *)$p)->getPackedValue($transparency)  #} ))   ;; uint32_t -> int








;;class SbLine : public InventorObject
(defclass SbLine  InventorObject)

(defmethod  SbLine  SbLine  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbLine; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbLine  SbLine (p0  p1)
;;   
;;   ((-gptr- "const SbVec3f *") p0)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") p1)     ;; reference -> gptr
;;   ( #{ ((SbLine *)$p)->SbLine(*$p0 ,*$p1)  #} ))

(defmethod  SbLine  setValue (p0  p1)
  
  ((-gptr- "const SbVec3f *") p0)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") p1)     ;; reference -> gptr
  #{ ((SbLine *)$p)->setValue(*$p0 ,*$p1);  #} 
  ())

(defmethod  SbLine  getClosestPoints (line2  ptOnThis  ptOnLine2)
  
  ((-gptr- "const SbLine  *") line2)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") ptOnThis)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") ptOnLine2)     ;; reference -> gptr
  (int #{ ((SbLine *)$p)->getClosestPoints(*$line2 ,*$ptOnThis ,*$ptOnLine2)  #} ))  ;; SbBool(int) -> int

(defmethod  SbLine  getClosestPoint (point)
  
  ((-gptr- "const SbVec3f *") point)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbLine *)$p)->getClosestPoint(*$point);  #} 
    retobj))

(defmethod  SbLine  getPosition ()
  
  (gptr #{ &(((SbLine *)$p)->getPosition())  #} ))   ;; const SbVec3f & -> gptr

(defmethod  SbLine  getDirection ()
  
  (gptr #{ &(((SbLine *)$p)->getDirection())  #} ))   ;; const SbVec3f & -> gptr





;;class SbPlane : public InventorObject
(defclass SbPlane  InventorObject)

(defmethod  SbPlane  SbPlane  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbPlane; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbPlane  SbPlane (p0  p1  p2)
;;   
;;   ((-gptr- "const SbVec3f *") p0)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") p1)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") p2)     ;; reference -> gptr
;;   ( #{ ((SbPlane *)$p)->SbPlane(*$p0 ,*$p1 ,*$p2)  #} ))
;; 
;; (defmethod  SbPlane  SbPlane (n  d)
;;   
;;   ((-gptr- "const SbVec3f *") n)     ;; reference -> gptr
;;   ((-float-) d)
;;   ( #{ ((SbPlane *)$p)->SbPlane(*$n ,$d)  #} ))
;; 
;; (defmethod  SbPlane  SbPlane (n  p)
;;   
;;   ((-gptr- "const SbVec3f *") n)     ;; reference -> gptr
;;   ((-gptr- "const SbVec3f *") p)     ;; reference -> gptr
;;   ( #{ ((SbPlane *)$p)->SbPlane(*$n ,*$p)  #} ))
 
(defmethod  SbPlane  offset (d)
  
  ((-float-) d)
  #{ ((SbPlane *)$p)->offset($d);  #} 
  ())

(defmethod  SbPlane  intersect (l  intersection)
  
  ((-gptr- "const SbLine *") l)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") intersection)     ;; reference -> gptr
  (int #{ ((SbPlane *)$p)->intersect(*$l ,*$intersection)  #} ))  ;; SbBool(int) -> int

(defmethod  SbPlane  transform (matrix)
  
  ((-gptr- "const SbMatrix *") matrix)     ;; reference -> gptr
  #{ ((SbPlane *)$p)->transform(*$matrix);  #} 
  ())

(defmethod  SbPlane  isInHalfSpace (point)
  
  ((-gptr- "const SbVec3f *") point)     ;; reference -> gptr
  (int #{ ((SbPlane *)$p)->isInHalfSpace(*$point)  #} ))  ;; SbBool(int) -> int

(defmethod  SbPlane  getNormal ()
  
  (gptr #{ &(((SbPlane *)$p)->getNormal())  #} ))   ;; const SbVec3f & -> gptr

(defmethod  SbPlane  getDistanceFromOrigin ()
  
  (float #{ ((SbPlane *)$p)->getDistanceFromOrigin()  #} ))




;;class SbCylinder : public InventorObject
(defclass SbCylinder  InventorObject)

(defmethod  SbCylinder  SbCylinder  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbCylinder; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbCylinder  SbCylinder (a  r)
;;   
;;   ((-gptr- "const SbLine *") a)     ;; reference -> gptr
;;   ((-float-) r)
;;   ( #{ ((SbCylinder *)$p)->SbCylinder(*$a ,$r)  #} ))

(defmethod  SbCylinder  setValue (a  r)
  
  ((-gptr- "const SbLine *") a)     ;; reference -> gptr
  ((-float-) r)
  #{ ((SbCylinder *)$p)->setValue(*$a ,$r);  #} 
  ())

(defmethod  SbCylinder  setAxis (a)
  
  ((-gptr- "const SbLine *") a)     ;; reference -> gptr
  #{ ((SbCylinder *)$p)->setAxis(*$a);  #} 
  ())

(defmethod  SbCylinder  setRadius (r)
  
  ((-float-) r)
  #{ ((SbCylinder *)$p)->setRadius($r);  #} 
  ())

(defmethod  SbCylinder  getAxis ()
  
  (gptr #{ &(((SbCylinder *)$p)->getAxis())  #} ))  ;; const SbLine &  -> gptr

(defmethod  SbCylinder  getRadius ()
  
  (float #{ ((SbCylinder *)$p)->getRadius()  #} ))

(defmethod  SbCylinder  intersect (l  intersection)
  
  ((-gptr- "const SbLine *") l)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") intersection)     ;; reference -> gptr
  (int #{ ((SbCylinder *)$p)->intersect(*$l ,*$intersection)  #} ))  ;; SbBool(int) -> int

;; (defmethod  SbCylinder  intersect (l  enter  exit)
;;   
;;   ((-gptr- "const SbLine *") l)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") enter)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") exit)     ;; reference -> gptr
;;   (int #{ ((SbCylinder *)$p)->intersect(*$l ,*$enter ,*$exit)  #} ))  ;; SbBool(int) -> int



;;class SbSphere : public InventorObject
(defclass SbSphere  InventorObject)

(defmethod  SbSphere  SbSphere  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbSphere; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbSphere  SbSphere (c  r)
;;   
;;   ((-gptr- "const SbVec3f *") c)     ;; reference -> gptr
;;   ((-float-) r)
;;   ( #{ ((SbSphere *)$p)->SbSphere(*$c ,$r)  #} ))

(defmethod  SbSphere  setValue (c  r)
  
  ((-gptr- "const SbVec3f *") c)     ;; reference -> gptr
  ((-float-) r)
  #{ ((SbSphere *)$p)->setValue(*$c ,$r);  #} 
  ())

(defmethod  SbSphere  setCenter (c)
  
  ((-gptr- "const SbVec3f *") c)     ;; reference -> gptr
  #{ ((SbSphere *)$p)->setCenter(*$c);  #} 
  ())

(defmethod  SbSphere  setRadius (r)
  
  ((-float-) r)
  #{ ((SbSphere *)$p)->setRadius($r);  #} 
  ())

(defmethod  SbSphere  getCenter ()
  
  (gptr #{ &(((SbSphere *)$p)->getCenter())  #} ))   ;; const SbVec3f & -> gptr

(defmethod  SbSphere  getRadius ()
  
  (float #{ ((SbSphere *)$p)->getRadius()  #} ))

(defmethod  SbSphere  circumscribe (box)
  
  ((-gptr- "const SbBox3f *") box)     ;; reference -> gptr
  #{ ((SbSphere *)$p)->circumscribe(*$box);  #} 
  ())

(defmethod  SbSphere  intersect (l  intersection)
  
  ((-gptr- "const SbLine *") l)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") intersection)     ;; reference -> gptr
  (int #{ ((SbSphere *)$p)->intersect(*$l ,*$intersection)  #} ))  ;; SbBool(int) -> int

;; (defmethod  SbSphere  intersect (l  enter  exit)
;;   
;;   ((-gptr- "const SbLine *") l)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") enter)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") exit)     ;; reference -> gptr
;;   (int #{ ((SbSphere *)$p)->intersect(*$l ,*$enter ,*$exit)  #} ))  ;; SbBool(int) -> int






;;class SbViewVolume : public InventorObject
(defclass SbViewVolume  InventorObject)


(defmethod  SbViewVolume  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbViewVolume *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

(defmethod  SbViewVolume  getMatrices (affine  proj)
  
  ((-gptr- "SbMatrix *") affine)     ;; reference -> gptr
  ((-gptr- "SbMatrix *") proj)     ;; reference -> gptr
  #{ ((SbViewVolume *)$p)->getMatrices(*$affine ,*$proj);  #} 
  ())

(defmethod  SbViewVolume  getMatrix ()
  
  (let*  ((retobj (new SbMatrix ()))
	  (retobjp :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SbViewVolume *)$p)->getMatrix();  #} 
    retobj))

(defmethod  SbViewVolume  getCameraSpaceMatrix ()
  
  (let*  ((retobj (new SbMatrix ()))
	  (retobjp :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SbViewVolume *)$p)->getCameraSpaceMatrix();  #} 
    retobj))

(defmethod  SbViewVolume  projectPointToLine (pt  line)
  
  ((-gptr- "const SbVec2f *") pt)     ;; reference -> gptr
  ((-gptr- "SbLine *") line)     ;; reference -> gptr
  #{ ((SbViewVolume *)$p)->projectPointToLine(*$pt ,*$line);  #} 
  ())

;; (defmethod  SbViewVolume  projectPointToLine (pt  line0  line1)
;;   
;;   ((-gptr- "const SbVec2f *") pt)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") line0)     ;; reference -> gptr
;;   ((-gptr- "SbVec3f *") line1)     ;; reference -> gptr
;;   #{ ((SbViewVolume *)$p)->projectPointToLine(*$pt ,*$line0 ,*$line1);  #} 
;;   ())

(defmethod  SbViewVolume  projectToScreen (src  dst)
  
  ((-gptr- "const SbVec3f *") src)     ;; reference -> gptr
  ((-gptr- "SbVec3f *") dst)     ;; reference -> gptr
  #{ ((SbViewVolume *)$p)->projectToScreen(*$src ,*$dst);  #} 
  ())

(defmethod  SbViewVolume  getPlane (distFromEye)
  
  ((-float-) distFromEye)
  (let*  ((retobj (new SbPlane ()))
	  (retobjp :retobj:p))
    #{ *((SbPlane *)$retobjp) = ((SbViewVolume *)$p)->getPlane($distFromEye);  #} 
    retobj))

(defmethod  SbViewVolume  getSightPoint (distFromEye)
  
  ((-float-) distFromEye)
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbViewVolume *)$p)->getSightPoint($distFromEye);  #} 
    retobj))

(defmethod  SbViewVolume  getPlanePoint (distFromEye  normPoint)
  
  ((-float-) distFromEye)
  ((-gptr- "const SbVec2f *") normPoint)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbViewVolume *)$p)->getPlanePoint($distFromEye ,*$normPoint);  #} 
    retobj))

(defmethod  SbViewVolume  getAlignRotation (rightAngleOnly)
  
  ((-int-) rightAngleOnly)    ;; SbBool(int) -> int
  (let*  ((retobj (new SbRotation ()))
	  (retobjp :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbViewVolume *)$p)->getAlignRotation($rightAngleOnly);  #} 
    retobj))

(defmethod  SbViewVolume  getWorldToScreenScale (worldCenter  normRadius)
  
  ((-gptr- "const SbVec3f *") worldCenter)     ;; reference -> gptr
  ((-float-) normRadius)
  (float #{ ((SbViewVolume *)$p)->getWorldToScreenScale(*$worldCenter ,$normRadius)  #} ))

(defmethod  SbViewVolume  projectBox (box)
  
  ((-gptr- "const SbBox3f *") box)     ;; reference -> gptr
  (let*  ((retobj (new SbVec2f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec2f *)$retobjp) = ((SbViewVolume *)$p)->projectBox(*$box);  #} 
    retobj))

(defmethod  SbViewVolume  narrow (left  bottom  right  top)
  
  ((-float-) left)
  ((-float-) bottom)
  ((-float-) right)
  ((-float-) top)
  (let*  ((retobj (new SbViewVolume ()))
	  (retobjp :retobj:p))
    #{ *((SbViewVolume *)$retobjp) = ((SbViewVolume *)$p)->narrow($left ,$bottom ,$right ,$top);  #} 
    retobj))

;; (defmethod  SbViewVolume  narrow (box)
;;   
;;   ((-gptr- "const SbBox3f *") box)     ;; reference -> gptr
;;   (let*  ((retobj (new SbViewVolume ()))
;; 	  (retobjp :retobj:p))
;;     #{ *((SbViewVolume *)$retobjp) = ((SbViewVolume *)$p)->narrow(*$box);  #} 
;;     retobj))

(defmethod  SbViewVolume  ortho (left  right  bottom  top  near  far)
  
  ((-float-) left)
  ((-float-) right)
  ((-float-) bottom)
  ((-float-) top)
  ((-float-) near)
  ((-float-) far)
  #{ ((SbViewVolume *)$p)->ortho($left ,$right ,$bottom ,$top ,$near ,$far);  #} 
  ())

(defmethod  SbViewVolume  perspective (fovy  aspect  near  far)
  
  ((-float-) fovy)
  ((-float-) aspect)
  ((-float-) near)
  ((-float-) far)
  #{ ((SbViewVolume *)$p)->perspective($fovy ,$aspect ,$near ,$far);  #} 
  ())

(defmethod  SbViewVolume  rotateCamera (q)
  
  ((-gptr- "const SbRotation *") q)     ;; reference -> gptr
  #{ ((SbViewVolume *)$p)->rotateCamera(*$q);  #} 
  ())

(defmethod  SbViewVolume  translateCamera (v)
  
  ((-gptr- "const SbVec3f *") v)     ;; reference -> gptr
  #{ ((SbViewVolume *)$p)->translateCamera(*$v);  #} 
  ())

(defmethod  SbViewVolume  zVector ()
  
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbViewVolume *)$p)->zVector();  #} 
    retobj))

(defmethod  SbViewVolume  zNarrow (near  far)
  
  ((-float-) near)
  ((-float-) far)
  (let*  ((retobj (new SbViewVolume ()))
	  (retobjp :retobj:p))
    #{ *((SbViewVolume *)$retobjp) = ((SbViewVolume *)$p)->zNarrow($near ,$far);  #} 
    retobj))

(defmethod  SbViewVolume  scale (factor)
  
  ((-float-) factor)
  #{ ((SbViewVolume *)$p)->scale($factor);  #} 
  ())

(defmethod  SbViewVolume  scaleWidth (ratio)
  
  ((-float-) ratio)
  #{ ((SbViewVolume *)$p)->scaleWidth($ratio);  #} 
  ())

(defmethod  SbViewVolume  scaleHeight (ratio)
  
  ((-float-) ratio)
  #{ ((SbViewVolume *)$p)->scaleHeight($ratio);  #} 
  ())

(defmethod  SbViewVolume  getProjectionType ()
  
  (int #{ ((SbViewVolume *)$p)->getProjectionType()  #} ))  ;; ProjectionType -> int

(defmethod  SbViewVolume  getProjectionPoint ()
  
  (gptr #{ &(((SbViewVolume *)$p)->getProjectionPoint())  #} ))   ;; const SbVec3f & -> gptr

(defmethod  SbViewVolume  getProjectionDirection ()
  
  (gptr #{ &(((SbViewVolume *)$p)->getProjectionDirection())  #} ))   ;; const SbVec3f & -> gptr

(defmethod  SbViewVolume  getNearDist ()
  
  (float #{ ((SbViewVolume *)$p)->getNearDist()  #} ))

(defmethod  SbViewVolume  getWidth ()
  
  (float #{ ((SbViewVolume *)$p)->getWidth()  #} ))

(defmethod  SbViewVolume  getHeight ()
  
  (float #{ ((SbViewVolume *)$p)->getHeight()  #} ))

(defmethod  SbViewVolume  getDepth ()
  
  (float #{ ((SbViewVolume *)$p)->getDepth()  #} )) 


(defmethod  SbViewVolume  SbViewVolume  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbViewVolume; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())











;;class SbPList : public InventorObject
(defclass SbPList  InventorObject)

(defmethod  SbPList  SbPList  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbPList; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbPList  SbPList (initSize)
;;   
;;   ((-int-) initSize)
;;   ( #{ ((SbPList *)$p)->SbPList($initSize)  #} ))
;; 
;; (defmethod  SbPList  SbPList (pl)
;;   
;;   ((-gptr- "const SbPList *") pl)     ;; reference -> gptr
;;   ( #{ ((SbPList *)$p)->SbPList(*$pl)  #} ))

(defmethod  SbPList  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbPList *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

(defmethod  SbPList  append (ptr)
  
  ((-gptr- "void *") ptr)
  #{ ((SbPList *)$p)->append($ptr);  #} 
  ())

(defmethod  SbPList  find (ptr)
  
  ((-gptr- "const void *") ptr)
  (int #{ ((SbPList *)$p)->find($ptr)  #} ))

(defmethod  SbPList  insert (ptr  addBefore)
  
  ((-gptr- "void *") ptr)
  ((-int-) addBefore)
  #{ ((SbPList *)$p)->insert($ptr ,$addBefore);  #} 
  ())

(defmethod  SbPList  remove (which)
  
  ((-int-) which)
  #{ ((SbPList *)$p)->remove($which);  #} 
  ())

(defmethod  SbPList  getLength ()
  
  (int #{ ((SbPList *)$p)->getLength()  #} ))

(defmethod  SbPList  truncate (start)
  
  ((-int-) start)
  #{ ((SbPList *)$p)->truncate($start);  #} 
  ())

(defmethod  SbPList  copy (pl)
  
  ((-gptr- "const SbPList *") pl)     ;; reference -> gptr
  #{ ((SbPList *)$p)->copy(*$pl);  #} 
  ())










;;class SbString : public InventorObject
(defclass SbString  InventorObject)


(defmethod  SbString  -destructor ()
  
  #{ if( $shell_flag == false ) {
        delete ((SbString *)$p);
        $p = NULL;
        $shell_flag = true;
     }
  #} 
  ())

(defmethod  SbString  hash ()
  
  (int #{ ((SbString *)$p)->hash()  #} ))   ;; uint32_t -> int

(defmethod  SbString  getLength ()
  
  (int #{ ((SbString *)$p)->getLength()  #} ))

(defmethod  SbString  makeEmpty (freeOld)
  
  ((-int-) freeOld)    ;; SbBool(int) -> int
  #{ ((SbString *)$p)->makeEmpty($freeOld);  #} 
  ())

(defmethod  SbString  getString ()
  
  (gptr #{ ((SbString *)$p)->getString()  #} ))  ;; const char *  -> gptr

(defmethod  SbString  getSubString (startChar  endChar)
  
  ((-int-) startChar)
  ((-int-) endChar)
  (let*  ((retobj (new SbString ()))
	  (retobjp :retobj:p))
    #{ *((SbString *)$retobjp) = ((SbString *)$p)->getSubString($startChar ,$endChar);  #} 
    retobj))

(defmethod  SbString  deleteSubString (startChar  endChar)
  
  ((-int-) startChar)
  ((-int-) endChar)
  #{ ((SbString *)$p)->deleteSubString($startChar ,$endChar);  #} 
  ())



(defmethod  SbString  SbString  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbString; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())  

;; (defmethod  SbString  SbString (str)
;;   
;;   ((-gptr- "const char *") str)
;;   ( #{ ((SbString *)$p)->SbString($str)  #} ))
;; 
;; (defmethod  SbString  SbString (str  start  end)
;;   
;;   ((-gptr- "const char *") str)
;;   ((-int-) start)
;;   ((-int-) end)
;;   ( #{ ((SbString *)$p)->SbString($str ,$start ,$end)  #} ))
;; 
;; (defmethod  SbString  SbString (str)
;;   
;;   ((-gptr- "const SbString *") str)     ;; reference -> gptr
;;   ( #{ ((SbString *)$p)->SbString(*$str)  #} ))
;; 
;; (defmethod  SbString  SbString (digitString)
;;   
;;   ((-int-) digitString)
;;   ( #{ ((SbString *)$p)->SbString($digitString)  #} ))




;;class SbName : public InventorObject
(defclass SbName  InventorObject)

(defmethod  SbName  SbName  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbName; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())  

;; (defmethod  SbName  SbName (s)
;;   
;;   ((-gptr- "const char *") s)
;;   ( #{ ((SbName *)$p)->SbName($s)  #} ))  
;; 
;; (defmethod  SbName  SbName (s)
;;   
;;   ((-gptr- "const SbString *") s)     ;; reference -> gptr
;;   ( #{ ((SbName *)$p)->SbName(*$s)  #} ))  
;; 
;; (defmethod  SbName  SbName (n)
;;   
;;   ((-gptr- "const SbName *") n)     ;; reference -> gptr
;;   ( #{ ((SbName *)$p)->SbName(*$n)  #} ))  
 
(defmethod  SbName  -destructor ()
   
  #{ if( $shell_flag == false ) {
         delete ((SbName *)$p);
         $p = NULL;
         $shell_flag = true;
     }
  #} 
  ())  

(defmethod  SbName  getString ()
  
  (gptr #{ ((SbName *)$p)->getString()  #} ))    ;; const char		*  -> gptr

(defmethod  SbName  getLength ()
  
  (int #{ ((SbName *)$p)->getLength()  #} ))  





;;class SbTime : public InventorObject
(defclass SbTime  InventorObject)

(defmethod  SbTime  SbTime  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbTime; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())  

;; (defmethod  SbTime  SbTime (sec)
;;   
;;   ((-double-) sec)
;;   ( #{ ((SbTime *)$p)->SbTime($sec)  #} ))  
;; 
;; (defmethod  SbTime  SbTime (sec  usec)
;;   
;;   ((-int-) sec)        ;; time_t -> int
;;   ((-int-) usec)       ;; long -> int
;;   ( #{ ((SbTime *)$p)->SbTime($sec ,$usec)  #} ))  
;; 
;; (defmethod  SbTime  SbTime (tv)
;;   
;;   ((-gptr- "const struct timeval *") tv)
;;   ( #{ ((SbTime *)$p)->SbTime($tv)  #} ))  


(defmethod  SbTime  setToTimeOfDay ()
  
  #{ ((SbTime *)$p)->setToTimeOfDay();  #} 
  ())  


(defmethod  SbTime  setValue (sec)
  
  ((-double-) sec)
  #{ ((SbTime *)$p)->setValue($sec);  #} 
  ()) 

;; (defmethod  SbTime  setValue (sec  usec)
;;   
;;   ((-int-) sec)      ;; time_t -> int
;;   ((-int-) usec)      ;; long -> int
;;   #{ ((SbTime *)$p)->setValue($sec ,$usec);  #} 
;;   ()) 

;; (defmethod  SbTime  setValue (tv)
;;   
;;   ((-gptr- "const struct timeval *") tv)
;;   #{ ((SbTime *)$p)->setValue($tv);  #} 
;;   ()) 

(defmethod  SbTime  setMsecValue (msec)
  
  ((-int-) msec)       ;; unsigned long -> int
  #{ ((SbTime *)$p)->setMsecValue($msec);  #} 
  ()) 

(defmethod  SbTime  getValue ()
  
  (double #{ ((SbTime *)$p)->getValue()  #} )) 

;; (defmethod  SbTime  getValue (sec  usec)
;;   
;;   ((-gptr- "time_t *") sec)     ;; reference -> gptr
;;   ((-gptr- "long *") usec)     ;; reference -> gptr
;;   #{ ((SbTime *)$p)->getValue(*$sec ,*$usec);  #} 
;;   ()) 
;; 
;; (defmethod  SbTime  getValue (tv)
;;   
;;   ((-gptr- "struct timeval *") tv)
;;   #{ ((SbTime *)$p)->getValue($tv);  #} 
;;   ()) 

(defmethod  SbTime  getMsecValue ()
  
  (int #{ ((SbTime *)$p)->getMsecValue()  #} ))  ;; unsigned long -> int

(defmethod  SbTime  format (fmt)
  
  ((-gptr- "const char *") fmt)
  (let*  ((retobj (new SbString ()))
	  (retobjp :retobj:p))
    #{ *((SbString *)$retobjp) = ((SbTime *)$p)->format($fmt);  #} 
    retobj)) 

(defmethod  SbTime  formatDate (fmt)
  
  ((-gptr- "const char *") fmt)
  (let*  ((retobj (new SbString ()))
	  (retobjp :retobj:p))
    #{ *((SbString *)$retobjp) = ((SbTime *)$p)->formatDate($fmt);  #} 
    retobj)) 





;;class SbViewportRegion : public InventorObject
(defclass SbViewportRegion  InventorObject)

(defmethod  SbViewportRegion  SbViewportRegion  ( flag )
  ((-bool-) flag)
  
  #{ if($flag == false) {
            $p = new SbViewportRegion; 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())    

;; (defmethod  SbViewportRegion  SbViewportRegion (width  height)
;;   
;;   ((-int-) width)   ;; short -> int
;;   ((-int-) height)   ;; short -> int
;;   ( #{ ((SbViewportRegion *)$p)->SbViewportRegion($width ,$height)  #} ))    
;; 
;; (defmethod  SbViewportRegion  SbViewportRegion (winSize)
;;   
;;   ((-gptr- "SbVec2s *") winSize)       ;; object -> gptr
;;   ( #{ ((SbViewportRegion *)$p)->SbViewportRegion(*$winSize)  #} ))    
;; 
;; (defmethod  SbViewportRegion  SbViewportRegion (vpReg)
;;   
;;   ((-gptr- "const SbViewportRegion *") vpReg)     ;; reference -> gptr
;;   ( #{ ((SbViewportRegion *)$p)->SbViewportRegion(*$vpReg)  #} ))    

(defmethod  SbViewportRegion  setWindowSize (width  height)
  
  ((-int-) width)   ;; short -> int
  ((-int-) height)   ;; short -> int
  #{ ((SbViewportRegion *)$p)->setWindowSize($width ,$height);  #} 
  ())    

;; (defmethod  SbViewportRegion  setWindowSize (winSize)
;;   
;;   ((-gptr- "SbVec2s *") winSize)     ;; object -> gptr
;;   #{ ((SbViewportRegion *)$p)->setWindowSize(*$winSize);  #} 
;;   ())    

(defmethod  SbViewportRegion  setViewport (left  bottom  width  height)
  
  ((-float-) left)
  ((-float-) bottom)
  ((-float-) width)
  ((-float-) height)
  #{ ((SbViewportRegion *)$p)->setViewport($left ,$bottom ,$width ,$height);  #} 
  ())    

;; (defmethod  SbViewportRegion  setViewport (origin  size)
;;   
;;   ((-gptr- "SbVec2f *") origin)  ;; object -> gptr
;;   ((-gptr- "SbVec2f *") size)    ;; object -> gptr
;;   #{ ((SbViewportRegion *)$p)->setViewport(*$origin ,*$size);  #} 
;;   ())    

(defmethod  SbViewportRegion  setViewportPixels (left  bottom  width  height)
  
  ((-int-) left)   ;; short -> int
  ((-int-) bottom)   ;; short -> int
  ((-int-) width)   ;; short -> int
  ((-int-) height)   ;; short -> int
  #{ ((SbViewportRegion *)$p)->setViewportPixels($left ,$bottom ,$width ,$height);  #} 
  ())    

;; (defmethod  SbViewportRegion  setViewportPixels (origin  size)
;;   
;;   ((-gptr- "SbVec2s *") origin)   ;; object -> gptr
;;   ((-gptr- "SbVec2s *") size)     ;; object -> gptr
;;   #{ ((SbViewportRegion *)$p)->setViewportPixels(*$origin ,*$size);  #} 
;;   ())    

(defmethod  SbViewportRegion  getWindowSize ()
  
  (gptr #{ &(((SbViewportRegion *)$p)->getWindowSize())  #} ))       ;; const SbVec2s & -> gptr

(defmethod  SbViewportRegion  getViewportOrigin ()
  
  (gptr #{ &(((SbViewportRegion *)$p)->getViewportOrigin())  #} ))       ;; const SbVec2f & -> gptr

(defmethod  SbViewportRegion  getViewportOriginPixels ()
  
  (gptr #{ &(((SbViewportRegion *)$p)->getViewportOriginPixels())  #} ))       ;; const SbVec2s & -> gptr

(defmethod  SbViewportRegion  getViewportSize ()
  
  (gptr #{ &(((SbViewportRegion *)$p)->getViewportSize())  #} ))       ;; const SbVec2f & -> gptr

(defmethod  SbViewportRegion  getViewportSizePixels ()
  
  (gptr #{ &(((SbViewportRegion *)$p)->getViewportSizePixels())  #} ))       ;; const SbVec2s & -> gptr

(defmethod  SbViewportRegion  getViewportAspectRatio ()
  
  (float #{ ((SbViewportRegion *)$p)->getViewportAspectRatio()  #} ))    

(defmethod  SbViewportRegion  scaleWidth (ratio)
  
  ((-float-) ratio)
  #{ ((SbViewportRegion *)$p)->scaleWidth($ratio);  #} 
  ())

(defmethod  SbViewportRegion  scaleHeight (ratio)
  
  ((-float-) ratio)
  #{ ((SbViewportRegion *)$p)->scaleHeight($ratio);  #} 
  ())    

(defmethod  SbViewportRegion  setPixelsPerInch (ppi)
  
  ((-float-) ppi)
  #{ ((SbViewportRegion *)$p)->setPixelsPerInch($ppi);  #} 
  ())

(defmethod  SbViewportRegion  getPixelsPerInch ()
  
  (float #{ ((SbViewportRegion *)$p)->getPixelsPerInch()  #} ))    

(defmethod  SbViewportRegion  getPixelsPerPoint ()
  
  (float #{ ((SbViewportRegion *)$p)->getPixelsPerPoint()  #} ))    




;; ********************************************************

(dhc-make-with-c++ () () 
  |dummy_sb|
  (sbvec3f  sbvec3f  getclosestaxis  equals  setvalue  negate  normalize  length  getvalue  dot  cross)
  (sbvec2f  equals  setvalue  normalize  negate  length  getvalue  dot  sbvec2f)
  (sbvec2s  setvalue  negate  getvalue  dot  sbvec2s)
  (sbvec4f  equals  setvalue  normalize  negate  length  getvalue  getreal  dot  sbvec4f)
  (sbrotation  sbrotation  scaleangle  multvec  equals  setvalue  inverse  invert  getvalue)
  (sbmatrix  sbmatrix  equals  print  multlinematrix  multdirmatrix  multvecmatrix  multmatrixvec  multleft  multright  transpose  lubacksubstitution  ludecomposition  inverse  factor  det4  det3  getvalue  gettransform  settransform  settranslate  setscale  setrotate  makeidentity  setvalue)
  (sbbox3f  getvolume  transform  getspan  hasvolume  isempty  makeempty  getsize  getorigin  getclosestpoint  getbounds  setbounds  outside  intersect  extendby  getcenter  getmax  getmin  -destructor  sbbox3f)
  (sbxfbox3f  project  transform  getspan  hasvolume  isempty  makeempty  getvolume  getsize  getorigin  getbounds  setbounds  intersect  extendby  getcenter  getinverse  gettransform  settransform  -destructor  sbxfbox3f)
  (sbbox2f  hasarea  isempty  makeempty  getaspectratio  getsize  getorigin  getclosestpoint  getbounds  setbounds  intersect  extendby  getcenter  getmax  getmin  -destructor  sbbox2f)
  (sbbox2s  makeempty  getaspectratio  getsize  getorigin  getbounds  setbounds  intersect  extendby  getmax  getmin  -destructor  sbbox2s)
  (sbcolor  getpackedvalue  setpackedvalue  gethsvvalue  sethsvvalue  sbcolor)
  (sbline  getdirection  getposition  getclosestpoint  getclosestpoints  setvalue  sbline)
  (sbplane  getdistancefromorigin  getnormal  isinhalfspace  transform  intersect  offset  sbplane)
  (sbcylinder  intersect  getradius  getaxis  setradius  setaxis  setvalue  sbcylinder)
  (sbsphere  intersect  circumscribe  getradius  getcenter  setradius  setcenter  setvalue  sbsphere)
  (sbviewvolume  sbviewvolume  getdepth  getheight  getwidth  getneardist  getprojectiondirection  getprojectionpoint  getprojectiontype  scaleheight  scalewidth  scale  znarrow  zvector  translatecamera  rotatecamera  perspective  ortho  narrow  projectbox  getworldtoscreenscale  getalignrotation  getplanepoint  getsightpoint  getplane  projecttoscreen  projectpointtoline  getcameraspacematrix  getmatrix  getmatrices  -destructor)
  (sbplist  copy  truncate  getlength  remove  insert  find  append  -destructor  sbplist)
  (sbstring  sbstring  deletesubstring  getsubstring  getstring  makeempty  getlength  hash  -destructor)
  (sbname  getlength  getstring  -destructor  sbname)
  (sbtime  formatdate  format  getmsecvalue  getvalue  setmsecvalue  setvalue  settotimeofday  sbtime)
  (sbviewportregion  getpixelsperpoint  getpixelsperinch  setpixelsperinch  scaleheight  scalewidth  getviewportaspectratio  getviewportsizepixels  getviewportsize  getviewportoriginpixels  getviewportorigin  getwindowsize  setviewportpixels  setviewport  setwindowsize  sbviewportregion)
)
