(cl:defclass sgbucket()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgbucket) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGBucket)))

(cl:defmethod initialize-instance :after ((obj sgbucket) &key (dlon cl:number) (dlat cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SGBucket dlon dlat)))

(cl:defmethod initialize-instance :after ((obj sgbucket) &key geod)
  (setf (slot-value obj 'ff-pointer) (new_SGBucket geod)))

(cl:defmethod initialize-instance :after ((obj sgbucket) &key (is_good t))
  (setf (slot-value obj 'ff-pointer) (new_SGBucket is_good)))

(cl:defmethod initialize-instance :after ((obj sgbucket) &key (bindex cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGBucket bindex)))

(cl:defmethod set-bucket ((self sgbucket) (dlon cl:number) (dlat cl:number))
  (SGBucket_set_bucket (ff-pointer self) dlon dlat))

(cl:defmethod set-bucket ((self sgbucket) lonlat)
  (SGBucket_set_bucket (ff-pointer self) lonlat))

(cl:defmethod set-bucket ((self sgbucket) geod)
  (SGBucket_set_bucket (ff-pointer self) geod))

(cl:defmethod make-bad ((self sgbucket))
  (SGBucket_make_bad (ff-pointer self)))

(cl:defmethod gen-index ((self sgbucket))
  (SGBucket_gen_index (ff-pointer self)))

(cl:defmethod gen-index-str ((self sgbucket))
  (SGBucket_gen_index_str (ff-pointer self)))

(cl:defmethod gen-base-path ((self sgbucket))
  (SGBucket_gen_base_path (ff-pointer self)))

(cl:defmethod get-center-lon ((self sgbucket))
  (SGBucket_get_center_lon (ff-pointer self)))

(cl:defmethod get-center-lat ((self sgbucket))
  (SGBucket_get_center_lat (ff-pointer self)))

(cl:defmethod get-width ((self sgbucket))
  (SGBucket_get_width (ff-pointer self)))

(cl:defmethod get-height ((self sgbucket))
  (SGBucket_get_height (ff-pointer self)))

(cl:defmethod get-width-m ((self sgbucket))
  (SGBucket_get_width_m (ff-pointer self)))

(cl:defmethod get-height-m ((self sgbucket))
  (SGBucket_get_height_m (ff-pointer self)))

(cl:defmethod get-center ((self sgbucket))
  (SGBucket_get_center (ff-pointer self)))

(cl:defmethod get-corner ((self sgbucket) (num cl:integer))
  (SGBucket_get_corner (ff-pointer self) num))

(cl:defmethod get-chunk-lon ((self sgbucket))
  (SGBucket_get_chunk_lon (ff-pointer self)))

(cl:defmethod get-chunk-lat ((self sgbucket))
  (SGBucket_get_chunk_lat (ff-pointer self)))

(cl:defmethod get-x ((self sgbucket))
  (SGBucket_get_x (ff-pointer self)))

(cl:defmethod get-y ((self sgbucket))
  (SGBucket_get_y (ff-pointer self)))


(cl:defclass logbuf()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj logbuf) &key)
  (setf (slot-value obj 'ff-pointer) (new_logbuf)))

(cl:defmethod enabled ((self logbuf))
  (logbuf_enabled (ff-pointer self)))

(cl:defmethod set-log-state ((self logbuf) c p)
  (logbuf_set_log_state (ff-pointer self) c p))

(cl:defmethod would-log ((self logbuf) c p)
  (logbuf_would_log (ff-pointer self) c p))

(cl:defmethod set-sb ((self logbuf) sb)
  (logbuf_set_sb (ff-pointer self) sb))


(cl:defclass logstream()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj logstream) &key out)
  (setf (slot-value obj 'ff-pointer) (new_logstream out)))

(cl:defmethod set-output ((self logstream) out)
  (logstream_set_output (ff-pointer self) out))

(cl:defmethod set-log-levels ((self logstream) c p)
  (logstream_setLogLevels (ff-pointer self) c p))

(cl:defmethod would-log ((self logstream) c p)
  (logstream_would_log (ff-pointer self) c p))

(cl:shadow "<<")
(cl:defmethod << ((self logstream) l)
  (logstream___lshift__ (ff-pointer self) l))


(cl:defclass sgprecipitation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgprecipitation) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGPrecipitation)))

(cl:defmethod build ((self sgprecipitation))
  (SGPrecipitation_build (ff-pointer self)))

(cl:defmethod update ((self sgprecipitation))
  (SGPrecipitation_update (ff-pointer self)))

(cl:defmethod set-wind-property ((self sgprecipitation) (arg1 cl:number) (arg2 cl:number))
  (SGPrecipitation_setWindProperty (ff-pointer self) arg1 arg2))

(cl:defmethod set-freezing ((self sgprecipitation) (arg1 t))
  (SGPrecipitation_setFreezing (ff-pointer self) arg1))

(cl:defmethod set-rain-intensity ((self sgprecipitation) (arg1 cl:number))
  (SGPrecipitation_setRainIntensity (ff-pointer self) arg1))

(cl:defmethod set-snow-intensity ((self sgprecipitation) (arg1 cl:number))
  (SGPrecipitation_setSnowIntensity (ff-pointer self) arg1))


(cl:defclass sgwx-radar-echo()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgwx-radar-echo) &key (_heading cl:number) (_alt cl:number) (_radius cl:number) (_dist cl:number) (_LWC cl:number) (_lightning t) (_cloudId cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGWxRadarEcho _heading _alt _radius _dist _LWC _lightning _cloudId)))

(cl:defmethod (cl:setf heading) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_heading_set (ff-pointer obj) arg0))

(cl:defmethod heading ((obj sgwx-radar-echo))
  (SGWxRadarEcho_heading_get (ff-pointer obj)))

(cl:defmethod (cl:setf alt) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_alt_set (ff-pointer obj) arg0))

(cl:defmethod alt ((obj sgwx-radar-echo))
  (SGWxRadarEcho_alt_get (ff-pointer obj)))

(cl:defmethod (cl:setf radius) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_radius_set (ff-pointer obj) arg0))

(cl:defmethod radius ((obj sgwx-radar-echo))
  (SGWxRadarEcho_radius_get (ff-pointer obj)))

(cl:defmethod (cl:setf dist) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_dist_set (ff-pointer obj) arg0))

(cl:defmethod dist ((obj sgwx-radar-echo))
  (SGWxRadarEcho_dist_get (ff-pointer obj)))

(cl:defmethod (cl:setf LWC) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_LWC_set (ff-pointer obj) arg0))

(cl:defmethod LWC ((obj sgwx-radar-echo))
  (SGWxRadarEcho_LWC_get (ff-pointer obj)))

(cl:defmethod (cl:setf lightning) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_lightning_set (ff-pointer obj) arg0))

(cl:defmethod lightning ((obj sgwx-radar-echo))
  (SGWxRadarEcho_lightning_get (ff-pointer obj)))

(cl:defmethod (cl:setf cloudId) (arg0 (obj sgwx-radar-echo))
  (SGWxRadarEcho_cloudId_set (ff-pointer obj) arg0))

(cl:defmethod cloudId ((obj sgwx-radar-echo))
  (SGWxRadarEcho_cloudId_get (ff-pointer obj)))


(cl:defclass sgenviro()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgenviro) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGEnviro)))

(cl:defmethod config ((self sgenviro) precip_rendering_cfgNode)
  (SGEnviro_config (ff-pointer self) precip_rendering_cfgNode))

(cl:defmethod start-of-frame ((self sgenviro) p up (lon cl:number) (lat cl:number) (alt cl:number) (delta_time cl:number))
  (SGEnviro_startOfFrame (ff-pointer self) p up lon lat alt delta_time))

(cl:defmethod end-of-frame ((self sgenviro))
  (SGEnviro_endOfFrame (ff-pointer self)))

(cl:defmethod draw-rain ((self sgenviro) (pitch cl:number) (roll cl:number) (heading cl:number) (hspeed cl:number) (rain_norm cl:number))
  (SGEnviro_drawRain (ff-pointer self) pitch roll heading hspeed rain_norm))

(cl:defmethod draw-precipitation ((self sgenviro) (rain_norm cl:number) (snow_norm cl:number) (hail_norm cl:number) (pitch cl:number) (roll cl:number) (heading cl:number) (hspeed cl:number))
  (SGEnviro_drawPrecipitation (ff-pointer self) rain_norm snow_norm hail_norm pitch roll heading hspeed))

(cl:defmethod draw-lightning ((self sgenviro))
  (SGEnviro_drawLightning (ff-pointer self)))

(cl:defmethod set-light ((self sgenviro) adj_fog_color)
  (SGEnviro_setLight (ff-pointer self) adj_fog_color))

(cl:defmethod is-view-in-cloud ((self sgenviro))
  (SGEnviro_is_view_in_cloud (ff-pointer self)))

(cl:defmethod set-view-in-cloud ((self sgenviro) (incloud t))
  (SGEnviro_set_view_in_cloud (ff-pointer self) incloud))

(cl:defmethod get-cloud-turbulence ((self sgenviro))
  (SGEnviro_get_cloud_turbulence (ff-pointer self)))

(cl:defmethod get-clouds-cache-size ((self sgenviro))
  (SGEnviro_get_clouds_CacheSize (ff-pointer self)))

(cl:defmethod get-cache-resolution ((self sgenviro))
  (SGEnviro_get_CacheResolution (ff-pointer self)))

(cl:defmethod get-clouds-visibility ((self sgenviro))
  (SGEnviro_get_clouds_visibility (ff-pointer self)))

(cl:defmethod get-clouds-density ((self sgenviro))
  (SGEnviro_get_clouds_density (ff-pointer self)))

(cl:defmethod get-clouds-enable-state ((self sgenviro))
  (SGEnviro_get_clouds_enable_state (ff-pointer self)))

(cl:defmethod get-turbulence-enable-state ((self sgenviro))
  (SGEnviro_get_turbulence_enable_state (ff-pointer self)))

(cl:defmethod set-clouds-cache-size ((self sgenviro) (sizeKb cl:integer))
  (SGEnviro_set_clouds_CacheSize (ff-pointer self) sizeKb))

(cl:defmethod set-cache-resolution ((self sgenviro) (resolutionPixels cl:integer))
  (SGEnviro_set_CacheResolution (ff-pointer self) resolutionPixels))

(cl:defmethod set-clouds-visibility ((self sgenviro) (distance cl:number))
  (SGEnviro_set_clouds_visibility (ff-pointer self) distance))

(cl:defmethod set-clouds-density ((self sgenviro) (density cl:number))
  (SGEnviro_set_clouds_density (ff-pointer self) density))

(cl:defmethod set-clouds-enable-state ((self sgenviro) (enable t))
  (SGEnviro_set_clouds_enable_state (ff-pointer self) enable))

(cl:defmethod set-turbulence-enable-state ((self sgenviro) (enable t))
  (SGEnviro_set_turbulence_enable_state (ff-pointer self) enable))

(cl:defmethod get-precipitation-density ((self sgenviro))
  (SGEnviro_get_precipitation_density (ff-pointer self)))

(cl:defmethod get-precipitation-enable-state ((self sgenviro))
  (SGEnviro_get_precipitation_enable_state (ff-pointer self)))

(cl:defmethod set-precipitation-density ((self sgenviro) (density cl:number))
  (SGEnviro_set_precipitation_density (ff-pointer self) density))

(cl:defmethod set-precipitation-enable-state ((self sgenviro) (enable t))
  (SGEnviro_set_precipitation_enable_state (ff-pointer self) enable))

(cl:defmethod get-lightning-enable-state ((self sgenviro))
  (SGEnviro_get_lightning_enable_state (ff-pointer self)))

(cl:defmethod set-lightning-enable-state ((self sgenviro) (enable t))
  (SGEnviro_set_lightning_enable_state (ff-pointer self) enable))

(cl:defmethod add-lightning ((self sgenviro) (lon cl:number) (lat cl:number) (alt cl:number))
  (SGEnviro_addLightning (ff-pointer self) lon lat alt))

(cl:defmethod set-sample-group ((self sgenviro) sgr)
  (SGEnviro_set_sampleGroup (ff-pointer self) sgr))

(cl:defmethod set-fov ((self sgenviro) (w cl:number) (h cl:number))
  (SGEnviro_setFOV (ff-pointer self) w h))

(cl:defmethod get-fov ((self sgenviro) w h)
  (SGEnviro_getFOV (ff-pointer self) w h))

(cl:defmethod get-radar-echo ((self sgenviro))
  (SGEnviro_get_radar_echo (ff-pointer self)))

(cl:defmethod get-transform ((self sgenviro))
  (SGEnviro_get_transform (ff-pointer self)))


(cl:defclass celestial-body()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj celestial-body) &key (Nf cl:number) (Ns cl:number) (If cl:number) (Is cl:number) (wf cl:number) (ws cl:number) (af cl:number) (as cl:number) (ef cl:number) (es cl:number) (Mf cl:number) (Ms cl:number) (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_CelestialBody Nf Ns If Is wf ws af as ef es Mf Ms mjd)))

