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



#? *** projectors

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

#? * sbprojector
;;.TYPE CLASS
#? (==> <sbprojector> setviewvolume <vol>)
#? (==> <sbprojector> getviewvolume)
#? (==> <sbprojector> setworkingspace <space>)
#? (==> <sbprojector> getworkingspace)

#? * sblineprojector
;;.TYPE CLASS
#? (new sblineprojector <flag>>
#? (==> <sblineprojector> -destructor)
#? (==> <sblineprojector> copy)
#? (==> <sblineprojector> project <point>)
#? (==> <sblineprojector> setline <line>)
#? (==> <sblineprojector> getline)
#? (==> <sblineprojector> getvector-2 <mouseposition1> <mouseposition2>)
#? (==> <sblineprojector> getvector <mouseposition>)
#? (==> <sblineprojector> setstartposition-2f <mouseposition>)
#? (==> <sblineprojector> setstartposition <point>)

#? * sbplaneprojector
;;.TYPE CLASS
#? (new sbplaneprojector <flag> <orient>>
#? (==> <sbplaneprojector> -destructor)
#? (==> <sbplaneprojector> copy)
#? (==> <sbplaneprojector> project <point>)
#? (==> <sbplaneprojector> setplane <plane>)
#? (==> <sbplaneprojector> getplane)
#? (==> <sbplaneprojector> setorienttoeye <orienttoeye>)
#? (==> <sbplaneprojector> isorienttoeye)
#? (==> <sbplaneprojector> getvector-2 <mouseposition1> <mouseposition2>)
#? (==> <sbplaneprojector> getvector <mouseposition>)
#? (==> <sbplaneprojector> setstartposition-2f <mouseposition>)
#? (==> <sbplaneprojector> setstartposition <point>)

#? * sbcylinderprojector
;;.TYPE CLASS
#? (new sbcylinderprojector <flag>>
#? (==> <sbcylinderprojector> -destructor)
#? (==> <sbcylinderprojector> projectandgetrotation <point> <rot>)
#? (==> <sbcylinderprojector> setcylinder <cyl>)
#? (==> <sbcylinderprojector> getcylinder)
#? (==> <sbcylinderprojector> setorienttoeye <orienttoeye>)
#? (==> <sbcylinderprojector> isorienttoeye)
#? (==> <sbcylinderprojector> setfront <isfront>)
#? (==> <sbcylinderprojector> isfront)
#? (==> <sbcylinderprojector> ispointinfront <point>)
#? (==> <sbcylinderprojector> setworkingspace <space>)

#? * sbsphereprojector
;;.TYPE CLASS
#? (==> <sbsphereprojector> projectandgetrotation <point> <rot>)
#? (==> <sbsphereprojector> setsphere <sph>)
#? (==> <sbsphereprojector> getsphere)
#? (==> <sbsphereprojector> setorienttoeye <orienttoeye>)
#? (==> <sbsphereprojector> isorienttoeye)
#? (==> <sbsphereprojector> setfront <infront>)
#? (==> <sbsphereprojector> isfront)
#? (==> <sbsphereprojector> ispointinfront <point>)
#? (==> <sbsphereprojector> setworkingspace <space>)
#? (==> <sbsphereprojector> -destructor)

#? * sbspheresectionprojector
;;.TYPE CLASS
#? (new sbspheresectionprojector <flag> <edgetol> <orienttoeye>>
#? (==> <sbspheresectionprojector> -destructor)
#? (==> <sbspheresectionprojector> copy)
#? (==> <sbspheresectionprojector> project <point>)
#? (==> <sbspheresectionprojector> getrotation <point1> <point2>)
#? (==> <sbspheresectionprojector> settolerance <edgetol>)
#? (==> <sbspheresectionprojector> gettolerance)
#? (==> <sbspheresectionprojector> setradialfactor <rad>)
#? (==> <sbspheresectionprojector> getradialfactor)
#? (==> <sbspheresectionprojector> iswithintolerance <point>)

