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



#? *** engines

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

#? * soengine
;;.TYPE CLASS
#? (==> <soengine> getoutputs <list>)
#? (==> <soengine> getoutput <outputname>)
#? (==> <soengine> getoutputname <output> <outputname>)
#? (==> <soengine> copy)

#? * sobooloperation
;;.TYPE CLASS
#? (==> <sobooloperation> getfielddata)
#? (==> <sobooloperation> getoutputdata)
#? (==> <sobooloperation> getmf-a)
#? (==> <sobooloperation> getmf-b)
#? (==> <sobooloperation> getmf-operation)
#? (==> <sobooloperation> geteo-output)
#? (==> <sobooloperation> geteo-inverse)
#? (new sobooloperation <flag>>

#? * socalculator
;;.TYPE CLASS
#? (==> <socalculator> getfielddata)
#? (==> <socalculator> getoutputdata)
#? (==> <socalculator> getmf-a)
#? (==> <socalculator> getmf-b)
#? (==> <socalculator> getmf-c)
#? (==> <socalculator> getmf-d)
#? (==> <socalculator> getmf-e)
#? (==> <socalculator> getmf-f)
#? (==> <socalculator> getmf-g)
#? (==> <socalculator> getmf-h)
#? (==> <socalculator> getmf-aa)
#? (==> <socalculator> getmf-bb)
#? (==> <socalculator> getmf-cc)
#? (==> <socalculator> getmf-dd)
#? (==> <socalculator> getmf-ee)
#? (==> <socalculator> getmf-ff)
#? (==> <socalculator> getmf-gg)
#? (==> <socalculator> getmf-hh)
#? (==> <socalculator> getmf-expression)
#? (==> <socalculator> geteo-oa)
#? (==> <socalculator> geteo-ob)
#? (==> <socalculator> geteo-oc)
#? (==> <socalculator> geteo-od)
#? (==> <socalculator> geteo-oaa)
#? (==> <socalculator> geteo-obb)
#? (==> <socalculator> geteo-occ)
#? (==> <socalculator> geteo-odd)
#? (new socalculator <flag>>

#? * socomposevec2f
;;.TYPE CLASS
#? (new socomposevec2f <flag>>
#? (==> <socomposevec2f> getmf-x)
#? (==> <socomposevec2f> getmf-y)
#? (==> <socomposevec2f> geteo-vector)

#? * socomposevec3f
;;.TYPE CLASS
#? (new socomposevec3f <flag>>
#? (==> <socomposevec3f> getmf-x)
#? (==> <socomposevec3f> getmf-y)
#? (==> <socomposevec3f> getmf-z)
#? (==> <socomposevec3f> geteo-vector)

#? * socomposevec4f
;;.TYPE CLASS
#? (new socomposevec4f <flag>>
#? (==> <socomposevec4f> getmf-x)
#? (==> <socomposevec4f> getmf-y)
#? (==> <socomposevec4f> getmf-z)
#? (==> <socomposevec4f> getmf-w)
#? (==> <socomposevec4f> geteo-vector)

#? * sodecomposevec2f
;;.TYPE CLASS
#? (new sodecomposevec2f <flag>>
#? (==> <sodecomposevec2f> getmf-vector)
#? (==> <sodecomposevec2f> geteo-x)
#? (==> <sodecomposevec2f> geteo-y)

#? * sodecomposevec3f
;;.TYPE CLASS
#? (new sodecomposevec3f <flag>>
#? (==> <sodecomposevec3f> getmf-vector)
#? (==> <sodecomposevec3f> geteo-x)
#? (==> <sodecomposevec3f> geteo-y)
#? (==> <sodecomposevec3f> geteo-z)

#? * sodecomposevec4f
;;.TYPE CLASS
#? (new sodecomposevec4f <flag>>
#? (==> <sodecomposevec4f> getmf-vector)
#? (==> <sodecomposevec4f> geteo-x)
#? (==> <sodecomposevec4f> geteo-y)
#? (==> <sodecomposevec4f> geteo-z)
#? (==> <sodecomposevec4f> geteo-w)

#? * socomposerotation
;;.TYPE CLASS
#? (new socomposerotation <flag>>
#? (==> <socomposerotation> getmf-axis)
#? (==> <socomposerotation> getmf-angle)
#? (==> <socomposerotation> geteo-rotation)

#? * socomposerotationfromto
;;.TYPE CLASS
#? (new socomposerotationfromto <flag>>
#? (==> <socomposerotationfromto> getmf-from)
#? (==> <socomposerotationfromto> getmf-to)
#? (==> <socomposerotationfromto> geteo-rotation)

#? * sodecomposerotation
;;.TYPE CLASS
#? (new sodecomposerotation <flag>>
#? (==> <sodecomposerotation> getmf-rotation)
#? (==> <sodecomposerotation> geteo-axis)
#? (==> <sodecomposerotation> geteo-angle)

#? * socomposematrix
;;.TYPE CLASS
#? (new socomposematrix <flag>>
#? (==> <socomposematrix> getmf-translation)
#? (==> <socomposematrix> getmf-rotation)
#? (==> <socomposematrix> getmf-scalefactor)
#? (==> <socomposematrix> getmf-scaleorientation)
#? (==> <socomposematrix> getmf-center)
#? (==> <socomposematrix> geteo-matrix)

