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

(libload "inventor/inventor-config")



#? *** nodes_others

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

#? * soinput
;;.TYPE CLASS
#? (new soinput <flag>>
#? (==> <soinput> -destructor)
#? (==> <soinput> setfilepointer <newfp>)
#? (==> <soinput> openfile <filename> <okifnotfound>)
#? (==> <soinput> pushfile <filename>)
#? (==> <soinput> closefile)
#? (==> <soinput> isvalidfile)
#? (==> <soinput> getcurfile)
#? (==> <soinput> getcurfilename)
#? (==> <soinput> setbuffer <bufpointer> <bufsize>)
#? (==> <soinput> getnumbytesread)
#? (==> <soinput> getheader)
#? (==> <soinput> getivversion)

#? * socolorpacker
;;.TYPE CLASS
#? (new socolorpacker <flag>>
#? (==> <socolorpacker> -destructor)
#? (==> <socolorpacker> getpackedcolors)
#? (==> <socolorpacker> diffusematch <nodeid>)
#? (==> <socolorpacker> transpmatch <nodeid>)
#? (==> <socolorpacker> setnodeids <diffnodeid> <tnodeid>)
#? (==> <socolorpacker> getsize)
#? (==> <socolorpacker> reallocate <size>)

#? * sooffscreenrenderer
;;.TYPE CLASS
#? (new sooffscreenrenderer <flag> <viewportregion>>
#? (==> <sooffscreenrenderer> -destructor)
#? (==> <sooffscreenrenderer> setcomponents <components>)
#? (==> <sooffscreenrenderer> getcomponents)
#? (==> <sooffscreenrenderer> setviewportregion <region>)
#? (==> <sooffscreenrenderer> getviewportregion)
#? (==> <sooffscreenrenderer> setbackgroundcolor <c>)
#? (==> <sooffscreenrenderer> getbackgroundcolor)
#? (==> <sooffscreenrenderer> setglrenderaction <ra>)
#? (==> <sooffscreenrenderer> getglrenderaction)
#? (==> <sooffscreenrenderer> render-node <scene>)
#? (==> <sooffscreenrenderer> render-path <scene>)
#? (==> <sooffscreenrenderer> getbuffer)
#? (==> <sooffscreenrenderer> writetorgb <fp>)
#? (==> <sooffscreenrenderer> writetopostscript <fp>)

#? * sooutput
;;.TYPE CLASS
#? (new sooutput <flag>>
#? (==> <sooutput> -destructor)
#? (==> <sooutput> setfilepointer <newfp>)
#? (==> <sooutput> getfilepointer)
#? (==> <sooutput> openfile <filename>)
#? (==> <sooutput> closefile)
#? (==> <sooutput> setbuffer <bufpointer> <initsize> <reallocfunc> <offset>)
#? (==> <sooutput> getbuffer <bufpointer> <nbytes>)
#? (==> <sooutput> getbuffersize)
#? (==> <sooutput> resetbuffer)
#? (==> <sooutput> setbinary <flag>)
#? (==> <sooutput> isbinary)
#? (==> <sooutput> setheaderstring <str>)
#? (==> <sooutput> resetheaderstring)
#? (==> <sooutput> setfloatprecision <precision>)

#? * sopickedpoint
;;.TYPE CLASS
#? (new sopickedpoint <flag> <pp>>
#? (==> <sopickedpoint> -destructor)
#? (==> <sopickedpoint> copy)
#? (==> <sopickedpoint> getpoint)
#? (==> <sopickedpoint> getnormal)
#? (==> <sopickedpoint> gettexturecoords)
#? (==> <sopickedpoint> getmaterialindex)
#? (==> <sopickedpoint> getpath)
#? (==> <sopickedpoint> isongeometry)
#? (==> <sopickedpoint> getdetail <node>)
#? (==> <sopickedpoint> getobjecttoworld <node>)
#? (==> <sopickedpoint> getworldtoobject <node>)
#? (==> <sopickedpoint> getobjecttoimage <node>)
#? (==> <sopickedpoint> getimagetoobject <node>)
#? (==> <sopickedpoint> getobjectpoint <node>)
#? (==> <sopickedpoint> getobjectnormal <node>)
#? (==> <sopickedpoint> getobjecttexturecoords <node>)

