;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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")



#? *** nodes_2

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

#? * sotexturecoordinatedefault
;;.TYPE CLASS
#? (new sotexturecoordinatedefault <flag>>

#? * sotexturecoordinateenvironment
;;.TYPE CLASS
#? (new sotexturecoordinateenvironment <flag>>

#? * sotexturecoordinateplane
;;.TYPE CLASS
#? (==> <sotexturecoordinateplane> getsf-directions)
#? (==> <sotexturecoordinateplane> getsf-directiont)
#? (new sotexturecoordinateplane <flag>>

#? * soblinker
;;.TYPE CLASS
#? (==> <soblinker> getsf-speed)
#? (==> <soblinker> getsf-on)
#? (new soblinker <flag>>

#? * sofontstyle
;;.TYPE CLASS
#? (new sofontstyle <flag>>
#? (==> <sofontstyle> getsf-family)
#? (==> <sofontstyle> getsf-style)
#? (==> <sofontstyle> getfontname)

#? * solinearprofile
;;.TYPE CLASS
#? (new solinearprofile <flag>>

#? * sobaselist
;;.TYPE CLASS
#? (new sobaselist <flag>>
#? (==> <sobaselist> -destructor)
#? (==> <sobaselist> append <ptr>)
#? (==> <sobaselist> insert <ptr> <addbefore>)
#? (==> <sobaselist> remove <which>)
#? (==> <sobaselist> truncate <start>)
#? (==> <sobaselist> copy <l>)
#? (==> <sobaselist> set <i> <ptr>)
#? (==> <sobaselist> addreferences <flag>)

#? * sopath
;;.TYPE CLASS
#? (new sopath <flag>>
#? (==> <sopath> sethead <node>)
#? (==> <sopath> append <childindex>)
#? (==> <sopath> append-node <childnode>)
#? (==> <sopath> append-path <frompath>)
#? (==> <sopath> push <childindex>)
#? (==> <sopath> pop)
#? (==> <sopath> gethead)
#? (==> <sopath> gettail)
#? (==> <sopath> getnode <i>)
#? (==> <sopath> getnodefromtail <i>)
#? (==> <sopath> getindex <i>)
#? (==> <sopath> getindexfromtail <i>)
#? (==> <sopath> getlength)
#? (==> <sopath> truncate <start>)
#? (==> <sopath> containsnode <node>)
#? (==> <sopath> containspath <path>)
#? (==> <sopath> findfork <path>)
#? (==> <sopath> copy <startfromnodeindex> <numnodes>)

#? * sonodekitpath
;;.TYPE CLASS
#? (==> <sonodekitpath> getlength)
#? (==> <sonodekitpath> gettail)
#? (==> <sonodekitpath> getnode <i>)
#? (==> <sonodekitpath> getnodefromtail <i>)
#? (==> <sonodekitpath> truncate <start>)
#? (==> <sonodekitpath> pop)
#? (==> <sonodekitpath> append <childkit>)
#? (==> <sonodekitpath> append-path <frompath>)
#? (==> <sonodekitpath> containsnode <node>)
#? (==> <sonodekitpath> findfork <path>)

#? * sonurbsprofile
;;.TYPE CLASS
#? (==> <sonurbsprofile> getmf-knotvector)
#? (new sonurbsprofile <flag>>

#? * soorthographiccamera
;;.TYPE CLASS
#? (==> <soorthographiccamera> getsf-height)
#? (new soorthographiccamera <flag>>
#? (==> <soorthographiccamera> scaleheight <scalefactor>)
#? (==> <soorthographiccamera> getviewvolume <useaspectratio>)

#? * soperspectivecamera
;;.TYPE CLASS
#? (==> <soperspectivecamera> getsf-heightangle)
#? (new soperspectivecamera <flag>>
#? (==> <soperspectivecamera> scaleheight <scalefactor>)
#? (==> <soperspectivecamera> getviewvolume <useaspectratio>)

#? * (|dummy_nodes_2|)

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

(libload "inventor/nodes_1")

;; class SoTextureCoordinateDefault : public SoTextureCoordinateFunction
(defclass SoTextureCoordinateDefault SoTextureCoordinateFunction)

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





;; class SoTextureCoordinateEnvironment : public SoTextureCoordinateFunction
(defclass SoTextureCoordinateEnvironment SoTextureCoordinateFunction)

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


;; class SoTextureCoordinatePlane : public SoTextureCoordinateFunction
(defclass SoTextureCoordinatePlane SoTextureCoordinateFunction)

(defmethod SoTextureCoordinatePlane  getsf_directionS (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTextureCoordinatePlane *)$p)->directionS);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTextureCoordinatePlane  getsf_directionT (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTextureCoordinatePlane *)$p)->directionT);  #} 
    (setq :retobj:p retobjp)
    retobj))

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



(libload "inventor/nodes_group")

;; class SoBlinker : public SoSwitch
(defclass SoBlinker SoSwitch)