#? * sodecomposematrix
;;.TYPE CLASS
#? (new sodecomposematrix <flag>>
#? (==> <sodecomposematrix> getmf-matrix)
#? (==> <sodecomposematrix> getmf-center)
#? (==> <sodecomposematrix> geteo-translation)
#? (==> <sodecomposematrix> geteo-rotation)
#? (==> <sodecomposematrix> geteo-scalefactor)
#? (==> <sodecomposematrix> geteo-scaleorientation)

#? * socomputeboundingbox
;;.TYPE CLASS
#? (==> <socomputeboundingbox> getfielddata)
#? (==> <socomputeboundingbox> getoutputdata)
#? (==> <socomputeboundingbox> getsf-node)
#? (==> <socomputeboundingbox> getsf-path)
#? (==> <socomputeboundingbox> geteo-min)
#? (==> <socomputeboundingbox> geteo-max)
#? (==> <socomputeboundingbox> geteo-boxcenter)
#? (==> <socomputeboundingbox> geteo-objectcenter)
#? (new socomputeboundingbox <flag>>
#? (==> <socomputeboundingbox> setviewportregion <vpreg>)
#? (==> <socomputeboundingbox> getviewportregion)

#? * soconcatenate
;;.TYPE CLASS
#? (==> <soconcatenate> getfielddata)
#? (==> <soconcatenate> getoutputdata)
#? (new soconcatenate <flag> <mfinputtype>>
#? (==> <soconcatenate> getval-input <s>)
#? (==> <soconcatenate> getval-output)

#? * socounter
;;.TYPE CLASS
#? (==> <socounter> getfielddata)
#? (==> <socounter> getoutputdata)
#? (==> <socounter> getsf-min)
#? (==> <socounter> getsf-max)
#? (==> <socounter> getsf-step)
#? (==> <socounter> getsf-trigger)
#? (==> <socounter> getsf-reset)
#? (==> <socounter> geteo-output)
#? (==> <socounter> geteo-syncout)
#? (new socounter <flag>>

#? * soelapsedtime
;;.TYPE CLASS
#? (==> <soelapsedtime> getfielddata)
#? (==> <soelapsedtime> getoutputdata)
#? (==> <soelapsedtime> getsf-timein)
#? (==> <soelapsedtime> getsf-speed)
#? (==> <soelapsedtime> getsf-on)
#? (==> <soelapsedtime> getsf-pause)
#? (==> <soelapsedtime> getsf-reset)
#? (==> <soelapsedtime> geteo-timeout)
#? (new soelapsedtime <flag>>

#? * sogate
;;.TYPE CLASS
#? (==> <sogate> getfielddata)
#? (==> <sogate> getoutputdata)
#? (new sogate <flag> <mfinputtype>>
#? (==> <sogate> getsf-enable)
#? (==> <sogate> getsf-trigger)
#? (==> <sogate> getval-input)
#? (==> <sogate> getval-output)

#? * sointerpolate
;;.TYPE CLASS
#? (==> <sointerpolate> getfielddata)
#? (==> <sointerpolate> getoutputdata)
#? (==> <sointerpolate> getsf-alpha)
#? (==> <sointerpolate> geteo-output)

#? * sooneshot
;;.TYPE CLASS
#? (==> <sooneshot> getfielddata)
#? (==> <sooneshot> getoutputdata)
#? (==> <sooneshot> getsf-duration)
#? (==> <sooneshot> getsf-trigger)
#? (==> <sooneshot> getsf-flags)
#? (==> <sooneshot> getsf-disable)
#? (==> <sooneshot> getsf-timein)
#? (==> <sooneshot> geteo-timeout)
#? (==> <sooneshot> geteo-isactive)
#? (==> <sooneshot> geteo-ramp)
#? (new sooneshot <flag>>

#? * soonoff
;;.TYPE CLASS
#? (==> <soonoff> getfielddata)
#? (==> <soonoff> getoutputdata)
#? (==> <soonoff> getsf-on)
#? (==> <soonoff> getsf-off)
#? (==> <soonoff> getsf-toggle)
#? (==> <soonoff> geteo-ison)
#? (==> <soonoff> geteo-isoff)
#? (new soonoff <flag>>

#? * soselectone
;;.TYPE CLASS
#? (==> <soselectone> getfielddata)
#? (==> <soselectone> getoutputdata)
#? (new soselectone <flag> <mfinputtype>>
#? (==> <soselectone> getsf-index)
#? (==> <soselectone> getval-input)
#? (==> <soselectone> getval-output)

#? * sotimecounter
;;.TYPE CLASS
#? (==> <sotimecounter> getfielddata)
#? (==> <sotimecounter> getoutputdata)
#? (==> <sotimecounter> getsf-min)
#? (==> <sotimecounter> getsf-max)
#? (==> <sotimecounter> getsf-step)
#? (==> <sotimecounter> getsf-on)
#? (==> <sotimecounter> getsf-frequency)
#? (==> <sotimecounter> getmf-duty)
#? (==> <sotimecounter> getsf-timein)
#? (==> <sotimecounter> getsf-syncin)
#? (==> <sotimecounter> getsf-reset)
#? (==> <sotimecounter> geteo-output)
#? (==> <sotimecounter> geteo-syncout)
#? (new sotimecounter <flag>>