#? * soprimitivevertex
;;.TYPE CLASS
#? (new soprimitivevertex <flag>>
#? (==> <soprimitivevertex> -destructor)
#? (==> <soprimitivevertex> getpoint)
#? (==> <soprimitivevertex> getnormal)
#? (==> <soprimitivevertex> gettexturecoords)
#? (==> <soprimitivevertex> getmaterialindex)
#? (==> <soprimitivevertex> getdetail)

#? * soscenemanager
;;.TYPE CLASS
#? (new soscenemanager <flag>>
#? (==> <soscenemanager> -destructor)
#? (==> <soscenemanager> render <clearwindow> <clearzbuffer>)
#? (==> <soscenemanager> processevent <event>)
#? (==> <soscenemanager> reinitialize)
#? (==> <soscenemanager> scheduleredraw)
#? (==> <soscenemanager> setscenegraph <newscene>)
#? (==> <soscenemanager> getscenegraph)
#? (==> <soscenemanager> setwindowsize <newsize>)
#? (==> <soscenemanager> getwindowsize)
#? (==> <soscenemanager> setsize <newsize>)
#? (==> <soscenemanager> getsize)
#? (==> <soscenemanager> setorigin <neworigin>)
#? (==> <soscenemanager> getorigin)
#? (==> <soscenemanager> setviewportregion <newregion>)
#? (==> <soscenemanager> getviewportregion)
#? (==> <soscenemanager> setbackgroundcolor <c>)
#? (==> <soscenemanager> getbackgroundcolor)
#? (==> <soscenemanager> setbackgroundindex <index>)
#? (==> <soscenemanager> getbackgroundindex)
#? (==> <soscenemanager> setrgbmode <onoroff>)
#? (==> <soscenemanager> isrgbmode)
#? (==> <soscenemanager> activate)
#? (==> <soscenemanager> deactivate)
#? (==> <soscenemanager> setrendercallback <f> <userdata>)
#? (==> <soscenemanager> isautoredraw)
#? (==> <soscenemanager> setredrawpriority <priority>)
#? (==> <soscenemanager> getredrawpriority)
#? (==> <soscenemanager> setantialiasing <smoothing> <numpasses>)
#? (==> <soscenemanager> getantialiasing <smoothing> <numpasses>)

#? * (|dummy_nodes_others|)

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



(libload "inventor/sotype")

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

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

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

(defmethod SoInput  setFilePointer ( newFP)
  
  ((-gptr- "FILE *") newFP)
  #{ ((SoInput *)$p)->setFilePointer($newFP);  #} 
  ())