(defmethod SoBlinker  getsf_speed (  )
  
  (let* ((retobj (new SoSFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBlinker *)$p)->speed);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoBlinker  getsf_on (  )
  
  (let* ((retobj (new SoSFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBlinker *)$p)->on);  #} 
    (setq :retobj:p retobjp)
    retobj))

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






;; class SoFontStyle : public SoFont
(defclass SoFontStyle SoFont)

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

(defmethod SoFontStyle  getsf_family (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoFontStyle *)$p)->family);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoFontStyle  getsf_style (  )
  
  (let* ((retobj (new SoSFBitMask t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoFontStyle *)$p)->style);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoFontStyle  getFontName (  )
  
  (let*  ((retobj (new SbString ()))
	  (retobjp  :retobj:p))
    #{ *((SbString *)$retobjp) = ((SoFontStyle *)$p)->getFontName();  #} 
    (setq :retobj:p retobjp)
    retobj))







;; class SoLinearProfile : public SoProfile
(defclass SoLinearProfile SoProfile)

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




 (libload "inventor/sb")


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

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

;; (defmethod SoBaseList  SoBaseList ( flag size)
;;   ((-bool-) flag)
;;   
;;   ((-int-) size)
;;   #{  if($flag == false ) {
;;             $p = new  SoBaseList($size);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())
;; 
;; (defmethod SoBaseList  SoBaseList ( flag l)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SoBaseList *") l)   ;; reference -> gptr
;;   #{  if($flag == false ) {
;;             $p = new  SoBaseList(*$l);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

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

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

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

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

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

(defmethod SoBaseList  set ( i ptr)
  
  ((-int-) i)
  ((-gptr- "SoBase *") ptr)
  #{ ((SoBaseList *)$p)->set($i,$ptr);  #} 
  ())

(defmethod SoBaseList  addReferences ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoBaseList *)$p)->addReferences($flag);  #} 
  ())



(libload "inventor/misc")

;; class SoPath : public SoBase
(defclass SoPath SoBase)

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

;; (defmethod SoPath  SoPath ( flag approxLength)
;;   ((-bool-) flag)
;;   
;;   ((-int-) approxLength)
;;   #{  if($flag == false ) {
;;             $p = new  SoPath($approxLength);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())
;; 
;; (defmethod SoPath  SoPath ( flag node)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "SoNode *") node)
;;   #{  if($flag == false ) {
;;             $p = new  SoPath($node);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

(defmethod SoPath  setHead ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoPath *)$p)->setHead($node);  #} 
  ())

(defmethod SoPath  append ( childIndex)
  
  ((-int-) childIndex)
  #{ ((SoPath *)$p)->append($childIndex);  #} 
  ())

(defmethod SoPath  append_node ( childNode)
  
  ((-gptr- "SoNode *") childNode)
  #{ ((SoPath *)$p)->append($childNode);  #} 
  ())

(defmethod SoPath  append_path ( fromPath)
  
  ((-gptr- "const SoPath *") fromPath)
  #{ ((SoPath *)$p)->append($fromPath);  #} 
  ())

(defmethod SoPath  push ( childIndex)
  
  ((-int-) childIndex)
  #{ ((SoPath *)$p)->push($childIndex);  #} 
  ())

(defmethod SoPath  pop (  )
  
  #{ ((SoPath *)$p)->pop();  #} 
  ())