(cl:defmethod initialize-instance :after ((obj celestial-body) &key (Nf cl:number) (Ns cl:number) (If cl:number) (Is cl:number) (wf cl:number) (ws cl:number) (af cl:number) (as cl:number) (ef cl:number) (es cl:number) (Mf cl:number) (Ms cl:number))
  (setf (slot-value obj 'ff-pointer) (new_CelestialBody Nf Ns If Is wf ws af as ef es Mf Ms)))

(cl:defmethod get-pos ((self celestial-body) ra dec)
  (CelestialBody_getPos (ff-pointer self) ra dec))

(cl:defmethod get-pos ((self celestial-body) ra dec magnitude)
  (CelestialBody_getPos (ff-pointer self) ra dec magnitude))

(cl:defmethod get-right-ascension ((self celestial-body))
  (CelestialBody_getRightAscension (ff-pointer self)))

(cl:defmethod get-declination ((self celestial-body))
  (CelestialBody_getDeclination (ff-pointer self)))

(cl:defmethod get-magnitude ((self celestial-body))
  (CelestialBody_getMagnitude (ff-pointer self)))

(cl:defmethod get-lon ((self celestial-body))
  (CelestialBody_getLon (ff-pointer self)))

(cl:defmethod get-lat ((self celestial-body))
  (CelestialBody_getLat (ff-pointer self)))

(cl:defmethod update-position ((self celestial-body) (mjd cl:number) ourSun)
  (CelestialBody_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass sgephemeris()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgephemeris) &key path)
  (setf (slot-value obj 'ff-pointer) (new_SGEphemeris path)))

(cl:defmethod update ((self sgephemeris) (mjd cl:number) (lst cl:number) (lat cl:number))
  (SGEphemeris_update (ff-pointer self) mjd lst lat))

(cl:defmethod get-sun ((self sgephemeris))
  (SGEphemeris_get_sun (ff-pointer self)))

(cl:defmethod get-sun-right-ascension ((self sgephemeris))
  (SGEphemeris_getSunRightAscension (ff-pointer self)))

(cl:defmethod get-sun-declination ((self sgephemeris))
  (SGEphemeris_getSunDeclination (ff-pointer self)))

(cl:defmethod get-moon ((self sgephemeris))
  (SGEphemeris_get_moon (ff-pointer self)))

(cl:defmethod get-moon-right-ascension ((self sgephemeris))
  (SGEphemeris_getMoonRightAscension (ff-pointer self)))

(cl:defmethod get-moon-declination ((self sgephemeris))
  (SGEphemeris_getMoonDeclination (ff-pointer self)))

(cl:defmethod get-num-planets ((self sgephemeris))
  (SGEphemeris_getNumPlanets (ff-pointer self)))

(cl:defmethod get-planets ((self sgephemeris))
  (SGEphemeris_getPlanets (ff-pointer self)))

(cl:defmethod get-planets ((self sgephemeris))
  (SGEphemeris_getPlanets (ff-pointer self)))

(cl:defmethod get-num-stars ((self sgephemeris))
  (SGEphemeris_getNumStars (ff-pointer self)))

(cl:defmethod get-stars ((self sgephemeris))
  (SGEphemeris_getStars (ff-pointer self)))

(cl:defmethod get-stars ((self sgephemeris))
  (SGEphemeris_getStars (ff-pointer self)))


(cl:defclass jupiter(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj jupiter) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Jupiter mjd)))

(cl:defmethod initialize-instance :after ((obj jupiter) &key)
  (setf (slot-value obj 'ff-pointer) (new_Jupiter)))

(cl:defmethod update-position ((self jupiter) (mjd cl:number) ourSun)
  (Jupiter_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass mars(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj mars) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Mars mjd)))

(cl:defmethod initialize-instance :after ((obj mars) &key)
  (setf (slot-value obj 'ff-pointer) (new_Mars)))

(cl:defmethod update-position ((self mars) (mjd cl:number) ourSun)
  (Mars_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass mercury(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj mercury) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Mercury mjd)))

(cl:defmethod initialize-instance :after ((obj mercury) &key)
  (setf (slot-value obj 'ff-pointer) (new_Mercury)))

(cl:defmethod update-position ((self mercury) (mjd cl:number) ourSun)
  (Mercury_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass moon-pos(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj moon-pos) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_MoonPos mjd)))

(cl:defmethod initialize-instance :after ((obj moon-pos) &key)
  (setf (slot-value obj 'ff-pointer) (new_MoonPos)))

(cl:defmethod update-position ((self moon-pos) (mjd cl:number) (lst cl:number) (lat cl:number) ourSun)
  (MoonPos_updatePosition (ff-pointer self) mjd lst lat ourSun))


(cl:defclass neptune(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj neptune) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Neptune mjd)))

(cl:defmethod initialize-instance :after ((obj neptune) &key)
  (setf (slot-value obj 'ff-pointer) (new_Neptune)))

(cl:defmethod update-position ((self neptune) (mjd cl:number) ourSun)
  (Neptune_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass saturn(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj saturn) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Saturn mjd)))

(cl:defmethod initialize-instance :after ((obj saturn) &key)
  (setf (slot-value obj 'ff-pointer) (new_Saturn)))

(cl:defmethod update-position ((self saturn) (mjd cl:number) ourSun)
  (Saturn_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass star(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj star) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Star mjd)))

(cl:defmethod initialize-instance :after ((obj star) &key)
  (setf (slot-value obj 'ff-pointer) (new_Star)))

(cl:defmethod update-position ((self star) (mjd cl:number))
  (Star_updatePosition (ff-pointer self) mjd))

(cl:defmethod get-m ((self star))
  (Star_getM (ff-pointer self)))

(cl:defmethod getw ((self star))
  (Star_getw (ff-pointer self)))

(cl:defmethod getxs ((self star))
  (Star_getxs (ff-pointer self)))

(cl:defmethod getys ((self star))
  (Star_getys (ff-pointer self)))

(cl:defmethod getye ((self star))
  (Star_getye (ff-pointer self)))

(cl:defmethod getze ((self star))
  (Star_getze (ff-pointer self)))

(cl:defmethod get-distance ((self star))
  (Star_getDistance (ff-pointer self)))


(cl:defclass sgstar-data()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgstar-data) &key path)
  (setf (slot-value obj 'ff-pointer) (new_SGStarData path)))

(cl:defmethod load ((self sgstar-data) path)
  (SGStarData_load (ff-pointer self) path))

(cl:defmethod get-num-stars ((self sgstar-data))
  (SGStarData_getNumStars (ff-pointer self)))

(cl:defmethod get-stars ((self sgstar-data))
  (SGStarData_getStars (ff-pointer self)))


(cl:defclass uranus(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj uranus) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Uranus mjd)))

(cl:defmethod initialize-instance :after ((obj uranus) &key)
  (setf (slot-value obj 'ff-pointer) (new_Uranus)))

(cl:defmethod update-position ((self uranus) (mjd cl:number) (ourSun star))
  (Uranus_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass venus(CelestialBody)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj venus) &key (mjd cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Venus mjd)))

(cl:defmethod initialize-instance :after ((obj venus) &key)
  (setf (slot-value obj 'ff-pointer) (new_Venus)))

(cl:defmethod update-position ((self venus) (mjd cl:number) (ourSun star))
  (Venus_updatePosition (ff-pointer self) mjd ourSun))


(cl:defclass sgiochannel()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgiochannel) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGIOChannel)))

(cl:defmethod open ((self sgiochannel) (d cl:integer))
  (SGIOChannel_open (ff-pointer self) d))

(cl:defmethod read ((self sgiochannel) (buf cl:string) (length cl:integer))
  (SGIOChannel_read (ff-pointer self) buf length))

(cl:defmethod readline ((self sgiochannel) (buf cl:string) (length cl:integer))
  (SGIOChannel_readline (ff-pointer self) buf length))

(cl:defmethod write ((self sgiochannel) (buf cl:string) (length cl:integer))
  (SGIOChannel_write (ff-pointer self) buf length))

(cl:defmethod writestring ((self sgiochannel) (str cl:string))
  (SGIOChannel_writestring (ff-pointer self) str))

(cl:defmethod close ((self sgiochannel))
  (SGIOChannel_close (ff-pointer self)))

(cl:defmethod eof ((self sgiochannel))
  (SGIOChannel_eof (ff-pointer self)))

(cl:defmethod set-type ((self sgiochannel) (t-arg1 cl:integer))
  (SGIOChannel_set_type (ff-pointer self) t-arg1))

(cl:defmethod get-type ((self sgiochannel))
  (SGIOChannel_get_type (ff-pointer self)))

(cl:defmethod set-dir ((self sgiochannel) (d cl:integer))
  (SGIOChannel_set_dir (ff-pointer self) d))

(cl:defmethod get-dir ((self sgiochannel))
  (SGIOChannel_get_dir (ff-pointer self)))

(cl:defmethod isvalid ((self sgiochannel))
  (SGIOChannel_isvalid (ff-pointer self)))

(cl:defmethod set-valid ((self sgiochannel) (v t))
  (SGIOChannel_set_valid (ff-pointer self) v))


(cl:defclass ipaddress()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj ipaddress) &key)
  (setf (slot-value obj 'ff-pointer) (new_IPAddress)))

(cl:defmethod initialize-instance :after ((obj ipaddress) &key (host cl:string) (port cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_IPAddress host port)))

(cl:defmethod set ((self ipaddress) (host cl:string) (port cl:integer))
  (IPAddress_set (ff-pointer self) host port))

(cl:defmethod get-host ((self ipaddress))
  (IPAddress_getHost (ff-pointer self)))

(cl:defmethod get-port ((self ipaddress))
  (IPAddress_getPort (ff-pointer self)))

(cl:defmethod get-ip ((self ipaddress))
  (IPAddress_getIP (ff-pointer self)))

(cl:defmethod get-family ((self ipaddress))
  (IPAddress_getFamily (ff-pointer self)))

(cl:defmethod get-broadcast ((self ipaddress))
  (IPAddress_getBroadcast (ff-pointer self)))


(cl:defclass socket()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj socket) &key)
  (setf (slot-value obj 'ff-pointer) (new_Socket)))

(cl:defmethod get-handle ((self socket))
  (Socket_getHandle (ff-pointer self)))

(cl:defmethod set-handle ((self socket) (handle cl:integer))
  (Socket_setHandle (ff-pointer self) handle))

(cl:defmethod open ((self socket) (stream t))
  (Socket_open (ff-pointer self) stream))

(cl:defmethod open ((self socket))
  (Socket_open (ff-pointer self)))

(cl:defmethod close ((self socket))
  (Socket_close (ff-pointer self)))

(cl:defmethod bind ((self socket) (host cl:string) (port cl:integer))
  (Socket_bind (ff-pointer self) host port))

(cl:defmethod listen ((self socket) (backlog cl:integer))
  (Socket_listen (ff-pointer self) backlog))

(cl:defmethod accept ((self socket) (addr ipaddress))
  (Socket_accept (ff-pointer self) addr))

(cl:defmethod connect ((self socket) (host cl:string) (port cl:integer))
  (Socket_connect (ff-pointer self) host port))

(cl:defmethod send ((self socket) buffer (size cl:integer) (flags cl:integer))
  (Socket_send (ff-pointer self) buffer size flags))

(cl:defmethod send ((self socket) buffer (size cl:integer))
  (Socket_send (ff-pointer self) buffer size))

(cl:defmethod sendto ((self socket) buffer (size cl:integer) (flags cl:integer) (to ipaddress))
  (Socket_sendto (ff-pointer self) buffer size flags to))

(cl:defmethod recv ((self socket) buffer (size cl:integer) (flags cl:integer))
  (Socket_recv (ff-pointer self) buffer size flags))

(cl:defmethod recv ((self socket) buffer (size cl:integer))
  (Socket_recv (ff-pointer self) buffer size))

(cl:defmethod recvfrom ((self socket) buffer (size cl:integer) (flags cl:integer) (from ipaddress))
  (Socket_recvfrom (ff-pointer self) buffer size flags from))

(cl:defmethod set-blocking ((self socket) (blocking t))
  (Socket_setBlocking (ff-pointer self) blocking))

(cl:defmethod set-broadcast ((self socket) (broadcast t))
  (Socket_setBroadcast (ff-pointer self) broadcast))


(cl:defclass sgbin-object()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod get-version ((self sgbin-object))
  (SGBinObject_get_version (ff-pointer self)))

(cl:defmethod get-gbs-center ((self sgbin-object))
  (SGBinObject_get_gbs_center (ff-pointer self)))

(cl:defmethod set-gbs-center ((self sgbin-object) p)
  (SGBinObject_set_gbs_center (ff-pointer self) p))

(cl:defmethod get-gbs-radius ((self sgbin-object))
  (SGBinObject_get_gbs_radius (ff-pointer self)))

(cl:defmethod set-gbs-radius ((self sgbin-object) (r cl:number))
  (SGBinObject_set_gbs_radius (ff-pointer self) r))

(cl:defmethod get-wgs84-nodes ((self sgbin-object))
  (SGBinObject_get_wgs84_nodes (ff-pointer self)))

(cl:defmethod set-wgs84-nodes ((self sgbin-object) n)
  (SGBinObject_set_wgs84_nodes (ff-pointer self) n))

(cl:defmethod get-colors ((self sgbin-object))
  (SGBinObject_get_colors (ff-pointer self)))

(cl:defmethod set-colors ((self sgbin-object) c)
  (SGBinObject_set_colors (ff-pointer self) c))

(cl:defmethod get-normals ((self sgbin-object))
  (SGBinObject_get_normals (ff-pointer self)))

(cl:defmethod set-normals ((self sgbin-object) n)
  (SGBinObject_set_normals (ff-pointer self) n))

(cl:defmethod get-texcoords ((self sgbin-object))
  (SGBinObject_get_texcoords (ff-pointer self)))

(cl:defmethod set-texcoords ((self sgbin-object) t-arg1)
  (SGBinObject_set_texcoords (ff-pointer self) t-arg1))

(cl:defmethod get-pts-v ((self sgbin-object))
  (SGBinObject_get_pts_v (ff-pointer self)))

(cl:defmethod set-pts-v ((self sgbin-object) g)
  (SGBinObject_set_pts_v (ff-pointer self) g))

(cl:defmethod get-pts-n ((self sgbin-object))
  (SGBinObject_get_pts_n (ff-pointer self)))

(cl:defmethod set-pts-n ((self sgbin-object) g)
  (SGBinObject_set_pts_n (ff-pointer self) g))

(cl:defmethod get-pts-c ((self sgbin-object))
  (SGBinObject_get_pts_c (ff-pointer self)))

(cl:defmethod set-pts-c ((self sgbin-object) g)
  (SGBinObject_set_pts_c (ff-pointer self) g))

(cl:defmethod get-pts-tc ((self sgbin-object))
  (SGBinObject_get_pts_tc (ff-pointer self)))

(cl:defmethod set-pts-tc ((self sgbin-object) g)
  (SGBinObject_set_pts_tc (ff-pointer self) g))

(cl:defmethod get-pt-materials ((self sgbin-object))
  (SGBinObject_get_pt_materials (ff-pointer self)))

(cl:defmethod set-pt-materials ((self sgbin-object) s)
  (SGBinObject_set_pt_materials (ff-pointer self) s))

(cl:defmethod get-tris-v ((self sgbin-object))
  (SGBinObject_get_tris_v (ff-pointer self)))

(cl:defmethod set-tris-v ((self sgbin-object) g)
  (SGBinObject_set_tris_v (ff-pointer self) g))

(cl:defmethod get-tris-n ((self sgbin-object))
  (SGBinObject_get_tris_n (ff-pointer self)))

(cl:defmethod set-tris-n ((self sgbin-object) g)
  (SGBinObject_set_tris_n (ff-pointer self) g))

(cl:defmethod get-tris-c ((self sgbin-object))
  (SGBinObject_get_tris_c (ff-pointer self)))

(cl:defmethod set-tris-c ((self sgbin-object) g)
  (SGBinObject_set_tris_c (ff-pointer self) g))

(cl:defmethod get-tris-tc ((self sgbin-object))
  (SGBinObject_get_tris_tc (ff-pointer self)))

(cl:defmethod set-tris-tc ((self sgbin-object) g)
  (SGBinObject_set_tris_tc (ff-pointer self) g))

(cl:defmethod get-tri-materials ((self sgbin-object))
  (SGBinObject_get_tri_materials (ff-pointer self)))

(cl:defmethod set-tri-materials ((self sgbin-object) s)
  (SGBinObject_set_tri_materials (ff-pointer self) s))

(cl:defmethod get-strips-v ((self sgbin-object))
  (SGBinObject_get_strips_v (ff-pointer self)))

(cl:defmethod set-strips-v ((self sgbin-object) g)
  (SGBinObject_set_strips_v (ff-pointer self) g))

(cl:defmethod get-strips-n ((self sgbin-object))
  (SGBinObject_get_strips_n (ff-pointer self)))

(cl:defmethod set-strips-n ((self sgbin-object) g)
  (SGBinObject_set_strips_n (ff-pointer self) g))

(cl:defmethod get-strips-c ((self sgbin-object))
  (SGBinObject_get_strips_c (ff-pointer self)))

(cl:defmethod set-strips-c ((self sgbin-object) g)
  (SGBinObject_set_strips_c (ff-pointer self) g))

(cl:defmethod get-strips-tc ((self sgbin-object))
  (SGBinObject_get_strips_tc (ff-pointer self)))

(cl:defmethod set-strips-tc ((self sgbin-object) g)
  (SGBinObject_set_strips_tc (ff-pointer self) g))

(cl:defmethod get-strip-materials ((self sgbin-object))
  (SGBinObject_get_strip_materials (ff-pointer self)))

(cl:defmethod set-strip-materials ((self sgbin-object) s)
  (SGBinObject_set_strip_materials (ff-pointer self) s))

(cl:defmethod get-fans-v ((self sgbin-object))
  (SGBinObject_get_fans_v (ff-pointer self)))

(cl:defmethod set-fans-v ((self sgbin-object) g)
  (SGBinObject_set_fans_v (ff-pointer self) g))

(cl:defmethod get-fans-n ((self sgbin-object))
  (SGBinObject_get_fans_n (ff-pointer self)))

(cl:defmethod set-fans-n ((self sgbin-object) g)
  (SGBinObject_set_fans_n (ff-pointer self) g))

(cl:defmethod get-fans-c ((self sgbin-object))
  (SGBinObject_get_fans_c (ff-pointer self)))

(cl:defmethod set-fans-c ((self sgbin-object) g)
  (SGBinObject_set_fans_c (ff-pointer self) g))

(cl:defmethod get-fans-tc ((self sgbin-object))
  (SGBinObject_get_fans_tc (ff-pointer self)))

(cl:defmethod set-fans-tc ((self sgbin-object) g)
  (SGBinObject_set_fans_tc (ff-pointer self) g))

(cl:defmethod get-fan-materials ((self sgbin-object))
  (SGBinObject_get_fan_materials (ff-pointer self)))

(cl:defmethod set-fan-materials ((self sgbin-object) s)
  (SGBinObject_set_fan_materials (ff-pointer self) s))

(cl:defmethod read-bin ((self sgbin-object) file)
  (SGBinObject_read_bin (ff-pointer self) file))

(cl:defmethod write-bin ((self sgbin-object) base name (b sgbucket))
  (SGBinObject_write_bin (ff-pointer self) base name b))

(cl:defmethod write-ascii ((self sgbin-object) base name (b sgbucket))
  (SGBinObject_write_ascii (ff-pointer self) base name b))

(cl:defmethod initialize-instance :after ((obj sgbin-object) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGBinObject)))


(cl:defclass sgfile(SGIOChannel)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgfile) &key file (repeat_ cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGFile file repeat_)))

(cl:defmethod initialize-instance :after ((obj sgfile) &key file)
  (setf (slot-value obj 'ff-pointer) (new_SGFile file)))

(cl:defmethod open ((self sgfile) (dir cl:integer))
  (SGFile_open (ff-pointer self) dir))

(cl:defmethod read ((self sgfile) (buf cl:string) (length cl:integer))
  (SGFile_read (ff-pointer self) buf length))

(cl:defmethod readline ((self sgfile) (buf cl:string) (length cl:integer))
  (SGFile_readline (ff-pointer self) buf length))

(cl:defmethod write ((self sgfile) (buf cl:string) (length cl:integer))
  (SGFile_write (ff-pointer self) buf length))

(cl:defmethod writestring ((self sgfile) (str cl:string))
  (SGFile_writestring (ff-pointer self) str))

(cl:defmethod close ((self sgfile))
  (SGFile_close (ff-pointer self)))

(cl:defmethod get-file-name ((self sgfile))
  (SGFile_get_file_name (ff-pointer self)))

(cl:defmethod eof ((self sgfile))
  (SGFile_eof (ff-pointer self)))


(cl:defclass net-buffer()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj net-buffer) &key (_max_length cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_NetBuffer _max_length)))

(cl:defmethod get-length ((self net-buffer))
  (NetBuffer_getLength (ff-pointer self)))

(cl:defmethod get-max-length ((self net-buffer))
  (NetBuffer_getMaxLength (ff-pointer self)))

(cl:defmethod get-data ((self net-buffer))
  (NetBuffer_getData (ff-pointer self)))

(cl:defmethod get-data ((self net-buffer))
  (NetBuffer_getData (ff-pointer self)))

(cl:defmethod remove ((self net-buffer))
  (NetBuffer_remove (ff-pointer self)))

(cl:defmethod remove ((self net-buffer) (pos cl:integer) (n cl:integer))
  (NetBuffer_remove (ff-pointer self) pos n))

(cl:defmethod append ((self net-buffer) (s cl:string) (n cl:integer))
  (NetBuffer_append (ff-pointer self) s n))

(cl:defmethod append ((self net-buffer) (n cl:integer))
  (NetBuffer_append (ff-pointer self) n))


(cl:defclass net-buffer-channel()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj net-buffer-channel) &key (in_buffer_size cl:integer) (out_buffer_size cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_NetBufferChannel in_buffer_size out_buffer_size)))

(cl:defmethod initialize-instance :after ((obj net-buffer-channel) &key (in_buffer_size cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_NetBufferChannel in_buffer_size)))

(cl:defmethod initialize-instance :after ((obj net-buffer-channel) &key)
  (setf (slot-value obj 'ff-pointer) (new_NetBufferChannel)))

(cl:defmethod handle-close ((self net-buffer-channel))
  (NetBufferChannel_handleClose (ff-pointer self)))

(cl:defmethod close-when-done ((self net-buffer-channel))
  (NetBufferChannel_closeWhenDone (ff-pointer self)))

(cl:defmethod buffer-send ((self net-buffer-channel) (msg cl:string) (msg_len cl:integer))
  (NetBufferChannel_bufferSend (ff-pointer self) msg msg_len))

(cl:defmethod handle-buffer-read ((self net-buffer-channel) (buffer net-buffer))
  (NetBufferChannel_handleBufferRead (ff-pointer self) buffer))


(cl:defclass net-chat(simgear::NetBufferChannel)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj net-chat) &key)
  (setf (slot-value obj 'ff-pointer) (new_NetChat)))

(cl:defmethod set-terminator ((self net-chat) (t-arg1 cl:string))
  (NetChat_setTerminator (ff-pointer self) t-arg1))

(cl:defmethod get-terminator ((self net-chat))
  (NetChat_getTerminator (ff-pointer self)))

(cl:defmethod push ((self net-chat) (s cl:string))
  (NetChat_push (ff-pointer self) s))

(cl:defmethod collect-incoming-data ((self net-chat) (s cl:string) (n cl:integer))
  (NetChat_collectIncomingData (ff-pointer self) s n))

(cl:defmethod found-terminator ((self net-chat))
  (NetChat_foundTerminator (ff-pointer self)))


(cl:defclass sgserial(SGIOChannel)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgserial) &key device_name baud_rate)
  (setf (slot-value obj 'ff-pointer) (new_SGSerial device_name baud_rate)))

(cl:defmethod open ((self sgserial) (d cl:integer))
  (SGSerial_open (ff-pointer self) d))

(cl:defmethod read ((self sgserial) (buf cl:string) (length cl:integer))
  (SGSerial_read (ff-pointer self) buf length))

(cl:defmethod readline ((self sgserial) (buf cl:string) (length cl:integer))
  (SGSerial_readline (ff-pointer self) buf length))

(cl:defmethod write ((self sgserial) (buf cl:string) (length cl:integer))
  (SGSerial_write (ff-pointer self) buf length))

(cl:defmethod writestring ((self sgserial) (str cl:string))
  (SGSerial_writestring (ff-pointer self) str))

(cl:defmethod close ((self sgserial))
  (SGSerial_close (ff-pointer self)))

(cl:defmethod get-device ((self sgserial))
  (SGSerial_get_device (ff-pointer self)))

(cl:defmethod get-baud ((self sgserial))
  (SGSerial_get_baud (ff-pointer self)))


(cl:defclass sgsocket(SGIOChannel)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsocket) &key host port style)
  (setf (slot-value obj 'ff-pointer) (new_SGSocket host port style)))

(cl:defmethod open ((self sgsocket) (d cl:integer))
  (SGSocket_open (ff-pointer self) d))

(cl:defmethod read ((self sgsocket) (buf cl:string) (length cl:integer))
  (SGSocket_read (ff-pointer self) buf length))

(cl:defmethod readline ((self sgsocket) (buf cl:string) (length cl:integer))
  (SGSocket_readline (ff-pointer self) buf length))

(cl:defmethod write ((self sgsocket) (buf cl:string) (length cl:integer))
  (SGSocket_write (ff-pointer self) buf length))

(cl:defmethod writestring ((self sgsocket) (str cl:string))
  (SGSocket_writestring (ff-pointer self) str))

(cl:defmethod close ((self sgsocket))
  (SGSocket_close (ff-pointer self)))

(cl:defmethod nonblock ((self sgsocket))
  (SGSocket_nonblock (ff-pointer self)))

(cl:defmethod set-timeout ((self sgsocket) (i cl:integer))
  (SGSocket_set_timeout (ff-pointer self) i))

(cl:defmethod get-hostname ((self sgsocket))
  (SGSocket_get_hostname (ff-pointer self)))

(cl:defmethod get-port-str ((self sgsocket))
  (SGSocket_get_port_str (ff-pointer self)))


(cl:defclass sgsocket-udp(SGIOChannel)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsocket-udp) &key host port)
  (setf (slot-value obj 'ff-pointer) (new_SGSocketUDP host port)))

(cl:defmethod open ((self sgsocket-udp) (d cl:integer))
  (SGSocketUDP_open (ff-pointer self) d))

(cl:defmethod read ((self sgsocket-udp) (buf cl:string) (length cl:integer))
  (SGSocketUDP_read (ff-pointer self) buf length))

(cl:defmethod readline ((self sgsocket-udp) (buf cl:string) (length cl:integer))
  (SGSocketUDP_readline (ff-pointer self) buf length))

(cl:defmethod write ((self sgsocket-udp) (buf cl:string) (length cl:integer))
  (SGSocketUDP_write (ff-pointer self) buf length))

(cl:defmethod writestring ((self sgsocket-udp) (str cl:string))
  (SGSocketUDP_writestring (ff-pointer self) str))

(cl:defmethod close ((self sgsocket-udp))
  (SGSocketUDP_close (ff-pointer self)))

(cl:defmethod set-blocking ((self sgsocket-udp) (value t))
  (SGSocketUDP_setBlocking (ff-pointer self) value))

(cl:defmethod get-hostname ((self sgsocket-udp))
  (SGSocketUDP_get_hostname (ff-pointer self)))

(cl:defmethod get-port-str ((self sgsocket-udp))
  (SGSocketUDP_get_port_str (ff-pointer self)))


(cl:defclass sgmag-var()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmag-var) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGMagVar)))

(cl:defmethod update ((self sgmag-var) (lon cl:number) (lat cl:number) (alt_m cl:number) (jd cl:number))
  (SGMagVar_update (ff-pointer self) lon lat alt_m jd))

(cl:defmethod update ((self sgmag-var) geod (jd cl:number))
  (SGMagVar_update (ff-pointer self) geod jd))

(cl:defmethod get-magvar ((self sgmag-var))
  (SGMagVar_get_magvar (ff-pointer self)))

(cl:defmethod get-magdip ((self sgmag-var))
  (SGMagVar_get_magdip (ff-pointer self)))


(cl:defclass sggeoc()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sggeoc) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGGeoc)))

(cl:defmethod get-longitude-rad ((self sggeoc))
  (SGGeoc_getLongitudeRad (ff-pointer self)))

(cl:defmethod set-longitude-rad ((self sggeoc) (lon cl:number))
  (SGGeoc_setLongitudeRad (ff-pointer self) lon))

(cl:defmethod get-longitude-deg ((self sggeoc))
  (SGGeoc_getLongitudeDeg (ff-pointer self)))

(cl:defmethod set-longitude-deg ((self sggeoc) (lon cl:number))
  (SGGeoc_setLongitudeDeg (ff-pointer self) lon))

(cl:defmethod get-latitude-rad ((self sggeoc))
  (SGGeoc_getLatitudeRad (ff-pointer self)))

(cl:defmethod set-latitude-rad ((self sggeoc) (lat cl:number))
  (SGGeoc_setLatitudeRad (ff-pointer self) lat))

(cl:defmethod get-latitude-deg ((self sggeoc))
  (SGGeoc_getLatitudeDeg (ff-pointer self)))

(cl:defmethod set-latitude-deg ((self sggeoc) (lat cl:number))
  (SGGeoc_setLatitudeDeg (ff-pointer self) lat))

(cl:defmethod get-radius-m ((self sggeoc))
  (SGGeoc_getRadiusM (ff-pointer self)))

(cl:defmethod set-radius-m ((self sggeoc) (radius cl:number))
  (SGGeoc_setRadiusM (ff-pointer self) radius))

(cl:defmethod get-radius-ft ((self sggeoc))
  (SGGeoc_getRadiusFt (ff-pointer self)))

(cl:defmethod set-radius-ft ((self sggeoc) (radius cl:number))
  (SGGeoc_setRadiusFt (ff-pointer self) radius))

(cl:defmethod advance-rad-m ((self sggeoc) (course cl:number) (distance cl:number))
  (SGGeoc_advanceRadM (ff-pointer self) course distance))

(cl:shadow "==")
(cl:defmethod == ((self sggeoc) (other sggeoc))
  (SGGeoc___eq__ (ff-pointer self) (ff-pointer other)))


(cl:defclass sggeod()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sggeod) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGGeod)))

(cl:defmethod get-longitude-rad ((self sggeod))
  (SGGeod_getLongitudeRad (ff-pointer self)))

(cl:defmethod set-longitude-rad ((self sggeod) (lon cl:number))
  (SGGeod_setLongitudeRad (ff-pointer self) lon))

(cl:defmethod get-longitude-deg ((self sggeod))
  (SGGeod_getLongitudeDeg (ff-pointer self)))

(cl:defmethod set-longitude-deg ((self sggeod) (lon cl:number))
  (SGGeod_setLongitudeDeg (ff-pointer self) lon))

(cl:defmethod get-latitude-rad ((self sggeod))
  (SGGeod_getLatitudeRad (ff-pointer self)))

(cl:defmethod set-latitude-rad ((self sggeod) (lat cl:number))
  (SGGeod_setLatitudeRad (ff-pointer self) lat))

(cl:defmethod get-latitude-deg ((self sggeod))
  (SGGeod_getLatitudeDeg (ff-pointer self)))

(cl:defmethod set-latitude-deg ((self sggeod) (lat cl:number))
  (SGGeod_setLatitudeDeg (ff-pointer self) lat))

(cl:defmethod get-elevation-m ((self sggeod))
  (SGGeod_getElevationM (ff-pointer self)))

(cl:defmethod set-elevation-m ((self sggeod) (elevation cl:number))
  (SGGeod_setElevationM (ff-pointer self) elevation))

(cl:defmethod get-elevation-ft ((self sggeod))
  (SGGeod_getElevationFt (ff-pointer self)))

(cl:defmethod set-elevation-ft ((self sggeod) (elevation cl:number))
  (SGGeod_setElevationFt (ff-pointer self) elevation))

(cl:shadow "==")
(cl:defmethod == ((self sggeod) (other sggeod))
  (SGGeod___eq__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod make-simulation-frame-relative ((self sggeod))
  (SGGeod_makeSimulationFrameRelative (ff-pointer self)))

(cl:defmethod make-simulation-frame ((self sggeod))
  (SGGeod_makeSimulationFrame (ff-pointer self)))

(cl:defmethod make-zup-frame-relative ((self sggeod))
  (SGGeod_makeZUpFrameRelative (ff-pointer self)))

(cl:defmethod make-zup-frame ((self sggeod))
  (SGGeod_makeZUpFrame (ff-pointer self)))


(cl:defclass sggeodesy()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sggeodesy) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGGeodesy)))


(cl:defclass sginterp-table()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sginterp-table) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGInterpTable)))

(cl:defmethod initialize-instance :after ((obj sginterp-table) &key interpolation)
  (setf (slot-value obj 'ff-pointer) (new_SGInterpTable interpolation)))

(cl:defmethod initialize-instance :after ((obj sginterp-table) &key file)
  (setf (slot-value obj 'ff-pointer) (new_SGInterpTable file)))

(cl:defmethod add-entry ((self sginterp-table) (ind cl:number) (dep cl:number))
  (SGInterpTable_addEntry (ff-pointer self) ind dep))

(cl:defmethod interpolate ((self sginterp-table) (x cl:number))
  (SGInterpTable_interpolate (ff-pointer self) x))


(cl:defclass point3-d()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj point3-d) &key)
  (setf (slot-value obj 'ff-pointer) (new_Point3D)))

(cl:defmethod initialize-instance :after ((obj point3-d) &key (x cl:number) (y cl:number) (z cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Point3D x y z)))

(cl:defmethod initialize-instance :after ((obj point3-d) &key (d cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Point3D d)))

(cl:defmethod initialize-instance :after ((obj point3-d) &key (p point3-d))
  (setf (slot-value obj 'ff-pointer) (new_Point3D (ff-pointer p))))

(cl:shadow "=")
(cl:defmethod = ((self point3-d) (p point3-d))
  (Point3D___assign__ (ff-pointer self) (ff-pointer p)))

(cl:shadow "+=")
(cl:defmethod += ((self point3-d) (p point3-d))
  (Point3D___add_assign__ (ff-pointer self) (ff-pointer p)))

(cl:shadow "-=")
(cl:defmethod -= ((self point3-d) (p point3-d))
  (Point3D___sub_assign__ (ff-pointer self) (ff-pointer p)))

(cl:shadow "*=")
(cl:defmethod *= ((self point3-d) (d cl:number))
  (Point3D___mul_assign__ (ff-pointer self) d))

(cl:shadow "/=")
(cl:defmethod /= ((self point3-d) (d cl:number))
  (Point3D___div_assign__ (ff-pointer self) d))

(cl:defmethod setx ((self point3-d) (x cl:number))
  (Point3D_setx (ff-pointer self) x))

(cl:defmethod sety ((self point3-d) (y cl:number))
  (Point3D_sety (ff-pointer self) y))

(cl:defmethod setz ((self point3-d) (z cl:number))
  (Point3D_setz (ff-pointer self) z))

(cl:defmethod setlon ((self point3-d) (x cl:number))
  (Point3D_setlon (ff-pointer self) x))

(cl:defmethod setlat ((self point3-d) (y cl:number))
  (Point3D_setlat (ff-pointer self) y))

(cl:defmethod setradius ((self point3-d) (z cl:number))
  (Point3D_setradius (ff-pointer self) z))

(cl:defmethod setelev ((self point3-d) (z cl:number))
  (Point3D_setelev (ff-pointer self) z))

(cl:shadow "[]")
(cl:defmethod [] ((self point3-d) (i cl:integer))
  (Point3D___aref__ (ff-pointer self) i))

(cl:shadow "[]")
(cl:defmethod [] ((self point3-d) (i cl:integer))
  (Point3D___aref__ (ff-pointer self) i))

(cl:defmethod get-n ((self point3-d))
  (Point3D_get_n (ff-pointer self)))

(cl:defmethod x ((self point3-d))
  (Point3D_x (ff-pointer self)))

(cl:defmethod y ((self point3-d))
  (Point3D_y (ff-pointer self)))

(cl:defmethod z ((self point3-d))
  (Point3D_z (ff-pointer self)))

(cl:defmethod lon ((self point3-d))
  (Point3D_lon (ff-pointer self)))

(cl:defmethod lat ((self point3-d))
  (Point3D_lat (ff-pointer self)))

(cl:defmethod radius ((self point3-d))
  (Point3D_radius (ff-pointer self)))

(cl:defmethod elev ((self point3-d))
  (Point3D_elev (ff-pointer self)))

(cl:defmethod to-sggeod ((self point3-d))
  (Point3D_toSGGeod (ff-pointer self)))

(cl:defmethod to-sggeoc ((self point3-d))
  (Point3D_toSGGeoc (ff-pointer self)))

(cl:defmethod to-sgvec3d ((self point3-d))
  (Point3D_toSGVec3d (ff-pointer self)))

(cl:defmethod to-sgvec3f ((self point3-d))
  (Point3D_toSGVec3f (ff-pointer self)))

(cl:defmethod to-sgvec2f ((self point3-d))
  (Point3D_toSGVec2f (ff-pointer self)))

(cl:defmethod distance3-d ((self point3-d) (a point3-d))
  (Point3D_distance3D (ff-pointer self) (ff-pointer a)))

(cl:defmethod distance3-dsquared ((self point3-d) (a point3-d))
  (Point3D_distance3Dsquared (ff-pointer self) (ff-pointer a)))


(cl:defclass resource-manager()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod add-base-path ((self resource-manager) aPath (aPriority cl:integer))
  (ResourceManager_addBasePath (ff-pointer self) aPath aPriority))

(cl:defmethod add-base-path ((self resource-manager) aPath)
  (ResourceManager_addBasePath (ff-pointer self) aPath))

(cl:defmethod add-provider ((self resource-manager) aProvider)
  (ResourceManager_addProvider (ff-pointer self) aProvider))

(cl:defmethod find-path ((self resource-manager) aResource aContext)
  (ResourceManager_findPath (ff-pointer self) aResource aContext))

(cl:defmethod find-path ((self resource-manager) aResource)
  (ResourceManager_findPath (ff-pointer self) aResource))


(cl:defclass resource-provider()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod resolve ((self resource-provider) aResource aContext)
  (ResourceProvider_resolve (ff-pointer self) aResource aContext))

(cl:defmethod priority ((self resource-provider))
  (ResourceProvider_priority (ff-pointer self)))


(cl:defclass sginterpolator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sginterpolator) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGInterpolator)))

(cl:defmethod init ((self sginterpolator))
  (SGInterpolator_init (ff-pointer self)))

(cl:defmethod update ((self sginterpolator) (delta_time_sec cl:number))
  (SGInterpolator_update (ff-pointer self) delta_time_sec))

(cl:defmethod interpolate ((self sginterpolator) prop (value cl:number) (dt_sec cl:number))
  (SGInterpolator_interpolate (ff-pointer self) prop value dt_sec))

(cl:defmethod interpolate ((self sginterpolator) prop (nPoints cl:integer) values deltas)
  (SGInterpolator_interpolate (ff-pointer self) prop nPoints values deltas))

(cl:defmethod cancel ((self sginterpolator) prop)
  (SGInterpolator_cancel (ff-pointer self) prop))


(cl:defclass dir()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj dir) &key path)
  (setf (slot-value obj 'ff-pointer) (new_Dir path)))

(cl:defmethod initialize-instance :after ((obj dir) &key (rel dir) relPath)
  (setf (slot-value obj 'ff-pointer) (new_Dir (ff-pointer rel) relPath)))

(cl:defmethod children ((self dir) (types cl:integer) nameGlob)
  (Dir_children (ff-pointer self) types nameGlob))

(cl:defmethod children ((self dir) (types cl:integer))
  (Dir_children (ff-pointer self) types))

(cl:defmethod children ((self dir))
  (Dir_children (ff-pointer self)))

(cl:defmethod file ((self dir) name)
  (Dir_file (ff-pointer self) name))

(cl:defmethod exists ((self dir))
  (Dir_exists (ff-pointer self)))


(cl:defclass sgpath()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgpath) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGPath)))

(cl:defmethod initialize-instance :after ((obj sgpath) &key (p sgpath))
  (setf (slot-value obj 'ff-pointer) (new_SGPath (ff-pointer p))))

(cl:shadow "=")
(cl:defmethod = ((self sgpath) (p sgpath))
  (SGPath___assign__ (ff-pointer self) (ff-pointer p)))

(cl:defmethod initialize-instance :after ((obj sgpath) &key p)
  (setf (slot-value obj 'ff-pointer) (new_SGPath p)))

(cl:defmethod initialize-instance :after ((obj sgpath) &key (p sgpath) r)
  (setf (slot-value obj 'ff-pointer) (new_SGPath (ff-pointer p) r)))

(cl:defmethod set ((self sgpath) p)
  (SGPath_set (ff-pointer self) p))

(cl:shadow "=")
(cl:defmethod = ((self sgpath) (p cl:string))
  (SGPath___assign__ (ff-pointer self) p))

(cl:defmethod append ((self sgpath) p)
  (SGPath_append (ff-pointer self) p))

(cl:defmethod add ((self sgpath) p)
  (SGPath_add (ff-pointer self) p))

(cl:defmethod concat ((self sgpath) p)
  (SGPath_concat (ff-pointer self) p))

(cl:defmethod file ((self sgpath))
  (SGPath_file (ff-pointer self)))

(cl:defmethod dir ((self sgpath))
  (SGPath_dir (ff-pointer self)))

(cl:defmethod base ((self sgpath))
  (SGPath_base (ff-pointer self)))

(cl:defmethod extension ((self sgpath))
  (SGPath_extension (ff-pointer self)))

(cl:defmethod str ((self sgpath))
  (SGPath_str (ff-pointer self)))

(cl:defmethod c-str ((self sgpath))
  (SGPath_c_str (ff-pointer self)))

(cl:defmethod exists ((self sgpath))
  (SGPath_exists (ff-pointer self)))

(cl:defmethod create-dir ((self sgpath) mode)
  (SGPath_create_dir (ff-pointer self) mode))

(cl:defmethod is-file ((self sgpath))
  (SGPath_isFile (ff-pointer self)))

(cl:defmethod is-dir ((self sgpath))
  (SGPath_isDir (ff-pointer self)))

(cl:defmethod is-relative ((self sgpath))
  (SGPath_isRelative (ff-pointer self)))

(cl:defmethod is-absolute ((self sgpath))
  (SGPath_isAbsolute (ff-pointer self)))

(cl:defmethod is-null ((self sgpath))
  (SGPath_isNull (ff-pointer self)))


(cl:defclass sg-gzifstream()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-gzifstream) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_gzifstream)))

(cl:defmethod initialize-instance :after ((obj sg-gzifstream) &key name io_mode)
  (setf (slot-value obj 'ff-pointer) (new_sg_gzifstream name io_mode)))

(cl:defmethod initialize-instance :after ((obj sg-gzifstream) &key name)
  (setf (slot-value obj 'ff-pointer) (new_sg_gzifstream name)))

(cl:defmethod initialize-instance :after ((obj sg-gzifstream) &key (fd cl:integer) io_mode)
  (setf (slot-value obj 'ff-pointer) (new_sg_gzifstream fd io_mode)))

(cl:defmethod initialize-instance :after ((obj sg-gzifstream) &key (fd cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_sg_gzifstream fd)))

(cl:defmethod open ((self sg-gzifstream) name io_mode)
  (sg_gzifstream_open (ff-pointer self) name io_mode))

(cl:defmethod open ((self sg-gzifstream) name)
  (sg_gzifstream_open (ff-pointer self) name))

(cl:defmethod attach ((self sg-gzifstream) (fd cl:integer) io_mode)
  (sg_gzifstream_attach (ff-pointer self) fd io_mode))

(cl:defmethod attach ((self sg-gzifstream) (fd cl:integer))
  (sg_gzifstream_attach (ff-pointer self) fd))

(cl:defmethod close ((self sg-gzifstream))
  (sg_gzifstream_close (ff-pointer self)))

(cl:defmethod is-open ((self sg-gzifstream))
  (sg_gzifstream_is_open (ff-pointer self)))


(cl:defclass stop-watch()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj stop-watch) &key)
  (setf (slot-value obj 'ff-pointer) (new_StopWatch)))

(cl:defmethod start ((self stop-watch))
  (StopWatch_start (ff-pointer self)))

(cl:defmethod stop ((self stop-watch))
  (StopWatch_stop (ff-pointer self)))

(cl:defmethod elapsed-seconds ((self stop-watch))
  (StopWatch_elapsedSeconds (ff-pointer self)))


(cl:defclass sgtabbed-values()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtabbed-values) &key (line cl:string))
  (setf (slot-value obj 'ff-pointer) (new_SGTabbedValues line)))

(cl:shadow "[]")
(cl:defmethod [] ((self sgtabbed-values) (arg1 cl:integer))
  (SGTabbedValues___aref__ (ff-pointer self) arg1))

(cl:defmethod is-value-at ((self sgtabbed-values) (arg1 cl:integer))
  (SGTabbedValues_isValueAt (ff-pointer self) arg1))

(cl:defmethod get-double-at ((self sgtabbed-values) (arg1 cl:integer))
  (SGTabbedValues_getDoubleAt (ff-pointer self) arg1))

(cl:defmethod get-char-at ((self sgtabbed-values) (arg1 cl:integer))
  (SGTabbedValues_getCharAt (ff-pointer self) arg1))

(cl:defmethod get-long-at ((self sgtabbed-values) (arg1 cl:integer))
  (SGTabbedValues_getLongAt (ff-pointer self) arg1))


(cl:defclass gzfilebuf()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj gzfilebuf) &key)
  (setf (slot-value obj 'ff-pointer) (new_gzfilebuf)))

(cl:defmethod open ((self gzfilebuf) (name cl:string) io_mode)
  (gzfilebuf_open (ff-pointer self) name io_mode))

(cl:defmethod attach ((self gzfilebuf) (file_descriptor cl:integer) io_mode)
  (gzfilebuf_attach (ff-pointer self) file_descriptor io_mode))

(cl:defmethod close ((self gzfilebuf))
  (gzfilebuf_close (ff-pointer self)))

(cl:defmethod is-open ((self gzfilebuf))
  (gzfilebuf_is_open (ff-pointer self)))

(cl:defmethod seekoff ((self gzfilebuf) off way (which cl:integer))
  (gzfilebuf_seekoff (ff-pointer self) off way which))

(cl:defmethod sync ((self gzfilebuf))
  (gzfilebuf_sync (ff-pointer self)))


(cl:defclass multi-change-listener()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj multi-change-listener) &key)
  (setf (slot-value obj 'ff-pointer) (new_MultiChangeListener)))


(cl:defclass atomic-change-listener(simgear::MultiChangeListener)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj atomic-change-listener) &key nodes)
  (setf (slot-value obj 'ff-pointer) (new_AtomicChangeListener nodes)))

(cl:defmethod is-dirty ((self atomic-change-listener))
  (AtomicChangeListener_isDirty (ff-pointer self)))

(cl:defmethod is-valid ((self atomic-change-listener))
  (AtomicChangeListener_isValid (ff-pointer self)))

(cl:defmethod unregister-property ((self atomic-change-listener) node)
  (AtomicChangeListener_unregister_property (ff-pointer self) node))


(cl:defclass sgcondition()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod test ((self sgcondition))
  (SGCondition_test (ff-pointer self)))


(cl:defclass sgconditional()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgconditional) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGConditional)))

(cl:defmethod set-condition ((self sgconditional) (condition sgcondition))
  (SGConditional_setCondition (ff-pointer self) condition))

(cl:defmethod get-condition ((self sgconditional))
  (SGConditional_getCondition (ff-pointer self)))

(cl:defmethod test ((self sgconditional))
  (SGConditional_test (ff-pointer self)))


(cl:defclass property-object-base()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj property-object-base) &key (aOther property-object-base))
  (setf (slot-value obj 'ff-pointer) (new_PropertyObjectBase (ff-pointer aOther))))

(cl:defmethod initialize-instance :after ((obj property-object-base) &key (aChild cl:string))
  (setf (slot-value obj 'ff-pointer) (new_PropertyObjectBase aChild)))

(cl:defmethod initialize-instance :after ((obj property-object-base) &key aNode (aChild cl:string))
  (setf (slot-value obj 'ff-pointer) (new_PropertyObjectBase aNode aChild)))

(cl:defmethod initialize-instance :after ((obj property-object-base) &key aNode)
  (setf (slot-value obj 'ff-pointer) (new_PropertyObjectBase aNode)))

(cl:defmethod node ((self property-object-base) (aCreate t))
  (PropertyObjectBase_node (ff-pointer self) aCreate))

(cl:defmethod get-or-throw ((self property-object-base))
  (PropertyObjectBase_getOrThrow (ff-pointer self)))


(cl:defclass sgraw()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod get-type ((self sgraw))
  (SGRaw_getType (ff-pointer self)))

(cl:defmethod clone ((self sgraw))
  (SGRaw_clone (ff-pointer self)))


(cl:defclass sgraw-extended(SGRaw)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod make-container ((self sgraw-extended))
  (SGRawExtended_makeContainer (ff-pointer self)))

(cl:defmethod print-on ((self sgraw-extended) stream)
  (SGRawExtended_printOn (ff-pointer self) stream))

(cl:defmethod read-from ((self sgraw-extended) stream)
  (SGRawExtended_readFrom (ff-pointer self) stream))


(cl:defclass sgproperty-change-listener()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod value-changed ((self sgproperty-change-listener) node)
  (SGPropertyChangeListener_valueChanged (ff-pointer self) node))

(cl:defmethod child-added ((self sgproperty-change-listener) parent child)
  (SGPropertyChangeListener_childAdded (ff-pointer self) parent child))

(cl:defmethod child-removed ((self sgproperty-change-listener) parent child)
  (SGPropertyChangeListener_childRemoved (ff-pointer self) parent child))

(cl:defmethod initialize-instance :after ((obj sgproperty-change-listener) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGPropertyChangeListener)))


(cl:defclass sgproperty-node()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgproperty-node) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGPropertyNode)))

(cl:defmethod initialize-instance :after ((obj sgproperty-node) &key (node sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGPropertyNode (ff-pointer node))))

(cl:defmethod has-value ((self sgproperty-node))
  (SGPropertyNode_hasValue (ff-pointer self)))

(cl:defmethod get-name ((self sgproperty-node))
  (SGPropertyNode_getName (ff-pointer self)))

(cl:defmethod get-name-string ((self sgproperty-node))
  (SGPropertyNode_getNameString (ff-pointer self)))

(cl:defmethod get-display-name ((self sgproperty-node) (simplify t))
  (SGPropertyNode_getDisplayName (ff-pointer self) simplify))

(cl:defmethod get-display-name ((self sgproperty-node))
  (SGPropertyNode_getDisplayName (ff-pointer self)))

(cl:defmethod get-index ((self sgproperty-node))
  (SGPropertyNode_getIndex (ff-pointer self)))

(cl:defmethod get-parent ((self sgproperty-node))
  (SGPropertyNode_getParent (ff-pointer self)))

(cl:defmethod get-parent ((self sgproperty-node))
  (SGPropertyNode_getParent (ff-pointer self)))

(cl:defmethod n-children ((self sgproperty-node))
  (SGPropertyNode_nChildren (ff-pointer self)))

(cl:defmethod get-child ((self sgproperty-node) (position cl:integer))
  (SGPropertyNode_getChild (ff-pointer self) position))

(cl:defmethod get-child ((self sgproperty-node) (position cl:integer))
  (SGPropertyNode_getChild (ff-pointer self) position))

(cl:defmethod has-child ((self sgproperty-node) (name cl:string) (index cl:integer))
  (SGPropertyNode_hasChild (ff-pointer self) name index))

(cl:defmethod has-child ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_hasChild (ff-pointer self) name))

(cl:defmethod has-child ((self sgproperty-node) name (index cl:integer))
  (SGPropertyNode_hasChild (ff-pointer self) name index))

(cl:defmethod has-child ((self sgproperty-node) name)
  (SGPropertyNode_hasChild (ff-pointer self) name))

(cl:defmethod add-child ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_addChild (ff-pointer self) name))

(cl:defmethod get-child ((self sgproperty-node) (name cl:string) (index cl:integer) (create t))
  (SGPropertyNode_getChild (ff-pointer self) name index create))

(cl:defmethod get-child ((self sgproperty-node) (name cl:string) (index cl:integer))
  (SGPropertyNode_getChild (ff-pointer self) name index))

(cl:defmethod get-child ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_getChild (ff-pointer self) name))

(cl:defmethod get-child ((self sgproperty-node) name (index cl:integer) (create t))
  (SGPropertyNode_getChild (ff-pointer self) name index create))

(cl:defmethod get-child ((self sgproperty-node) name (index cl:integer))
  (SGPropertyNode_getChild (ff-pointer self) name index))

(cl:defmethod get-child ((self sgproperty-node) name)
  (SGPropertyNode_getChild (ff-pointer self) name))

(cl:defmethod get-child ((self sgproperty-node) (name cl:string) (index cl:integer))
  (SGPropertyNode_getChild (ff-pointer self) name index))

(cl:defmethod get-child ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_getChild (ff-pointer self) name))

(cl:defmethod get-child ((self sgproperty-node) name (index cl:integer))
  (SGPropertyNode_getChild (ff-pointer self) name index))

(cl:defmethod get-child ((self sgproperty-node) name)
  (SGPropertyNode_getChild (ff-pointer self) name))

(cl:defmethod get-children ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_getChildren (ff-pointer self) name))

(cl:defmethod get-children ((self sgproperty-node) name)
  (SGPropertyNode_getChildren (ff-pointer self) name))

(cl:defmethod remove-child ((self sgproperty-node) (pos cl:integer) (keep t))
  (SGPropertyNode_removeChild (ff-pointer self) pos keep))

(cl:defmethod remove-child ((self sgproperty-node) (pos cl:integer))
  (SGPropertyNode_removeChild (ff-pointer self) pos))

(cl:defmethod remove-child ((self sgproperty-node) (name cl:string) (index cl:integer) (keep t))
  (SGPropertyNode_removeChild (ff-pointer self) name index keep))

(cl:defmethod remove-child ((self sgproperty-node) (name cl:string) (index cl:integer))
  (SGPropertyNode_removeChild (ff-pointer self) name index))

(cl:defmethod remove-child ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_removeChild (ff-pointer self) name))

(cl:defmethod remove-child ((self sgproperty-node) name (index cl:integer) (keep t))
  (SGPropertyNode_removeChild (ff-pointer self) name index keep))

(cl:defmethod remove-child ((self sgproperty-node) name (index cl:integer))
  (SGPropertyNode_removeChild (ff-pointer self) name index))

(cl:defmethod remove-child ((self sgproperty-node) name)
  (SGPropertyNode_removeChild (ff-pointer self) name))

(cl:defmethod remove-children ((self sgproperty-node) (name cl:string) (keep t))
  (SGPropertyNode_removeChildren (ff-pointer self) name keep))

(cl:defmethod remove-children ((self sgproperty-node) (name cl:string))
  (SGPropertyNode_removeChildren (ff-pointer self) name))

(cl:defmethod remove-children ((self sgproperty-node) name (keep t))
  (SGPropertyNode_removeChildren (ff-pointer self) name keep))

(cl:defmethod remove-children ((self sgproperty-node) name)
  (SGPropertyNode_removeChildren (ff-pointer self) name))

(cl:defmethod alias ((self sgproperty-node) (target sgproperty-node))
  (SGPropertyNode_alias (ff-pointer self) (ff-pointer target)))

(cl:defmethod alias ((self sgproperty-node) (path cl:string))
  (SGPropertyNode_alias (ff-pointer self) path))

(cl:defmethod alias ((self sgproperty-node) path)
  (SGPropertyNode_alias (ff-pointer self) path))

(cl:defmethod unalias ((self sgproperty-node))
  (SGPropertyNode_unalias (ff-pointer self)))

(cl:defmethod is-alias ((self sgproperty-node))
  (SGPropertyNode_isAlias (ff-pointer self)))

(cl:defmethod get-alias-target ((self sgproperty-node))
  (SGPropertyNode_getAliasTarget (ff-pointer self)))

(cl:defmethod get-alias-target ((self sgproperty-node))
  (SGPropertyNode_getAliasTarget (ff-pointer self)))

(cl:defmethod get-path ((self sgproperty-node) (simplify t))
  (SGPropertyNode_getPath (ff-pointer self) simplify))

(cl:defmethod get-path ((self sgproperty-node))
  (SGPropertyNode_getPath (ff-pointer self)))

(cl:defmethod get-root-node ((self sgproperty-node))
  (SGPropertyNode_getRootNode (ff-pointer self)))

(cl:defmethod get-root-node ((self sgproperty-node))
  (SGPropertyNode_getRootNode (ff-pointer self)))

(cl:defmethod get-node ((self sgproperty-node) (relative_path cl:string) (create t))
  (SGPropertyNode_getNode (ff-pointer self) relative_path create))

(cl:defmethod get-node ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getNode (ff-pointer self) relative_path))

(cl:defmethod get-node ((self sgproperty-node) relative_path (create t))
  (SGPropertyNode_getNode (ff-pointer self) relative_path create))

(cl:defmethod get-node ((self sgproperty-node) relative_path)
  (SGPropertyNode_getNode (ff-pointer self) relative_path))

(cl:defmethod get-node ((self sgproperty-node) (relative_path cl:string) (index cl:integer) (create t))
  (SGPropertyNode_getNode (ff-pointer self) relative_path index create))

(cl:defmethod get-node ((self sgproperty-node) (relative_path cl:string) (index cl:integer))
  (SGPropertyNode_getNode (ff-pointer self) relative_path index))

(cl:defmethod get-node ((self sgproperty-node) relative_path (index cl:integer) (create t))
  (SGPropertyNode_getNode (ff-pointer self) relative_path index create))

(cl:defmethod get-node ((self sgproperty-node) relative_path (index cl:integer))
  (SGPropertyNode_getNode (ff-pointer self) relative_path index))

(cl:defmethod get-node ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getNode (ff-pointer self) relative_path))

(cl:defmethod get-node ((self sgproperty-node) relative_path)
  (SGPropertyNode_getNode (ff-pointer self) relative_path))

(cl:defmethod get-node ((self sgproperty-node) (relative_path cl:string) (index cl:integer))
  (SGPropertyNode_getNode (ff-pointer self) relative_path index))

(cl:defmethod get-node ((self sgproperty-node) relative_path (index cl:integer))
  (SGPropertyNode_getNode (ff-pointer self) relative_path index))

(cl:defmethod get-attribute ((self sgproperty-node) (attr cl:integer))
  (SGPropertyNode_getAttribute (ff-pointer self) attr))

(cl:defmethod set-attribute ((self sgproperty-node) (attr cl:integer) (state t))
  (SGPropertyNode_setAttribute (ff-pointer self) attr state))

(cl:defmethod get-attributes ((self sgproperty-node))
  (SGPropertyNode_getAttributes (ff-pointer self)))

(cl:defmethod set-attributes ((self sgproperty-node) (attr cl:integer))
  (SGPropertyNode_setAttributes (ff-pointer self) attr))

(cl:defmethod get-type ((self sgproperty-node))
  (SGPropertyNode_getType (ff-pointer self)))

(cl:defmethod get-bool-value ((self sgproperty-node))
  (SGPropertyNode_getBoolValue (ff-pointer self)))

(cl:defmethod get-int-value ((self sgproperty-node))
  (SGPropertyNode_getIntValue (ff-pointer self)))

(cl:defmethod get-long-value ((self sgproperty-node))
  (SGPropertyNode_getLongValue (ff-pointer self)))

(cl:defmethod get-float-value ((self sgproperty-node))
  (SGPropertyNode_getFloatValue (ff-pointer self)))

(cl:defmethod get-double-value ((self sgproperty-node))
  (SGPropertyNode_getDoubleValue (ff-pointer self)))

(cl:defmethod get-string-value ((self sgproperty-node))
  (SGPropertyNode_getStringValue (ff-pointer self)))

(cl:defmethod set-bool-value ((self sgproperty-node) (value t))
  (SGPropertyNode_setBoolValue (ff-pointer self) value))

(cl:defmethod set-int-value ((self sgproperty-node) (value cl:integer))
  (SGPropertyNode_setIntValue (ff-pointer self) value))

(cl:defmethod set-long-value ((self sgproperty-node) (value cl:integer))
  (SGPropertyNode_setLongValue (ff-pointer self) value))

(cl:defmethod set-float-value ((self sgproperty-node) (value cl:number))
  (SGPropertyNode_setFloatValue (ff-pointer self) value))

(cl:defmethod set-double-value ((self sgproperty-node) (value cl:number))
  (SGPropertyNode_setDoubleValue (ff-pointer self) value))

(cl:defmethod set-string-value ((self sgproperty-node) (value cl:string))
  (SGPropertyNode_setStringValue (ff-pointer self) value))

(cl:defmethod set-string-value ((self sgproperty-node) value)
  (SGPropertyNode_setStringValue (ff-pointer self) value))

(cl:defmethod set-unspecified-value ((self sgproperty-node) (value cl:string))
  (SGPropertyNode_setUnspecifiedValue (ff-pointer self) value))

(cl:defmethod print-on ((self sgproperty-node) stream)
  (SGPropertyNode_printOn (ff-pointer self) stream))

(cl:defmethod is-tied ((self sgproperty-node))
  (SGPropertyNode_isTied (ff-pointer self)))

(cl:defmethod untie ((self sgproperty-node))
  (SGPropertyNode_untie (ff-pointer self)))

(cl:defmethod get-type ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getType (ff-pointer self) relative_path))

(cl:defmethod get-type ((self sgproperty-node) relative_path)
  (SGPropertyNode_getType (ff-pointer self) relative_path))

(cl:defmethod has-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_hasValue (ff-pointer self) relative_path))

(cl:defmethod has-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_hasValue (ff-pointer self) relative_path))

(cl:defmethod get-bool-value ((self sgproperty-node) (relative_path cl:string) (defaultValue t))
  (SGPropertyNode_getBoolValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-bool-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getBoolValue (ff-pointer self) relative_path))

(cl:defmethod get-bool-value ((self sgproperty-node) relative_path (defaultValue t))
  (SGPropertyNode_getBoolValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-bool-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_getBoolValue (ff-pointer self) relative_path))

(cl:defmethod get-int-value ((self sgproperty-node) (relative_path cl:string) (defaultValue cl:integer))
  (SGPropertyNode_getIntValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-int-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getIntValue (ff-pointer self) relative_path))

(cl:defmethod get-int-value ((self sgproperty-node) relative_path (defaultValue cl:integer))
  (SGPropertyNode_getIntValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-int-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_getIntValue (ff-pointer self) relative_path))

(cl:defmethod get-long-value ((self sgproperty-node) (relative_path cl:string) (defaultValue cl:integer))
  (SGPropertyNode_getLongValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-long-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getLongValue (ff-pointer self) relative_path))

(cl:defmethod get-long-value ((self sgproperty-node) relative_path (defaultValue cl:integer))
  (SGPropertyNode_getLongValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-long-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_getLongValue (ff-pointer self) relative_path))

(cl:defmethod get-float-value ((self sgproperty-node) (relative_path cl:string) (defaultValue cl:number))
  (SGPropertyNode_getFloatValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-float-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getFloatValue (ff-pointer self) relative_path))

(cl:defmethod get-float-value ((self sgproperty-node) relative_path (defaultValue cl:number))
  (SGPropertyNode_getFloatValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-float-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_getFloatValue (ff-pointer self) relative_path))

(cl:defmethod get-double-value ((self sgproperty-node) (relative_path cl:string) (defaultValue cl:number))
  (SGPropertyNode_getDoubleValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-double-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getDoubleValue (ff-pointer self) relative_path))

(cl:defmethod get-double-value ((self sgproperty-node) relative_path (defaultValue cl:number))
  (SGPropertyNode_getDoubleValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-double-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_getDoubleValue (ff-pointer self) relative_path))

(cl:defmethod get-string-value ((self sgproperty-node) (relative_path cl:string) (defaultValue cl:string))
  (SGPropertyNode_getStringValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-string-value ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_getStringValue (ff-pointer self) relative_path))

(cl:defmethod get-string-value ((self sgproperty-node) relative_path (defaultValue cl:string))
  (SGPropertyNode_getStringValue (ff-pointer self) relative_path defaultValue))

(cl:defmethod get-string-value ((self sgproperty-node) relative_path)
  (SGPropertyNode_getStringValue (ff-pointer self) relative_path))

(cl:defmethod set-bool-value ((self sgproperty-node) (relative_path cl:string) (value t))
  (SGPropertyNode_setBoolValue (ff-pointer self) relative_path value))

(cl:defmethod set-bool-value ((self sgproperty-node) relative_path (value t))
  (SGPropertyNode_setBoolValue (ff-pointer self) relative_path value))

(cl:defmethod set-int-value ((self sgproperty-node) (relative_path cl:string) (value cl:integer))
  (SGPropertyNode_setIntValue (ff-pointer self) relative_path value))

(cl:defmethod set-int-value ((self sgproperty-node) relative_path (value cl:integer))
  (SGPropertyNode_setIntValue (ff-pointer self) relative_path value))

(cl:defmethod set-long-value ((self sgproperty-node) (relative_path cl:string) (value cl:integer))
  (SGPropertyNode_setLongValue (ff-pointer self) relative_path value))

(cl:defmethod set-long-value ((self sgproperty-node) relative_path (value cl:integer))
  (SGPropertyNode_setLongValue (ff-pointer self) relative_path value))

(cl:defmethod set-float-value ((self sgproperty-node) (relative_path cl:string) (value cl:number))
  (SGPropertyNode_setFloatValue (ff-pointer self) relative_path value))

(cl:defmethod set-float-value ((self sgproperty-node) relative_path (value cl:number))
  (SGPropertyNode_setFloatValue (ff-pointer self) relative_path value))

(cl:defmethod set-double-value ((self sgproperty-node) (relative_path cl:string) (value cl:number))
  (SGPropertyNode_setDoubleValue (ff-pointer self) relative_path value))

(cl:defmethod set-double-value ((self sgproperty-node) relative_path (value cl:number))
  (SGPropertyNode_setDoubleValue (ff-pointer self) relative_path value))

(cl:defmethod set-string-value ((self sgproperty-node) (relative_path cl:string) (value cl:string))
  (SGPropertyNode_setStringValue (ff-pointer self) relative_path value))

(cl:defmethod set-string-value ((self sgproperty-node) (relative_path cl:string) value)
  (SGPropertyNode_setStringValue (ff-pointer self) relative_path value))

(cl:defmethod set-string-value ((self sgproperty-node) relative_path (value cl:string))
  (SGPropertyNode_setStringValue (ff-pointer self) relative_path value))

(cl:defmethod set-string-value ((self sgproperty-node) relative_path value)
  (SGPropertyNode_setStringValue (ff-pointer self) relative_path value))

(cl:defmethod set-unspecified-value ((self sgproperty-node) (relative_path cl:string) (value cl:string))
  (SGPropertyNode_setUnspecifiedValue (ff-pointer self) relative_path value))

(cl:defmethod is-tied ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_isTied (ff-pointer self) relative_path))

(cl:defmethod is-tied ((self sgproperty-node) relative_path)
  (SGPropertyNode_isTied (ff-pointer self) relative_path))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) (relative_path cl:string) rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue (useDefault t))
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue useDefault))

(cl:defmethod tie ((self sgproperty-node) relative_path rawValue)
  (SGPropertyNode_tie (ff-pointer self) relative_path rawValue))

(cl:defmethod untie ((self sgproperty-node) (relative_path cl:string))
  (SGPropertyNode_untie (ff-pointer self) relative_path))

(cl:defmethod untie ((self sgproperty-node) relative_path)
  (SGPropertyNode_untie (ff-pointer self) relative_path))

(cl:defmethod add-change-listener ((self sgproperty-node) (listener sgproperty-change-listener) (initial t))
  (SGPropertyNode_addChangeListener (ff-pointer self) listener initial))

(cl:defmethod add-change-listener ((self sgproperty-node) (listener sgproperty-change-listener))
  (SGPropertyNode_addChangeListener (ff-pointer self) listener))

(cl:defmethod remove-change-listener ((self sgproperty-node) (listener sgproperty-change-listener))
  (SGPropertyNode_removeChangeListener (ff-pointer self) listener))

(cl:defmethod n-listeners ((self sgproperty-node))
  (SGPropertyNode_nListeners (ff-pointer self)))

(cl:defmethod fire-value-changed ((self sgproperty-node))
  (SGPropertyNode_fireValueChanged (ff-pointer self)))

(cl:defmethod fire-child-added ((self sgproperty-node) (child sgproperty-node))
  (SGPropertyNode_fireChildAdded (ff-pointer self) (ff-pointer child)))

(cl:defmethod fire-child-removed ((self sgproperty-node) (child sgproperty-node))
  (SGPropertyNode_fireChildRemoved (ff-pointer self) (ff-pointer child)))

(cl:defmethod clear-value ((self sgproperty-node))
  (SGPropertyNode_clearValue (ff-pointer self)))


(cl:defclass sgroute()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgroute) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGRoute)))

(cl:defmethod clear ((self sgroute))
  (SGRoute_clear (ff-pointer self)))

(cl:defmethod add-waypoint ((self sgroute) wp (n cl:integer))
  (SGRoute_add_waypoint (ff-pointer self) wp n))

(cl:defmethod add-waypoint ((self sgroute) wp)
  (SGRoute_add_waypoint (ff-pointer self) wp))

(cl:defmethod size ((self sgroute))
  (SGRoute_size (ff-pointer self)))

(cl:defmethod get-first ((self sgroute))
  (SGRoute_get_first (ff-pointer self)))

(cl:defmethod get-current ((self sgroute))
  (SGRoute_get_current (ff-pointer self)))

(cl:defmethod get-previous ((self sgroute))
  (SGRoute_get_previous (ff-pointer self)))

(cl:defmethod get-next ((self sgroute))
  (SGRoute_get_next (ff-pointer self)))

(cl:defmethod set-current ((self sgroute) (n cl:integer))
  (SGRoute_set_current (ff-pointer self) n))

(cl:defmethod current-index ((self sgroute))
  (SGRoute_current_index (ff-pointer self)))

(cl:defmethod increment-current ((self sgroute))
  (SGRoute_increment_current (ff-pointer self)))

(cl:defmethod get-waypoint ((self sgroute) (n cl:integer))
  (SGRoute_get_waypoint (ff-pointer self) n))

(cl:defmethod delete-first ((self sgroute))
  (SGRoute_delete_first (ff-pointer self)))

(cl:defmethod delete-waypoint ((self sgroute) (n cl:integer))
  (SGRoute_delete_waypoint (ff-pointer self) n))

(cl:defmethod delete-waypoint ((self sgroute))
  (SGRoute_delete_waypoint (ff-pointer self)))

(cl:defmethod total-distance ((self sgroute))
  (SGRoute_total_distance (ff-pointer self)))


(cl:defclass sgway-point()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (lon cl:number) (lat cl:number) (alt cl:number) (m cl:integer) s n)
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint lon lat alt m s n)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (lon cl:number) (lat cl:number) (alt cl:number) (m cl:integer) s)
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint lon lat alt m s)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (lon cl:number) (lat cl:number) (alt cl:number) (m cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint lon lat alt m)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (lon cl:number) (lat cl:number) (alt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint lon lat alt)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (lon cl:number) (lat cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint lon lat)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (lon cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint lon)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint)))

(cl:defmethod initialize-instance :after ((obj sgway-point) &key (pos sggeod) s n)
  (setf (slot-value obj 'ff-pointer) (new_SGWayPoint pos s n)))

(cl:defmethod course-and-distance ((self sgway-point) (cur_lon cl:number) (cur_lat cl:number) (cur_alt cl:number) course dist)
  (SGWayPoint_CourseAndDistance (ff-pointer self) cur_lon cur_lat cur_alt course dist))

(cl:defmethod course-and-distance ((self sgway-point) (current sggeod) course dist)
  (SGWayPoint_CourseAndDistance (ff-pointer self) current course dist))

(cl:defmethod course-and-distance ((self sgway-point) (wp sgway-point) course dist)
  (SGWayPoint_CourseAndDistance (ff-pointer self) (ff-pointer wp) course dist))

(cl:defmethod get-target-lon ((self sgway-point))
  (SGWayPoint_get_target_lon (ff-pointer self)))

(cl:defmethod get-target-lat ((self sgway-point))
  (SGWayPoint_get_target_lat (ff-pointer self)))

(cl:defmethod get-target-alt ((self sgway-point))
  (SGWayPoint_get_target_alt (ff-pointer self)))

(cl:defmethod get-target ((self sgway-point))
  (SGWayPoint_get_target (ff-pointer self)))

(cl:defmethod set-target-alt-ft ((self sgway-point) (elev cl:number))
  (SGWayPoint_setTargetAltFt (ff-pointer self) elev))

(cl:defmethod get-distance ((self sgway-point))
  (SGWayPoint_get_distance (ff-pointer self)))

(cl:defmethod set-distance ((self sgway-point) (d cl:number))
  (SGWayPoint_set_distance (ff-pointer self) d))

(cl:defmethod get-track ((self sgway-point))
  (SGWayPoint_get_track (ff-pointer self)))

(cl:defmethod set-track ((self sgway-point) (t-arg1 cl:number))
  (SGWayPoint_set_track (ff-pointer self) t-arg1))

(cl:defmethod get-speed ((self sgway-point))
  (SGWayPoint_get_speed (ff-pointer self)))

(cl:defmethod set-speed ((self sgway-point) (v cl:number))
  (SGWayPoint_set_speed (ff-pointer self) v))

(cl:defmethod get-id ((self sgway-point))
  (SGWayPoint_get_id (ff-pointer self)))

(cl:defmethod get-name ((self sgway-point))
  (SGWayPoint_get_name (ff-pointer self)))


(cl:defclass effect-cull-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj effect-cull-visitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_EffectCullVisitor)))

(cl:defmethod initialize-instance :after ((obj effect-cull-visitor) &key (arg0 effect-cull-visitor))
  (setf (slot-value obj 'ff-pointer) (new_EffectCullVisitor (ff-pointer arg0))))

(cl:defmethod clone ((self effect-cull-visitor))
  (EffectCullVisitor_clone (ff-pointer self)))

(cl:defmethod apply ((self effect-cull-visitor) node)
  (EffectCullVisitor_apply (ff-pointer self) node))


(cl:defclass pass()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj pass) &key)
  (setf (slot-value obj 'ff-pointer) (new_Pass)))

(cl:defmethod initialize-instance :after ((obj pass) &key rhs copyop)
  (setf (slot-value obj 'ff-pointer) (new_Pass rhs copyop)))

(cl:defmethod initialize-instance :after ((obj pass) &key rhs)
  (setf (slot-value obj 'ff-pointer) (new_Pass rhs)))


(cl:defclass sgmaterial()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmaterial) &key arg0 (props sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGMaterial arg0 props)))

(cl:defmethod initialize-instance :after ((obj sgmaterial) &key arg0 (props sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGMaterial arg0 props)))

(cl:defmethod get-effect ((self sgmaterial) (n cl:integer))
  (SGMaterial_get_effect (ff-pointer self) n))

(cl:defmethod get-effect ((self sgmaterial))
  (SGMaterial_get_effect (ff-pointer self)))

(cl:defmethod get-num ((self sgmaterial))
  (SGMaterial_get_num (ff-pointer self)))

(cl:defmethod get-xsize ((self sgmaterial))
  (SGMaterial_get_xsize (ff-pointer self)))

(cl:defmethod get-ysize ((self sgmaterial))
  (SGMaterial_get_ysize (ff-pointer self)))

(cl:defmethod get-light-coverage ((self sgmaterial))
  (SGMaterial_get_light_coverage (ff-pointer self)))

(cl:defmethod get-wood-coverage ((self sgmaterial))
  (SGMaterial_get_wood_coverage (ff-pointer self)))

(cl:defmethod get-tree-density ((self sgmaterial))
  (SGMaterial_get_tree_density (ff-pointer self)))

(cl:defmethod get-wood-size ((self sgmaterial))
  (SGMaterial_get_wood_size (ff-pointer self)))

(cl:defmethod get-tree-height ((self sgmaterial))
  (SGMaterial_get_tree_height (ff-pointer self)))

(cl:defmethod get-tree-width ((self sgmaterial))
  (SGMaterial_get_tree_width (ff-pointer self)))

(cl:defmethod get-tree-range ((self sgmaterial))
  (SGMaterial_get_tree_range (ff-pointer self)))

(cl:defmethod get-tree-varieties ((self sgmaterial))
  (SGMaterial_get_tree_varieties (ff-pointer self)))

(cl:defmethod get-tree-texture ((self sgmaterial))
  (SGMaterial_get_tree_texture (ff-pointer self)))

(cl:defmethod get-solid ((self sgmaterial))
  (SGMaterial_get_solid (ff-pointer self)))

(cl:defmethod get-friction-factor ((self sgmaterial))
  (SGMaterial_get_friction_factor (ff-pointer self)))

(cl:defmethod get-rolling-friction ((self sgmaterial))
  (SGMaterial_get_rolling_friction (ff-pointer self)))

(cl:defmethod get-bumpiness ((self sgmaterial))
  (SGMaterial_get_bumpiness (ff-pointer self)))

(cl:defmethod get-load-resistance ((self sgmaterial))
  (SGMaterial_get_load_resistance (ff-pointer self)))

(cl:defmethod get-names ((self sgmaterial))
  (SGMaterial_get_names (ff-pointer self)))

(cl:defmethod add-name ((self sgmaterial) name)
  (SGMaterial_add_name (ff-pointer self) name))

(cl:defmethod get-object-group-count ((self sgmaterial))
  (SGMaterial_get_object_group_count (ff-pointer self)))

(cl:defmethod get-object-group ((self sgmaterial) (index cl:integer))
  (SGMaterial_get_object_group (ff-pointer self) index))

(cl:defmethod get-glyph ((self sgmaterial) name)
  (SGMaterial_get_glyph (ff-pointer self) name))

(cl:defmethod set-light-color ((self sgmaterial) color)
  (SGMaterial_set_light_color (ff-pointer self) color))

(cl:defmethod get-light-color ((self sgmaterial))
  (SGMaterial_get_light_color (ff-pointer self)))

(cl:defmethod get-tex-coord-scale ((self sgmaterial))
  (SGMaterial_get_tex_coord_scale (ff-pointer self)))


(cl:defclass sgmaterial-glyph()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmaterial-glyph) &key (arg0 sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGMaterialGlyph arg0)))

(cl:defmethod get-left ((self sgmaterial-glyph))
  (SGMaterialGlyph_get_left (ff-pointer self)))

(cl:defmethod get-right ((self sgmaterial-glyph))
  (SGMaterialGlyph_get_right (ff-pointer self)))

(cl:defmethod get-width ((self sgmaterial-glyph))
  (SGMaterialGlyph_get_width (ff-pointer self)))


(cl:defclass sgmaterial-user-data()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmaterial-user-data) &key (material sgmaterial))
  (setf (slot-value obj 'ff-pointer) (new_SGMaterialUserData material)))

(cl:defmethod get-material ((self sgmaterial-user-data))
  (SGMaterialUserData_getMaterial (ff-pointer self)))


(cl:defclass sgmat-model()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod get-model-count ((self sgmat-model) (prop_root sgproperty-node))
  (SGMatModel_get_model_count (ff-pointer self) prop_root))

(cl:defmethod get-random-model ((self sgmat-model) (prop_root sgproperty-node) seed)
  (SGMatModel_get_random_model (ff-pointer self) prop_root seed))

(cl:defmethod get-coverage-m2 ((self sgmat-model))
  (SGMatModel_get_coverage_m2 (ff-pointer self)))

(cl:defmethod get-range-m ((self sgmat-model))
  (SGMatModel_get_range_m (ff-pointer self)))

(cl:defmethod get-randomized-range-m ((self sgmat-model) seed)
  (SGMatModel_get_randomized_range_m (ff-pointer self) seed))

(cl:defmethod get-heading-type ((self sgmat-model))
  (SGMatModel_get_heading_type (ff-pointer self)))


(cl:defclass sgmat-model-group()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod get-range-m ((self sgmat-model-group))
  (SGMatModelGroup_get_range_m (ff-pointer self)))

(cl:defmethod get-object-count ((self sgmat-model-group))
  (SGMatModelGroup_get_object_count (ff-pointer self)))

(cl:defmethod get-object ((self sgmat-model-group) (index cl:integer))
  (SGMatModelGroup_get_object (ff-pointer self) index))


(cl:defclass check-scenery-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj check-scenery-visitor) &key dbp position (range cl:number) framestamp)
  (setf (slot-value obj 'ff-pointer) (new_CheckSceneryVisitor dbp position range framestamp)))

(cl:defmethod apply ((self check-scenery-visitor) node)
  (CheckSceneryVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self check-scenery-visitor) node)
  (CheckSceneryVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self check-scenery-visitor) node)
  (CheckSceneryVisitor_apply (ff-pointer self) node))

(cl:defmethod is-loaded ((self check-scenery-visitor))
  (CheckSceneryVisitor_isLoaded (ff-pointer self)))

(cl:defmethod set-loaded ((self check-scenery-visitor) (l t))
  (CheckSceneryVisitor_setLoaded (ff-pointer self) l))

(cl:defmethod get-position ((self check-scenery-visitor))
  (CheckSceneryVisitor_getPosition (ff-pointer self)))


(cl:defclass condition-node()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj condition-node) &key)
  (setf (slot-value obj 'ff-pointer) (new_ConditionNode)))

(cl:defmethod initialize-instance :after ((obj condition-node) &key (rhs condition-node) op)
  (setf (slot-value obj 'ff-pointer) (new_ConditionNode (ff-pointer rhs) op)))

(cl:defmethod initialize-instance :after ((obj condition-node) &key (rhs condition-node))
  (setf (slot-value obj 'ff-pointer) (new_ConditionNode (ff-pointer rhs))))

(cl:defmethod get-condition ((self condition-node))
  (ConditionNode_getCondition (ff-pointer self)))

(cl:defmethod set-condition ((self condition-node) (condition sgcondition))
  (ConditionNode_setCondition (ff-pointer self) condition))

(cl:defmethod traverse ((self condition-node) nv)
  (ConditionNode_traverse (ff-pointer self) nv))


(cl:defclass optimize-model-policy()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj optimize-model-policy) &key extension)
  (setf (slot-value obj 'ff-pointer) (new_OptimizeModelPolicy extension)))

(cl:defmethod optimize ((self optimize-model-policy) node fileName opt)
  (OptimizeModelPolicy_optimize (ff-pointer self) node fileName opt))


(cl:defclass model-registry()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj model-registry) &key)
  (setf (slot-value obj 'ff-pointer) (new_ModelRegistry)))

(cl:defmethod read-image ((self model-registry) fileName opt)
  (ModelRegistry_readImage (ff-pointer self) fileName opt))

(cl:defmethod read-node ((self model-registry) fileName opt)
  (ModelRegistry_readNode (ff-pointer self) fileName opt))

(cl:defmethod add-image-callback-for-extension ((self model-registry) extension callback)
  (ModelRegistry_addImageCallbackForExtension (ff-pointer self) extension callback))

(cl:defmethod add-node-callback-for-extension ((self model-registry) extension callback)
  (ModelRegistry_addNodeCallbackForExtension (ff-pointer self) extension callback))


(cl:defclass sgclip-group()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgclip-group) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGClipGroup)))

(cl:defmethod initialize-instance :after ((obj sgclip-group) &key (arg0 sgclip-group) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGClipGroup (ff-pointer arg0) copyop)))

(cl:defmethod initialize-instance :after ((obj sgclip-group) &key (arg0 sgclip-group))
  (setf (slot-value obj 'ff-pointer) (new_SGClipGroup (ff-pointer arg0))))

(cl:defmethod compute-bound ((self sgclip-group))
  (SGClipGroup_computeBound (ff-pointer self)))

(cl:defmethod add-clip-plane ((self sgclip-group) (num cl:integer) p0 p1)
  (SGClipGroup_addClipPlane (ff-pointer self) num p0 p1))

(cl:defmethod set-draw-area ((self sgclip-group) lowerLeft upperRight)
  (SGClipGroup_setDrawArea (ff-pointer self) lowerLeft upperRight))

(cl:defmethod set-draw-area ((self sgclip-group) bottomLeft topLeft bottomRight topRight)
  (SGClipGroup_setDrawArea (ff-pointer self) bottomLeft topLeft bottomRight topRight))


(cl:defclass sginteraction-animation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sginteraction-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGInteractionAnimation configNode modelRoot)))

(cl:defmethod install ((self sginteraction-animation) node)
  (SGInteractionAnimation_install (ff-pointer self) node))


(cl:defclass sgmaterial-animation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmaterial-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node) options)
  (setf (slot-value obj 'ff-pointer) (new_SGMaterialAnimation configNode modelRoot options)))

(cl:defmethod create-animation-group ((self sgmaterial-animation) parent)
  (SGMaterialAnimation_createAnimationGroup (ff-pointer self) parent))

(cl:defmethod install ((self sgmaterial-animation) node)
  (SGMaterialAnimation_install (ff-pointer self) node))


(cl:defclass sgoffset-transform()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgoffset-transform) &key (scaleFactor cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SGOffsetTransform scaleFactor)))

(cl:defmethod initialize-instance :after ((obj sgoffset-transform) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGOffsetTransform)))

(cl:defmethod initialize-instance :after ((obj sgoffset-transform) &key (arg0 sgoffset-transform) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGOffsetTransform (ff-pointer arg0) copyop)))

(cl:defmethod initialize-instance :after ((obj sgoffset-transform) &key (arg0 sgoffset-transform))
  (setf (slot-value obj 'ff-pointer) (new_SGOffsetTransform (ff-pointer arg0))))

(cl:defmethod get-scale-factor ((self sgoffset-transform))
  (SGOffsetTransform_getScaleFactor (ff-pointer self)))

(cl:defmethod set-scale-factor ((self sgoffset-transform) (scaleFactor cl:number))
  (SGOffsetTransform_setScaleFactor (ff-pointer self) scaleFactor))

(cl:defmethod compute-local-to-world-matrix ((self sgoffset-transform) matrix nv)
  (SGOffsetTransform_computeLocalToWorldMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-world-to-local-matrix ((self sgoffset-transform) matrix nv)
  (SGOffsetTransform_computeWorldToLocalMatrix (ff-pointer self) matrix nv))


(cl:defclass sgpaged-lod()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgpaged-lod) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGPagedLOD)))

(cl:defmethod initialize-instance :after ((obj sgpaged-lod) &key (arg0 sgpaged-lod) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGPagedLOD (ff-pointer arg0) copyop)))

(cl:defmethod initialize-instance :after ((obj sgpaged-lod) &key (arg0 sgpaged-lod))
  (setf (slot-value obj 'ff-pointer) (new_SGPagedLOD (ff-pointer arg0))))

(cl:defmethod force-load ((self sgpaged-lod) dbp framestamp path)
  (SGPagedLOD_forceLoad (ff-pointer self) dbp framestamp path))

(cl:defmethod add-child ((self sgpaged-lod) child)
  (SGPagedLOD_addChild (ff-pointer self) child))

(cl:defmethod set-reader-writer-options ((self sgpaged-lod) options)
  (SGPagedLOD_setReaderWriterOptions (ff-pointer self) options))

(cl:defmethod get-reader-writer-options ((self sgpaged-lod))
  (SGPagedLOD_getReaderWriterOptions (ff-pointer self)))


(cl:defclass sgreader-writer-xmloptions()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-xmloptions) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterXMLOptions)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-xmloptions) &key str)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterXMLOptions str)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-xmloptions) &key (options sgreader-writer-xmloptions) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterXMLOptions (ff-pointer options) copyop)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-xmloptions) &key (options sgreader-writer-xmloptions))
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterXMLOptions (ff-pointer options))))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-xmloptions) &key options copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterXMLOptions options copyop)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-xmloptions) &key options)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterXMLOptions options)))

(cl:defmethod get-prop-root ((self sgreader-writer-xmloptions))
  (SGReaderWriterXMLOptions_getPropRoot (ff-pointer self)))

(cl:defmethod get-load-panel ((self sgreader-writer-xmloptions))
  (SGReaderWriterXMLOptions_getLoadPanel (ff-pointer self)))

(cl:defmethod get-model-data ((self sgreader-writer-xmloptions))
  (SGReaderWriterXMLOptions_getModelData (ff-pointer self)))

(cl:defmethod get-instantiate-effects ((self sgreader-writer-xmloptions))
  (SGReaderWriterXMLOptions_getInstantiateEffects (ff-pointer self)))

(cl:defmethod set-prop-root ((self sgreader-writer-xmloptions) (p sgproperty-node))
  (SGReaderWriterXMLOptions_setPropRoot (ff-pointer self) p))

(cl:defmethod set-load-panel ((self sgreader-writer-xmloptions) pf)
  (SGReaderWriterXMLOptions_setLoadPanel (ff-pointer self) pf))

(cl:defmethod set-model-data ((self sgreader-writer-xmloptions) d)
  (SGReaderWriterXMLOptions_setModelData (ff-pointer self) d))

(cl:defmethod set-instantiate-effects ((self sgreader-writer-xmloptions) (doit t))
  (SGReaderWriterXMLOptions_setInstantiateEffects (ff-pointer self) doit))


(cl:defclass sgrotate-transform()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgrotate-transform) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGRotateTransform)))

(cl:defmethod initialize-instance :after ((obj sgrotate-transform) &key (arg0 sgrotate-transform) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGRotateTransform (ff-pointer arg0) copyop)))

(cl:defmethod initialize-instance :after ((obj sgrotate-transform) &key (arg0 sgrotate-transform))
  (setf (slot-value obj 'ff-pointer) (new_SGRotateTransform (ff-pointer arg0))))

(cl:defmethod set-center ((self sgrotate-transform) center)
  (SGRotateTransform_setCenter (ff-pointer self) center))

(cl:defmethod set-center ((self sgrotate-transform) center)
  (SGRotateTransform_setCenter (ff-pointer self) center))

(cl:defmethod get-center ((self sgrotate-transform))
  (SGRotateTransform_getCenter (ff-pointer self)))

(cl:defmethod set-axis ((self sgrotate-transform) axis)
  (SGRotateTransform_setAxis (ff-pointer self) axis))

(cl:defmethod set-axis ((self sgrotate-transform) axis)
  (SGRotateTransform_setAxis (ff-pointer self) axis))

(cl:defmethod get-axis ((self sgrotate-transform))
  (SGRotateTransform_getAxis (ff-pointer self)))

(cl:defmethod set-angle-rad ((self sgrotate-transform) (angle cl:number))
  (SGRotateTransform_setAngleRad (ff-pointer self) angle))

(cl:defmethod get-angle-rad ((self sgrotate-transform))
  (SGRotateTransform_getAngleRad (ff-pointer self)))

(cl:defmethod set-angle-deg ((self sgrotate-transform) (angle cl:number))
  (SGRotateTransform_setAngleDeg (ff-pointer self) angle))

(cl:defmethod get-angle-deg ((self sgrotate-transform))
  (SGRotateTransform_getAngleDeg (ff-pointer self)))

(cl:defmethod compute-local-to-world-matrix ((self sgrotate-transform) matrix nv)
  (SGRotateTransform_computeLocalToWorldMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-world-to-local-matrix ((self sgrotate-transform) matrix nv)
  (SGRotateTransform_computeWorldToLocalMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-bound ((self sgrotate-transform))
  (SGRotateTransform_computeBound (ff-pointer self)))


(cl:defclass sgscale-transform()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgscale-transform) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGScaleTransform)))

(cl:defmethod initialize-instance :after ((obj sgscale-transform) &key (arg0 sgscale-transform) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGScaleTransform (ff-pointer arg0) copyop)))

(cl:defmethod initialize-instance :after ((obj sgscale-transform) &key (arg0 sgscale-transform))
  (setf (slot-value obj 'ff-pointer) (new_SGScaleTransform (ff-pointer arg0))))

(cl:defmethod set-center ((self sgscale-transform) center)
  (SGScaleTransform_setCenter (ff-pointer self) center))

(cl:defmethod set-center ((self sgscale-transform) center)
  (SGScaleTransform_setCenter (ff-pointer self) center))

(cl:defmethod get-center ((self sgscale-transform))
  (SGScaleTransform_getCenter (ff-pointer self)))

(cl:defmethod set-scale-factor ((self sgscale-transform) scaleFactor)
  (SGScaleTransform_setScaleFactor (ff-pointer self) scaleFactor))

(cl:defmethod set-scale-factor ((self sgscale-transform) (scaleFactor cl:number))
  (SGScaleTransform_setScaleFactor (ff-pointer self) scaleFactor))

(cl:defmethod get-scale-factor ((self sgscale-transform))
  (SGScaleTransform_getScaleFactor (ff-pointer self)))

(cl:defmethod compute-local-to-world-matrix ((self sgscale-transform) matrix nv)
  (SGScaleTransform_computeLocalToWorldMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-world-to-local-matrix ((self sgscale-transform) matrix nv)
  (SGScaleTransform_computeWorldToLocalMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-bound ((self sgscale-transform))
  (SGScaleTransform_computeBound (ff-pointer self)))


(cl:defclass sgtext()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtext) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGText)))


(cl:defclass sgtranslate-transform()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtranslate-transform) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGTranslateTransform)))

(cl:defmethod initialize-instance :after ((obj sgtranslate-transform) &key (arg0 sgtranslate-transform) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGTranslateTransform (ff-pointer arg0) copyop)))

(cl:defmethod initialize-instance :after ((obj sgtranslate-transform) &key (arg0 sgtranslate-transform))
  (setf (slot-value obj 'ff-pointer) (new_SGTranslateTransform (ff-pointer arg0))))

(cl:defmethod set-axis ((self sgtranslate-transform) axis)
  (SGTranslateTransform_setAxis (ff-pointer self) axis))

(cl:defmethod get-axis ((self sgtranslate-transform))
  (SGTranslateTransform_getAxis (ff-pointer self)))

(cl:defmethod set-value ((self sgtranslate-transform) (value cl:number))
  (SGTranslateTransform_setValue (ff-pointer self) value))

(cl:defmethod get-value ((self sgtranslate-transform))
  (SGTranslateTransform_getValue (ff-pointer self)))

(cl:defmethod compute-local-to-world-matrix ((self sgtranslate-transform) matrix nv)
  (SGTranslateTransform_computeLocalToWorldMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-world-to-local-matrix ((self sgtranslate-transform) matrix nv)
  (SGTranslateTransform_computeWorldToLocalMatrix (ff-pointer self) matrix nv))

(cl:defmethod compute-bound ((self sgtranslate-transform))
  (SGTranslateTransform_computeBound (ff-pointer self)))


(cl:defclass sganimation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sganimation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGAnimation configNode modelRoot)))


(cl:defclass sggroup-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sggroup-animation) &key (arg0 sgproperty-node) (arg1 sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGGroupAnimation arg0 arg1)))

(cl:defmethod create-animation-group ((self sggroup-animation) parent)
  (SGGroupAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgtranslate-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtranslate-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGTranslateAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgtranslate-animation) parent)
  (SGTranslateAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgrotate-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgrotate-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGRotateAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgrotate-animation) parent)
  (SGRotateAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgscale-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgscale-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGScaleAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgscale-animation) parent)
  (SGScaleAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgdist-scale-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgdist-scale-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGDistScaleAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgdist-scale-animation) parent)
  (SGDistScaleAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgflash-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgflash-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGFlashAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgflash-animation) parent)
  (SGFlashAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgbillboard-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgbillboard-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGBillboardAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgbillboard-animation) parent)
  (SGBillboardAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgrange-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgrange-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGRangeAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgrange-animation) parent)
  (SGRangeAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgselect-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgselect-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGSelectAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgselect-animation) parent)
  (SGSelectAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgalpha-test-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgalpha-test-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGAlphaTestAnimation configNode modelRoot)))