#? * sbspheresheetprojector
;;.TYPE CLASS
#? (new sbspheresheetprojector <flag> <orienttoeye>>
#? (==> <sbspheresheetprojector> -destructor)
#? (==> <sbspheresheetprojector> copy)
#? (==> <sbspheresheetprojector> project <point>)
#? (==> <sbspheresheetprojector> getrotation <point1> <point2>)

#? * sbcylindersectionprojector
;;.TYPE CLASS
#? (new sbcylindersectionprojector <flag> <edgetol> <orienttoeye>>
#? (==> <sbcylindersectionprojector> -destructor)
#? (==> <sbcylindersectionprojector> copy)
#? (==> <sbcylindersectionprojector> project <point>)
#? (==> <sbcylindersectionprojector> getrotation <point1> <point2>)
#? (==> <sbcylindersectionprojector> settolerance <edgetol>)
#? (==> <sbcylindersectionprojector> gettolerance)
#? (==> <sbcylindersectionprojector> iswithintolerance <point>)

#? * sbcylindersheetprojector
;;.TYPE CLASS
#? (new sbcylindersheetprojector <flag> <orienttoeye>>
#? (==> <sbcylindersheetprojector> -destructor)
#? (==> <sbcylindersheetprojector> copy)
#? (==> <sbcylindersheetprojector> project <point>)
#? (==> <sbcylindersheetprojector> getrotation <point1> <point2>)

#? * sbcylinderplaneprojector
;;.TYPE CLASS
#? (new sbcylinderplaneprojector <flag> <edgetol> <orienttoeye>>
#? (==> <sbcylinderplaneprojector> -destructor)
#? (==> <sbcylinderplaneprojector> copy)
#? (==> <sbcylinderplaneprojector> project <point>)
#? (==> <sbcylinderplaneprojector> getrotation <point1> <point2>)

#? * sbsphereplaneprojector
;;.TYPE CLASS
#? (new sbsphereplaneprojector <flag> <edgetol> <orienttoeye>>
#? (==> <sbsphereplaneprojector> -destructor)
#? (==> <sbsphereplaneprojector> copy)
#? (==> <sbsphereplaneprojector> project <point>)
#? (==> <sbsphereplaneprojector> getrotation <point1> <point2>)

#? * (|dummy_projectors|)

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



;;************************************************************
;;********** projectors
;;************************************************************
(libload "inventor/sotype")

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

(defmethod  SbProjector  setViewVolume (vol)
  
  ((-gptr- "const SbViewVolume *") vol)     ;; reference -> gptr
  #{ ((SbProjector *)$p)->setViewVolume(*$vol);  #} 
  ())

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

(defmethod  SbProjector  setWorkingSpace (space)
  
  ((-gptr- "const SbMatrix *") space)     ;; reference -> gptr
  #{ ((SbProjector *)$p)->setWorkingSpace(*$space);  #} 
  ())

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






;;class SbLineProjector : public SbProjector
(defclass SbLineProjector  SbProjector)

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

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

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

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

(defmethod  SbLineProjector  setLine (line)
  
  ((-gptr- "const SbLine *") line)     ;; reference -> gptr
  #{ ((SbLineProjector *)$p)->setLine(*$line);  #} 
  ())

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

(defmethod  SbLineProjector  getVector_2 (mousePosition1  mousePosition2)
  
  ((-gptr- "const SbVec2f *") mousePosition1)     ;; reference -> gptr
  ((-gptr- "const SbVec2f *") mousePosition2)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbLineProjector *)$p)->getVector(*$mousePosition1 ,*$mousePosition2);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod  SbLineProjector  getVector (mousePosition)
  
  ((-gptr- "const SbVec2f *") mousePosition)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbLineProjector *)$p)->getVector(*$mousePosition);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod  SbLineProjector  setStartPosition_2f (mousePosition)
  
  ((-gptr- "const SbVec2f *") mousePosition)     ;; reference -> gptr
  #{ ((SbLineProjector *)$p)->setStartPosition(*$mousePosition);  #} 
  ())

(defmethod  SbLineProjector  setStartPosition (point)
  
  ((-gptr- "const SbVec3f *") point)     ;; reference -> gptr
  #{ ((SbLineProjector *)$p)->setStartPosition(*$point);  #} 
  ())