#? * sotransformvec3f
;;.TYPE CLASS
#? (==> <sotransformvec3f> getfielddata)
#? (==> <sotransformvec3f> getoutputdata)
#? (==> <sotransformvec3f> getmf-vector)
#? (==> <sotransformvec3f> getmf-matrix)
#? (==> <sotransformvec3f> geteo-point)
#? (==> <sotransformvec3f> geteo-direction)
#? (==> <sotransformvec3f> geteo-normaldirection)
#? (new sotransformvec3f <flag>>

#? * sotriggerany
;;.TYPE CLASS
#? (==> <sotriggerany> getfielddata)
#? (==> <sotriggerany> getoutputdata)
#? (==> <sotriggerany> getsf-input0)
#? (==> <sotriggerany> getsf-input1)
#? (==> <sotriggerany> getsf-input2)
#? (==> <sotriggerany> getsf-input3)
#? (==> <sotriggerany> getsf-input4)
#? (==> <sotriggerany> getsf-input5)
#? (==> <sotriggerany> getsf-input6)
#? (==> <sotriggerany> getsf-input7)
#? (==> <sotriggerany> getsf-input8)
#? (==> <sotriggerany> getsf-input9)
#? (==> <sotriggerany> geteo-output)
#? (new sotriggerany <flag>>

#? * sointerpolatefloat
;;.TYPE CLASS
#? (==> <sointerpolatefloat> getfielddata)
#? (==> <sointerpolatefloat> getoutputdata)
#? (new sointerpolatefloat <flag>>
#? (==> <sointerpolatefloat> getmf-input0)
#? (==> <sointerpolatefloat> getmf-input1)

#? * sointerpolaterotation
;;.TYPE CLASS
#? (==> <sointerpolaterotation> getfielddata)
#? (==> <sointerpolaterotation> getoutputdata)
#? (new sointerpolaterotation <flag>>
#? (==> <sointerpolaterotation> getmf-input0)
#? (==> <sointerpolaterotation> getmf-input1)

#? * sointerpolatevec2f
;;.TYPE CLASS
#? (==> <sointerpolatevec2f> getfielddata)
#? (==> <sointerpolatevec2f> getoutputdata)
#? (new sointerpolatevec2f <flag>>
#? (==> <sointerpolatevec2f> getmf-input0)
#? (==> <sointerpolatevec2f> getmf-input1)

#? * sointerpolatevec3f
;;.TYPE CLASS
#? (==> <sointerpolatevec3f> getfielddata)
#? (==> <sointerpolatevec3f> getoutputdata)
#? (new sointerpolatevec3f <flag>>
#? (==> <sointerpolatevec3f> getmf-input0)
#? (==> <sointerpolatevec3f> getmf-input1)

#? * sointerpolatevec4f
;;.TYPE CLASS
#? (==> <sointerpolatevec4f> getfielddata)
#? (==> <sointerpolatevec4f> getoutputdata)
#? (new sointerpolatevec4f <flag>>
#? (==> <sointerpolatevec4f> getmf-input0)
#? (==> <sointerpolatevec4f> getmf-input1)

#? * (|dummy_engines|)

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



;;*****************************************************************
;;***********  engines
;;*****************************************************************
(libload "inventor/sotype")
(libload "inventor/soengineoutput")

;; class SoEngine : public SoFieldContainer
(defclass SoEngine SoFieldContainer)