(cl:defmethod install ((self sgalpha-test-animation) node)
  (SGAlphaTestAnimation_install (ff-pointer self) node))


(cl:defclass sgblend-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgblend-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGBlendAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgblend-animation) parent)
  (SGBlendAnimation_createAnimationGroup (ff-pointer self) parent))

(cl:defmethod install ((self sgblend-animation) node)
  (SGBlendAnimation_install (ff-pointer self) node))


(cl:defclass sgtimed-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtimed-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGTimedAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgtimed-animation) parent)
  (SGTimedAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgshadow-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgshadow-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGShadowAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgshadow-animation) parent)
  (SGShadowAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgtex-transform-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtex-transform-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGTexTransformAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgtex-transform-animation) parent)
  (SGTexTransformAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgshader-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgshader-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node) options)
  (setf (slot-value obj 'ff-pointer) (new_SGShaderAnimation configNode modelRoot options)))

(cl:defmethod create-animation-group ((self sgshader-animation) parent)
  (SGShaderAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass sgpick-animation(SGAnimation)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgpick-animation) &key (configNode sgproperty-node) (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGPickAnimation configNode modelRoot)))

(cl:defmethod create-animation-group ((self sgpick-animation) parent)
  (SGPickAnimation_createAnimationGroup (ff-pointer self) parent))


(cl:defclass texture-update-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj texture-update-visitor) &key pathList)
  (setf (slot-value obj 'ff-pointer) (new_TextureUpdateVisitor pathList)))

(cl:defmethod apply ((self texture-update-visitor) node)
  (TextureUpdateVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self texture-update-visitor) drawable)
  (TextureUpdateVisitor_apply (ff-pointer self) drawable))


(cl:defclass user-data-copy-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj user-data-copy-visitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_UserDataCopyVisitor)))