;;class SbPlaneProjector : public SbProjector
(defclass SbPlaneProjector  SbProjector)

(defmethod  SbPlaneProjector  SbPlaneProjector  ( flag orient)
  ((-bool-) flag)
  ((-int-) orient)    ;; SbBool(int) -> int  
  #{ if($flag == false) {
            $p = new SbPlaneProjector($orient); 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbPlaneProjector  SbPlaneProjector ( flag  plane  orient)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbPlane *") plane)     ;; reference -> gptr
;;   ((-int-) orient)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbPlaneProjector(*$plane, $orientx;
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

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

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

(defmethod  SbPlaneProjector  setPlane (plane)
  
  ((-gptr- "const SbPlane *") plane)     ;; reference -> gptr
  #{ ((SbPlaneProjector *)$p)->setPlane(*$plane);  #} 
  ())

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

(defmethod  SbPlaneProjector  setOrientToEye (orientToEye)
  
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  #{ ((SbPlaneProjector *)$p)->setOrientToEye($orientToEye);  #} 
  ())

(defmethod  SbPlaneProjector  isOrientToEye ()
  
  (int #{ ((SbPlaneProjector *)$p)->isOrientToEye()  #} ))    ;; SbBool(int) -> int

(defmethod  SbPlaneProjector  getVector_2 (mousePosition1  mousePosition2)
  
  ((-gptr- "const SbVec2f *") mousePosition1)     ;; reference -> gptr
  ((-gptr- "const SbVec2f *") mousePosition2)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbPlaneProjector *)$p)->getVector(*$mousePosition1 ,*$mousePosition2);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod  SbPlaneProjector  getVector (mousePosition)
  
  ((-gptr- "const SbVec2f *") mousePosition)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbPlaneProjector *)$p)->getVector(*$mousePosition);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod  SbPlaneProjector  setStartPosition_2f (mousePosition)
  
  ((-gptr- "const SbVec2f *") mousePosition)     ;; reference -> gptr
  #{ ((SbPlaneProjector *)$p)->setStartPosition(*$mousePosition);  #} 
  ())

(defmethod  SbPlaneProjector  setStartPosition (point)
  
  ((-gptr- "const SbVec3f *") point)     ;; reference -> gptr
  #{ ((SbPlaneProjector *)$p)->setStartPosition(*$point);  #} 
  ())



;;class SbCylinderProjector : public SbProjector
(defclass SbCylinderProjector  SbProjector)

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

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

(defmethod  SbCylinderProjector  projectAndGetRotation (point  rot )
  
  ((-gptr- "const SbVec2f *") point)     ;; reference -> gptr
  ((-gptr- "SbRotation *") rot)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbCylinderProjector *)$p)->projectAndGetRotation(*$point ,*$rot);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod  SbCylinderProjector  setCylinder (cyl )
  
  ((-gptr- "const SbCylinder *") cyl)     ;; reference -> gptr
  #{ ((SbCylinderProjector *)$p)->setCylinder(*$cyl);  #} 
  ())

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

(defmethod  SbCylinderProjector  setOrientToEye (orientToEye )
  
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  #{ ((SbCylinderProjector *)$p)->setOrientToEye($orientToEye);  #} 
  ())