(defmethod SoEngine  getOutputs ( list)
  
  ((-gptr- "SoEngineOutputList *") list)   ;; reference -> gptr
  (int #{ ((SoEngine *)$p)->getOutputs(*$list)  #} ))

(defmethod SoEngine  getOutput ( outputName)
  
  ((-gptr- "const SbName *") outputName)   ;; reference -> gptr
  (gptr #{ ((SoEngine *)$p)->getOutput(*$outputName)  #} ))    ;; SoEngineOutput *  -> gptr

(defmethod SoEngine  getOutputName ( output outputName)
  
  ((-gptr- "const SoEngineOutput *") output)
  ((-gptr- "SbName *") outputName)   ;; reference -> gptr
  (int #{ ((SoEngine *)$p)->getOutputName($output, *$outputName)  #} ))

(defmethod SoEngine  copy (  )
  
  (gptr #{ ((SoEngine *)$p)->copy()  #} ))    ;; SoEngine *  -> gptr




;; class SoBoolOperation : public SoEngine
(defclass SoBoolOperation SoEngine)

(defmethod SoBoolOperation  getFieldData (  )
  
  (gptr #{ ((SoBoolOperation *)$p)->getFieldData()  #} ))    ;; const SoFieldData*  -> gptr

(defmethod SoBoolOperation  getOutputData (  )
  
  (gptr #{ ((SoBoolOperation *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData*  -> gptr

(defmethod SoBoolOperation  getmf_a (  )
  
  (let* ((retobj (new SoMFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBoolOperation *)$p)->a);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoBoolOperation  getmf_b (  )
  
  (let* ((retobj (new SoMFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBoolOperation *)$p)->b);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoBoolOperation  getmf_operation (  )
  
  (let* ((retobj (new SoMFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBoolOperation *)$p)->operation);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoBoolOperation  geteo_output (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBoolOperation *)$p)->output);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoBoolOperation  geteo_inverse (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoBoolOperation *)$p)->inverse);  #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoCalculator : public SoEngine
(defclass SoCalculator SoEngine)

(defmethod SoCalculator  getFieldData (  )
  
  (gptr #{ ((SoCalculator *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoCalculator  getOutputData (  )
  
  (gptr #{ ((SoCalculator *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoCalculator  getmf_a (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->a);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_b (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->b);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_c (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->c);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_d (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->d);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_e (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->e);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_f (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->f);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_g (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->g);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_h (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->h);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_aa (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->A);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_bb (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->B);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_cc (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->C);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_dd (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->D);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_ee (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->E);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_ff (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->F);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_gg (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->G);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_hh (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->H);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  getmf_expression (  )
  
  (let* ((retobj (new SoMFString t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->expression);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_oa (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->oa);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_ob (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->ob);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_oc (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->oc);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_od (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->od);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_oaa (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->oA);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_obb (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->oB);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_occ (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->oC);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCalculator  geteo_odd (  )
  
  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCalculator *)$p)->oD);  #} 
    (setq :retobj:p retobjp)
    retobj))

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



;; class SoComposeVec2f : public SoEngine
(defclass SoComposeVec2f SoEngine)

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

(defmethod SoComposeVec2f  getmf_x (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec2f *)$p)->x);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec2f  getmf_y (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec2f *)$p)->y);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec2f  geteo_vector ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec2f *)$p)->vector); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoComposeVec3f : public SoEngine
(defclass SoComposeVec3f SoEngine)

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

(defmethod SoComposeVec3f  getmf_x (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec3f *)$p)->x);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec3f  getmf_y (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec3f *)$p)->y);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec3f  getmf_z (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec3f *)$p)->z);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec3f  geteo_vector ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec3f *)$p)->vector); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoComposeVec4f : public SoEngine
(defclass SoComposeVec4f SoEngine)

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

(defmethod SoComposeVec4f  getmf_x (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec4f *)$p)->x);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec4f  getmf_y (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec4f *)$p)->y);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec4f  getmf_z (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec4f *)$p)->z);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec4f  getmf_w (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec4f *)$p)->w);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeVec4f  geteo_vector ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeVec4f *)$p)->vector); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoDecomposeVec2f : public SoEngine
(defclass SoDecomposeVec2f SoEngine)

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

(defmethod SoDecomposeVec2f  getmf_vector (  )
  
  (let* ((retobj (new SoMFVec2f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec2f *)$p)->vector);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec2f  geteo_x ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec2f *)$p)->x); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec2f  geteo_y ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec2f *)$p)->y); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoDecomposeVec3f : public SoEngine
(defclass SoDecomposeVec3f SoEngine)

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

(defmethod SoDecomposeVec3f  getmf_vector (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec3f *)$p)->vector);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec3f  geteo_x ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec3f *)$p)->x); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec3f  geteo_y ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec3f *)$p)->y); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec3f  geteo_z ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec3f *)$p)->z); #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoDecomposeVec4f : public SoEngine
(defclass SoDecomposeVec4f SoEngine)

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

(defmethod SoDecomposeVec4f  getmf_vector (  )
  
  (let* ((retobj (new SoMFVec4f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec4f *)$p)->vector);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec4f  geteo_x ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec4f *)$p)->x); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec4f  geteo_y ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec4f *)$p)->y); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec4f  geteo_z ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec4f *)$p)->z); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeVec4f  geteo_w ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeVec4f *)$p)->w); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoComposeRotation : public SoEngine
(defclass SoComposeRotation SoEngine)

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

(defmethod SoComposeRotation  getmf_axis (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeRotation *)$p)->axis);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeRotation  getmf_angle (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeRotation *)$p)->angle);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeRotation  geteo_rotation ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeRotation *)$p)->rotation); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoComposeRotationFromTo : public SoEngine
(defclass SoComposeRotationFromTo SoEngine)

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

(defmethod SoComposeRotationFromTo  getmf_from (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeRotationFromTo *)$p)->from);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeRotationFromTo  getmf_to (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeRotationFromTo *)$p)->to);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeRotationFromTo  geteo_rotation ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeRotationFromTo *)$p)->rotation); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoDecomposeRotation : public SoEngine
(defclass SoDecomposeRotation SoEngine)

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

(defmethod SoDecomposeRotation  getmf_rotation (  )
  
  (let* ((retobj (new SoMFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeRotation *)$p)->rotation);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeRotation  geteo_axis ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeRotation *)$p)->axis); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeRotation  geteo_angle ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeRotation *)$p)->angle); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoComposeMatrix : public SoEngine