(defmethod SoInput  openFile ( fileName okIfNotFound)
  
  ((-str-) fileName)
  ((-int-) okIfNotFound)                    ;; SbBool -> int
  (int #{ ((SoInput *)$p)->openFile((const char *)$fileName->data,$okIfNotFound)  #} ))

(defmethod SoInput  pushFile ( fileName)
  
  ((-gptr- "const char *") fileName)
  (int #{ ((SoInput *)$p)->pushFile($fileName)  #} ))

(defmethod SoInput  closeFile (  )
  
  #{ ((SoInput *)$p)->closeFile();  #} 
  ())

(defmethod SoInput  isValidFile (  )
  
  (int #{ ((SoInput *)$p)->isValidFile()  #} ))

(defmethod SoInput  getCurFile (  )
  
  (gptr #{ ((SoInput *)$p)->getCurFile()  #} ))    ;; FILE *  -> gptr

(defmethod SoInput  getCurFileName (  )
  
  (gptr #{ ((SoInput *)$p)->getCurFileName()  #} ))    ;; const char *  -> gptr

(defmethod SoInput  setBuffer ( bufPointer bufSize)
  
  ((-gptr-) bufPointer)
  ((-int-) bufSize)     ;; size_t -> int
  #{ ((SoInput *)$p)->setBuffer($bufPointer,$bufSize);  #} 
  ())

(defmethod SoInput  getNumBytesRead (  )
  
  (int #{ ((SoInput *)$p)->getNumBytesRead()  #} ))  ;; size_t -> int

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

(defmethod SoInput  getIVVersion (  )
  
  (float #{ ((SoInput *)$p)->getIVVersion()  #} ))





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

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

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

(defmethod SoColorPacker  getPackedColors (  )
  
  (gptr #{ ((SoColorPacker *)$p)->getPackedColors()  #} ))    ;; uint32_t*  -> gptr

(defmethod SoColorPacker  diffuseMatch ( nodeId)
  
  ((-int-) nodeId)   ;; uint32_t -> int
  (int #{ ((SoColorPacker *)$p)->diffuseMatch($nodeId)  #} ))

(defmethod SoColorPacker  transpMatch ( nodeId)
  
  ((-int-) nodeId)    ;; uint32_t -> int
  (int #{ ((SoColorPacker *)$p)->transpMatch($nodeId)  #} ))

(defmethod SoColorPacker  setNodeIds ( diffNodeId tNodeId)
  
  ((-int-) diffNodeId)   ;; uint32_t -> int
  ((-int-) tNodeId)      ;; uint32_t -> int
  #{ ((SoColorPacker *)$p)->setNodeIds($diffNodeId,$tNodeId);  #} 
  ())

(defmethod SoColorPacker  getSize (  )
  
  (int #{ ((SoColorPacker *)$p)->getSize()  #} ))  ;; int32_t -> int

(defmethod SoColorPacker  reallocate ( size)
  
  ((-int-) size)   ;; int32_t -> int
  #{ ((SoColorPacker *)$p)->reallocate($size);  #} 
  ())






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

(defmethod SoOffscreenRenderer  SoOffscreenRenderer ( flag viewportRegion)
  ((-bool-) flag)
  
  ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
  #{  if($flag == false ) {
            $p = new  SoOffscreenRenderer(*$viewportRegion);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

;; (defmethod SoOffscreenRenderer  SoOffscreenRenderer ( flag ra)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "SoGLRenderAction *") ra)
;;   #{  if($flag == false ) {
;;             $p = new  SoOffscreenRenderer($ra);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

(defmethod SoOffscreenRenderer  setComponents ( components)
  
  ((-int-) components)  ;; Components
  #{ ((SoOffscreenRenderer *)$p)->setComponents((SoOffscreenRenderer::Components)$components);  #} 
  ())

(defmethod SoOffscreenRenderer  getComponents (  )
  
  (int #{ ((SoOffscreenRenderer *)$p)->getComponents()  #} )) ;; Components

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

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

(defmethod SoOffscreenRenderer  setBackgroundColor ( c)
  
  ((-gptr- "const SbColor *") c)   ;; reference -> gptr
  #{ ((SoOffscreenRenderer *)$p)->setBackgroundColor(*$c);  #} 
  ())

(defmethod SoOffscreenRenderer  getBackgroundColor (  )
  
  (gptr #{ &(((SoOffscreenRenderer *)$p)->getBackgroundColor())  #} ))  ;; const SbColor & -> gptr

(defmethod SoOffscreenRenderer  setGLRenderAction ( ra)
  
  ((-gptr- "SoGLRenderAction *") ra)
  #{ ((SoOffscreenRenderer *)$p)->setGLRenderAction($ra);  #} 
  ())

(defmethod SoOffscreenRenderer  getGLRenderAction (  )
  
  (gptr #{ ((SoOffscreenRenderer *)$p)->getGLRenderAction()  #} ))    ;; SoGLRenderAction *  -> gptr

(defmethod SoOffscreenRenderer  render_node ( scene)
  
  ((-gptr- "SoNode *") scene)
  (int #{ ((SoOffscreenRenderer *)$p)->render($scene)  #} ))

(defmethod SoOffscreenRenderer  render_path ( scene)
  
  ((-gptr- "SoPath *") scene)
  (int #{ ((SoOffscreenRenderer *)$p)->render($scene)  #} ))

(defmethod SoOffscreenRenderer  getBuffer (  )
  
  (gptr #{ ((SoOffscreenRenderer *)$p)->getBuffer()  #} ))    ;; unsigned char *  -> gptr

(defmethod SoOffscreenRenderer  writeToRGB ( fp)
  
  ((-gptr- "FILE *") fp)
  (int #{ ((SoOffscreenRenderer *)$p)->writeToRGB($fp)  #} ))

(defmethod SoOffscreenRenderer  writeToPostScript ( fp)
  
  ((-gptr- "FILE *") fp)
  (int #{ ((SoOffscreenRenderer *)$p)->writeToPostScript($fp)  #} ))

;; (defmethod SoOffscreenRenderer  writeToPostScript ( fp printSize)
;;   
;;   ((-gptr- "FILE *") fp)
;;   ((-gptr- "const SbVec2f *") printSize)   ;; reference -> gptr
;;   (int #{ ((SoOffscreenRenderer *)$p)->writeToPostScript(*$fp,$printSize)  #} ))



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

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

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

(defmethod SoOutput  setFilePointer ( newFP)
  
  ((-gptr- "FILE *") newFP)
  #{ ((SoOutput *)$p)->setFilePointer($newFP);  #} 
  ())

(defmethod SoOutput  getFilePointer (  )
  
  (gptr #{ ((SoOutput *)$p)->getFilePointer()  #} ))    ;; FILE *  -> gptr

(defmethod SoOutput  openFile ( fileName)
  
  ((-gptr- "const char *") fileName)
  (int #{ ((SoOutput *)$p)->openFile($fileName)  #} ))

(defmethod SoOutput  closeFile (  )
  
  #{ ((SoOutput *)$p)->closeFile();  #} 
  ())

(defmethod SoOutput  setBuffer ( bufPointer initSize reallocFunc offset)
  
  ((-gptr-) bufPointer)
  ((-int-) initSize)   ;; size_t -> int
  ((-gptr- "SoOutputReallocCB *") reallocFunc)
  ((-int-) offset)    ;; int32_t -> int
  #{ ((SoOutput *)$p)->setBuffer($bufPointer,$initSize,$reallocFunc,$offset);  #} 
  ())

(defmethod SoOutput  getBuffer ( bufPointer nBytes)
  
  ((-gptr- "void * *") bufPointer)   ;; reference -> gptr
  ((-gptr- "size_t *") nBytes)   ;; reference -> gptr
  (int #{ ((SoOutput *)$p)->getBuffer(*$bufPointer, *$nBytes)  #} ))

(defmethod SoOutput  getBufferSize (  )
  
  (int #{ ((SoOutput *)$p)->getBufferSize()  #} ))  ;; size_t -> int

(defmethod SoOutput  resetBuffer (  )
  
  #{ ((SoOutput *)$p)->resetBuffer();  #} 
  ())

(defmethod SoOutput  setBinary ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoOutput *)$p)->setBinary($flag);  #} 
  ())

(defmethod SoOutput  isBinary (  )
  
  (int #{ ((SoOutput *)$p)->isBinary()  #} ))

(defmethod SoOutput  setHeaderString ( str)
  
  ((-gptr- "const SbString *") str)   ;; reference -> gptr
  #{ ((SoOutput *)$p)->setHeaderString(*$str);  #} 
  ())

(defmethod SoOutput  resetHeaderString (  )
  
  #{ ((SoOutput *)$p)->resetHeaderString();  #} 
  ())

(defmethod SoOutput  setFloatPrecision ( precision)
  
  ((-int-) precision)
  #{ ((SoOutput *)$p)->setFloatPrecision($precision);  #} 
  ())




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

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

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

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

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

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

(defmethod SoPickedPoint  getTextureCoords (  )
  
  (gptr #{ &(((SoPickedPoint *)$p)->getTextureCoords())  #} ))  ;; const SbVec4f & -> gptr

(defmethod SoPickedPoint  getMaterialIndex (  )
  
  (int #{ ((SoPickedPoint *)$p)->getMaterialIndex()  #} ))

(defmethod SoPickedPoint  getPath (  )
  
  (gptr #{ ((SoPickedPoint *)$p)->getPath()  #} ))    ;; SoPath *  -> gptr

(defmethod SoPickedPoint  isOnGeometry (  )
  
  (int #{ ((SoPickedPoint *)$p)->isOnGeometry()  #} ))

(defmethod SoPickedPoint  getDetail ( node)
  
  ((-gptr- "const SoNode *") node)
  (gptr #{ ((SoPickedPoint *)$p)->getDetail($node)  #} ))    ;; const SoDetail *  -> gptr

(defmethod SoPickedPoint  getObjectToWorld ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbMatrix ()))
	  (retobjp  :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SoPickedPoint *)$p)->getObjectToWorld($node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPickedPoint  getWorldToObject ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbMatrix ()))
	  (retobjp  :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SoPickedPoint *)$p)->getWorldToObject($node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPickedPoint  getObjectToImage ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbMatrix ()))
	  (retobjp  :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SoPickedPoint *)$p)->getObjectToImage($node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPickedPoint  getImageToObject ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbMatrix ()))
	  (retobjp  :retobj:p))
    #{ *((SbMatrix *)$retobjp) = ((SoPickedPoint *)$p)->getImageToObject($node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPickedPoint  getObjectPoint ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SoPickedPoint *)$p)->getObjectPoint($node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPickedPoint  getObjectNormal ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbVec3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec3f *)$retobjp) = ((SoPickedPoint *)$p)->getObjectNormal($node);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoPickedPoint  getObjectTextureCoords ( node)
  
  ((-gptr- "const SoNode *") node)
  (let*  ((retobj (new SbVec4f ()))
	  (retobjp  :retobj:p))
    #{ *((SbVec4f *)$retobjp) = ((SoPickedPoint *)$p)->getObjectTextureCoords($node);  #} 
    (setq :retobj:p retobjp)
    retobj))





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

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

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

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

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

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

(defmethod SoPrimitiveVertex  getTextureCoords (  )
  
  (gptr #{ &(((SoPrimitiveVertex *)$p)->getTextureCoords())  #} ))  ;; const SbVec4f & -> gptr

(defmethod SoPrimitiveVertex  getMaterialIndex (  )
  
  (int #{ ((SoPrimitiveVertex *)$p)->getMaterialIndex()  #} ))

(defmethod SoPrimitiveVertex  getDetail (  )
  
  (gptr #{ ((SoPrimitiveVertex *)$p)->getDetail()  #} ))    ;; const SoDetail *  -> gptr







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

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

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

(defmethod SoSceneManager  render ( clearWindow clearZbuffer)
  
  ((-int-) clearWindow)                    ;; SbBool -> int
  ((-int-) clearZbuffer)                    ;; SbBool -> int
  #{ ((SoSceneManager *)$p)->render($clearWindow,$clearZbuffer);  #} 
  ())

(defmethod SoSceneManager  processEvent ( event)
  
  ((-gptr- "const SoEvent *") event)
  (int #{ ((SoSceneManager *)$p)->processEvent($event)  #} ))

(defmethod SoSceneManager  reinitialize (  )
  
  #{ ((SoSceneManager *)$p)->reinitialize();  #} 
  ())

(defmethod SoSceneManager  scheduleRedraw (  )
  
  #{ ((SoSceneManager *)$p)->scheduleRedraw();  #} 
  ())

(defmethod SoSceneManager  setSceneGraph ( newScene)
  
  ((-gptr- "SoNode *") newScene)
  #{ ((SoSceneManager *)$p)->setSceneGraph($newScene);  #} 
  ())

(defmethod SoSceneManager  getSceneGraph (  )
  
  (gptr #{ ((SoSceneManager *)$p)->getSceneGraph()  #} ))    ;; SoNode *  -> gptr

(defmethod SoSceneManager  setWindowSize ( newSize)
  
  ((-gptr- "const SbVec2s *") newSize)   ;; reference -> gptr
  #{ ((SoSceneManager *)$p)->setWindowSize(*$newSize);  #} 
  ())

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

(defmethod SoSceneManager  setSize ( newSize)
  
  ((-gptr- "const SbVec2s *") newSize)   ;; reference -> gptr
  #{ ((SoSceneManager *)$p)->setSize(*$newSize);  #} 
  ())

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

(defmethod SoSceneManager  setOrigin ( newOrigin)
  
  ((-gptr- "const SbVec2s *") newOrigin)   ;; reference -> gptr
  #{ ((SoSceneManager *)$p)->setOrigin(*$newOrigin);  #} 
  ())

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

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

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

(defmethod SoSceneManager  setBackgroundColor ( c)
  
  ((-gptr- "const SbColor *") c)   ;; reference -> gptr
  #{ ((SoSceneManager *)$p)->setBackgroundColor(*$c);  #} 
  ())

(defmethod SoSceneManager  getBackgroundColor (  )
  
  (gptr #{ &(((SoSceneManager *)$p)->getBackgroundColor())  #} ))  ;; const SbColor & -> gptr

(defmethod SoSceneManager  setBackgroundIndex ( index)
  
  ((-int-) index)
  #{ ((SoSceneManager *)$p)->setBackgroundIndex($index);  #} 
  ())

(defmethod SoSceneManager  getBackgroundIndex (  )
  
  (int #{ ((SoSceneManager *)$p)->getBackgroundIndex()  #} ))

(defmethod SoSceneManager  setRGBMode ( onOrOff)
  
  ((-int-) onOrOff)                    ;; SbBool -> int
  #{ ((SoSceneManager *)$p)->setRGBMode($onOrOff);  #} 
  ())

(defmethod SoSceneManager  isRGBMode (  )
  
  (int #{ ((SoSceneManager *)$p)->isRGBMode()  #} ))

(defmethod SoSceneManager  activate (  )
  
  #{ ((SoSceneManager *)$p)->activate();  #} 
  ())

(defmethod SoSceneManager  deactivate (  )
  
  #{ ((SoSceneManager *)$p)->deactivate();  #} 
  ())

(defmethod SoSceneManager  setRenderCallback ( f  userData)
  
  ((-gptr-) f) 
  ((-gptr-) userData)
  #{ ((SoSceneManager *)$p)->setRenderCallback((SoSceneManagerRenderCB *)$f,$userData);  #} 
  ())


(defmethod SoSceneManager  isAutoRedraw (  )
  
  (int #{ ((SoSceneManager *)$p)->isAutoRedraw()  #} ))

(defmethod SoSceneManager  setRedrawPriority ( priority)
  
  ((-int-) priority)   ;; uint32_t -> int
  #{ ((SoSceneManager *)$p)->setRedrawPriority($priority);  #} 
  ())

(defmethod SoSceneManager  getRedrawPriority (  )
  
  (int #{ ((SoSceneManager *)$p)->getRedrawPriority()  #} ))  ;; uint32_t -> int

(defmethod SoSceneManager  setAntialiasing ( smoothing numPasses)
  
  ((-int-) smoothing)                    ;; SbBool -> int
  ((-int-) numPasses)
  #{ ((SoSceneManager *)$p)->setAntialiasing($smoothing,$numPasses);  #} 
  ())

(defmethod SoSceneManager  getAntialiasing ( smoothing numPasses)
  
  ((-gptr- "SbBool *") smoothing)   ;; reference -> gptr
  ((-gptr- "int *") numPasses)   ;; reference -> gptr
  #{ ((SoSceneManager *)$p)->getAntialiasing(*$smoothing, *$numPasses);  #} 
  ())


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

(dhc-make-with-c++ () () 
  |dummy_nodes_others|
  (soinput  getivversion  getheader  getnumbytesread  setbuffer  getcurfilename  getcurfile  isvalidfile  closefile  pushfile  openfile  setfilepointer  -destructor  soinput)
  (socolorpacker  reallocate  getsize  setnodeids  transpmatch  diffusematch  getpackedcolors  -destructor  socolorpacker)
  (sooffscreenrenderer  writetopostscript  writetorgb  getbuffer  render-path  render-node  getglrenderaction  setglrenderaction  getbackgroundcolor  setbackgroundcolor  getviewportregion  setviewportregion  getcomponents  setcomponents  -destructor  sooffscreenrenderer)
  (sooutput  setfloatprecision  resetheaderstring  setheaderstring  isbinary  setbinary  resetbuffer  getbuffersize  getbuffer  setbuffer  closefile  openfile  getfilepointer  setfilepointer  -destructor  sooutput)
  (sopickedpoint  getobjecttexturecoords  getobjectnormal  getobjectpoint  getimagetoobject  getobjecttoimage  getworldtoobject  getobjecttoworld  getdetail  isongeometry  getpath  getmaterialindex  gettexturecoords  getnormal  getpoint  copy  -destructor  sopickedpoint)
  (soprimitivevertex  getdetail  getmaterialindex  gettexturecoords  getnormal  getpoint  -destructor  soprimitivevertex)
  (soscenemanager  getantialiasing  setantialiasing  getredrawpriority  setredrawpriority  isautoredraw  setrendercallback  deactivate  activate  isrgbmode  setrgbmode  getbackgroundindex  setbackgroundindex  getbackgroundcolor  setbackgroundcolor  getviewportregion  setviewportregion  getorigin  setorigin  getsize  setsize  getwindowsize  setwindowsize  getscenegraph  setscenegraph  scheduleredraw  reinitialize  processevent  render  -destructor  soscenemanager)
)