(cl:defmethod apply ((self user-data-copy-visitor) node)
  (UserDataCopyVisitor_apply (ff-pointer self) node))


(cl:defclass sgmodel-lib()
  ((ff-pointer :reader ff-pointer)))


(cl:defclass sgmodel-data()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod model-loaded ((self sgmodel-data) path (prop sgproperty-node) branch)
  (SGModelData_modelLoaded (ff-pointer self) path prop branch))


(cl:defclass global-particle-callback()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj global-particle-callback) &key (modelRoot sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_GlobalParticleCallback modelRoot)))

(cl:shadow "()")
(cl:defmethod () ((self global-particle-callback) node nv)
  (GlobalParticleCallback___funcall__ (ff-pointer self) node nv))


(cl:defclass particles()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj particles) &key)
  (setf (slot-value obj 'ff-pointer) (new_Particles)))

(cl:shadow "()")
(cl:defmethod () ((self particles) node nv)
  (Particles___funcall__ (ff-pointer self) node nv))

(cl:defmethod setup-shooter-speed-data ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node))
  (Particles_setupShooterSpeedData (ff-pointer self) configNode modelRoot))

(cl:defmethod setup-counter-data ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node))
  (Particles_setupCounterData (ff-pointer self) configNode modelRoot))

(cl:defmethod setup-counter-condition ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node))
  (Particles_setupCounterCondition (ff-pointer self) configNode modelRoot))