(defclass SoComposeMatrix SoEngine)

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

(defmethod SoComposeMatrix  getmf_translation (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeMatrix *)$p)->translation);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeMatrix  getmf_rotation (  )
  
  (let* ((retobj (new SoMFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeMatrix *)$p)->rotation);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeMatrix  getmf_scaleFactor (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeMatrix *)$p)->scaleFactor);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeMatrix  getmf_scaleOrientation (  )
  
  (let* ((retobj (new SoMFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeMatrix *)$p)->scaleOrientation);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeMatrix  getmf_center (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeMatrix *)$p)->center);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComposeMatrix  geteo_matrix ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComposeMatrix *)$p)->matrix); #} 
    (setq :retobj:p retobjp)
    retobj))


;; class SoDecomposeMatrix : public SoEngine
(defclass SoDecomposeMatrix SoEngine)

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

(defmethod SoDecomposeMatrix  getmf_matrix (  )
  
  (let* ((retobj (new SoMFMatrix t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeMatrix *)$p)->matrix);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeMatrix  getmf_center (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeMatrix *)$p)->center);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeMatrix  geteo_translation ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeMatrix *)$p)->translation); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeMatrix  geteo_rotation ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeMatrix *)$p)->rotation); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeMatrix  geteo_scaleFactor ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeMatrix *)$p)->scaleFactor); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoDecomposeMatrix  geteo_scaleOrientation ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoDecomposeMatrix *)$p)->scaleOrientation); #} 
    (setq :retobj:p retobjp)
    retobj))    



;; class SoComputeBoundingBox : public SoEngine
(defclass SoComputeBoundingBox SoEngine)

(defmethod SoComputeBoundingBox  getFieldData (  )
  
  (gptr #{ ((SoComputeBoundingBox *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoComputeBoundingBox  getOutputData (  )
  
  (gptr #{ ((SoComputeBoundingBox *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoComputeBoundingBox  getsf_node (  )
  
  (let* ((retobj (new SoSFNode t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComputeBoundingBox *)$p)->node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComputeBoundingBox  getsf_path (  )
  
  (let* ((retobj (new SoSFPath t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComputeBoundingBox *)$p)->path);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComputeBoundingBox  geteo_min ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComputeBoundingBox *)$p)->min); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComputeBoundingBox  geteo_max ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComputeBoundingBox *)$p)->max); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComputeBoundingBox  geteo_boxCenter ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComputeBoundingBox *)$p)->boxCenter); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoComputeBoundingBox  geteo_objectCenter ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoComputeBoundingBox *)$p)->objectCenter); #} 
    (setq :retobj:p retobjp)
    retobj))