(defmethod SoPath  getHead (  )
  
  (gptr #{ ((SoPath *)$p)->getHead()  #} ))    ;; SoNode *  -> gptr

(defmethod SoPath  getTail (  )
  
  (gptr #{ ((SoPath *)$p)->getTail()  #} ))    ;; SoNode *  -> gptr

(defmethod SoPath  getNode ( i)
  
  ((-int-) i)
  (gptr #{ ((SoPath *)$p)->getNode($i)  #} ))    ;; SoNode *  -> gptr

(defmethod SoPath  getNodeFromTail ( i)
  
  ((-int-) i)
  (gptr #{ ((SoPath *)$p)->getNodeFromTail($i)  #} ))    ;; SoNode *  -> gptr

(defmethod SoPath  getIndex ( i)
  
  ((-int-) i)
  (int #{ ((SoPath *)$p)->getIndex($i)  #} ))

(defmethod SoPath  getIndexFromTail ( i)
  
  ((-int-) i)
  (int #{ ((SoPath *)$p)->getIndexFromTail($i)  #} ))

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

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

(defmethod SoPath  containsNode ( node)
  
  ((-gptr- "const SoNode *") node)
  (int #{ ((SoPath *)$p)->containsNode($node)  #} ))

(defmethod SoPath  containsPath ( path)
  
  ((-gptr- "const SoPath *") path)
  (int #{ ((SoPath *)$p)->containsPath($path)  #} ))

(defmethod SoPath  findFork ( path)
  
  ((-gptr- "const SoPath *") path)
  (int #{ ((SoPath *)$p)->findFork($path)  #} ))

(defmethod SoPath  copy ( startFromNodeIndex numNodes)
  
  ((-int-) startFromNodeIndex)
  ((-int-) numNodes)
  (gptr #{ ((SoPath *)$p)->copy($startFromNodeIndex,$numNodes)  #} ))    ;; SoPath *  -> gptr





;; class SoNodeKitPath : public SoPath
(defclass SoNodeKitPath SoPath)

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

(defmethod SoNodeKitPath  getTail (  )
  
  (gptr #{ ((SoNodeKitPath *)$p)->getTail()  #} ))    ;; SoNode *  -> gptr

(defmethod SoNodeKitPath  getNode ( i)
  
  ((-int-) i)
  (gptr #{ ((SoNodeKitPath *)$p)->getNode($i)  #} ))    ;; SoNode *  -> gptr

(defmethod SoNodeKitPath  getNodeFromTail ( i)
  
  ((-int-) i)
  (gptr #{ ((SoNodeKitPath *)$p)->getNodeFromTail($i)  #} ))    ;; SoNode *  -> gptr

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

(defmethod SoNodeKitPath  pop (  )
  
  #{ ((SoNodeKitPath *)$p)->pop();  #} 
  ())

(defmethod SoNodeKitPath  append ( childKit)
  
  ((-gptr- "SoBaseKit *") childKit)
  #{ ((SoNodeKitPath *)$p)->append($childKit);  #} 
  ())

(defmethod SoNodeKitPath  append_path ( fromPath)
  
  ((-gptr- "const SoNodeKitPath *") fromPath)
  #{ ((SoNodeKitPath *)$p)->append($fromPath);  #} 
  ())

(defmethod SoNodeKitPath  containsNode ( node)
  
  ((-gptr- "SoBaseKit *") node)
  (int #{ ((SoNodeKitPath *)$p)->containsNode($node)  #} ))

(defmethod SoNodeKitPath  findFork ( path)
  
  ((-gptr- "const SoNodeKitPath *") path)
  (int #{ ((SoNodeKitPath *)$p)->findFork($path)  #} ))













;; class SoNurbsProfile : public SoProfile
(defclass SoNurbsProfile SoProfile)

(defmethod SoNurbsProfile  getmf_knotVector (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoNurbsProfile *)$p)->knotVector);  #} 
    (setq :retobj:p retobjp)
    retobj))

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















;; class SoOrthographicCamera : public SoCamera
(defclass SoOrthographicCamera SoCamera)

(defmethod SoOrthographicCamera  getsf_height (  )
  
  (let* ((retobj (new SoSFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOrthographicCamera *)$p)->height);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

(defmethod SoOrthographicCamera  scaleHeight ( scaleFactor)
  
  ((-float-) scaleFactor)
  #{ ((SoOrthographicCamera *)$p)->scaleHeight($scaleFactor);  #} 
  ())

(defmethod SoOrthographicCamera  getViewVolume ( useAspectRatio)
  
  ((-float-) useAspectRatio)
  (let*  ((retobj (new SbViewVolume ()))
	  (retobjp  :retobj:p))
    #{ *((SbViewVolume *)$retobjp) = ((SoOrthographicCamera *)$p)->getViewVolume($useAspectRatio);  #} 
    (setq :retobj:p retobjp)
    retobj))








;; class SoPerspectiveCamera : public SoCamera
(defclass SoPerspectiveCamera SoCamera)

(defmethod SoPerspectiveCamera  getsf_heightAngle (  )
  
  (let* ((retobj (new SoSFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoPerspectiveCamera *)$p)->heightAngle);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

(defmethod SoPerspectiveCamera  scaleHeight ( scaleFactor)
  
  ((-float-) scaleFactor)
  #{ ((SoPerspectiveCamera *)$p)->scaleHeight($scaleFactor);  #} 
  ())

(defmethod SoPerspectiveCamera  getViewVolume ( useAspectRatio)
  
  ((-float-) useAspectRatio)
  (let*  ((retobj (new SbViewVolume ()))
	  (retobjp  :retobj:p))
    #{ *((SbViewVolume *)$retobjp) = ((SoPerspectiveCamera *)$p)->getViewVolume($useAspectRatio);  #} 
    (setq :retobj:p retobjp)
    retobj))







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

(dhc-make-with-c++ () () 
  |dummy_nodes_2|
  (sotexturecoordinatedefault  sotexturecoordinatedefault)
  (sotexturecoordinateenvironment  sotexturecoordinateenvironment)
  (sotexturecoordinateplane  sotexturecoordinateplane  getsf-directiont  getsf-directions)
  (soblinker  soblinker  getsf-on  getsf-speed)
  (sofontstyle  getfontname  getsf-style  getsf-family  sofontstyle)
  (solinearprofile  solinearprofile)
  (sobaselist  addreferences  set  copy  truncate  remove  insert  append  -destructor  sobaselist)
  (sopath  copy  findfork  containspath  containsnode  truncate  getlength  getindexfromtail  getindex  getnodefromtail  getnode  gettail  gethead  pop  push  append-path  append-node  append  sethead  sopath)
  (sonodekitpath  findfork  containsnode  append-path    pop  truncate  getnodefromtail  getnode  gettail  getlength)  ;; append
  (sonurbsprofile  sonurbsprofile  getmf-knotvector)
  (soorthographiccamera  getviewvolume  scaleheight  soorthographiccamera  getsf-height)
  (soperspectivecamera  getviewvolume  scaleheight  soperspectivecamera  getsf-heightangle)
)