(cl:defmethod setup-counter-condition ((self particles) (counterStaticValue cl:number) (counterStaticExtraRange cl:number))
  (Particles_setupCounterCondition (ff-pointer self) counterStaticValue counterStaticExtraRange))

(cl:defmethod setup-start-size-data ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node))
  (Particles_setupStartSizeData (ff-pointer self) configNode modelRoot))

(cl:defmethod setup-end-size-data ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node))
  (Particles_setupEndSizeData (ff-pointer self) configNode modelRoot))

(cl:defmethod setup-life-data ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node))
  (Particles_setupLifeData (ff-pointer self) configNode modelRoot))

(cl:defmethod setup-static-size-data ((self particles) (startSize cl:number) (endSize cl:number))
  (Particles_setupStaticSizeData (ff-pointer self) startSize endSize))

(cl:defmethod set-general-data ((self particles) shooter counter particleSys program)
  (Particles_setGeneralData (ff-pointer self) shooter counter particleSys program))

(cl:defmethod setup-program-gravity ((self particles) (useGravity t))
  (Particles_setupProgramGravity (ff-pointer self) useGravity))

(cl:defmethod setup-program-wind ((self particles) (useWind t))
  (Particles_setupProgramWind (ff-pointer self) useWind))

(cl:defmethod setup-color-component ((self particles) (configNode sgproperty-node) (modelRoot sgproperty-node) (color cl:integer) (component cl:integer))
  (Particles_setupColorComponent (ff-pointer self) configNode modelRoot color component))

(cl:defmethod setup-static-color-component ((self particles) (r1 cl:number) (g1 cl:number) (b1 cl:number) (a1 cl:number) (r2 cl:number) (g2 cl:number) (b2 cl:number) (a2 cl:number))
  (Particles_setupStaticColorComponent (ff-pointer self) r1 g1 b1 a1 r2 g2 b2 a2))


(cl:defclass sgmodel-placement()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmodel-placement) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGModelPlacement)))

(cl:defmethod init ((self sgmodel-placement) model)
  (SGModelPlacement_init (ff-pointer self) model))

(cl:defmethod update ((self sgmodel-placement))
  (SGModelPlacement_update (ff-pointer self)))

(cl:defmethod get-scene-graph ((self sgmodel-placement))
  (SGModelPlacement_getSceneGraph (ff-pointer self)))

(cl:defmethod get-visible ((self sgmodel-placement))
  (SGModelPlacement_getVisible (ff-pointer self)))

(cl:defmethod set-visible ((self sgmodel-placement) (visible t))
  (SGModelPlacement_setVisible (ff-pointer self) visible))

(cl:defmethod get-longitude-deg ((self sgmodel-placement))
  (SGModelPlacement_getLongitudeDeg (ff-pointer self)))

(cl:defmethod get-latitude-deg ((self sgmodel-placement))
  (SGModelPlacement_getLatitudeDeg (ff-pointer self)))

(cl:defmethod get-elevation-ft ((self sgmodel-placement))
  (SGModelPlacement_getElevationFt (ff-pointer self)))

(cl:defmethod set-longitude-deg ((self sgmodel-placement) (lon_deg cl:number))
  (SGModelPlacement_setLongitudeDeg (ff-pointer self) lon_deg))

(cl:defmethod set-latitude-deg ((self sgmodel-placement) (lat_deg cl:number))
  (SGModelPlacement_setLatitudeDeg (ff-pointer self) lat_deg))

(cl:defmethod set-elevation-ft ((self sgmodel-placement) (elev_ft cl:number))
  (SGModelPlacement_setElevationFt (ff-pointer self) elev_ft))

(cl:defmethod set-position ((self sgmodel-placement) (lon_deg cl:number) (lat_deg cl:number) (elev_ft cl:number))
  (SGModelPlacement_setPosition (ff-pointer self) lon_deg lat_deg elev_ft))

(cl:defmethod set-position ((self sgmodel-placement) (position sggeod))
  (SGModelPlacement_setPosition (ff-pointer self) position))

(cl:defmethod get-position ((self sgmodel-placement))
  (SGModelPlacement_getPosition (ff-pointer self)))

(cl:defmethod get-roll-deg ((self sgmodel-placement))
  (SGModelPlacement_getRollDeg (ff-pointer self)))

(cl:defmethod get-pitch-deg ((self sgmodel-placement))
  (SGModelPlacement_getPitchDeg (ff-pointer self)))

(cl:defmethod get-heading-deg ((self sgmodel-placement))
  (SGModelPlacement_getHeadingDeg (ff-pointer self)))

(cl:defmethod set-roll-deg ((self sgmodel-placement) (roll_deg cl:number))
  (SGModelPlacement_setRollDeg (ff-pointer self) roll_deg))

(cl:defmethod set-pitch-deg ((self sgmodel-placement) (pitch_deg cl:number))
  (SGModelPlacement_setPitchDeg (ff-pointer self) pitch_deg))

(cl:defmethod set-heading-deg ((self sgmodel-placement) (heading_deg cl:number))
  (SGModelPlacement_setHeadingDeg (ff-pointer self) heading_deg))

(cl:defmethod set-orientation ((self sgmodel-placement) (roll_deg cl:number) (pitch_deg cl:number) (heading_deg cl:number))
  (SGModelPlacement_setOrientation (ff-pointer self) roll_deg pitch_deg heading_deg))

(cl:defmethod set-orientation ((self sgmodel-placement) orientation)
  (SGModelPlacement_setOrientation (ff-pointer self) orientation))

(cl:defmethod set-reference-time ((self sgmodel-placement) referenceTime)
  (SGModelPlacement_setReferenceTime (ff-pointer self) referenceTime))

(cl:defmethod set-body-linear-velocity ((self sgmodel-placement) velocity)
  (SGModelPlacement_setBodyLinearVelocity (ff-pointer self) velocity))

(cl:defmethod set-body-angular-velocity ((self sgmodel-placement) velocity)
  (SGModelPlacement_setBodyAngularVelocity (ff-pointer self) velocity))


(cl:defclass sgbb-cache()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgbb-cache) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGBbCache)))

(cl:defmethod init ((self sgbb-cache) (cacheCount cl:integer))
  (SGBbCache_init (ff-pointer self) cacheCount))

(cl:defmethod free ((self sgbb-cache) (bbId cl:integer) (cldId cl:integer))
  (SGBbCache_free (ff-pointer self) bbId cldId))

(cl:defmethod alloc ((self sgbb-cache) (cldId cl:integer))
  (SGBbCache_alloc (ff-pointer self) cldId))

(cl:defmethod query-tex-id ((self sgbb-cache) (cldId cl:integer) (bbId cl:integer))
  (SGBbCache_QueryTexID (ff-pointer self) cldId bbId))

(cl:defmethod set-texture-data ((self sgbb-cache) (bbId cl:integer))
  (SGBbCache_setTextureData (ff-pointer self) bbId))

(cl:defmethod begin-capture ((self sgbb-cache))
  (SGBbCache_beginCapture (ff-pointer self)))

(cl:defmethod set-radius ((self sgbb-cache) (radius cl:number) (dist_center cl:number))
  (SGBbCache_setRadius (ff-pointer self) radius dist_center))

(cl:defmethod end-capture ((self sgbb-cache))
  (SGBbCache_endCapture (ff-pointer self)))

(cl:defmethod query-impostor-age ((self sgbb-cache) (bbId cl:integer))
  (SGBbCache_queryImpostorAge (ff-pointer self) bbId))

(cl:defmethod is-bb-valid ((self sgbb-cache) (cloudId cl:integer) (bbId cl:integer) (angleY cl:number) (angleX cl:number))
  (SGBbCache_isBbValid (ff-pointer self) cloudId bbId angleY angleX))

(cl:defmethod set-reference ((self sgbb-cache) (cloudId cl:integer) (bbId cl:integer) (angleY cl:number) (angleX cl:number))
  (SGBbCache_setReference (ff-pointer self) cloudId bbId angleY angleX))

(cl:defmethod start-new-frame ((self sgbb-cache))
  (SGBbCache_startNewFrame (ff-pointer self)))

(cl:defmethod set-cache-size ((self sgbb-cache) (sizeKb cl:integer))
  (SGBbCache_setCacheSize (ff-pointer self) sizeKb))

(cl:defmethod set-cache-size ((self sgbb-cache) (count cl:integer) (textureDimension cl:integer))
  (SGBbCache_setCacheSize (ff-pointer self) count textureDimension))

(cl:defmethod is-rtt-available ((self sgbb-cache))
  (SGBbCache_isRttAvailable (ff-pointer self)))

(cl:defmethod invalidate-cache ((self sgbb-cache))
  (SGBbCache_invalidateCache (ff-pointer self)))

(cl:defmethod invalidate ((self sgbb-cache) (cldId cl:integer) (bbId cl:integer))
  (SGBbCache_invalidate (ff-pointer self) cldId bbId))

(cl:defmethod query-cache-size ((self sgbb-cache))
  (SGBbCache_queryCacheSize (ff-pointer self)))

(cl:defmethod (cl:setf maxImpostorRegenFrame) (arg0 (obj sgbb-cache))
  (SGBbCache_maxImpostorRegenFrame_set (ff-pointer obj) arg0))

(cl:defmethod maxImpostorRegenFrame ((obj sgbb-cache))
  (SGBbCache_maxImpostorRegenFrame_get (ff-pointer obj)))


(cl:defclass sgcloud-layer()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgcloud-layer) &key tex_path)
  (setf (slot-value obj 'ff-pointer) (new_SGCloudLayer tex_path)))

(cl:defmethod get-span-m ((self sgcloud-layer))
  (SGCloudLayer_getSpan_m (ff-pointer self)))

(cl:defmethod set-span-m ((self sgcloud-layer) (span_m cl:number))
  (SGCloudLayer_setSpan_m (ff-pointer self) span_m))

(cl:defmethod get-elevation-m ((self sgcloud-layer))
  (SGCloudLayer_getElevation_m (ff-pointer self)))

(cl:defmethod set-elevation-m ((self sgcloud-layer) (elevation_m cl:number) (set_span t))
  (SGCloudLayer_setElevation_m (ff-pointer self) elevation_m set_span))

(cl:defmethod set-elevation-m ((self sgcloud-layer) (elevation_m cl:number))
  (SGCloudLayer_setElevation_m (ff-pointer self) elevation_m))

(cl:defmethod get-thickness-m ((self sgcloud-layer))
  (SGCloudLayer_getThickness_m (ff-pointer self)))

(cl:defmethod set-thickness-m ((self sgcloud-layer) (thickness_m cl:number))
  (SGCloudLayer_setThickness_m (ff-pointer self) thickness_m))

(cl:defmethod get-visibility-m ((self sgcloud-layer))
  (SGCloudLayer_getVisibility_m (ff-pointer self)))

(cl:defmethod set-visibility-m ((self sgcloud-layer) (visibility_m cl:number))
  (SGCloudLayer_setVisibility_m (ff-pointer self) visibility_m))

(cl:defmethod get-transition-m ((self sgcloud-layer))
  (SGCloudLayer_getTransition_m (ff-pointer self)))

(cl:defmethod set-transition-m ((self sgcloud-layer) (transition_m cl:number))
  (SGCloudLayer_setTransition_m (ff-pointer self) transition_m))

(cl:defmethod get-coverage ((self sgcloud-layer))
  (SGCloudLayer_getCoverage (ff-pointer self)))

(cl:defmethod set-coverage ((self sgcloud-layer) (coverage cl:integer))
  (SGCloudLayer_setCoverage (ff-pointer self) coverage))

(cl:defmethod get-coverage-string ((self sgcloud-layer))
  (SGCloudLayer_getCoverageString (ff-pointer self)))

(cl:defmethod set-coverage-string ((self sgcloud-layer) coverage)
  (SGCloudLayer_setCoverageString (ff-pointer self) coverage))

(cl:defmethod set-direction ((self sgcloud-layer) (dir cl:number))
  (SGCloudLayer_setDirection (ff-pointer self) dir))

(cl:defmethod get-direction ((self sgcloud-layer))
  (SGCloudLayer_getDirection (ff-pointer self)))

(cl:defmethod set-speed ((self sgcloud-layer) (sp cl:number))
  (SGCloudLayer_setSpeed (ff-pointer self) sp))

(cl:defmethod get-speed ((self sgcloud-layer))
  (SGCloudLayer_getSpeed (ff-pointer self)))

(cl:defmethod set-alpha ((self sgcloud-layer) (alpha cl:number))
  (SGCloudLayer_setAlpha (ff-pointer self) alpha))

(cl:defmethod set-max-alpha ((self sgcloud-layer) (alpha cl:number))
  (SGCloudLayer_setMaxAlpha (ff-pointer self) alpha))

(cl:defmethod get-max-alpha ((self sgcloud-layer))
  (SGCloudLayer_getMaxAlpha (ff-pointer self)))

(cl:defmethod rebuild ((self sgcloud-layer))
  (SGCloudLayer_rebuild (ff-pointer self)))

(cl:defmethod set-enable3d-clouds ((self sgcloud-layer) (enable t))
  (SGCloudLayer_set_enable3dClouds (ff-pointer self) enable))

(cl:defmethod repaint ((self sgcloud-layer) fog_color)
  (SGCloudLayer_repaint (ff-pointer self) fog_color))

(cl:defmethod reposition ((self sgcloud-layer) p up (lon cl:number) (lat cl:number) (alt cl:number) (dt cl:number))
  (SGCloudLayer_reposition (ff-pointer self) p up lon lat alt dt))

(cl:defmethod reposition ((self sgcloud-layer) p up (lon cl:number) (lat cl:number) (alt cl:number))
  (SGCloudLayer_reposition (ff-pointer self) p up lon lat alt))

(cl:defmethod get-node ((self sgcloud-layer))
  (SGCloudLayer_getNode (ff-pointer self)))

(cl:defmethod get-layer3-d ((self sgcloud-layer))
  (SGCloudLayer_get_layer3D (ff-pointer self)))


(cl:defclass sgcloud-field()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgcloud-field) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGCloudField)))

(cl:defmethod clear ((self sgcloud-field))
  (SGCloudField_clear (ff-pointer self)))

(cl:defmethod add-cloud ((self sgcloud-field) pos cloud)
  (SGCloudField_addCloud (ff-pointer self) pos cloud))

(cl:defmethod reposition ((self sgcloud-field) p up (lon cl:number) (lat cl:number) (dt cl:number) (asl cl:integer))
  (SGCloudField_reposition (ff-pointer self) p up lon lat dt asl))

(cl:defmethod get-node ((self sgcloud-field))
  (SGCloudField_getNode (ff-pointer self)))

(cl:defmethod (cl:setf defined3D) (arg0 (obj sgcloud-field))
  (SGCloudField_defined3D_set (ff-pointer obj) arg0))

(cl:defmethod defined3D ((obj sgcloud-field))
  (SGCloudField_defined3D_get (ff-pointer obj)))

(cl:defmethod get-coverage ((self sgcloud-field))
  (SGCloudField_getCoverage (ff-pointer self)))

(cl:defmethod set-coverage ((self sgcloud-field) (c cl:number))
  (SGCloudField_setCoverage (ff-pointer self) c))

(cl:defmethod apply-coverage ((self sgcloud-field))
  (SGCloudField_applyCoverage (ff-pointer self)))

(cl:defmethod apply-vis-range ((self sgcloud-field))
  (SGCloudField_applyVisRange (ff-pointer self)))