(defmethod SoComputeBoundingBox  SoComputeBoundingBox ( flag  )
  ((-bool-) flag)
  
  #{  if($flag == false ) {
            $p = new  SoComputeBoundingBox;
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

(defmethod SoComputeBoundingBox  setViewportRegion ( vpReg)
  
  ((-gptr- "const SbViewportRegion *") vpReg)   ;; reference -> gptr
  #{ ((SoComputeBoundingBox *)$p)->setViewportRegion(*$vpReg);  #} 
  ())

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




;; class SoConcatenate : public SoEngine
(defclass SoConcatenate SoEngine)

(defmethod SoConcatenate  getFieldData (  )
  
  (gptr #{ ((SoConcatenate *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoConcatenate  getOutputData (  )
  
  (gptr #{ ((SoConcatenate *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoConcatenate  SoConcatenate ( flag mfInputType)
  ((-bool-) flag)
  
  ((-gptr- "SoType *") mfInputType)    ;; object -> gptr
  #{  if($flag == false ) {
            $p = new  SoConcatenate(*$mfInputType);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

(defmethod SoConcatenate  getval_input ( s )
  
  ((-int-) s)
  (gptr #{ ((SoConcatenate *)$p)->input[$s]  #} ))    ;; SoMField *  -> gptr

(defmethod SoConcatenate  getval_output ()

  (gptr #{ ((SoConcatenate *)$p)->output #} )) ;; SoEngineOutput * -> gptr


;; class SoCounter : public SoEngine
(defclass SoCounter SoEngine)

(defmethod SoCounter  getFieldData (  )
  
  (gptr #{ ((SoCounter *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoCounter  getOutputData (  )
  
  (gptr #{ ((SoCounter *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoCounter  getsf_min (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->min);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCounter  getsf_max (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->max);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCounter  getsf_step (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->step);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCounter  getsf_trigger (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->trigger);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCounter  getsf_reset (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->reset);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCounter  geteo_output ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->output); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoCounter  geteo_syncOut ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoCounter *)$p)->syncOut); #} 
    (setq :retobj:p retobjp)
    retobj))
(defmethod SoCounter  SoCounter ( flag  )
  ((-bool-) flag)
  
  #{  if($flag == false ) {
            $p = new  SoCounter;
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())


;; class SoElapsedTime : public SoEngine
(defclass SoElapsedTime SoEngine)

(defmethod SoElapsedTime  getFieldData (  )
  
  (gptr #{ ((SoElapsedTime *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoElapsedTime  getOutputData (  )
  
  (gptr #{ ((SoElapsedTime *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoElapsedTime  getsf_timeIn (  )
  
  (let* ((retobj (new SoSFTime t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoElapsedTime *)$p)->timeIn);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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

(defmethod SoElapsedTime  getsf_pause (  )
  
  (let* ((retobj (new SoSFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoElapsedTime *)$p)->pause);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoElapsedTime  getsf_reset (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoElapsedTime *)$p)->reset);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoElapsedTime  geteo_timeOut ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoElapsedTime *)$p)->timeOut); #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoGate : public SoEngine
(defclass SoGate SoEngine)

(defmethod SoGate  getFieldData (  )
  
  (gptr #{ ((SoGate *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoGate  getOutputData (  )
  
  (gptr #{ ((SoGate *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoGate  SoGate ( flag mfInputType)
  ((-bool-) flag)
  
  ((-gptr- "SoType *") mfInputType)    ;; object -> gptr
  #{  if($flag == false ) {
            $p = new  SoGate(*$mfInputType);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

(defmethod SoGate  getsf_enable (  )
  
  (let* ((retobj (new SoSFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoGate *)$p)->enable);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoGate  getsf_trigger (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoGate *)$p)->trigger);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoGate  getval_input (  )
  
  (gptr #{ ((SoGate *)$p)->input  #} ))

(defmethod SoGate  getval_output ()

  (gptr #{ ((SoGate *)$p)->output  #} ))





;; class SoInterpolate : public SoEngine
(defclass SoInterpolate SoEngine)

(defmethod SoInterpolate  getFieldData (  )
  
  (gptr #{ ((SoInterpolate *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoInterpolate  getOutputData (  )
  
  (gptr #{ ((SoInterpolate *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoInterpolate  getsf_alpha (  )
  
  (let* ((retobj (new SoSFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolate *)$p)->alpha);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInterpolate  geteo_output ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolate *)$p)->output); #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoOneShot : public SoEngine
(defclass SoOneShot SoEngine)

(defmethod SoOneShot  getFieldData (  )
  
  (gptr #{ ((SoOneShot *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoOneShot  getOutputData (  )
  
  (gptr #{ ((SoOneShot *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoOneShot  getsf_duration (  )
  
  (let* ((retobj (new SoSFTime t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->duration);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  getsf_trigger (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->trigger);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  getsf_flags (  )
  
  (let* ((retobj (new SoSFBitMask t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->flags);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  getsf_disable (  )
  
  (let* ((retobj (new SoSFBool t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->disable);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  getsf_timeIn (  )
  
  (let* ((retobj (new SoSFTime t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->timeIn);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  geteo_timeOut ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->timeOut); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  geteo_isActive ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->isActive); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOneShot  geteo_ramp ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOneShot *)$p)->ramp); #} 
    (setq :retobj:p retobjp)
    retobj))

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





;; class SoOnOff : public SoEngine
(defclass SoOnOff SoEngine)

(defmethod SoOnOff  getFieldData (  )
  
  (gptr #{ ((SoOnOff *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoOnOff  getOutputData (  )
  
  (gptr #{ ((SoOnOff *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

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

(defmethod SoOnOff  getsf_off (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOnOff *)$p)->off);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOnOff  getsf_toggle (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOnOff *)$p)->toggle);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOnOff  geteo_isOn ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOnOff *)$p)->isOn); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoOnOff  geteo_isOff ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoOnOff *)$p)->isOff); #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoSelectOne : public SoEngine
(defclass SoSelectOne SoEngine)

(defmethod SoSelectOne  getFieldData (  )
  
  (gptr #{ ((SoSelectOne *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoSelectOne  getOutputData (  )
  
  (gptr #{ ((SoSelectOne *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoSelectOne  SoSelectOne ( flag mfInputType)
  ((-bool-) flag)
  
  ((-gptr- "SoType *") mfInputType)    ;; object -> gptr
  #{  if($flag == false ) {
            $p = new  SoSelectOne(*$mfInputType);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

(defmethod SoSelectOne  getsf_index (  )
  
  (let* ((retobj (new SoSFInt32 t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSelectOne *)$p)->index);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSelectOne  getval_input (  )
  
  (gptr #{ ((SoSelectOne *)$p)->input  #} ))        ;; SoMField  * -> gptr

(defmethod SoSelectOne getval_output ()

  (gptr #{ ((SoSelectOne *)$p)->output  #} ))       ;; SoEngineOutput * -> gptr





;; class SoTimeCounter : public SoEngine
(defclass SoTimeCounter SoEngine)

(defmethod SoTimeCounter  getFieldData (  )
  
  (gptr #{ ((SoTimeCounter *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoTimeCounter  getOutputData (  )
  
  (gptr #{ ((SoTimeCounter *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoTimeCounter  getsf_min (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->min);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  getsf_max (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->max);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  getsf_step (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->step);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

(defmethod SoTimeCounter  getsf_frequency (  )
  
  (let* ((retobj (new SoSFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->frequency);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  getmf_duty (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->duty);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  getsf_timeIn (  )
  
  (let* ((retobj (new SoSFTime t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->timeIn);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  getsf_syncIn (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->syncIn);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  getsf_reset (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->reset);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  geteo_output ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->output); #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTimeCounter  geteo_syncOut ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTimeCounter *)$p)->syncOut); #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoTransformVec3f : public SoEngine
(defclass SoTransformVec3f SoEngine)

(defmethod SoTransformVec3f  getFieldData (  )
  
  (gptr #{ ((SoTransformVec3f *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoTransformVec3f  getOutputData (  )
  
  (gptr #{ ((SoTransformVec3f *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoTransformVec3f  getmf_vector (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTransformVec3f *)$p)->vector);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTransformVec3f  getmf_matrix (  )
  
  (let* ((retobj (new SoMFMatrix t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTransformVec3f *)$p)->matrix);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTransformVec3f  geteo_point ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTransformVec3f *)$p)->point); #} 
    (setq :retobj:p retobjp)
    retobj))


(defmethod SoTransformVec3f  geteo_direction ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTransformVec3f *)$p)->direction); #} 
    (setq :retobj:p retobjp)
    retobj))


(defmethod SoTransformVec3f  geteo_normalDirection ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTransformVec3f *)$p)->normalDirection); #} 
    (setq :retobj:p retobjp)
    retobj))

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



;; class SoTriggerAny : public SoEngine
(defclass SoTriggerAny SoEngine)

(defmethod SoTriggerAny  getFieldData (  )
  
  (gptr #{ ((SoTriggerAny *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoTriggerAny  getOutputData (  )
  
  (gptr #{ ((SoTriggerAny *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

(defmethod SoTriggerAny  getsf_input0 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input1 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input1);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input2 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input2);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input3 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input3);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input4 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input4);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input5 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input5);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input6 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input6);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input7 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input7);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input8 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input8);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  getsf_input9 (  )
  
  (let* ((retobj (new SoSFTrigger t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)->input9);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoTriggerAny  geteo_output ()

  (let* ((retobj (new SoEngineOutput t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoTriggerAny *)$p)-> output); #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoInterpolateFloat : public SoInterpolate
(defclass SoInterpolateFloat SoInterpolate)

(defmethod SoInterpolateFloat  getFieldData (  )
  
  (gptr #{ ((SoInterpolateFloat *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoInterpolateFloat  getOutputData (  )
  
  (gptr #{ ((SoInterpolateFloat *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

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

(defmethod SoInterpolateFloat  getmf_input0 (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateFloat *)$p)->input0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInterpolateFloat  getmf_input1 (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateFloat *)$p)->input1);  #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoInterpolateRotation : public SoInterpolate
(defclass SoInterpolateRotation SoInterpolate)

(defmethod SoInterpolateRotation  getFieldData (  )
  
  (gptr #{ ((SoInterpolateRotation *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoInterpolateRotation  getOutputData (  )
  
  (gptr #{ ((SoInterpolateRotation *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

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

(defmethod SoInterpolateRotation  getmf_input0 (  )
  
  (let* ((retobj (new SoMFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateRotation *)$p)->input0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInterpolateRotation  getmf_input1 (  )
  
  (let* ((retobj (new SoMFRotation t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateRotation *)$p)->input1);  #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoInterpolateVec2f : public SoInterpolate
(defclass SoInterpolateVec2f SoInterpolate)

(defmethod SoInterpolateVec2f  getFieldData (  )
  
  (gptr #{ ((SoInterpolateVec2f *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoInterpolateVec2f  getOutputData (  )
  
  (gptr #{ ((SoInterpolateVec2f *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

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

(defmethod SoInterpolateVec2f  getmf_input0 (  )
  
  (let* ((retobj (new SoMFVec2f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateVec2f *)$p)->input0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInterpolateVec2f  getmf_input1 (  )
  
  (let* ((retobj (new SoMFVec2f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateVec2f *)$p)->input1);  #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoInterpolateVec3f : public SoInterpolate
(defclass SoInterpolateVec3f SoInterpolate)

(defmethod SoInterpolateVec3f  getFieldData (  )
  
  (gptr #{ ((SoInterpolateVec3f *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoInterpolateVec3f  getOutputData (  )
  
  (gptr #{ ((SoInterpolateVec3f *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

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

(defmethod SoInterpolateVec3f  getmf_input0 (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateVec3f *)$p)->input0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInterpolateVec3f  getmf_input1 (  )
  
  (let* ((retobj (new SoMFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateVec3f *)$p)->input1);  #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoInterpolateVec4f : public SoInterpolate
(defclass SoInterpolateVec4f SoInterpolate)

(defmethod SoInterpolateVec4f  getFieldData (  )
  
  (gptr #{ ((SoInterpolateVec4f *)$p)->getFieldData()  #} ))    ;; const SoFieldData *  -> gptr

(defmethod SoInterpolateVec4f  getOutputData (  )
  
  (gptr #{ ((SoInterpolateVec4f *)$p)->getOutputData()  #} ))    ;; const SoEngineOutputData *  -> gptr

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

(defmethod SoInterpolateVec4f  getmf_input0 (  )
  
  (let* ((retobj (new SoMFVec4f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateVec4f *)$p)->input0);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInterpolateVec4f  getmf_input1 (  )
  
  (let* ((retobj (new SoMFVec4f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInterpolateVec4f *)$p)->input1);  #} 
    (setq :retobj:p retobjp)
    retobj))


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

(dhc-make-with-c++ () () 
  |dummy_engines|
  (soengine  copy  getoutputname  getoutput  getoutputs)
  (sobooloperation  sobooloperation  geteo-inverse  geteo-output  getmf-operation  getmf-b  getmf-a  getoutputdata  getfielddata)
  (socalculator  socalculator  geteo-odd  geteo-occ  geteo-obb  geteo-oaa  geteo-od  geteo-oc  geteo-ob  geteo-oa  getmf-expression  getmf-hh  getmf-gg  getmf-ff  getmf-ee  getmf-dd  getmf-cc  getmf-bb  getmf-aa  getmf-h  getmf-g  getmf-f  getmf-e  getmf-d  getmf-c  getmf-b  getmf-a  getoutputdata  getfielddata)
  (socomposevec2f  geteo-vector  getmf-y  getmf-x  socomposevec2f)
  (socomposevec3f  geteo-vector  getmf-z  getmf-y  getmf-x  socomposevec3f)
  (socomposevec4f  geteo-vector  getmf-w  getmf-z  getmf-y  getmf-x  socomposevec4f)
  (sodecomposevec2f  geteo-y  geteo-x  getmf-vector  sodecomposevec2f)
  (sodecomposevec3f  geteo-z  geteo-y  geteo-x  getmf-vector  sodecomposevec3f)
  (sodecomposevec4f  geteo-w  geteo-z  geteo-y  geteo-x  getmf-vector  sodecomposevec4f)
  (socomposerotation  geteo-rotation  getmf-angle  getmf-axis  socomposerotation)
  (socomposerotationfromto  geteo-rotation  getmf-to  getmf-from  socomposerotationfromto)
  (sodecomposerotation  geteo-angle  geteo-axis  getmf-rotation  sodecomposerotation)
  (socomposematrix  geteo-matrix  getmf-center  getmf-scaleorientation  getmf-scalefactor  getmf-rotation  getmf-translation  socomposematrix)
  (sodecomposematrix  geteo-scaleorientation  geteo-scalefactor  geteo-rotation  geteo-translation  getmf-center  getmf-matrix  sodecomposematrix)
  (socomputeboundingbox  getviewportregion  setviewportregion  socomputeboundingbox  geteo-objectcenter  geteo-boxcenter  geteo-max  geteo-min  getsf-path  getsf-node  getoutputdata  getfielddata)
  (soconcatenate  getval-output  getval-input  soconcatenate  getoutputdata  getfielddata)
  (socounter  socounter  geteo-syncout  geteo-output  getsf-reset  getsf-trigger  getsf-step  getsf-max  getsf-min  getoutputdata  getfielddata)
  (soelapsedtime  soelapsedtime  geteo-timeout  getsf-reset  getsf-pause  getsf-on  getsf-speed  getsf-timein  getoutputdata  getfielddata)
  (sogate  getval-output  getval-input  getsf-trigger  getsf-enable  sogate  getoutputdata  getfielddata)
  (sointerpolate  geteo-output  getsf-alpha  getoutputdata  getfielddata)
  (sooneshot  sooneshot  geteo-ramp  geteo-isactive  geteo-timeout  getsf-timein  getsf-disable  getsf-flags  getsf-trigger  getsf-duration  getoutputdata  getfielddata)
  (soonoff  soonoff  geteo-isoff  geteo-ison  getsf-toggle  getsf-off  getsf-on  getoutputdata  getfielddata)
  (soselectone  getval-output  getval-input  getsf-index  soselectone  getoutputdata  getfielddata)
  (sotimecounter  sotimecounter  geteo-syncout  geteo-output  getsf-reset  getsf-syncin  getsf-timein  getmf-duty  getsf-frequency  getsf-on  getsf-step  getsf-max  getsf-min  getoutputdata  getfielddata)
  (sotransformvec3f  sotransformvec3f  geteo-normaldirection  geteo-direction  geteo-point  getmf-matrix  getmf-vector  getoutputdata  getfielddata)
  (sotriggerany  sotriggerany  geteo-output  getsf-input9  getsf-input8  getsf-input7  getsf-input6  getsf-input5  getsf-input4  getsf-input3  getsf-input2  getsf-input1  getsf-input0  getoutputdata  getfielddata)
  (sointerpolatefloat  getmf-input1  getmf-input0  sointerpolatefloat  getoutputdata  getfielddata)
  (sointerpolaterotation  getmf-input1  getmf-input0  sointerpolaterotation  getoutputdata  getfielddata)
  (sointerpolatevec2f  getmf-input1  getmf-input0  sointerpolatevec2f  getoutputdata  getfielddata)
  (sointerpolatevec3f  getmf-input1  getmf-input0  sointerpolatevec3f  getoutputdata  getfielddata)
  (sointerpolatevec4f  getmf-input1  getmf-input0  sointerpolatevec4f  getoutputdata  getfielddata)
)