(defmethod  SbCylinderProjector  isOrientToEye ()
  
  (int #{ ((SbCylinderProjector *)$p)->isOrientToEye()  #} ))  ;; SbBool(int) -> int

(defmethod  SbCylinderProjector  setFront (isFront )
  
  ((-int-) isFront)    ;; SbBool(int) -> int
  #{ ((SbCylinderProjector *)$p)->setFront($isFront);  #} 
  ())

(defmethod  SbCylinderProjector  isFront ()
  
  (int #{ ((SbCylinderProjector *)$p)->isFront()  #} ))  ;; SbBool(int) -> int

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

(defmethod  SbCylinderProjector  setWorkingSpace (space)
  
  ((-gptr- "const SbMatrix *") space)     ;; reference -> gptr
  #{ ((SbCylinderProjector *)$p)->setWorkingSpace(*$space);  #} 
  ())







;;class SbSphereProjector : public SbProjector
(defclass SbSphereProjector  SbProjector)

(defmethod  SbSphereProjector  projectAndGetRotation (point  rot)
  
  ((-gptr- "const SbVec2f *") point)     ;; reference -> gptr
  ((-gptr- "SbRotation *") rot)     ;; reference -> gptr
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SbSphereProjector *)$p)->projectAndGetRotation(*$point ,*$rot);  #} 
    (setq :retobj:p retobjp)
    retobj))  

(defmethod  SbSphereProjector  setSphere (sph)
  
  ((-gptr- "const SbSphere *") sph)     ;; reference -> gptr
  #{ ((SbSphereProjector *)$p)->setSphere(*$sph);  #} 
  ())  

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

(defmethod  SbSphereProjector  setOrientToEye (orientToEye)
  
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  #{ ((SbSphereProjector *)$p)->setOrientToEye($orientToEye);  #} 
  ())

(defmethod  SbSphereProjector  isOrientToEye ()
  
  (int #{ ((SbSphereProjector *)$p)->isOrientToEye()  #} ))    ;; SbBool(int) -> int

(defmethod  SbSphereProjector  setFront (inFront)
  
  ((-int-) inFront)    ;; SbBool(int) -> int
  #{ ((SbSphereProjector *)$p)->setFront($inFront);  #} 
  ())

(defmethod  SbSphereProjector  isFront ()
  
  (int #{ ((SbSphereProjector *)$p)->isFront()  #} ))  ;; SbBool(int) -> int

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

(defmethod  SbSphereProjector  setWorkingSpace (space)
  
  ((-gptr- "const SbMatrix *") space)     ;; reference -> gptr
  #{ ((SbSphereProjector *)$p)->setWorkingSpace(*$space);  #} 
  ())  

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




;;class SbSphereSectionProjector : public SbSphereProjector
(defclass SbSphereSectionProjector  SbSphereProjector)

(defmethod  SbSphereSectionProjector  SbSphereSectionProjector  ( flag edgeTol  orientToEye)
  ((-bool-) flag)
  ((-float-) edgeTol)
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  
  #{ if($flag == false) {
            $p = new SbSphereSectionProjector($edgeTol ,$orientToEye); 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbSphereSectionProjector  SbSphereSectionProjector ( flag  sph  edgeTol  orientToEye)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbSphere *") sph)     ;; reference -> gptr
;;   ((-float-) edgeTol)
;;   ((-int-) orientToEye)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbSphereSectionProjector(*$sph, $edgeTol, $orientToEye);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())  

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

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

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

(defmethod  SbSphereSectionProjector  getRotation (point1  point2)
  
  ((-gptr- "const SbVec3f *") point1)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") point2)     ;; reference -> gptr
  (let*  ((retobj (new SbRotation ()))
	  (retobjp  :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbSphereSectionProjector *)$p)->getRotation(*$point1 ,*$point2);  #} 
    (setq :retobj:p retobjp)
    retobj))  

(defmethod  SbSphereSectionProjector  setTolerance (edgeTol)
  
  ((-float-) edgeTol)
  #{ ((SbSphereSectionProjector *)$p)->setTolerance($edgeTol);  #} 
  ())  

(defmethod  SbSphereSectionProjector  getTolerance ()
  
  (float #{ ((SbSphereSectionProjector *)$p)->getTolerance()  #} ))  

(defmethod  SbSphereSectionProjector  setRadialFactor (rad)
  
  ((-float-) rad)
  #{ ((SbSphereSectionProjector *)$p)->setRadialFactor($rad);  #} 
  ())

(defmethod  SbSphereSectionProjector  getRadialFactor ()
  
  (float #{ ((SbSphereSectionProjector *)$p)->getRadialFactor()  #} ))  

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




;;class SbSphereSheetProjector : public SbSphereProjector
(defclass SbSphereSheetProjector  SbSphereProjector)

(defmethod  SbSphereSheetProjector  SbSphereSheetProjector  ( flag orientToEye)
  ((-bool-) flag)
  ((-int-) orientToEye)    ;; SbBool(int) -> int  
  #{ if($flag == false) {
            $p = new SbSphereSheetProjector($orientToEye); 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())  


;; (defmethod  SbSphereSheetProjector  SbSphereSheetProjector ( flag  sph  orientToEye)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbSphere *") sph)     ;; reference -> gptr
;;   ((-int-) orientToEye)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbSphereSheetProjector(*$sph, $orientToEye);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())  

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

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

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

(defmethod  SbSphereSheetProjector  getRotation (point1  point2)
  
  ((-gptr- "const SbVec3f *") point1)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") point2)     ;; reference -> gptr
  (let*  ((retobj (new SbRotation ()))
	  (retobjp  :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbSphereSheetProjector *)$p)->getRotation(*$point1 ,*$point2);  #} 
    (setq :retobj:p retobjp)
    retobj))  





;;class SbCylinderSectionProjector : public SbCylinderProjector
(defclass SbCylinderSectionProjector  SbCylinderProjector)

(defmethod  SbCylinderSectionProjector  SbCylinderSectionProjector  ( flag  edgeTol  orientToEye)
  ((-bool-) flag)
  ((-float-) edgeTol)
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  #{  if($flag == false ) {
            $p = new SbCylinderSectionProjector($edgeTol ,$orientToEye);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())


;; (defmethod  SbCylinderSectionProjector  SbCylinderSectionProjector ( flag  cyl  edgeTol  orientToEye)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbCylinder *") cyl)     ;; reference -> gptr
;;   ((-float-) edgeTol)
;;   ((-int-) orientToEye)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbCylinderSectionProjector(*$cyl,$edgeTol,$orientToEye);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

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

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

(defmethod  SbCylinderSectionProjector  getRotation (point1  point2)
  
  ((-gptr- "const SbVec3f *") point1)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") point2)     ;; reference -> gptr
  (let*  ((retobj (new SbRotation ()))
	  (retobjp  :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbCylinderSectionProjector *)$p)->getRotation(*$point1 ,*$point2);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod  SbCylinderSectionProjector  setTolerance (edgeTol)
  
  ((-float-) edgeTol)
  #{ ((SbCylinderSectionProjector *)$p)->setTolerance($edgeTol);  #} 
  ())

(defmethod  SbCylinderSectionProjector  getTolerance ()
  
  (float #{ ((SbCylinderSectionProjector *)$p)->getTolerance()  #} ))

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




;;class SbCylinderSheetProjector : public SbCylinderProjector
(defclass SbCylinderSheetProjector  SbCylinderProjector)

(defmethod  SbCylinderSheetProjector  SbCylinderSheetProjector  ( flag orientToEye )
  ((-bool-) flag)
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  
  #{  if($flag == false ) {
            $p = new SbCylinderSheetProjector($orientToEye);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())


;; (defmethod  SbCylinderSheetProjector  SbCylinderSheetProjector ( flag  cyl  orientToEye)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const  SbCylinder *") cyl)     ;; reference -> gptr
;;   ((-int-) orientToEye)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbCylinderSheetProjector(*$cyl,$orientToEye);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

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

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

(defmethod  SbCylinderSheetProjector  getRotation (point1  point2)
  
  ((-gptr- "const SbVec3f *") point1)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") point2)     ;; reference -> gptr
  (let*  ((retobj (new SbRotation ()))
	  (retobjp  :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbCylinderSheetProjector *)$p)->getRotation(*$point1 ,*$point2);  #} 
    (setq :retobj:p retobjp)
    retobj))



;;class SbCylinderPlaneProjector : public SbCylinderSectionProjector
(defclass SbCylinderPlaneProjector  SbCylinderSectionProjector)

(defmethod  SbCylinderPlaneProjector  SbCylinderPlaneProjector  ( flag edgeTol  orientToEye )
  ((-bool-) flag)
  ((-float-) edgeTol)
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  
  #{ if($flag == false) {
            $p = new SbCylinderPlaneProjector($edgeTol ,$orientToEye); 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbCylinderPlaneProjector  SbCylinderPlaneProjector ( flag  cyl  edgeTol  orientToEye )
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbCylinder *") cyl)     ;; reference -> gptr
;;   ((-float-) edgeTol)
;;   ((-int-) orientToEye)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbCylinderPlaneProjector(*$cyl, $edgeTol, $orientToEye);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

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

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

(defmethod  SbCylinderPlaneProjector  getRotation (point1  point2 )
  
  ((-gptr- "const SbVec3f *") point1)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") point2)     ;; reference -> gptr
  (let*  ((retobj (new SbRotation ()))
	  (retobjp  :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbCylinderPlaneProjector *)$p)->getRotation(*$point1 ,*$point2);  #} 
    (setq :retobj:p retobjp)
    retobj))









;;class SbSpherePlaneProjector : public SbSphereSectionProjector
(defclass SbSpherePlaneProjector  SbSphereSectionProjector)

(defmethod  SbSpherePlaneProjector  SbSpherePlaneProjector  ( flag edgeTol  orientToEye)
  ((-bool-) flag)
  ((-float-) edgeTol)
  ((-int-) orientToEye)    ;; SbBool(int) -> int
  
  #{ if($flag == false) {
            $p = new SbSpherePlaneProjector($edgeTol ,$orientToEye); 
            $shell_flag = false;
     }
     else 
            $shell_flag = true;
  #} 
 ())

;; (defmethod  SbSpherePlaneProjector  SbSpherePlaneProjector ( flag  sph  edgeTol  orientToEye)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const  SbSphere *") sph)     ;; reference -> gptr
;;   ((-float-) edgeTol)
;;   ((-int-) orientToEye)    ;; SbBool(int) -> int
;;   #{  if($flag == false ) {
;;             $p = new  SbSpherePlaneProjector(*$sph, $edgeTol, $orientToEye);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

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

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

(defmethod  SbSpherePlaneProjector  getRotation (point1  point2)
  
  ((-gptr- "const SbVec3f *") point1)     ;; reference -> gptr
  ((-gptr- "const SbVec3f *") point2)     ;; reference -> gptr
  (let*  ((retobj (new SbRotation ()))
	  (retobjp  :retobj:p))
    #{ *((SbRotation *)$retobjp) = ((SbSpherePlaneProjector *)$p)->getRotation(*$point1 ,*$point2);  #} 
    (setq :retobj:p retobjp)
    retobj))







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

(dhc-make-with-c++ () () 
  |dummy_projectors|
  (sbprojector  getworkingspace  setworkingspace  getviewvolume  setviewvolume)
  (sblineprojector  setstartposition  setstartposition-2f  getvector  getvector-2  getline  setline  project  copy  -destructor  sblineprojector)
  (sbplaneprojector  setstartposition  setstartposition-2f  getvector  getvector-2  isorienttoeye  setorienttoeye  getplane  setplane  project  copy  -destructor  sbplaneprojector)
  (sbcylinderprojector  setworkingspace  ispointinfront  isfront  setfront  isorienttoeye  setorienttoeye  getcylinder  setcylinder  projectandgetrotation  -destructor  sbcylinderprojector)
  (sbsphereprojector  -destructor  setworkingspace  ispointinfront  isfront  setfront  isorienttoeye  setorienttoeye  getsphere  setsphere  projectandgetrotation)
  (sbspheresectionprojector  iswithintolerance  getradialfactor  setradialfactor  gettolerance  settolerance  getrotation  project  copy  -destructor  sbspheresectionprojector)
  (sbspheresheetprojector  getrotation  project  copy  -destructor  sbspheresheetprojector)
  (sbcylindersectionprojector  iswithintolerance  gettolerance  settolerance  getrotation  project  copy  -destructor  sbcylindersectionprojector)
  (sbcylindersheetprojector  getrotation  project  copy  -destructor  sbcylindersheetprojector)
  (sbcylinderplaneprojector  getrotation  project  copy  -destructor  sbcylinderplaneprojector)
  (sbsphereplaneprojector  getrotation  project  copy  -destructor  sbsphereplaneprojector)
)