(cl:defclass sgsky-dome()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsky-dome) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSkyDome)))

(cl:defmethod build ((self sgsky-dome) (hscale cl:number) (vscale cl:number))
  (SGSkyDome_build (ff-pointer self) hscale vscale))

(cl:defmethod build ((self sgsky-dome) (hscale cl:number))
  (SGSkyDome_build (ff-pointer self) hscale))

(cl:defmethod build ((self sgsky-dome))
  (SGSkyDome_build (ff-pointer self)))

(cl:defmethod repaint ((self sgsky-dome) sun_color sky_color fog_color (sun_angle cl:number) (vis cl:number))
  (SGSkyDome_repaint (ff-pointer self) sun_color sky_color fog_color sun_angle vis))

(cl:defmethod reposition ((self sgsky-dome) p (asl cl:number) (lon cl:number) (lat cl:number) (spin cl:number))
  (SGSkyDome_reposition (ff-pointer self) p asl lon lat spin))


(cl:defclass sgmoon()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmoon) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGMoon)))

(cl:defmethod build ((self sgmoon) (path sgpath) (moon_size cl:number))
  (SGMoon_build (ff-pointer self) path moon_size))

(cl:defmethod repaint ((self sgmoon) (moon_angle cl:number))
  (SGMoon_repaint (ff-pointer self) moon_angle))

(cl:defmethod reposition ((self sgmoon) (rightAscension cl:number) (declination cl:number) (moon_dist cl:number))
  (SGMoon_reposition (ff-pointer self) rightAscension declination moon_dist))


(cl:defclass sgnew-cloud()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgnew-cloud) &key type (tex_path sgpath) tex (min_w cl:number) (max_w cl:number) (min_h cl:number) (max_h cl:number) (min_sprite_w cl:number) (max_sprite_w cl:number) (min_sprite_h cl:number) (max_sprite_h cl:number) (b cl:number) (n cl:integer) (nt_x cl:integer) (nt_y cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGNewCloud type tex_path tex min_w max_w min_h max_h min_sprite_w max_sprite_w min_sprite_h max_sprite_h b n nt_x nt_y)))

(cl:defmethod gen-cloud ((self sgnew-cloud))
  (SGNewCloud_genCloud (ff-pointer self)))


(cl:defclass sgsun()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsun) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSun)))

(cl:defmethod build ((self sgsun) (path sgpath) (sun_size cl:number) (property_tree_Node sgproperty-node))
  (SGSun_build (ff-pointer self) path sun_size property_tree_Node))

(cl:defmethod repaint ((self sgsun) (sun_angle cl:number) (new_visibility cl:number))
  (SGSun_repaint (ff-pointer self) sun_angle new_visibility))

(cl:defmethod reposition ((self sgsun) (rightAscension cl:number) (declination cl:number) (sun_dist cl:number) (lat cl:number) (alt_asl cl:number) (sun_angle cl:number))
  (SGSun_reposition (ff-pointer self) rightAscension declination sun_dist lat alt_asl sun_angle))

(cl:defmethod get-color ((self sgsun))
  (SGSun_get_color (ff-pointer self)))

(cl:defmethod get-scene-color ((self sgsun))
  (SGSun_get_scene_color (ff-pointer self)))


(cl:defclass sgsky()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsky) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSky)))

(cl:defmethod build ((self sgsky) (h_radius_m cl:number) (v_radius_m cl:number) (sun_size cl:number) (moon_size cl:number) (eph sgephemeris) (property_tree_node sgproperty-node))
  (SGSky_build (ff-pointer self) h_radius_m v_radius_m sun_size moon_size eph property_tree_node))

(cl:defmethod repaint ((self sgsky) sc (eph sgephemeris))
  (SGSky_repaint (ff-pointer self) sc eph))

(cl:defmethod reposition ((self sgsky) st (eph sgephemeris) (dt cl:number))
  (SGSky_reposition (ff-pointer self) st eph dt))

(cl:defmethod reposition ((self sgsky) st (eph sgephemeris))
  (SGSky_reposition (ff-pointer self) st eph))

(cl:defmethod modify-vis ((self sgsky) (alt cl:number) (time_factor cl:number))
  (SGSky_modify_vis (ff-pointer self) alt time_factor))

(cl:defmethod get-pre-root ((self sgsky))
  (SGSky_getPreRoot (ff-pointer self)))

(cl:defmethod get-cloud-root ((self sgsky))
  (SGSky_getCloudRoot (ff-pointer self)))

(cl:defmethod texture-path ((self sgsky) path)
  (SGSky_texture_path (ff-pointer self) path))

(cl:defmethod enable ((self sgsky))
  (SGSky_enable (ff-pointer self)))

(cl:defmethod disable ((self sgsky))
  (SGSky_disable (ff-pointer self)))

(cl:defmethod get-sun-color ((self sgsky))
  (SGSky_get_sun_color (ff-pointer self)))

(cl:defmethod get-scene-color ((self sgsky))
  (SGSky_get_scene_color (ff-pointer self)))

(cl:defmethod add-cloud-layer ((self sgsky) (layer sgcloud-layer))
  (SGSky_add_cloud_layer (ff-pointer self) layer))

(cl:defmethod get-cloud-layer ((self sgsky) (i cl:integer))
  (SGSky_get_cloud_layer (ff-pointer self) i))

(cl:defmethod get-cloud-layer ((self sgsky) (i cl:integer))
  (SGSky_get_cloud_layer (ff-pointer self) i))

(cl:defmethod get-cloud-layer-count ((self sgsky))
  (SGSky_get_cloud_layer_count (ff-pointer self)))

(cl:defmethod get-visibility ((self sgsky))
  (SGSky_get_visibility (ff-pointer self)))

(cl:defmethod set-visibility ((self sgsky) (v cl:number))
  (SGSky_set_visibility (ff-pointer self) v))

(cl:defmethod get-3d-cloud-density ((self sgsky))
  (SGSky_get_3dCloudDensity (ff-pointer self)))

(cl:defmethod set-3d-cloud-density ((self sgsky) (density cl:number))
  (SGSky_set_3dCloudDensity (ff-pointer self) density))

(cl:defmethod get-3d-cloud-vis-range ((self sgsky))
  (SGSky_get_3dCloudVisRange (ff-pointer self)))

(cl:defmethod set-3d-cloud-vis-range ((self sgsky) (vis cl:number))
  (SGSky_set_3dCloudVisRange (ff-pointer self) vis))


(cl:defclass sgstars()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgstars) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGStars)))

(cl:defmethod build ((self sgstars) (num cl:integer) star_data (star_dist cl:number))
  (SGStars_build (ff-pointer self) num star_data star_dist))

(cl:defmethod repaint ((self sgstars) (sun_angle cl:number) (num cl:integer) star_data)
  (SGStars_repaint (ff-pointer self) sun_angle num star_data))


(cl:defclass ground-light-manager()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj ground-light-manager) &key)
  (setf (slot-value obj 'ff-pointer) (new_GroundLightManager)))

(cl:defmethod get-runway-light-state-set ((self ground-light-manager))
  (GroundLightManager_getRunwayLightStateSet (ff-pointer self)))

(cl:defmethod get-taxi-light-state-set ((self ground-light-manager))
  (GroundLightManager_getTaxiLightStateSet (ff-pointer self)))

(cl:defmethod get-ground-light-state-set ((self ground-light-manager))
  (GroundLightManager_getGroundLightStateSet (ff-pointer self)))

(cl:defmethod update ((self ground-light-manager) updateVisitor)
  (GroundLightManager_update (ff-pointer self) updateVisitor))

(cl:defmethod get-light-node-mask ((self ground-light-manager) updateVisitor)
  (GroundLightManager_getLightNodeMask (ff-pointer self) updateVisitor))


(cl:defclass sgreader-writer-btgoptions()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-btgoptions) &key str)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterBTGOptions str)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-btgoptions) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterBTGOptions)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-btgoptions) &key (options sgreader-writer-btgoptions) copyop)
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterBTGOptions (ff-pointer options) copyop)))

(cl:defmethod initialize-instance :after ((obj sgreader-writer-btgoptions) &key (options sgreader-writer-btgoptions))
  (setf (slot-value obj 'ff-pointer) (new_SGReaderWriterBTGOptions (ff-pointer options))))

(cl:defmethod get-matlib ((self sgreader-writer-btgoptions))
  (SGReaderWriterBTGOptions_getMatlib (ff-pointer self)))

(cl:defmethod set-matlib ((self sgreader-writer-btgoptions) matlib)
  (SGReaderWriterBTGOptions_setMatlib (ff-pointer self) matlib))

(cl:defmethod get-calc-lights ((self sgreader-writer-btgoptions))
  (SGReaderWriterBTGOptions_getCalcLights (ff-pointer self)))

(cl:defmethod set-calc-lights ((self sgreader-writer-btgoptions) (calcLights t))
  (SGReaderWriterBTGOptions_setCalcLights (ff-pointer self) calcLights))

(cl:defmethod get-use-random-objects ((self sgreader-writer-btgoptions))
  (SGReaderWriterBTGOptions_getUseRandomObjects (ff-pointer self)))

(cl:defmethod get-use-random-vegetation ((self sgreader-writer-btgoptions))
  (SGReaderWriterBTGOptions_getUseRandomVegetation (ff-pointer self)))

(cl:defmethod set-use-random-objects ((self sgreader-writer-btgoptions) (useRandomObjects t))
  (SGReaderWriterBTGOptions_setUseRandomObjects (ff-pointer self) useRandomObjects))

(cl:defmethod set-use-random-vegetation ((self sgreader-writer-btgoptions) (useRandomVegetation t))
  (SGReaderWriterBTGOptions_setUseRandomVegetation (ff-pointer self) useRandomVegetation))


(cl:defclass shader-geometry()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj shader-geometry) &key)
  (setf (slot-value obj 'ff-pointer) (new_ShaderGeometry)))

(cl:defmethod initialize-instance :after ((obj shader-geometry) &key (v cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_ShaderGeometry v)))

(cl:defmethod initialize-instance :after ((obj shader-geometry) &key (ShaderGeometry shader-geometry) copyop)
  (setf (slot-value obj 'ff-pointer) (new_ShaderGeometry (ff-pointer ShaderGeometry) copyop)))

(cl:defmethod initialize-instance :after ((obj shader-geometry) &key (ShaderGeometry shader-geometry))
  (setf (slot-value obj 'ff-pointer) (new_ShaderGeometry (ff-pointer ShaderGeometry))))

(cl:defmethod draw-implementation ((self shader-geometry) renderInfo)
  (ShaderGeometry_drawImplementation (ff-pointer self) renderInfo))

(cl:defmethod compute-bound ((self shader-geometry))
  (ShaderGeometry_computeBound (ff-pointer self)))

(cl:defmethod set-geometry ((self shader-geometry) geometry)
  (ShaderGeometry_setGeometry (ff-pointer self) geometry))

(cl:defmethod add-object ((self shader-geometry) position (scale cl:number) (texture_index cl:integer))
  (ShaderGeometry_addObject (ff-pointer self) position scale texture_index))

(cl:defmethod (cl:setf _geometry) (arg0 (obj shader-geometry))
  (ShaderGeometry__geometry_set (ff-pointer obj) arg0))

(cl:defmethod _geometry ((obj shader-geometry))
  (ShaderGeometry__geometry_get (ff-pointer obj)))

(cl:defmethod (cl:setf varieties) (arg0 (obj shader-geometry))
  (ShaderGeometry_varieties_set (ff-pointer obj) arg0))

(cl:defmethod varieties ((obj shader-geometry))
  (ShaderGeometry_varieties_get (ff-pointer obj)))

(cl:defmethod (cl:setf _posScaleArray) (arg0 (obj shader-geometry))
  (ShaderGeometry__posScaleArray_set (ff-pointer obj) arg0))

(cl:defmethod _posScaleArray ((obj shader-geometry))
  (ShaderGeometry__posScaleArray_get (ff-pointer obj)))

(cl:defmethod (cl:setf _vertexAttribArray) (arg0 (obj shader-geometry))
  (ShaderGeometry__vertexAttribArray_set (ff-pointer obj) arg0))

(cl:defmethod _vertexAttribArray ((obj shader-geometry))
  (ShaderGeometry__vertexAttribArray_get (ff-pointer obj)))


(cl:defclass tile-entry()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf tile_bucket) (arg0 (obj tile-entry))
  (TileEntry_tile_bucket_set (ff-pointer obj) arg0))

(cl:defmethod tile_bucket ((obj tile-entry))
  (TileEntry_tile_bucket_get (ff-pointer obj)))

(cl:defmethod (cl:setf tileFileName) (arg0 (obj tile-entry))
  (TileEntry_tileFileName_set (ff-pointer obj) arg0))

(cl:defmethod tileFileName ((obj tile-entry))
  (TileEntry_tileFileName_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj tile-entry) &key (b sgbucket))
  (setf (slot-value obj 'ff-pointer) (new_TileEntry b)))

(cl:defmethod prep-ssg-node ((self tile-entry) (vis cl:number))
  (TileEntry_prep_ssg_node (ff-pointer self) vis))

(cl:defmethod is-loaded ((self tile-entry))
  (TileEntry_is_loaded (ff-pointer self)))

(cl:defmethod get-tile-bucket ((self tile-entry))
  (TileEntry_get_tile_bucket (ff-pointer self)))

(cl:defmethod add-to-scene-graph ((self tile-entry) terrain_branch)
  (TileEntry_addToSceneGraph (ff-pointer self) terrain_branch))

(cl:defmethod remove-from-scene-graph ((self tile-entry))
  (TileEntry_removeFromSceneGraph (ff-pointer self)))

(cl:defmethod get-node ((self tile-entry))
  (TileEntry_getNode (ff-pointer self)))

(cl:defmethod get-time-expired ((self tile-entry))
  (TileEntry_get_time_expired (ff-pointer self)))

(cl:defmethod update-time-expired ((self tile-entry) (time_expired cl:number))
  (TileEntry_update_time_expired (ff-pointer self) time_expired))

(cl:defmethod set-priority ((self tile-entry) (priority cl:number))
  (TileEntry_set_priority (ff-pointer self) priority))

(cl:defmethod get-priority ((self tile-entry))
  (TileEntry_get_priority (ff-pointer self)))

(cl:defmethod set-current-view ((self tile-entry) (current_view t))
  (TileEntry_set_current_view (ff-pointer self) current_view))

(cl:defmethod is-current-view ((self tile-entry))
  (TileEntry_is_current_view (ff-pointer self)))

(cl:defmethod is-expired ((self tile-entry) (current_time cl:number))
  (TileEntry_is_expired (ff-pointer self) current_time))

(cl:defmethod get-database-request ((self tile-entry))
  (TileEntry_getDatabaseRequest (ff-pointer self)))


(cl:defclass model-load-helper()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod load-tile-model ((self model-load-helper) modelPath (cacheModel t))
  (ModelLoadHelper_loadTileModel (ff-pointer self) modelPath cacheModel))


(cl:defclass sglight-factory()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sglight-factory) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGLightFactory)))


(cl:defclass copy-op()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj copy-op) &key flags)
  (setf (slot-value obj 'ff-pointer) (new_CopyOp flags)))

(cl:defmethod initialize-instance :after ((obj copy-op) &key)
  (setf (slot-value obj 'ff-pointer) (new_CopyOp)))

(cl:shadow "()")
(cl:defmethod () ((self copy-op) obj)
  (CopyOp___funcall__ (ff-pointer self) obj))


(cl:defclass node-and-drawable-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj node-and-drawable-visitor) &key tm)
  (setf (slot-value obj 'ff-pointer) (new_NodeAndDrawableVisitor tm)))

(cl:defmethod initialize-instance :after ((obj node-and-drawable-visitor) &key type tm)
  (setf (slot-value obj 'ff-pointer) (new_NodeAndDrawableVisitor type tm)))

(cl:defmethod apply ((self node-and-drawable-visitor) node)
  (NodeAndDrawableVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self node-and-drawable-visitor) drawable)
  (NodeAndDrawableVisitor_apply (ff-pointer self) drawable))

(cl:defmethod traverse ((self node-and-drawable-visitor) node)
  (NodeAndDrawableVisitor_traverse (ff-pointer self) node))


(cl:defclass sgenlarge-bounding-box()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgenlarge-bounding-box) &key (offset cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SGEnlargeBoundingBox offset)))

(cl:defmethod initialize-instance :after ((obj sgenlarge-bounding-box) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGEnlargeBoundingBox)))

(cl:defmethod initialize-instance :after ((obj sgenlarge-bounding-box) &key (cb sgenlarge-bounding-box) arg1)
  (setf (slot-value obj 'ff-pointer) (new_SGEnlargeBoundingBox (ff-pointer cb) arg1)))

(cl:defmethod compute-bound ((self sgenlarge-bounding-box) drawable)
  (SGEnlargeBoundingBox_computeBound (ff-pointer self) drawable))


(cl:defclass sgscene-features()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod set-texture-compression ((self sgscene-features) (textureCompression cl:integer))
  (SGSceneFeatures_setTextureCompression (ff-pointer self) textureCompression))

(cl:defmethod get-texture-compression ((self sgscene-features))
  (SGSceneFeatures_getTextureCompression (ff-pointer self)))

(cl:defmethod set-texture-compression ((self sgscene-features) texture)
  (SGSceneFeatures_setTextureCompression (ff-pointer self) texture))

(cl:defmethod set-enable-point-sprite-lights ((self sgscene-features) (enable t))
  (SGSceneFeatures_setEnablePointSpriteLights (ff-pointer self) enable))

(cl:defmethod get-enable-point-sprite-lights ((self sgscene-features) (contextId cl:integer))
  (SGSceneFeatures_getEnablePointSpriteLights (ff-pointer self) contextId))

(cl:defmethod set-enable-distance-attenuation-lights ((self sgscene-features) (enable t))
  (SGSceneFeatures_setEnableDistanceAttenuationLights (ff-pointer self) enable))

(cl:defmethod get-enable-distance-attenuation-lights ((self sgscene-features) (contextId cl:integer))
  (SGSceneFeatures_getEnableDistanceAttenuationLights (ff-pointer self) contextId))

(cl:defmethod set-enable-shader-lights ((self sgscene-features) (enable t))
  (SGSceneFeatures_setEnableShaderLights (ff-pointer self) enable))

(cl:defmethod get-enable-shader-lights ((self sgscene-features) (contextId cl:integer))
  (SGSceneFeatures_getEnableShaderLights (ff-pointer self) contextId))

(cl:defmethod set-texture-filter ((self sgscene-features) (max cl:integer))
  (SGSceneFeatures_setTextureFilter (ff-pointer self) max))

(cl:defmethod get-texture-filter ((self sgscene-features))
  (SGSceneFeatures_getTextureFilter (ff-pointer self)))


(cl:defclass sgstate-attribute-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgstate-attribute-visitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGStateAttributeVisitor)))

(cl:defmethod apply ((self sgstate-attribute-visitor) arg1)
  (SGStateAttributeVisitor_apply (ff-pointer self) arg1))

(cl:defmethod apply ((self sgstate-attribute-visitor) attrList)
  (SGStateAttributeVisitor_apply (ff-pointer self) attrList))

(cl:defmethod apply ((self sgstate-attribute-visitor) stateSet)
  (SGStateAttributeVisitor_apply (ff-pointer self) stateSet))

(cl:defmethod apply ((self sgstate-attribute-visitor) node)
  (SGStateAttributeVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self sgstate-attribute-visitor) node)
  (SGStateAttributeVisitor_apply (ff-pointer self) node))


(cl:defclass sgtexture-state-attribute-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtexture-state-attribute-visitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGTextureStateAttributeVisitor)))

(cl:defmethod apply ((self sgtexture-state-attribute-visitor) (textureUnit cl:integer) refAttr)
  (SGTextureStateAttributeVisitor_apply (ff-pointer self) textureUnit refAttr))

(cl:defmethod apply ((self sgtexture-state-attribute-visitor) (textureUnit cl:integer) attrList)
  (SGTextureStateAttributeVisitor_apply (ff-pointer self) textureUnit attrList))

(cl:defmethod apply ((self sgtexture-state-attribute-visitor) attrList)
  (SGTextureStateAttributeVisitor_apply (ff-pointer self) attrList))

(cl:defmethod apply ((self sgtexture-state-attribute-visitor) stateSet)
  (SGTextureStateAttributeVisitor_apply (ff-pointer self) stateSet))

(cl:defmethod apply ((self sgtexture-state-attribute-visitor) node)
  (SGTextureStateAttributeVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self sgtexture-state-attribute-visitor) node)
  (SGTextureStateAttributeVisitor_apply (ff-pointer self) node))


(cl:defclass sgupdate-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgupdate-visitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGUpdateVisitor)))

(cl:defmethod set-view-data ((self sgupdate-visitor) globalEyePos globalViewOrientation)
  (SGUpdateVisitor_setViewData (ff-pointer self) globalEyePos globalViewOrientation))

(cl:defmethod set-visibility ((self sgupdate-visitor) (visibility cl:number))
  (SGUpdateVisitor_setVisibility (ff-pointer self) visibility))

(cl:defmethod get-visibility ((self sgupdate-visitor))
  (SGUpdateVisitor_getVisibility (ff-pointer self)))

(cl:defmethod get-sqr-visibility ((self sgupdate-visitor))
  (SGUpdateVisitor_getSqrVisibility (ff-pointer self)))

(cl:defmethod get-fog-exp-density ((self sgupdate-visitor))
  (SGUpdateVisitor_getFogExpDensity (ff-pointer self)))

(cl:defmethod get-fog-exp2-density ((self sgupdate-visitor))
  (SGUpdateVisitor_getFogExp2Density (ff-pointer self)))

(cl:defmethod get-runway-fog-exp2-density ((self sgupdate-visitor))
  (SGUpdateVisitor_getRunwayFogExp2Density (ff-pointer self)))

(cl:defmethod get-taxi-fog-exp2-density ((self sgupdate-visitor))
  (SGUpdateVisitor_getTaxiFogExp2Density (ff-pointer self)))

(cl:defmethod get-ground-lights-fog-exp2-density ((self sgupdate-visitor))
  (SGUpdateVisitor_getGroundLightsFogExp2Density (ff-pointer self)))

(cl:defmethod get-global-eye-pos ((self sgupdate-visitor))
  (SGUpdateVisitor_getGlobalEyePos (ff-pointer self)))

(cl:defmethod get-geod-eye-pos ((self sgupdate-visitor))
  (SGUpdateVisitor_getGeodEyePos (ff-pointer self)))

(cl:defmethod get-global-view-or ((self sgupdate-visitor))
  (SGUpdateVisitor_getGlobalViewOr (ff-pointer self)))

(cl:defmethod get-global-horiz-local-or ((self sgupdate-visitor))
  (SGUpdateVisitor_getGlobalHorizLocalOr (ff-pointer self)))

(cl:defmethod get-horiz-local-north ((self sgupdate-visitor))
  (SGUpdateVisitor_getHorizLocalNorth (ff-pointer self)))

(cl:defmethod get-horiz-local-east ((self sgupdate-visitor))
  (SGUpdateVisitor_getHorizLocalEast (ff-pointer self)))

(cl:defmethod get-horiz-local-down ((self sgupdate-visitor))
  (SGUpdateVisitor_getHorizLocalDown (ff-pointer self)))

(cl:defmethod set-light ((self sgupdate-visitor) direction ambient diffuse specular fogColor (sunAngleDeg cl:number))
  (SGUpdateVisitor_setLight (ff-pointer self) direction ambient diffuse specular fogColor sunAngleDeg))

(cl:defmethod get-light-direction ((self sgupdate-visitor))
  (SGUpdateVisitor_getLightDirection (ff-pointer self)))

(cl:defmethod get-ambient-light ((self sgupdate-visitor))
  (SGUpdateVisitor_getAmbientLight (ff-pointer self)))

(cl:defmethod get-diffuse-light ((self sgupdate-visitor))
  (SGUpdateVisitor_getDiffuseLight (ff-pointer self)))

(cl:defmethod get-specular-light ((self sgupdate-visitor))
  (SGUpdateVisitor_getSpecularLight (ff-pointer self)))

(cl:defmethod get-fog-color ((self sgupdate-visitor))
  (SGUpdateVisitor_getFogColor (ff-pointer self)))

(cl:defmethod get-sun-angle-deg ((self sgupdate-visitor))
  (SGUpdateVisitor_getSunAngleDeg (ff-pointer self)))

(cl:defmethod apply ((self sgupdate-visitor) node)
  (SGUpdateVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self sgupdate-visitor) pagedLOD)
  (SGUpdateVisitor_apply (ff-pointer self) pagedLOD))

(cl:defmethod apply ((self sgupdate-visitor) transform)
  (SGUpdateVisitor_apply (ff-pointer self) transform))

(cl:defmethod apply ((self sgupdate-visitor) camera)
  (SGUpdateVisitor_apply (ff-pointer self) camera))

(cl:defmethod get-distance-to-view-point ((self sgupdate-visitor) pos (arg2 t))
  (SGUpdateVisitor_getDistanceToViewPoint (ff-pointer self) pos arg2))


(cl:defclass splicing-visitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj splicing-visitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_SplicingVisitor)))

(cl:defmethod reset ((self splicing-visitor))
  (SplicingVisitor_reset (ff-pointer self)))

(cl:defmethod traverse ((self splicing-visitor) node)
  (SplicingVisitor_traverse (ff-pointer self) node))

(cl:defmethod apply ((self splicing-visitor) node)
  (SplicingVisitor_apply (ff-pointer self) node))

(cl:defmethod apply ((self splicing-visitor) node)
  (SplicingVisitor_apply (ff-pointer self) node))

(cl:defmethod push-result-node ((self splicing-visitor) node newNode children)
  (SplicingVisitor_pushResultNode (ff-pointer self) node newNode children))

(cl:defmethod push-result-node ((self splicing-visitor) node newNode)
  (SplicingVisitor_pushResultNode (ff-pointer self) node newNode))

(cl:defmethod push-node ((self splicing-visitor) node)
  (SplicingVisitor_pushNode (ff-pointer self) node))

(cl:defmethod get-result ((self splicing-visitor))
  (SplicingVisitor_getResult (ff-pointer self)))

(cl:defmethod get-new-node ((self splicing-visitor) node)
  (SplicingVisitor_getNewNode (ff-pointer self) node))

(cl:defmethod get-new-node ((self splicing-visitor) node)
  (SplicingVisitor_getNewNode (ff-pointer self) node))

(cl:defmethod record-new-node ((self splicing-visitor) oldNode newNode)
  (SplicingVisitor_recordNewNode (ff-pointer self) oldNode newNode))

(cl:defmethod get-results ((self splicing-visitor))
  (SplicingVisitor_getResults (ff-pointer self)))


(cl:defclass update-once-callback()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj update-once-callback) &key)
  (setf (slot-value obj 'ff-pointer) (new_UpdateOnceCallback)))

(cl:defmethod initialize-instance :after ((obj update-once-callback) &key (nc update-once-callback) copyop)
  (setf (slot-value obj 'ff-pointer) (new_UpdateOnceCallback (ff-pointer nc) copyop)))

(cl:defmethod do-update ((self update-once-callback) node nv)
  (UpdateOnceCallback_doUpdate (ff-pointer self) node nv))

(cl:shadow "()")
(cl:defmethod () ((self update-once-callback) node nv)
  (UpdateOnceCallback___funcall__ (ff-pointer self) node nv))


(cl:defclass sgserial-port()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgserial-port) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSerialPort)))

(cl:defmethod initialize-instance :after ((obj sgserial-port) &key device (baud cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSerialPort device baud)))

(cl:defmethod open-port ((self sgserial-port) device)
  (SGSerialPort_open_port (ff-pointer self) device))

(cl:defmethod close-port ((self sgserial-port))
  (SGSerialPort_close_port (ff-pointer self)))

(cl:defmethod set-baud ((self sgserial-port) (baud cl:integer))
  (SGSerialPort_set_baud (ff-pointer self) baud))

(cl:defmethod read-port ((self sgserial-port))
  (SGSerialPort_read_port (ff-pointer self)))

(cl:defmethod read-port ((self sgserial-port) (buf cl:string) (len cl:integer))
  (SGSerialPort_read_port (ff-pointer self) buf len))

(cl:defmethod write-port ((self sgserial-port) value)
  (SGSerialPort_write_port (ff-pointer self) value))

(cl:defmethod write-port ((self sgserial-port) (buf cl:string) (len cl:integer))
  (SGSerialPort_write_port (ff-pointer self) buf len))

(cl:defmethod is-enabled ((self sgserial-port))
  (SGSerialPort_is_enabled (ff-pointer self)))


(cl:defclass sgsample-group()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsample-group) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSampleGroup)))

(cl:defmethod initialize-instance :after ((obj sgsample-group) &key smgr refname)
  (setf (slot-value obj 'ff-pointer) (new_SGSampleGroup smgr refname)))

(cl:defmethod activate ((self sgsample-group))
  (SGSampleGroup_activate (ff-pointer self)))

(cl:defmethod update ((self sgsample-group) (dt cl:number))
  (SGSampleGroup_update (ff-pointer self) dt))

(cl:defmethod add ((self sgsample-group) sound refname)
  (SGSampleGroup_add (ff-pointer self) sound refname))

(cl:defmethod remove ((self sgsample-group) refname)
  (SGSampleGroup_remove (ff-pointer self) refname))

(cl:defmethod exists ((self sgsample-group) refname)
  (SGSampleGroup_exists (ff-pointer self) refname))

(cl:defmethod find ((self sgsample-group) refname)
  (SGSampleGroup_find (ff-pointer self) refname))

(cl:defmethod stop ((self sgsample-group))
  (SGSampleGroup_stop (ff-pointer self)))

(cl:defmethod suspend ((self sgsample-group))
  (SGSampleGroup_suspend (ff-pointer self)))

(cl:defmethod resume ((self sgsample-group))
  (SGSampleGroup_resume (ff-pointer self)))

(cl:defmethod play ((self sgsample-group) refname (looping t))
  (SGSampleGroup_play (ff-pointer self) refname looping))

(cl:defmethod play-looped ((self sgsample-group) refname)
  (SGSampleGroup_play_looped (ff-pointer self) refname))

(cl:defmethod play-once ((self sgsample-group) refname)
  (SGSampleGroup_play_once (ff-pointer self) refname))

(cl:defmethod is-playing ((self sgsample-group) refname)
  (SGSampleGroup_is_playing (ff-pointer self) refname))

(cl:defmethod stop ((self sgsample-group) refname)
  (SGSampleGroup_stop (ff-pointer self) refname))

(cl:defmethod set-volume ((self sgsample-group) (vol cl:number))
  (SGSampleGroup_set_volume (ff-pointer self) vol))

(cl:defmethod set-velocity ((self sgsample-group) vel)
  (SGSampleGroup_set_velocity (ff-pointer self) vel))

(cl:defmethod set-position-geod ((self sgsample-group) (pos sggeod))
  (SGSampleGroup_set_position_geod (ff-pointer self) pos))

(cl:defmethod set-orientation ((self sgsample-group) ori)
  (SGSampleGroup_set_orientation (ff-pointer self) ori))

(cl:defmethod tie-to-listener ((self sgsample-group))
  (SGSampleGroup_tie_to_listener (ff-pointer self)))


(cl:defclass sgsound-sample()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsound-sample) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSoundSample)))

(cl:defmethod initialize-instance :after ((obj sgsound-sample) &key (file cl:string) (currentDir sgpath))
  (setf (slot-value obj 'ff-pointer) (new_SGSoundSample file currentDir)))

(cl:defmethod initialize-instance :after ((obj sgsound-sample) &key data (len cl:integer) (freq cl:integer) (format cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSoundSample data len freq format)))

(cl:defmethod initialize-instance :after ((obj sgsound-sample) &key data (len cl:integer) (freq cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSoundSample data len freq)))

(cl:defmethod initialize-instance :after ((obj sgsound-sample) &key data (len cl:integer) (freq cl:integer) (format cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSoundSample data len freq format)))

(cl:defmethod initialize-instance :after ((obj sgsound-sample) &key data (len cl:integer) (freq cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSoundSample data len freq)))

(cl:defmethod is-file ((self sgsound-sample))
  (SGSoundSample_is_file (ff-pointer self)))

(cl:defmethod file-path ((self sgsound-sample))
  (SGSoundSample_file_path (ff-pointer self)))

(cl:defmethod has-changed ((self sgsound-sample))
  (SGSoundSample_has_changed (ff-pointer self)))

(cl:defmethod has-static-data-changed ((self sgsound-sample))
  (SGSoundSample_has_static_data_changed (ff-pointer self)))

(cl:defmethod play ((self sgsound-sample) (loop t))
  (SGSoundSample_play (ff-pointer self) loop))

(cl:defmethod play ((self sgsound-sample))
  (SGSoundSample_play (ff-pointer self)))

(cl:defmethod is-looping ((self sgsound-sample))
  (SGSoundSample_is_looping (ff-pointer self)))

(cl:defmethod stop ((self sgsound-sample))
  (SGSoundSample_stop (ff-pointer self)))

(cl:defmethod play-once ((self sgsound-sample))
  (SGSoundSample_play_once (ff-pointer self)))

(cl:defmethod play-looped ((self sgsound-sample))
  (SGSoundSample_play_looped (ff-pointer self)))

(cl:defmethod is-playing ((self sgsound-sample))
  (SGSoundSample_is_playing (ff-pointer self)))

(cl:defmethod set-data ((self sgsound-sample) data)
  (SGSoundSample_set_data (ff-pointer self) data))

(cl:defmethod set-data ((self sgsound-sample) data)
  (SGSoundSample_set_data (ff-pointer self) data))

(cl:defmethod get-data ((self sgsound-sample))
  (SGSoundSample_get_data (ff-pointer self)))

(cl:defmethod free-data ((self sgsound-sample))
  (SGSoundSample_free_data (ff-pointer self)))

(cl:defmethod set-source ((self sgsound-sample) (sid cl:integer))
  (SGSoundSample_set_source (ff-pointer self) sid))

(cl:defmethod get-source ((self sgsound-sample))
  (SGSoundSample_get_source (ff-pointer self)))

(cl:defmethod is-valid-source ((self sgsound-sample))
  (SGSoundSample_is_valid_source (ff-pointer self)))

(cl:defmethod no-valid-source ((self sgsound-sample))
  (SGSoundSample_no_valid_source (ff-pointer self)))

(cl:defmethod set-buffer ((self sgsound-sample) (bid cl:integer))
  (SGSoundSample_set_buffer (ff-pointer self) bid))

(cl:defmethod get-buffer ((self sgsound-sample))
  (SGSoundSample_get_buffer (ff-pointer self)))

(cl:defmethod is-valid-buffer ((self sgsound-sample))
  (SGSoundSample_is_valid_buffer (ff-pointer self)))

(cl:defmethod no-valid-buffer ((self sgsound-sample))
  (SGSoundSample_no_valid_buffer (ff-pointer self)))

(cl:defmethod set-pitch ((self sgsound-sample) (p cl:number))
  (SGSoundSample_set_pitch (ff-pointer self) p))

(cl:defmethod get-pitch ((self sgsound-sample))
  (SGSoundSample_get_pitch (ff-pointer self)))

(cl:defmethod set-master-volume ((self sgsound-sample) (v cl:number))
  (SGSoundSample_set_master_volume (ff-pointer self) v))

(cl:defmethod set-volume ((self sgsound-sample) (v cl:number))
  (SGSoundSample_set_volume (ff-pointer self) v))

(cl:defmethod get-volume ((self sgsound-sample))
  (SGSoundSample_get_volume (ff-pointer self)))

(cl:defmethod set-format ((self sgsound-sample) (format cl:integer))
  (SGSoundSample_set_format (ff-pointer self) format))

(cl:defmethod get-format ((self sgsound-sample))
  (SGSoundSample_get_format (ff-pointer self)))

(cl:defmethod set-frequency ((self sgsound-sample) (freq cl:integer))
  (SGSoundSample_set_frequency (ff-pointer self) freq))

(cl:defmethod get-frequency ((self sgsound-sample))
  (SGSoundSample_get_frequency (ff-pointer self)))

(cl:defmethod set-size ((self sgsound-sample) size)
  (SGSoundSample_set_size (ff-pointer self) size))

(cl:defmethod get-size ((self sgsound-sample))
  (SGSoundSample_get_size (ff-pointer self)))

(cl:defmethod set-relative-position ((self sgsound-sample) pos)
  (SGSoundSample_set_relative_position (ff-pointer self) pos))

(cl:defmethod set-position ((self sgsound-sample) pos)
  (SGSoundSample_set_position (ff-pointer self) pos))

(cl:defmethod get-position ((self sgsound-sample))
  (SGSoundSample_get_position (ff-pointer self)))

(cl:defmethod set-orientation ((self sgsound-sample) ori)
  (SGSoundSample_set_orientation (ff-pointer self) ori))

(cl:defmethod set-rotation ((self sgsound-sample) ec2body)
  (SGSoundSample_set_rotation (ff-pointer self) ec2body))

(cl:defmethod set-direction ((self sgsound-sample) dir)
  (SGSoundSample_set_direction (ff-pointer self) dir))

(cl:defmethod set-audio-cone ((self sgsound-sample) (inner cl:number) (outer cl:number) (gain cl:number))
  (SGSoundSample_set_audio_cone (ff-pointer self) inner outer gain))

(cl:defmethod get-orientation ((self sgsound-sample))
  (SGSoundSample_get_orientation (ff-pointer self)))

(cl:defmethod get-innerangle ((self sgsound-sample))
  (SGSoundSample_get_innerangle (ff-pointer self)))

(cl:defmethod get-outerangle ((self sgsound-sample))
  (SGSoundSample_get_outerangle (ff-pointer self)))

(cl:defmethod get-outergain ((self sgsound-sample))
  (SGSoundSample_get_outergain (ff-pointer self)))

(cl:defmethod set-velocity ((self sgsound-sample) vel)
  (SGSoundSample_set_velocity (ff-pointer self) vel))

(cl:defmethod get-velocity ((self sgsound-sample))
  (SGSoundSample_get_velocity (ff-pointer self)))

(cl:defmethod set-reference-dist ((self sgsound-sample) (dist cl:number))
  (SGSoundSample_set_reference_dist (ff-pointer self) dist))

(cl:defmethod get-reference-dist ((self sgsound-sample))
  (SGSoundSample_get_reference_dist (ff-pointer self)))

(cl:defmethod set-max-dist ((self sgsound-sample) (dist cl:number))
  (SGSoundSample_set_max_dist (ff-pointer self) dist))

(cl:defmethod get-max-dist ((self sgsound-sample))
  (SGSoundSample_get_max_dist (ff-pointer self)))

(cl:defmethod get-sample-name ((self sgsound-sample))
  (SGSoundSample_get_sample_name (ff-pointer self)))

(cl:defmethod is-queue ((self sgsound-sample))
  (SGSoundSample_is_queue (ff-pointer self)))

(cl:defmethod update-pos-and-orientation ((self sgsound-sample))
  (SGSoundSample_update_pos_and_orientation (ff-pointer self)))


(cl:defclass sgsample-queue(SGSoundSample)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsample-queue) &key (freq cl:integer) (format cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSampleQueue freq format)))

(cl:defmethod initialize-instance :after ((obj sgsample-queue) &key (freq cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGSampleQueue freq)))

(cl:defmethod stop ((self sgsample-queue))
  (SGSampleQueue_stop (ff-pointer self)))

(cl:defmethod add ((self sgsample-queue) smp_data len)
  (SGSampleQueue_add (ff-pointer self) smp_data len))

(cl:defmethod set-source ((self sgsample-queue) (sid cl:integer))
  (SGSampleQueue_set_source (ff-pointer self) sid))

(cl:defmethod get-source ((self sgsample-queue))
  (SGSampleQueue_get_source (ff-pointer self)))

(cl:defmethod is-valid-source ((self sgsample-queue))
  (SGSampleQueue_is_valid_source (ff-pointer self)))

(cl:defmethod no-valid-source ((self sgsample-queue))
  (SGSampleQueue_no_valid_source (ff-pointer self)))

(cl:defmethod is-valid-buffer ((self sgsample-queue))
  (SGSampleQueue_is_valid_buffer (ff-pointer self)))

(cl:defmethod is-queue ((self sgsample-queue))
  (SGSampleQueue_is_queue (ff-pointer self)))


(cl:defclass sgsound-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsound-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSoundMgr)))

(cl:defmethod init ((self sgsound-mgr) (devname cl:string))
  (SGSoundMgr_init (ff-pointer self) devname))

(cl:defmethod init ((self sgsound-mgr))
  (SGSoundMgr_init (ff-pointer self)))

(cl:defmethod bind ((self sgsound-mgr))
  (SGSoundMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self sgsound-mgr))
  (SGSoundMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self sgsound-mgr) (dt cl:number))
  (SGSoundMgr_update (ff-pointer self) dt))

