;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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_transformation

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

#? * soantisquish
;;.TYPE CLASS
#? (new soantisquish <flag>>
#? (==> <soantisquish> getsf-sizing)
#? (==> <soantisquish> getsf-recalcalways)
#? (==> <soantisquish> recalc)

#? * somatrixtransform
;;.TYPE CLASS
#? (==> <somatrixtransform> getsf-matrix)
#? (new somatrixtransform <flag>>

#? * soresettransform
;;.TYPE CLASS
#? (==> <soresettransform> getsf-whattoreset)
#? (new soresettransform <flag>>

#? * sorotation
;;.TYPE CLASS
#? (==> <sorotation> getsf-rotation)
#? (new sorotation <flag>>

#? * sorotationxyz
;;.TYPE CLASS
#? (==> <sorotationxyz> getsf-axis)
#? (==> <sorotationxyz> getsf-angle)
#? (new sorotationxyz <flag>>
#? (==> <sorotationxyz> getrotation)

#? * soscale
;;.TYPE CLASS
#? (==> <soscale> getsf-scalefactor)
#? (new soscale <flag>>

#? * sosurroundscale
;;.TYPE CLASS
#? (new sosurroundscale <flag>>
#? (==> <sosurroundscale> getsf-numnodesuptocontainer)
#? (==> <sosurroundscale> getsf-numnodesuptoreset)
#? (==> <sosurroundscale> invalidate)

#? * sotranslation
;;.TYPE CLASS
#? (==> <sotranslation> getsf-translation)
#? (new sotranslation <flag>>

#? * sounits
;;.TYPE CLASS
#? (==> <sounits> getsf-units)
#? (new sounits <flag>>

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

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

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

#? * (|dummy_nodes_transformation|)

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


(libload "inventor/nodes_1")

;; class SoAntiSquish : public SoTransformation    
(defclass SoAntiSquish SoTransformation)

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

(defmethod SoAntiSquish  getsf_sizing (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoAntiSquish *)$p)->sizing);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoAntiSquish  getsf_recalcAlways (  )
  
  (let* ((retobj (new SoSFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoAntiSquish *)$p)->recalcAlways);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoAntiSquish  recalc (  )
  
  #{ ((SoAntiSquish *)$p)->recalc();  #} 
  ())





;; class SoMatrixTransform : public SoTransformation
(defclass SoMatrixTransform SoTransformation)

(defmethod SoMatrixTransform  getsf_matrix (  )
  
  (let* ((retobj (new SoSFMatrix t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoMatrixTransform *)$p)->matrix);  #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoResetTransform : public SoTransformation
(defclass SoResetTransform SoTransformation)

(defmethod SoResetTransform  getsf_whatToReset (  )
  
  (let* ((retobj (new SoSFBitMask t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoResetTransform *)$p)->whatToReset);  #} 
    (setq :retobj:p retobjp)
    retobj))

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





;; class SoRotation : public SoTransformation
(defclass SoRotation SoTransformation)

(defmethod SoRotation  getsf_rotation (  )
  
  (let* ((retobj (new SoSFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoRotation *)$p)->rotation);  #} 
    (setq :retobj:p retobjp)
    retobj))

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






;; class SoRotationXYZ : public SoTransformation
(defclass SoRotationXYZ SoTransformation)

(defmethod SoRotationXYZ  getsf_axis (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoRotationXYZ *)$p)->axis);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoRotationXYZ  getsf_angle (  )
  
  (let* ((retobj (new SoSFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoRotationXYZ *)$p)->angle);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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






;; class SoScale : public SoTransformation
(defclass SoScale SoTransformation)

(defmethod SoScale  getsf_scaleFactor (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoScale *)$p)->scaleFactor);  #} 
    (setq :retobj:p retobjp)
    retobj))

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



;; class SoSurroundScale : public SoTransformation
(defclass SoSurroundScale SoTransformation)

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

(defmethod SoSurroundScale  getsf_numNodesUpToContainer (  )
  
  (let* ((retobj (new SoSFInt32 t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSurroundScale *)$p)->numNodesUpToContainer);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSurroundScale  getsf_numNodesUpToReset (  )
  
  (let* ((retobj (new SoSFInt32 t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSurroundScale *)$p)->numNodesUpToReset);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSurroundScale  invalidate (  )
  
  #{ ((SoSurroundScale *)$p)->invalidate();  #} 
  ())




;; class SoTranslation : public SoTransformation
(defclass SoTranslation SoTransformation)

(defmethod SoTranslation  getsf_translation (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTranslation *)$p)->translation);  #} 
    (setq :retobj:p retobjp)
    retobj))

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



;; class SoUnits : public SoTransformation
(defclass SoUnits SoTransformation)

(defmethod SoUnits  getsf_units (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoUnits *)$p)->units);  #} 
    (setq :retobj:p retobjp)
    retobj))

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









;; class SoShuttle : public SoTranslation
(defclass SoShuttle SoTranslation)

(defmethod SoShuttle  getsf_translation0 (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoShuttle *)$p)->translation0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoShuttle  getsf_translation1 (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoShuttle *)$p)->translation1);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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

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



;; class SoRotor : public SoRotation
(defclass SoRotor SoRotation)

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

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

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




;; class SoPendulum : public SoRotation
(defclass SoPendulum SoRotation)

(defmethod SoPendulum  getsf_rotation0 (  )
  
  (let* ((retobj (new SoSFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoPendulum *)$p)->rotation0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPendulum  getsf_rotation1 (  )
  
  (let* ((retobj (new SoSFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoPendulum *)$p)->rotation1);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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

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





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

(dhc-make-with-c++ () () 
  |dummy_nodes_transformation|
  (soantisquish  recalc  getsf-recalcalways  getsf-sizing  soantisquish)
  (somatrixtransform  somatrixtransform  getsf-matrix)
  (soresettransform  soresettransform  getsf-whattoreset)
  (sorotation  sorotation  getsf-rotation)
  (sorotationxyz  getrotation  sorotationxyz  getsf-angle  getsf-axis)
  (soscale  soscale  getsf-scalefactor)
  (sosurroundscale  invalidate  getsf-numnodesuptoreset  getsf-numnodesuptocontainer  sosurroundscale)
  (sotranslation  sotranslation  getsf-translation)
  (sounits  sounits  getsf-units)
  (soshuttle  soshuttle  getsf-on  getsf-speed  getsf-translation1  getsf-translation0)
  (sorotor  sorotor  getsf-on  getsf-speed)
  (sopendulum  sopendulum  getsf-on  getsf-speed  getsf-rotation1  getsf-rotation0)
)