(cl:defmethod suspend ((self sgsound-mgr))
  (SGSoundMgr_suspend (ff-pointer self)))

(cl:defmethod resume ((self sgsound-mgr))
  (SGSoundMgr_resume (ff-pointer self)))

(cl:defmethod stop ((self sgsound-mgr))
  (SGSoundMgr_stop (ff-pointer self)))

(cl:defmethod reinit ((self sgsound-mgr))
  (SGSoundMgr_reinit (ff-pointer self)))

(cl:defmethod is-working ((self sgsound-mgr))
  (SGSoundMgr_is_working (ff-pointer self)))

(cl:defmethod activate ((self sgsound-mgr))
  (SGSoundMgr_activate (ff-pointer self)))

(cl:defmethod is-active ((self sgsound-mgr))
  (SGSoundMgr_is_active (ff-pointer self)))

(cl:defmethod add ((self sgsound-mgr) (sgrp sgsample-group) refname)
  (SGSoundMgr_add (ff-pointer self) sgrp refname))

(cl:defmethod remove ((self sgsound-mgr) refname)
  (SGSoundMgr_remove (ff-pointer self) refname))

(cl:defmethod exists ((self sgsound-mgr) refname)
  (SGSoundMgr_exists (ff-pointer self) refname))

(cl:defmethod find ((self sgsound-mgr) refname (create t))
  (SGSoundMgr_find (ff-pointer self) refname create))

(cl:defmethod find ((self sgsound-mgr) refname)
  (SGSoundMgr_find (ff-pointer self) refname))

(cl:defmethod set-position ((self sgsound-mgr) pos (pos_geod sggeod))
  (SGSoundMgr_set_position (ff-pointer self) pos pos_geod))

(cl:defmethod set-position-offset ((self sgsound-mgr) pos)
  (SGSoundMgr_set_position_offset (ff-pointer self) pos))

(cl:defmethod get-position ((self sgsound-mgr))
  (SGSoundMgr_get_position (ff-pointer self)))

(cl:defmethod set-velocity ((self sgsound-mgr) vel)
  (SGSoundMgr_set_velocity (ff-pointer self) vel))

(cl:defmethod get-velocity ((self sgsound-mgr))
  (SGSoundMgr_get_velocity (ff-pointer self)))

(cl:defmethod set-orientation ((self sgsound-mgr) ori)
  (SGSoundMgr_set_orientation (ff-pointer self) ori))

(cl:defmethod get-orientation ((self sgsound-mgr))
  (SGSoundMgr_get_orientation (ff-pointer self)))

(cl:defmethod get-direction ((self sgsound-mgr))
  (SGSoundMgr_get_direction (ff-pointer self)))

(cl:defmethod set-volume ((self sgsound-mgr) (vol cl:number))
  (SGSoundMgr_set_volume (ff-pointer self) vol))

(cl:defmethod get-volume ((self sgsound-mgr))
  (SGSoundMgr_get_volume (ff-pointer self)))

(cl:defmethod request-source ((self sgsound-mgr))
  (SGSoundMgr_request_source (ff-pointer self)))

(cl:defmethod release-source ((self sgsound-mgr) (source cl:integer))
  (SGSoundMgr_release_source (ff-pointer self) source))

(cl:defmethod request-buffer ((self sgsound-mgr) (sample sgsound-sample))
  (SGSoundMgr_request_buffer (ff-pointer self) sample))

(cl:defmethod release-buffer ((self sgsound-mgr) (sample sgsound-sample))
  (SGSoundMgr_release_buffer (ff-pointer self) sample))

(cl:defmethod has-changed ((self sgsound-mgr))
  (SGSoundMgr_has_changed (ff-pointer self)))

(cl:defmethod bad-doppler-effect ((self sgsound-mgr))
  (SGSoundMgr_bad_doppler_effect (ff-pointer self)))

(cl:defmethod load ((self sgsound-mgr) samplepath data format size freq)
  (SGSoundMgr_load (ff-pointer self) samplepath data format size freq))

(cl:defmethod get-available-devices ((self sgsound-mgr))
  (SGSoundMgr_get_available_devices (ff-pointer self)))

(cl:defmethod get-vendor ((self sgsound-mgr))
  (SGSoundMgr_get_vendor (ff-pointer self)))

(cl:defmethod get-renderer ((self sgsound-mgr))
  (SGSoundMgr_get_renderer (ff-pointer self)))


(cl:defclass sgxml-sound()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgxml-sound) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGXmlSound)))

(cl:defmethod init ((self sgxml-sound) (arg1 sgproperty-node) (arg2 sgproperty-node) (arg3 sgsample-group) (arg4 sgsample-group) (currentDir sgpath))
  (SGXmlSound_init (ff-pointer self) arg1 arg2 arg3 arg4 currentDir))

(cl:defmethod update ((self sgxml-sound) (dt cl:number))
  (SGXmlSound_update (ff-pointer self) dt))

(cl:defmethod stop ((self sgxml-sound))
  (SGXmlSound_stop (ff-pointer self)))


(cl:defclass sgatomic()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgatomic) &key (value cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGAtomic value)))

(cl:defmethod initialize-instance :after ((obj sgatomic) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGAtomic)))

(cl:shadow "++")
(cl:defmethod ++ ((self sgatomic))
  (SGAtomic___preincr__ (ff-pointer self)))

(cl:shadow "--")
(cl:defmethod -- ((self sgatomic))
  (SGAtomic___predecr__ (ff-pointer self)))

(cl:defmethod compare-and-exchange ((self sgatomic) (oldValue cl:integer) (newValue cl:integer))
  (SGAtomic_compareAndExchange (ff-pointer self) oldValue newValue))


(cl:defclass sgbinding(SGConditional)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgbinding) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGBinding)))

(cl:defmethod initialize-instance :after ((obj sgbinding) &key (node sgproperty-node) (root sgproperty-node))
  (setf (slot-value obj 'ff-pointer) (new_SGBinding node root)))

(cl:defmethod get-command-name ((self sgbinding))
  (SGBinding_getCommandName (ff-pointer self)))

(cl:defmethod get-command ((self sgbinding))
  (SGBinding_getCommand (ff-pointer self)))

(cl:defmethod get-arg ((self sgbinding))
  (SGBinding_getArg (ff-pointer self)))

(cl:defmethod read ((self sgbinding) (node sgproperty-node) (root sgproperty-node))
  (SGBinding_read (ff-pointer self) node root))

(cl:defmethod fire ((self sgbinding))
  (SGBinding_fire (ff-pointer self)))

(cl:defmethod fire ((self sgbinding) (offset cl:number) (max cl:number))
  (SGBinding_fire (ff-pointer self) offset max))

(cl:defmethod fire ((self sgbinding) (setting cl:number))
  (SGBinding_fire (ff-pointer self) setting))


(cl:defclass sgreferenced()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgreferenced) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGReferenced)))

(cl:defmethod initialize-instance :after ((obj sgreferenced) &key (arg0 sgreferenced))
  (setf (slot-value obj 'ff-pointer) (new_SGReferenced (ff-pointer arg0))))

(cl:shadow "=")
(cl:defmethod = ((self sgreferenced) (arg1 sgreferenced))
  (SGReferenced___assign__ (ff-pointer self) (ff-pointer arg1)))


(cl:defclass sample-histogram()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sample-histogram) &key (low cl:number) (hi cl:number) (bucketWidth cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SampleHistogram low hi bucketWidth)))

(cl:defmethod initialize-instance :after ((obj sample-histogram) &key (low cl:number) (hi cl:number))
  (setf (slot-value obj 'ff-pointer) (new_SampleHistogram low hi)))

(cl:defmethod reset ((self sample-histogram))
  (SampleHistogram_reset (ff-pointer self)))

(cl:shadow "+=")
(cl:defmethod += ((self sample-histogram) (arg1 cl:number))
  (SampleHistogram___add_assign__ (ff-pointer self) arg1))

(cl:defmethod similar-samples ((self sample-histogram) (arg1 cl:number))
  (SampleHistogram_similarSamples (ff-pointer self) arg1))

(cl:defmethod buckets ((self sample-histogram))
  (SampleHistogram_buckets (ff-pointer self)))

(cl:defmethod bucket-threshold ((self sample-histogram) (i cl:integer))
  (SampleHistogram_bucketThreshold (ff-pointer self) i))

(cl:defmethod in-bucket ((self sample-histogram) (i cl:integer))
  (SampleHistogram_inBucket (ff-pointer self) i))

(cl:defmethod print-buckets ((self sample-histogram) arg1)
  (SampleHistogram_printBuckets (ff-pointer self) arg1))


(cl:defclass sample-statistic()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sample-statistic) &key)
  (setf (slot-value obj 'ff-pointer) (new_SampleStatistic)))

(cl:defmethod reset ((self sample-statistic))
  (SampleStatistic_reset (ff-pointer self)))

(cl:shadow "+=")
(cl:defmethod += ((self sample-statistic) (arg1 cl:number))
  (SampleStatistic___add_assign__ (ff-pointer self) arg1))

(cl:defmethod samples ((self sample-statistic))
  (SampleStatistic_samples (ff-pointer self)))

(cl:defmethod mean ((self sample-statistic))
  (SampleStatistic_mean (ff-pointer self)))

(cl:defmethod std-dev ((self sample-statistic))
  (SampleStatistic_stdDev (ff-pointer self)))

(cl:defmethod var ((self sample-statistic))
  (SampleStatistic_var (ff-pointer self)))

(cl:defmethod min ((self sample-statistic))
  (SampleStatistic_min (ff-pointer self)))

(cl:defmethod max ((self sample-statistic))
  (SampleStatistic_max (ff-pointer self)))

(cl:defmethod confidence ((self sample-statistic) (p_percentage cl:integer))
  (SampleStatistic_confidence (ff-pointer self) p_percentage))

(cl:defmethod confidence ((self sample-statistic) (p_value cl:number))
  (SampleStatistic_confidence (ff-pointer self) p_value))

(cl:defmethod error ((self sample-statistic) (msg cl:string))
  (SampleStatistic_error (ff-pointer self) msg))


(cl:defclass sgweak-referenced()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgweak-referenced) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGWeakReferenced)))

(cl:defmethod initialize-instance :after ((obj sgweak-referenced) &key (weakReferenced sgweak-referenced))
  (setf (slot-value obj 'ff-pointer) (new_SGWeakReferenced (ff-pointer weakReferenced))))

(cl:shadow "=")
(cl:defmethod = ((self sgweak-referenced) (arg1 sgweak-referenced))
  (SGWeakReferenced___assign__ (ff-pointer self) (ff-pointer arg1)))


(cl:defclass string-table()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj string-table) &key)
  (setf (slot-value obj 'ff-pointer) (new_StringTable)))


(cl:defclass sgcallback()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod clone ((self sgcallback))
  (SGCallback_clone (ff-pointer self)))

(cl:shadow "()")
(cl:defmethod () ((self sgcallback))
  (SGCallback___funcall__ (ff-pointer self)))


(cl:defclass sgcommand-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod add-command ((self sgcommand-mgr) name command)
  (SGCommandMgr_addCommand (ff-pointer self) name command))

(cl:defmethod get-command ((self sgcommand-mgr) name)
  (SGCommandMgr_getCommand (ff-pointer self) name))

(cl:defmethod get-command-names ((self sgcommand-mgr))
  (SGCommandMgr_getCommandNames (ff-pointer self)))

(cl:defmethod execute ((self sgcommand-mgr) name (arg sgproperty-node))
  (SGCommandMgr_execute (ff-pointer self) name arg))


(cl:defclass sgtimer()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod run ((self sgtimer))
  (SGTimer_run (ff-pointer self)))

(cl:defmethod (cl:setf name) (arg0 (obj sgtimer))
  (SGTimer_name_set (ff-pointer obj) arg0))

(cl:defmethod name ((obj sgtimer))
  (SGTimer_name_get (ff-pointer obj)))

(cl:defmethod (cl:setf interval) (arg0 (obj sgtimer))
  (SGTimer_interval_set (ff-pointer obj) arg0))

(cl:defmethod interval ((obj sgtimer))
  (SGTimer_interval_get (ff-pointer obj)))

(cl:defmethod (cl:setf callback) (arg0 (obj sgtimer))
  (SGTimer_callback_set (ff-pointer obj) arg0))

(cl:defmethod callback ((obj sgtimer))
  (SGTimer_callback_get (ff-pointer obj)))

(cl:defmethod (cl:setf repeat) (arg0 (obj sgtimer))
  (SGTimer_repeat_set (ff-pointer obj) arg0))

(cl:defmethod repeat ((obj sgtimer))
  (SGTimer_repeat_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj sgtimer) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGTimer)))


(cl:defclass sgtimer-queue()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtimer-queue) &key (preSize cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_SGTimerQueue preSize)))

(cl:defmethod initialize-instance :after ((obj sgtimer-queue) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGTimerQueue)))

(cl:defmethod update ((self sgtimer-queue) (deltaSecs cl:number))
  (SGTimerQueue_update (ff-pointer self) deltaSecs))

(cl:defmethod now ((self sgtimer-queue))
  (SGTimerQueue_now (ff-pointer self)))

(cl:defmethod insert ((self sgtimer-queue) (timer sgtimer) (time cl:number))
  (SGTimerQueue_insert (ff-pointer self) timer time))

(cl:defmethod remove ((self sgtimer-queue) (timer sgtimer))
  (SGTimerQueue_remove (ff-pointer self) timer))

(cl:defmethod remove ((self sgtimer-queue))
  (SGTimerQueue_remove (ff-pointer self)))

(cl:defmethod next-timer ((self sgtimer-queue))
  (SGTimerQueue_nextTimer (ff-pointer self)))

(cl:defmethod next-time ((self sgtimer-queue))
  (SGTimerQueue_nextTime (ff-pointer self)))

(cl:defmethod find-by-name ((self sgtimer-queue) name)
  (SGTimerQueue_findByName (ff-pointer self) name))


(cl:defclass sgevent-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgevent-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGEventMgr)))

(cl:defmethod init ((self sgevent-mgr))
  (SGEventMgr_init (ff-pointer self)))

(cl:defmethod update ((self sgevent-mgr) (delta_time_sec cl:number))
  (SGEventMgr_update (ff-pointer self) delta_time_sec))

(cl:defmethod set-realtime-property ((self sgevent-mgr) (node sgproperty-node))
  (SGEventMgr_setRealtimeProperty (ff-pointer self) node))

(cl:defmethod remove-task ((self sgevent-mgr) name)
  (SGEventMgr_removeTask (ff-pointer self) name))


(cl:defclass sg-location()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_location)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key path (line cl:integer) (column cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_sg_location path line column)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key path (line cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_sg_location path line)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key path)
  (setf (slot-value obj 'ff-pointer) (new_sg_location path)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key (path cl:string) (line cl:integer) (column cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_sg_location path line column)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key (path cl:string) (line cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_sg_location path line)))

(cl:defmethod initialize-instance :after ((obj sg-location) &key (path cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_location path)))

(cl:defmethod get-path ((self sg-location))
  (sg_location_getPath (ff-pointer self)))

(cl:defmethod set-path ((self sg-location) (path cl:string))
  (sg_location_setPath (ff-pointer self) path))

(cl:defmethod get-line ((self sg-location))
  (sg_location_getLine (ff-pointer self)))

(cl:defmethod set-line ((self sg-location) (line cl:integer))
  (sg_location_setLine (ff-pointer self) line))

(cl:defmethod get-column ((self sg-location))
  (sg_location_getColumn (ff-pointer self)))

(cl:defmethod set-column ((self sg-location) (column cl:integer))
  (sg_location_setColumn (ff-pointer self) column))

(cl:defmethod get-byte ((self sg-location))
  (sg_location_getByte (ff-pointer self)))

(cl:defmethod set-byte ((self sg-location) (byte cl:integer))
  (sg_location_setByte (ff-pointer self) byte))

(cl:defmethod as-string ((self sg-location))
  (sg_location_asString (ff-pointer self)))


(cl:defclass sg-throwable()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-throwable) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_throwable)))

(cl:defmethod initialize-instance :after ((obj sg-throwable) &key (message cl:string) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_throwable message origin)))

(cl:defmethod initialize-instance :after ((obj sg-throwable) &key (message cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_throwable message)))

(cl:defmethod get-message ((self sg-throwable))
  (sg_throwable_getMessage (ff-pointer self)))

(cl:defmethod get-formatted-message ((self sg-throwable))
  (sg_throwable_getFormattedMessage (ff-pointer self)))

(cl:defmethod set-message ((self sg-throwable) (message cl:string))
  (sg_throwable_setMessage (ff-pointer self) message))

(cl:defmethod get-origin ((self sg-throwable))
  (sg_throwable_getOrigin (ff-pointer self)))

(cl:defmethod set-origin ((self sg-throwable) (origin cl:string))
  (sg_throwable_setOrigin (ff-pointer self) origin))

(cl:defmethod what ((self sg-throwable))
  (sg_throwable_what (ff-pointer self)))


(cl:defclass sg-error(sg_throwable)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-error) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_error)))

(cl:defmethod initialize-instance :after ((obj sg-error) &key (message cl:string) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_error message origin)))

(cl:defmethod initialize-instance :after ((obj sg-error) &key (message cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_error message)))

(cl:defmethod initialize-instance :after ((obj sg-error) &key message origin)
  (setf (slot-value obj 'ff-pointer) (new_sg_error message origin)))

(cl:defmethod initialize-instance :after ((obj sg-error) &key message)
  (setf (slot-value obj 'ff-pointer) (new_sg_error message)))


(cl:defclass sg-exception(sg_throwable)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-exception) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_exception)))

(cl:defmethod initialize-instance :after ((obj sg-exception) &key (message cl:string) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_exception message origin)))

(cl:defmethod initialize-instance :after ((obj sg-exception) &key (message cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_exception message)))

(cl:defmethod initialize-instance :after ((obj sg-exception) &key message arg1)
  (setf (slot-value obj 'ff-pointer) (new_sg_exception message arg1)))

(cl:defmethod initialize-instance :after ((obj sg-exception) &key message)
  (setf (slot-value obj 'ff-pointer) (new_sg_exception message)))


(cl:defclass sg-io-exception(sg_exception)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key (message cl:string) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message origin)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key (message cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key (message cl:string) (location sg-location) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message location origin)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key (message cl:string) (location sg-location))
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message location)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key message origin)
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message origin)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key message)
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key message (location sg-location) origin)
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message location origin)))

(cl:defmethod initialize-instance :after ((obj sg-io-exception) &key message (location sg-location))
  (setf (slot-value obj 'ff-pointer) (new_sg_io_exception message location)))

(cl:defmethod get-formatted-message ((self sg-io-exception))
  (sg_io_exception_getFormattedMessage (ff-pointer self)))

(cl:defmethod get-location ((self sg-io-exception))
  (sg_io_exception_getLocation (ff-pointer self)))

(cl:defmethod set-location ((self sg-io-exception) (location sg-location))
  (sg_io_exception_setLocation (ff-pointer self) location))


(cl:defclass sg-format-exception(sg_exception)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-format-exception) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_format_exception)))

(cl:defmethod initialize-instance :after ((obj sg-format-exception) &key (message cl:string) (text cl:string) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_format_exception message text origin)))

(cl:defmethod initialize-instance :after ((obj sg-format-exception) &key (message cl:string) (text cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_format_exception message text)))

(cl:defmethod initialize-instance :after ((obj sg-format-exception) &key message text origin)
  (setf (slot-value obj 'ff-pointer) (new_sg_format_exception message text origin)))

(cl:defmethod initialize-instance :after ((obj sg-format-exception) &key message text)
  (setf (slot-value obj 'ff-pointer) (new_sg_format_exception message text)))

(cl:defmethod get-text ((self sg-format-exception))
  (sg_format_exception_getText (ff-pointer self)))

(cl:defmethod set-text ((self sg-format-exception) (text cl:string))
  (sg_format_exception_setText (ff-pointer self) text))


(cl:defclass sg-range-exception(sg_exception)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sg-range-exception) &key)
  (setf (slot-value obj 'ff-pointer) (new_sg_range_exception)))

(cl:defmethod initialize-instance :after ((obj sg-range-exception) &key (message cl:string) (origin cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_range_exception message origin)))

(cl:defmethod initialize-instance :after ((obj sg-range-exception) &key (message cl:string))
  (setf (slot-value obj 'ff-pointer) (new_sg_range_exception message)))

(cl:defmethod initialize-instance :after ((obj sg-range-exception) &key message origin)
  (setf (slot-value obj 'ff-pointer) (new_sg_range_exception message origin)))

(cl:defmethod initialize-instance :after ((obj sg-range-exception) &key message)
  (setf (slot-value obj 'ff-pointer) (new_sg_range_exception message)))


(cl:defclass timing-info()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj timing-info) &key name t-arg1)
  (setf (slot-value obj 'ff-pointer) (new_TimingInfo name t-arg1)))

(cl:defmethod get-name ((self timing-info))
  (TimingInfo_getName (ff-pointer self)))

(cl:defmethod get-time ((self timing-info))
  (TimingInfo_getTime (ff-pointer self)))


(cl:defclass sgsubsystem(SGReferenced)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod init ((self sgsubsystem))
  (SGSubsystem_init (ff-pointer self)))

(cl:defmethod postinit ((self sgsubsystem))
  (SGSubsystem_postinit (ff-pointer self)))

(cl:defmethod reinit ((self sgsubsystem))
  (SGSubsystem_reinit (ff-pointer self)))

(cl:defmethod shutdown ((self sgsubsystem))
  (SGSubsystem_shutdown (ff-pointer self)))

(cl:defmethod bind ((self sgsubsystem))
  (SGSubsystem_bind (ff-pointer self)))

(cl:defmethod unbind ((self sgsubsystem))
  (SGSubsystem_unbind (ff-pointer self)))

(cl:defmethod update ((self sgsubsystem) (delta_time_sec cl:number))
  (SGSubsystem_update (ff-pointer self) delta_time_sec))

(cl:defmethod suspend ((self sgsubsystem))
  (SGSubsystem_suspend (ff-pointer self)))

(cl:defmethod suspend ((self sgsubsystem) (suspended t))
  (SGSubsystem_suspend (ff-pointer self) suspended))

(cl:defmethod resume ((self sgsubsystem))
  (SGSubsystem_resume (ff-pointer self)))

(cl:defmethod is-suspended ((self sgsubsystem))
  (SGSubsystem_is_suspended (ff-pointer self)))

(cl:defmethod update-execution-time ((self sgsubsystem) (time cl:number))
  (SGSubsystem_updateExecutionTime (ff-pointer self) time))

(cl:defmethod print-timing-information ((self sgsubsystem))
  (SGSubsystem_printTimingInformation (ff-pointer self)))

(cl:defmethod stamp ((self sgsubsystem) name)
  (SGSubsystem_stamp (ff-pointer self) name))


(cl:defclass sgsubsystem-group(SGSubsystem)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsubsystem-group) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSubsystemGroup)))

(cl:defmethod init ((self sgsubsystem-group))
  (SGSubsystemGroup_init (ff-pointer self)))

(cl:defmethod postinit ((self sgsubsystem-group))
  (SGSubsystemGroup_postinit (ff-pointer self)))

(cl:defmethod reinit ((self sgsubsystem-group))
  (SGSubsystemGroup_reinit (ff-pointer self)))

(cl:defmethod shutdown ((self sgsubsystem-group))
  (SGSubsystemGroup_shutdown (ff-pointer self)))

(cl:defmethod bind ((self sgsubsystem-group))
  (SGSubsystemGroup_bind (ff-pointer self)))

(cl:defmethod unbind ((self sgsubsystem-group))
  (SGSubsystemGroup_unbind (ff-pointer self)))

(cl:defmethod update ((self sgsubsystem-group) (delta_time_sec cl:number))
  (SGSubsystemGroup_update (ff-pointer self) delta_time_sec))

(cl:defmethod suspend ((self sgsubsystem-group))
  (SGSubsystemGroup_suspend (ff-pointer self)))

(cl:defmethod resume ((self sgsubsystem-group))
  (SGSubsystemGroup_resume (ff-pointer self)))

(cl:defmethod is-suspended ((self sgsubsystem-group))
  (SGSubsystemGroup_is_suspended (ff-pointer self)))

(cl:defmethod set-subsystem ((self sgsubsystem-group) name (subsystem sgsubsystem) (min_step_sec cl:number))
  (SGSubsystemGroup_set_subsystem (ff-pointer self) name subsystem min_step_sec))

(cl:defmethod set-subsystem ((self sgsubsystem-group) name (subsystem sgsubsystem))
  (SGSubsystemGroup_set_subsystem (ff-pointer self) name subsystem))

(cl:defmethod get-subsystem ((self sgsubsystem-group) name)
  (SGSubsystemGroup_get_subsystem (ff-pointer self) name))

(cl:defmethod remove-subsystem ((self sgsubsystem-group) name)
  (SGSubsystemGroup_remove_subsystem (ff-pointer self) name))

(cl:defmethod has-subsystem ((self sgsubsystem-group) name)
  (SGSubsystemGroup_has_subsystem (ff-pointer self) name))

(cl:defmethod collect-debug-timing ((self sgsubsystem-group) (collect t))
  (SGSubsystemGroup_collectDebugTiming (ff-pointer self) collect))

(cl:defmethod print-timing-statistics ((self sgsubsystem-group) (minMaxTime cl:number) (minJitter cl:number))
  (SGSubsystemGroup_printTimingStatistics (ff-pointer self) minMaxTime minJitter))

(cl:defmethod print-timing-statistics ((self sgsubsystem-group) (minMaxTime cl:number))
  (SGSubsystemGroup_printTimingStatistics (ff-pointer self) minMaxTime))

(cl:defmethod print-timing-statistics ((self sgsubsystem-group))
  (SGSubsystemGroup_printTimingStatistics (ff-pointer self)))

(cl:defmethod set-fixed-update-time ((self sgsubsystem-group) (fixed_dt cl:number))
  (SGSubsystemGroup_set_fixed_update_time (ff-pointer self) fixed_dt))


(cl:defclass sgsubsystem-mgr(SGSubsystem)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgsubsystem-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGSubsystemMgr)))

(cl:defmethod init ((self sgsubsystem-mgr))
  (SGSubsystemMgr_init (ff-pointer self)))

(cl:defmethod postinit ((self sgsubsystem-mgr))
  (SGSubsystemMgr_postinit (ff-pointer self)))

(cl:defmethod reinit ((self sgsubsystem-mgr))
  (SGSubsystemMgr_reinit (ff-pointer self)))

(cl:defmethod shutdown ((self sgsubsystem-mgr))
  (SGSubsystemMgr_shutdown (ff-pointer self)))

(cl:defmethod bind ((self sgsubsystem-mgr))
  (SGSubsystemMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self sgsubsystem-mgr))
  (SGSubsystemMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self sgsubsystem-mgr) (delta_time_sec cl:number))
  (SGSubsystemMgr_update (ff-pointer self) delta_time_sec))

(cl:defmethod suspend ((self sgsubsystem-mgr))
  (SGSubsystemMgr_suspend (ff-pointer self)))

(cl:defmethod resume ((self sgsubsystem-mgr))
  (SGSubsystemMgr_resume (ff-pointer self)))

(cl:defmethod is-suspended ((self sgsubsystem-mgr))
  (SGSubsystemMgr_is_suspended (ff-pointer self)))

(cl:defmethod add ((self sgsubsystem-mgr) (name cl:string) (subsystem sgsubsystem) (group cl:integer) (min_time_sec cl:number))
  (SGSubsystemMgr_add (ff-pointer self) name subsystem group min_time_sec))

(cl:defmethod add ((self sgsubsystem-mgr) (name cl:string) (subsystem sgsubsystem) (group cl:integer))
  (SGSubsystemMgr_add (ff-pointer self) name subsystem group))

(cl:defmethod add ((self sgsubsystem-mgr) (name cl:string) (subsystem sgsubsystem))
  (SGSubsystemMgr_add (ff-pointer self) name subsystem))

(cl:defmethod remove ((self sgsubsystem-mgr) (name cl:string))
  (SGSubsystemMgr_remove (ff-pointer self) name))

(cl:defmethod get-group ((self sgsubsystem-mgr) (group cl:integer))
  (SGSubsystemMgr_get_group (ff-pointer self) group))

(cl:defmethod get-subsystem ((self sgsubsystem-mgr) name)
  (SGSubsystemMgr_get_subsystem (ff-pointer self) name))

(cl:defmethod collect-debug-timing ((self sgsubsystem-mgr) (collect t))
  (SGSubsystemMgr_collectDebugTiming (ff-pointer self) collect))

(cl:defmethod print-timing-statistics ((self sgsubsystem-mgr) (minMaxTime cl:number) (minJitter cl:number))
  (SGSubsystemMgr_printTimingStatistics (ff-pointer self) minMaxTime minJitter))

(cl:defmethod print-timing-statistics ((self sgsubsystem-mgr) (minMaxTime cl:number))
  (SGSubsystemMgr_printTimingStatistics (ff-pointer self) minMaxTime))

(cl:defmethod print-timing-statistics ((self sgsubsystem-mgr))
  (SGSubsystemMgr_printTimingStatistics (ff-pointer self)))


(cl:defclass sgthread()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod start ((self sgthread) (cpu cl:integer))
  (SGThread_start (ff-pointer self) cpu))

(cl:defmethod start ((self sgthread))
  (SGThread_start (ff-pointer self)))

(cl:defmethod cancel ((self sgthread))
  (SGThread_cancel (ff-pointer self)))

(cl:defmethod join ((self sgthread))
  (SGThread_join (ff-pointer self)))


(cl:defclass sgmutex()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgmutex) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGMutex)))

(cl:defmethod lock ((self sgmutex))
  (SGMutex_lock (ff-pointer self)))

(cl:defmethod trylock ((self sgmutex))
  (SGMutex_trylock (ff-pointer self)))

(cl:defmethod unlock ((self sgmutex))
  (SGMutex_unlock (ff-pointer self)))


(cl:defclass sgpthread-cond()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgpthread-cond) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGPthreadCond)))

(cl:defmethod wait ((self sgpthread-cond) (arg1 sgmutex))
  (SGPthreadCond_wait (ff-pointer self) arg1))

(cl:defmethod wait ((self sgpthread-cond) (mutex sgmutex) (ms cl:integer))
  (SGPthreadCond_wait (ff-pointer self) mutex ms))

(cl:defmethod signal ((self sgpthread-cond))
  (SGPthreadCond_signal (ff-pointer self)))

(cl:defmethod broadcast ((self sgpthread-cond))
  (SGPthreadCond_broadcast (ff-pointer self)))


(cl:defclass sgtime()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj sgtime) &key)
  (setf (slot-value obj 'ff-pointer) (new_SGTime)))

(cl:defmethod initialize-instance :after ((obj sgtime) &key (lon_rad cl:number) (lat_rad cl:number) root init_time)
  (setf (slot-value obj 'ff-pointer) (new_SGTime lon_rad lat_rad root init_time)))

(cl:defmethod initialize-instance :after ((obj sgtime) &key root)
  (setf (slot-value obj 'ff-pointer) (new_SGTime root)))

(cl:defmethod update ((self sgtime) (lon_rad cl:number) (lat_rad cl:number) ct (warp cl:integer))
  (SGTime_update (ff-pointer self) lon_rad lat_rad ct warp))

(cl:defmethod update-local ((self sgtime) (lon_rad cl:number) (lat_rad cl:number) root)
  (SGTime_updateLocal (ff-pointer self) lon_rad lat_rad root))

(cl:defmethod get-cur-time ((self sgtime))
  (SGTime_get_cur_time (ff-pointer self)))

(cl:defmethod get-zonename ((self sgtime))
  (SGTime_get_zonename (ff-pointer self)))

(cl:defmethod get-gmt ((self sgtime))
  (SGTime_getGmt (ff-pointer self)))

(cl:defmethod get-jd ((self sgtime))
  (SGTime_getJD (ff-pointer self)))

(cl:defmethod get-mjd ((self sgtime))
  (SGTime_getMjd (ff-pointer self)))

(cl:defmethod get-lst ((self sgtime))
  (SGTime_getLst (ff-pointer self)))

(cl:defmethod get-gst ((self sgtime))
  (SGTime_getGst (ff-pointer self)))

(cl:defmethod get-local-offset ((self sgtime))
  (SGTime_get_local_offset (ff-pointer self)))


(cl:defclass xmlattributes()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod size ((self xmlattributes))
  (XMLAttributes_size (ff-pointer self)))

(cl:defmethod get-name ((self xmlattributes) (i cl:integer))
  (XMLAttributes_getName (ff-pointer self) i))

(cl:defmethod get-value ((self xmlattributes) (i cl:integer))
  (XMLAttributes_getValue (ff-pointer self) i))

(cl:defmethod find-attribute ((self xmlattributes) (name cl:string))
  (XMLAttributes_findAttribute (ff-pointer self) name))

(cl:defmethod has-attribute ((self xmlattributes) (name cl:string))
  (XMLAttributes_hasAttribute (ff-pointer self) name))

(cl:defmethod get-value ((self xmlattributes) (name cl:string))
  (XMLAttributes_getValue (ff-pointer self) name))


(cl:defclass xmlattributes-default(XMLAttributes)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj xmlattributes-default) &key)
  (setf (slot-value obj 'ff-pointer) (new_XMLAttributesDefault)))

(cl:defmethod initialize-instance :after ((obj xmlattributes-default) &key (atts xmlattributes))
  (setf (slot-value obj 'ff-pointer) (new_XMLAttributesDefault atts)))

(cl:defmethod size ((self xmlattributes-default))
  (XMLAttributesDefault_size (ff-pointer self)))

(cl:defmethod get-name ((self xmlattributes-default) (i cl:integer))
  (XMLAttributesDefault_getName (ff-pointer self) i))

(cl:defmethod get-value ((self xmlattributes-default) (i cl:integer))
  (XMLAttributesDefault_getValue (ff-pointer self) i))

(cl:defmethod add-attribute ((self xmlattributes-default) (name cl:string) (value cl:string))
  (XMLAttributesDefault_addAttribute (ff-pointer self) name value))

(cl:defmethod set-name ((self xmlattributes-default) (i cl:integer) (name cl:string))
  (XMLAttributesDefault_setName (ff-pointer self) i name))

(cl:defmethod set-value ((self xmlattributes-default) (i cl:integer) (value cl:string))
  (XMLAttributesDefault_setValue (ff-pointer self) i value))

(cl:defmethod set-value ((self xmlattributes-default) (name cl:string) (value cl:string))
  (XMLAttributesDefault_setValue (ff-pointer self) name value))


(cl:defclass xmlvisitor()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod start-xml ((self xmlvisitor))
  (XMLVisitor_startXML (ff-pointer self)))

(cl:defmethod end-xml ((self xmlvisitor))
  (XMLVisitor_endXML (ff-pointer self)))

(cl:defmethod start-element ((self xmlvisitor) (name cl:string) (atts xmlattributes))
  (XMLVisitor_startElement (ff-pointer self) name atts))

(cl:defmethod end-element ((self xmlvisitor) (name cl:string))
  (XMLVisitor_endElement (ff-pointer self) name))

(cl:defmethod data ((self xmlvisitor) (s cl:string) (length cl:integer))
  (XMLVisitor_data (ff-pointer self) s length))

(cl:defmethod pi ((self xmlvisitor) (target cl:string) (data cl:string))
  (XMLVisitor_pi (ff-pointer self) target data))

(cl:defmethod warning ((self xmlvisitor) (message cl:string) (line cl:integer) (column cl:integer))
  (XMLVisitor_warning (ff-pointer self) message line column))

(cl:defmethod initialize-instance :after ((obj xmlvisitor) &key)
  (setf (slot-value obj 'ff-pointer) (new_XMLVisitor)))
ViewGit