(cl:defclass fgaiaircraft(FGAIBase)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgaiaircraft) &key ref)
  (setf (slot-value obj 'ff-pointer) (new_FGAIAircraft ref)))

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

(cl:defmethod read-from-scenario ((self fgaiaircraft) scFileNode)
  (FGAIAircraft_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod bind ((self fgaiaircraft))
  (FGAIAircraft_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaiaircraft))
  (FGAIAircraft_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaiaircraft) (dt cl:number))
  (FGAIAircraft_update (ff-pointer self) dt))

(cl:defmethod set-performance ((self fgaiaircraft) perfString)
  (FGAIAircraft_setPerformance (ff-pointer self) perfString))

(cl:defmethod set-performance ((self fgaiaircraft) ps)
  (FGAIAircraft_setPerformance (ff-pointer self) ps))

(cl:defmethod set-flight-plan ((self fgaiaircraft) fp (repat t))
  (FGAIAircraft_setFlightPlan (ff-pointer self) fp repat))

(cl:defmethod set-flight-plan ((self fgaiaircraft) fp)
  (FGAIAircraft_setFlightPlan (ff-pointer self) fp))

(cl:defmethod set-flight-plan ((self fgaiaircraft) f)
  (FGAIAircraft_SetFlightPlan (ff-pointer self) f))

(cl:defmethod initialize-flight-plan ((self fgaiaircraft))
  (FGAIAircraft_initializeFlightPlan (ff-pointer self)))

(cl:defmethod get-flight-plan ((self fgaiaircraft))
  (FGAIAircraft_GetFlightPlan (ff-pointer self)))

(cl:defmethod process-flight-plan ((self fgaiaircraft) (dt cl:number) now)
  (FGAIAircraft_ProcessFlightPlan (ff-pointer self) dt now))

(cl:defmethod check-for-arrival-time ((self fgaiaircraft) wptName)
  (FGAIAircraft_checkForArrivalTime (ff-pointer self) wptName))

(cl:defmethod accel-to ((self fgaiaircraft) (speed cl:number))
  (FGAIAircraft_AccelTo (ff-pointer self) speed))

(cl:defmethod pitch-to ((self fgaiaircraft) (angle cl:number))
  (FGAIAircraft_PitchTo (ff-pointer self) angle))

(cl:defmethod roll-to ((self fgaiaircraft) (angle cl:number))
  (FGAIAircraft_RollTo (ff-pointer self) angle))

(cl:defmethod yaw-to ((self fgaiaircraft) (angle cl:number))
  (FGAIAircraft_YawTo (ff-pointer self) angle))

(cl:defmethod climb-to ((self fgaiaircraft) (altitude cl:number))
  (FGAIAircraft_ClimbTo (ff-pointer self) altitude))

(cl:defmethod turn-to ((self fgaiaircraft) (heading cl:number))
  (FGAIAircraft_TurnTo (ff-pointer self) heading))

(cl:defmethod get-ground-elev ((self fgaiaircraft) (dt cl:number))
  (FGAIAircraft_getGroundElev (ff-pointer self) dt))

(cl:defmethod do-ground-altitude ((self fgaiaircraft))
  (FGAIAircraft_doGroundAltitude (ff-pointer self)))

(cl:defmethod load-next-leg ((self fgaiaircraft) (dist cl:number))
  (FGAIAircraft_loadNextLeg (ff-pointer self) dist))

(cl:defmethod load-next-leg ((self fgaiaircraft))
  (FGAIAircraft_loadNextLeg (ff-pointer self)))

(cl:defmethod reset-position-from-flight-plan ((self fgaiaircraft))
  (FGAIAircraft_resetPositionFromFlightPlan (ff-pointer self)))

(cl:defmethod get-bearing ((self fgaiaircraft) (crse cl:number))
  (FGAIAircraft_getBearing (ff-pointer self) crse))

(cl:defmethod set-ac-type ((self fgaiaircraft) ac)
  (FGAIAircraft_setAcType (ff-pointer self) ac))

(cl:defmethod set-company ((self fgaiaircraft) comp)
  (FGAIAircraft_setCompany (ff-pointer self) comp))

(cl:defmethod announce-position-to-controller ((self fgaiaircraft))
  (FGAIAircraft_announcePositionToController (ff-pointer self)))

(cl:defmethod process-atc ((self fgaiaircraft) instruction)
  (FGAIAircraft_processATC (ff-pointer self) instruction))

(cl:defmethod set-taxi-clearance-request ((self fgaiaircraft) (arg t))
  (FGAIAircraft_setTaxiClearanceRequest (ff-pointer self) arg))

(cl:defmethod get-taxi-clearance-request ((self fgaiaircraft))
  (FGAIAircraft_getTaxiClearanceRequest (ff-pointer self)))

(cl:defmethod get-traffic-ref ((self fgaiaircraft))
  (FGAIAircraft_getTrafficRef (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaiaircraft))
  (FGAIAircraft_getTypeString (ff-pointer self)))

(cl:defmethod get-transponder-code ((self fgaiaircraft))
  (FGAIAircraft_GetTransponderCode (ff-pointer self)))

(cl:defmethod set-transponder-code ((self fgaiaircraft) tc)
  (FGAIAircraft_SetTransponderCode (ff-pointer self) tc))

(cl:defmethod get-performance ((self fgaiaircraft))
  (FGAIAircraft_getPerformance (ff-pointer self)))

(cl:defmethod on-ground ((self fgaiaircraft))
  (FGAIAircraft_onGround (ff-pointer self)))

(cl:defmethod get-speed ((self fgaiaircraft))
  (FGAIAircraft_getSpeed (ff-pointer self)))

(cl:defmethod get-roll ((self fgaiaircraft))
  (FGAIAircraft_getRoll (ff-pointer self)))

(cl:defmethod get-pitch ((self fgaiaircraft))
  (FGAIAircraft_getPitch (ff-pointer self)))

(cl:defmethod get-altitude ((self fgaiaircraft))
  (FGAIAircraft_getAltitude (ff-pointer self)))

(cl:defmethod get-vertical-speed ((self fgaiaircraft))
  (FGAIAircraft_getVerticalSpeed (ff-pointer self)))

(cl:defmethod altitude-agl ((self fgaiaircraft))
  (FGAIAircraft_altitudeAGL (ff-pointer self)))

(cl:defmethod airspeed ((self fgaiaircraft))
  (FGAIAircraft_airspeed (ff-pointer self)))

(cl:defmethod at-gate ((self fgaiaircraft))
  (FGAIAircraft_atGate (ff-pointer self)))

(cl:defmethod check-tcas ((self fgaiaircraft))
  (FGAIAircraft_checkTcas (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fgaibase) &key (ot cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGAIBase ot)))

(cl:defmethod read-from-scenario ((self fgaibase) scFileNode)
  (FGAIBase_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod init ((self fgaibase) (search_in_AI_path t))
  (FGAIBase_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaibase))
  (FGAIBase_init (ff-pointer self)))

(cl:defmethod init-model ((self fgaibase) node)
  (FGAIBase_initModel (ff-pointer self) node))

(cl:defmethod update ((self fgaibase) (dt cl:number))
  (FGAIBase_update (ff-pointer self) dt))

(cl:defmethod bind ((self fgaibase))
  (FGAIBase_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaibase))
  (FGAIBase_unbind (ff-pointer self)))

(cl:defmethod reinit ((self fgaibase))
  (FGAIBase_reinit (ff-pointer self)))

(cl:defmethod set-manager ((self fgaibase) mgr p)
  (FGAIBase_setManager (ff-pointer self) mgr p))

(cl:defmethod set-path ((self fgaibase) (model cl:string))
  (FGAIBase_setPath (ff-pointer self) model))

(cl:defmethod set-smpath ((self fgaibase) p)
  (FGAIBase_setSMPath (ff-pointer self) p))

(cl:defmethod set-call-sign ((self fgaibase) arg1)
  (FGAIBase_setCallSign (ff-pointer self) arg1))

(cl:defmethod set-speed ((self fgaibase) (speed_KTAS cl:number))
  (FGAIBase_setSpeed (ff-pointer self) speed_KTAS))

(cl:defmethod set-altitude ((self fgaibase) (altitude_ft cl:number))
  (FGAIBase_setAltitude (ff-pointer self) altitude_ft))

(cl:defmethod set-altitude-agl ((self fgaibase) (altitude_agl_ft cl:number))
  (FGAIBase_setAltitudeAGL (ff-pointer self) altitude_agl_ft))

(cl:defmethod set-heading ((self fgaibase) (heading cl:number))
  (FGAIBase_setHeading (ff-pointer self) heading))

(cl:defmethod set-latitude ((self fgaibase) (latitude cl:number))
  (FGAIBase_setLatitude (ff-pointer self) latitude))

(cl:defmethod set-longitude ((self fgaibase) (longitude cl:number))
  (FGAIBase_setLongitude (ff-pointer self) longitude))

(cl:defmethod set-bank ((self fgaibase) (bank cl:number))
  (FGAIBase_setBank (ff-pointer self) bank))

(cl:defmethod set-pitch ((self fgaibase) (newpitch cl:number))
  (FGAIBase_setPitch (ff-pointer self) newpitch))

(cl:defmethod set-radius ((self fgaibase) (radius cl:number))
  (FGAIBase_setRadius (ff-pointer self) radius))

(cl:defmethod set-xoffset ((self fgaibase) (x_offset cl:number))
  (FGAIBase_setXoffset (ff-pointer self) x_offset))

(cl:defmethod set-yoffset ((self fgaibase) (y_offset cl:number))
  (FGAIBase_setYoffset (ff-pointer self) y_offset))

(cl:defmethod set-zoffset ((self fgaibase) (z_offset cl:number))
  (FGAIBase_setZoffset (ff-pointer self) z_offset))

(cl:defmethod set-pitchoffset ((self fgaibase) (x_offset cl:number))
  (FGAIBase_setPitchoffset (ff-pointer self) x_offset))

(cl:defmethod set-rolloffset ((self fgaibase) (y_offset cl:number))
  (FGAIBase_setRolloffset (ff-pointer self) y_offset))

(cl:defmethod set-yawoffset ((self fgaibase) (z_offset cl:number))
  (FGAIBase_setYawoffset (ff-pointer self) z_offset))

(cl:defmethod set-serviceable ((self fgaibase) (serviceable t))
  (FGAIBase_setServiceable (ff-pointer self) serviceable))

(cl:defmethod set-die ((self fgaibase) (die t))
  (FGAIBase_setDie (ff-pointer self) die))

(cl:defmethod set-collision-data ((self fgaibase) (i t) (lat cl:number) (lon cl:number) (elev cl:number))
  (FGAIBase_setCollisionData (ff-pointer self) i lat lon elev))

(cl:defmethod set-impact-data ((self fgaibase) (d t))
  (FGAIBase_setImpactData (ff-pointer self) d))

(cl:defmethod set-impact-lat ((self fgaibase) (lat cl:number))
  (FGAIBase_setImpactLat (ff-pointer self) lat))

(cl:defmethod set-impact-lon ((self fgaibase) (lon cl:number))
  (FGAIBase_setImpactLon (ff-pointer self) lon))

(cl:defmethod set-impact-elev ((self fgaibase) (e cl:number))
  (FGAIBase_setImpactElev (ff-pointer self) e))

(cl:defmethod set-parent-name ((self fgaibase) p)
  (FGAIBase_setParentName (ff-pointer self) p))

(cl:defmethod set-name ((self fgaibase) n)
  (FGAIBase_setName (ff-pointer self) n))

(cl:defmethod set-max-speed ((self fgaibase) (kts cl:number))
  (FGAIBase_setMaxSpeed (ff-pointer self) kts))

(cl:defmethod calc-range-bearing ((self fgaibase) (lat cl:number) (lon cl:number) (lat2 cl:number) (lon2 cl:number) range bearing)
  (FGAIBase_calcRangeBearing (ff-pointer self) lat lon lat2 lon2 range bearing))

(cl:defmethod calc-rel-bearing-deg ((self fgaibase) (bearing cl:number) (heading cl:number))
  (FGAIBase_calcRelBearingDeg (ff-pointer self) bearing heading))

(cl:defmethod calc-true-bearing-deg ((self fgaibase) (bearing cl:number) (heading cl:number))
  (FGAIBase_calcTrueBearingDeg (ff-pointer self) bearing heading))

(cl:defmethod calc-recip-bearing-deg ((self fgaibase) (bearing cl:number))
  (FGAIBase_calcRecipBearingDeg (ff-pointer self) bearing))

(cl:defmethod set-parent-node ((self fgaibase))
  (FGAIBase_setParentNode (ff-pointer self)))

(cl:defmethod get-id ((self fgaibase))
  (FGAIBase_getID (ff-pointer self)))

(cl:defmethod -get-sub-id ((self fgaibase))
  (FGAIBase__getSubID (ff-pointer self)))

(cl:defmethod get-die ((self fgaibase))
  (FGAIBase_getDie (ff-pointer self)))

(cl:defmethod get-cart-pos-at ((self fgaibase) off)
  (FGAIBase_getCartPosAt (ff-pointer self) off))

(cl:defmethod get-cart-pos ((self fgaibase))
  (FGAIBase_getCartPos (ff-pointer self)))

(cl:defmethod get-ground-elevation-m ((self fgaibase) pos elev material)
  (FGAIBase_getGroundElevationM (ff-pointer self) pos elev material))

(cl:defmethod (cl:setf _elevation_m) (arg0 (obj fgaibase))
  (FGAIBase__elevation_m_set (ff-pointer obj) arg0))

(cl:defmethod _elevation_m ((obj fgaibase))
  (FGAIBase__elevation_m_get (ff-pointer obj)))

(cl:defmethod (cl:setf _material) (arg0 (obj fgaibase))
  (FGAIBase__material_set (ff-pointer obj) arg0))

(cl:defmethod _material ((obj fgaibase))
  (FGAIBase__material_get (ff-pointer obj)))

(cl:defmethod -get-cart-pos-x ((self fgaibase))
  (FGAIBase__getCartPosX (ff-pointer self)))

(cl:defmethod -get-cart-pos-y ((self fgaibase))
  (FGAIBase__getCartPosY (ff-pointer self)))

(cl:defmethod -get-cart-pos-z ((self fgaibase))
  (FGAIBase__getCartPosZ (ff-pointer self)))

(cl:defmethod (cl:setf _x_offset) (arg0 (obj fgaibase))
  (FGAIBase__x_offset_set (ff-pointer obj) arg0))

(cl:defmethod _x_offset ((obj fgaibase))
  (FGAIBase__x_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf _y_offset) (arg0 (obj fgaibase))
  (FGAIBase__y_offset_set (ff-pointer obj) arg0))

(cl:defmethod _y_offset ((obj fgaibase))
  (FGAIBase__y_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf _z_offset) (arg0 (obj fgaibase))
  (FGAIBase__z_offset_set (ff-pointer obj) arg0))

(cl:defmethod _z_offset ((obj fgaibase))
  (FGAIBase__z_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf _pitch_offset) (arg0 (obj fgaibase))
  (FGAIBase__pitch_offset_set (ff-pointer obj) arg0))

(cl:defmethod _pitch_offset ((obj fgaibase))
  (FGAIBase__pitch_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf _roll_offset) (arg0 (obj fgaibase))
  (FGAIBase__roll_offset_set (ff-pointer obj) arg0))

(cl:defmethod _roll_offset ((obj fgaibase))
  (FGAIBase__roll_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf _yaw_offset) (arg0 (obj fgaibase))
  (FGAIBase__yaw_offset_set (ff-pointer obj) arg0))

(cl:defmethod _yaw_offset ((obj fgaibase))
  (FGAIBase__yaw_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf _max_speed) (arg0 (obj fgaibase))
  (FGAIBase__max_speed_set (ff-pointer obj) arg0))

(cl:defmethod _max_speed ((obj fgaibase))
  (FGAIBase__max_speed_get (ff-pointer obj)))

(cl:defmethod (cl:setf _path) (arg0 (obj fgaibase))
  (FGAIBase__path_set (ff-pointer obj) arg0))

(cl:defmethod _path ((obj fgaibase))
  (FGAIBase__path_get (ff-pointer obj)))

(cl:defmethod (cl:setf _callsign) (arg0 (obj fgaibase))
  (FGAIBase__callsign_set (ff-pointer obj) arg0))

(cl:defmethod _callsign ((obj fgaibase))
  (FGAIBase__callsign_get (ff-pointer obj)))

(cl:defmethod (cl:setf _submodel) (arg0 (obj fgaibase))
  (FGAIBase__submodel_set (ff-pointer obj) arg0))

(cl:defmethod _submodel ((obj fgaibase))
  (FGAIBase__submodel_get (ff-pointer obj)))

(cl:defmethod (cl:setf _name) (arg0 (obj fgaibase))
  (FGAIBase__name_set (ff-pointer obj) arg0))

(cl:defmethod _name ((obj fgaibase))
  (FGAIBase__name_get (ff-pointer obj)))

(cl:defmethod (cl:setf _parent) (arg0 (obj fgaibase))
  (FGAIBase__parent_set (ff-pointer obj) arg0))

(cl:defmethod _parent ((obj fgaibase))
  (FGAIBase__parent_get (ff-pointer obj)))

(cl:defmethod (cl:setf userpos) (arg0 (obj fgaibase))
  (FGAIBase_userpos_set (ff-pointer obj) arg0))

(cl:defmethod userpos ((obj fgaibase))
  (FGAIBase_userpos_get (ff-pointer obj)))

(cl:defmethod get-type ((self fgaibase))
  (FGAIBase_getType (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaibase))
  (FGAIBase_getTypeString (ff-pointer self)))

(cl:defmethod isa ((self fgaibase) (otype cl:integer))
  (FGAIBase_isa (ff-pointer self) otype))

(cl:defmethod -set-vs-fps ((self fgaibase) (_vs cl:number))
  (FGAIBase__setVS_fps (ff-pointer self) _vs))

(cl:defmethod -set-altitude ((self fgaibase) (_alt cl:number))
  (FGAIBase__setAltitude (ff-pointer self) _alt))

(cl:defmethod -set-longitude ((self fgaibase) (longitude cl:number))
  (FGAIBase__setLongitude (ff-pointer self) longitude))

(cl:defmethod -set-latitude ((self fgaibase) (latitude cl:number))
  (FGAIBase__setLatitude (ff-pointer self) latitude))

(cl:defmethod -set-sub-id ((self fgaibase) (s cl:integer))
  (FGAIBase__setSubID (ff-pointer self) s))

(cl:defmethod -set-user-pos ((self fgaibase))
  (FGAIBase__setUserPos (ff-pointer self)))

(cl:defmethod -get-altitude-agl ((self fgaibase) inpos (start cl:number))
  (FGAIBase__getAltitudeAGL (ff-pointer self) inpos start))

(cl:defmethod -get-vs-fps ((self fgaibase))
  (FGAIBase__getVS_fps (ff-pointer self)))

(cl:defmethod -get-altitude ((self fgaibase))
  (FGAIBase__getAltitude (ff-pointer self)))

(cl:defmethod -get-longitude ((self fgaibase))
  (FGAIBase__getLongitude (ff-pointer self)))

(cl:defmethod -get-latitude ((self fgaibase))
  (FGAIBase__getLatitude (ff-pointer self)))

(cl:defmethod -get-elevation-ft ((self fgaibase))
  (FGAIBase__getElevationFt (ff-pointer self)))

(cl:defmethod -get-rdot ((self fgaibase))
  (FGAIBase__getRdot (ff-pointer self)))

(cl:defmethod -get-h-offset ((self fgaibase))
  (FGAIBase__getH_offset (ff-pointer self)))

(cl:defmethod -get-v-offset ((self fgaibase))
  (FGAIBase__getV_offset (ff-pointer self)))

(cl:defmethod -get-x-shift ((self fgaibase))
  (FGAIBase__getX_shift (ff-pointer self)))

(cl:defmethod -get-y-shift ((self fgaibase))
  (FGAIBase__getY_shift (ff-pointer self)))

(cl:defmethod -get-rotation ((self fgaibase))
  (FGAIBase__getRotation (ff-pointer self)))

(cl:defmethod -get-speed ((self fgaibase))
  (FGAIBase__getSpeed (ff-pointer self)))

(cl:defmethod -get-roll ((self fgaibase))
  (FGAIBase__getRoll (ff-pointer self)))

(cl:defmethod -get-pitch ((self fgaibase))
  (FGAIBase__getPitch (ff-pointer self)))

(cl:defmethod -get-heading ((self fgaibase))
  (FGAIBase__getHeading (ff-pointer self)))

(cl:defmethod -get-speed-east-fps ((self fgaibase))
  (FGAIBase__get_speed_east_fps (ff-pointer self)))

(cl:defmethod -get-speed-north-fps ((self fgaibase))
  (FGAIBase__get_speed_north_fps (ff-pointer self)))

(cl:defmethod -get-sub-path ((self fgaibase))
  (FGAIBase__get_SubPath (ff-pointer self)))

(cl:defmethod -get-impact-lat ((self fgaibase))
  (FGAIBase__getImpactLat (ff-pointer self)))

(cl:defmethod -get-impact-lon ((self fgaibase))
  (FGAIBase__getImpactLon (ff-pointer self)))

(cl:defmethod -get-impact-elev-ft ((self fgaibase))
  (FGAIBase__getImpactElevFt (ff-pointer self)))

(cl:defmethod -get-impact-hdg ((self fgaibase))
  (FGAIBase__getImpactHdg (ff-pointer self)))

(cl:defmethod -get-impact-pitch ((self fgaibase))
  (FGAIBase__getImpactPitch (ff-pointer self)))

(cl:defmethod -get-impact-roll ((self fgaibase))
  (FGAIBase__getImpactRoll (ff-pointer self)))

(cl:defmethod -get-impact-speed ((self fgaibase))
  (FGAIBase__getImpactSpeed (ff-pointer self)))

(cl:defmethod -get-xoffset ((self fgaibase))
  (FGAIBase__getXOffset (ff-pointer self)))

(cl:defmethod -get-yoffset ((self fgaibase))
  (FGAIBase__getYOffset (ff-pointer self)))

(cl:defmethod -get-zoffset ((self fgaibase))
  (FGAIBase__getZOffset (ff-pointer self)))

(cl:defmethod -get-serviceable ((self fgaibase))
  (FGAIBase__getServiceable (ff-pointer self)))

(cl:defmethod -get-first-time ((self fgaibase))
  (FGAIBase__getFirstTime (ff-pointer self)))

(cl:defmethod -get-impact ((self fgaibase))
  (FGAIBase__getImpact (ff-pointer self)))

(cl:defmethod -get-impact-data ((self fgaibase))
  (FGAIBase__getImpactData (ff-pointer self)))

(cl:defmethod -get-collision-data ((self fgaibase))
  (FGAIBase__getCollisionData (ff-pointer self)))

(cl:defmethod -get-expiry-data ((self fgaibase))
  (FGAIBase__getExpiryData (ff-pointer self)))

(cl:defmethod -get-props ((self fgaibase))
  (FGAIBase__getProps (ff-pointer self)))

(cl:defmethod -get-path ((self fgaibase))
  (FGAIBase__getPath (ff-pointer self)))

(cl:defmethod -get-smpath ((self fgaibase))
  (FGAIBase__getSMPath (ff-pointer self)))

(cl:defmethod -get-callsign ((self fgaibase))
  (FGAIBase__getCallsign (ff-pointer self)))

(cl:defmethod -get-trigger-node ((self fgaibase))
  (FGAIBase__getTriggerNode (ff-pointer self)))

(cl:defmethod -get-name ((self fgaibase))
  (FGAIBase__getName (ff-pointer self)))

(cl:defmethod -get-submodel ((self fgaibase))
  (FGAIBase__getSubmodel (ff-pointer self)))

(cl:defmethod (cl:setf rho) (arg0 (obj fgaibase))
  (FGAIBase_rho_set (ff-pointer obj) arg0))

(cl:defmethod rho ((obj fgaibase))
  (FGAIBase_rho_get (ff-pointer obj)))

(cl:defmethod (cl:setf T) (arg0 (obj fgaibase))
  (FGAIBase_T_set (ff-pointer obj) arg0))

(cl:defmethod T ((obj fgaibase))
  (FGAIBase_T_get (ff-pointer obj)))

(cl:defmethod (cl:setf p) (arg0 (obj fgaibase))
  (FGAIBase_p_set (ff-pointer obj) arg0))

(cl:defmethod p ((obj fgaibase))
  (FGAIBase_p_get (ff-pointer obj)))

(cl:defmethod (cl:setf a) (arg0 (obj fgaibase))
  (FGAIBase_a_set (ff-pointer obj) arg0))

(cl:defmethod a ((obj fgaibase))
  (FGAIBase_a_get (ff-pointer obj)))

(cl:defmethod (cl:setf Mach) (arg0 (obj fgaibase))
  (FGAIBase_Mach_set (ff-pointer obj) arg0))

(cl:defmethod Mach ((obj fgaibase))
  (FGAIBase_Mach_get (ff-pointer obj)))

(cl:defmethod -get-range ((self fgaibase))
  (FGAIBase__getRange (ff-pointer self)))

(cl:defmethod -get-bearing ((self fgaibase))
  (FGAIBase__getBearing (ff-pointer self)))

(cl:defmethod load3-dmodel ((self fgaibase) path prop_root)
  (FGAIBase_load3DModel (ff-pointer self) path prop_root))


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

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

(cl:defmethod read-from-scenario ((self fgaicarrier) scFileNode)
  (FGAICarrier_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod set-sign ((self fgaicarrier) arg1)
  (FGAICarrier_setSign (ff-pointer self) arg1))

(cl:defmethod set-tacanchannel-id ((self fgaicarrier) arg1)
  (FGAICarrier_setTACANChannelID (ff-pointer self) arg1))

(cl:defmethod bind ((self fgaicarrier))
  (FGAICarrier_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaicarrier))
  (FGAICarrier_unbind (ff-pointer self)))

(cl:defmethod update-wind ((self fgaicarrier) (dt cl:number))
  (FGAICarrier_UpdateWind (ff-pointer self) dt))

(cl:defmethod set-wind-from-east ((self fgaicarrier) (fps cl:number))
  (FGAICarrier_setWind_from_east (ff-pointer self) fps))

(cl:defmethod set-wind-from-north ((self fgaicarrier) (fps cl:number))
  (FGAICarrier_setWind_from_north (ff-pointer self) fps))

(cl:defmethod set-max-lat ((self fgaicarrier) (deg cl:number))
  (FGAICarrier_setMaxLat (ff-pointer self) deg))

(cl:defmethod set-min-lat ((self fgaicarrier) (deg cl:number))
  (FGAICarrier_setMinLat (ff-pointer self) deg))

(cl:defmethod set-max-long ((self fgaicarrier) (deg cl:number))
  (FGAICarrier_setMaxLong (ff-pointer self) deg))

(cl:defmethod set-min-long ((self fgaicarrier) (deg cl:number))
  (FGAICarrier_setMinLong (ff-pointer self) deg))

(cl:defmethod set-mpcontrol ((self fgaicarrier) (c t))
  (FGAICarrier_setMPControl (ff-pointer self) c))

(cl:defmethod set-aicontrol ((self fgaicarrier) (c t))
  (FGAICarrier_setAIControl (ff-pointer self) c))

(cl:defmethod turn-to-launch ((self fgaicarrier))
  (FGAICarrier_TurnToLaunch (ff-pointer self)))

(cl:defmethod turn-to-recover ((self fgaicarrier))
  (FGAICarrier_TurnToRecover (ff-pointer self)))

(cl:defmethod turn-to-base ((self fgaicarrier))
  (FGAICarrier_TurnToBase (ff-pointer self)))

(cl:defmethod return-to-box ((self fgaicarrier))
  (FGAICarrier_ReturnToBox (ff-pointer self)))

(cl:defmethod outside-box ((self fgaicarrier))
  (FGAICarrier_OutsideBox (ff-pointer self)))

(cl:defmethod init ((self fgaicarrier) (search_in_AI_path t))
  (FGAICarrier_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaicarrier))
  (FGAICarrier_init (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaicarrier))
  (FGAICarrier_getTypeString (ff-pointer self)))

(cl:defmethod get-park-position ((self fgaicarrier) id geodPos hdng uvw)
  (FGAICarrier_getParkPosition (ff-pointer self) id geodPos hdng uvw))


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

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

(cl:defmethod read-from-scenario ((self fgaiescort) scFileNode)
  (FGAIEscort_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod bind ((self fgaiescort))
  (FGAIEscort_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaiescort))
  (FGAIEscort_unbind (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaiescort))
  (FGAIEscort_getTypeString (ff-pointer self)))

(cl:defmethod init ((self fgaiescort) (search_in_AI_path t))
  (FGAIEscort_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaiescort))
  (FGAIEscort_init (ff-pointer self)))


(cl:defclass fgaiground-vehicle()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgaiground-vehicle) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGAIGroundVehicle)))

(cl:defmethod read-from-scenario ((self fgaiground-vehicle) scFileNode)
  (FGAIGroundVehicle_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod bind ((self fgaiground-vehicle))
  (FGAIGroundVehicle_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaiground-vehicle))
  (FGAIGroundVehicle_unbind (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaiground-vehicle))
  (FGAIGroundVehicle_getTypeString (ff-pointer self)))

(cl:defmethod init ((self fgaiground-vehicle) (search_in_AI_path t))
  (FGAIGroundVehicle_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaiground-vehicle))
  (FGAIGroundVehicle_init (ff-pointer self)))


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

(cl:defmethod (cl:setf ai_list) (arg0 (obj fgaimanager))
  (FGAIManager_ai_list_set (ff-pointer obj) arg0))

(cl:defmethod ai_list ((obj fgaimanager))
  (FGAIManager_ai_list_get (ff-pointer obj)))

(cl:defmethod get-ai-list ((self fgaimanager))
  (FGAIManager_get_ai_list (ff-pointer self)))

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

(cl:defmethod init ((self fgaimanager))
  (FGAIManager_init (ff-pointer self)))

(cl:defmethod postinit ((self fgaimanager))
  (FGAIManager_postinit (ff-pointer self)))

(cl:defmethod reinit ((self fgaimanager))
  (FGAIManager_reinit (ff-pointer self)))

(cl:defmethod bind ((self fgaimanager))
  (FGAIManager_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaimanager))
  (FGAIManager_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaimanager) (dt cl:number))
  (FGAIManager_update (ff-pointer self) dt))

(cl:defmethod attach ((self fgaimanager) (model fgaibase))
  (FGAIManager_attach (ff-pointer self) model))

(cl:defmethod destroy-object ((self fgaimanager) (ID cl:integer))
  (FGAIManager_destroyObject (ff-pointer self) ID))

(cl:defmethod calc-collision ((self fgaimanager) (alt cl:number) (lat cl:number) (lon cl:number) (fuse_range cl:number))
  (FGAIManager_calcCollision (ff-pointer self) alt lat lon fuse_range))

(cl:defmethod get-user-latitude ((self fgaimanager))
  (FGAIManager_get_user_latitude (ff-pointer self)))

(cl:defmethod get-user-longitude ((self fgaimanager))
  (FGAIManager_get_user_longitude (ff-pointer self)))

(cl:defmethod get-user-altitude ((self fgaimanager))
  (FGAIManager_get_user_altitude (ff-pointer self)))

(cl:defmethod get-user-heading ((self fgaimanager))
  (FGAIManager_get_user_heading (ff-pointer self)))

(cl:defmethod get-user-pitch ((self fgaimanager))
  (FGAIManager_get_user_pitch (ff-pointer self)))

(cl:defmethod get-user-yaw ((self fgaimanager))
  (FGAIManager_get_user_yaw (ff-pointer self)))

(cl:defmethod get-user-speed ((self fgaimanager))
  (FGAIManager_get_user_speed (ff-pointer self)))

(cl:defmethod get-wind-from-east ((self fgaimanager))
  (FGAIManager_get_wind_from_east (ff-pointer self)))

(cl:defmethod get-wind-from-north ((self fgaimanager))
  (FGAIManager_get_wind_from_north (ff-pointer self)))

(cl:defmethod get-user-roll ((self fgaimanager))
  (FGAIManager_get_user_roll (ff-pointer self)))

(cl:defmethod get-user-agl ((self fgaimanager))
  (FGAIManager_get_user_agl (ff-pointer self)))

(cl:defmethod get-num-ai-objects ((self fgaimanager))
  (FGAIManager_getNumAiObjects (ff-pointer self)))

(cl:defmethod process-scenario ((self fgaimanager) filename)
  (FGAIManager_processScenario (ff-pointer self) filename))


(cl:defclass fgaimultiplayer(FGAIBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod init ((self fgaimultiplayer) (search_in_AI_path t))
  (FGAIMultiplayer_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaimultiplayer))
  (FGAIMultiplayer_init (ff-pointer self)))

(cl:defmethod bind ((self fgaimultiplayer))
  (FGAIMultiplayer_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaimultiplayer))
  (FGAIMultiplayer_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaimultiplayer) (dt cl:number))
  (FGAIMultiplayer_update (ff-pointer self) dt))

(cl:defmethod add-motion-info ((self fgaimultiplayer) motionInfo (stamp cl:integer))
  (FGAIMultiplayer_addMotionInfo (ff-pointer self) motionInfo stamp))

(cl:defmethod set-double-property ((self fgaimultiplayer) prop (val cl:number))
  (FGAIMultiplayer_setDoubleProperty (ff-pointer self) prop val))

(cl:defmethod get-last-timestamp ((self fgaimultiplayer))
  (FGAIMultiplayer_getLastTimestamp (ff-pointer self)))

(cl:defmethod set-allow-extrapolation ((self fgaimultiplayer) (allowExtrapolation t))
  (FGAIMultiplayer_setAllowExtrapolation (ff-pointer self) allowExtrapolation))

(cl:defmethod get-allow-extrapolation ((self fgaimultiplayer))
  (FGAIMultiplayer_getAllowExtrapolation (ff-pointer self)))

(cl:defmethod set-lag-adjust-system-speed ((self fgaimultiplayer) (lagAdjustSystemSpeed cl:number))
  (FGAIMultiplayer_setLagAdjustSystemSpeed (ff-pointer self) lagAdjustSystemSpeed))

(cl:defmethod get-lag-adjust-system-speed ((self fgaimultiplayer))
  (FGAIMultiplayer_getLagAdjustSystemSpeed (ff-pointer self)))

(cl:defmethod add-property-id ((self fgaimultiplayer) (id cl:integer) (name cl:string))
  (FGAIMultiplayer_addPropertyId (ff-pointer self) id name))

(cl:defmethod get-property-root ((self fgaimultiplayer))
  (FGAIMultiplayer_getPropertyRoot (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaimultiplayer))
  (FGAIMultiplayer_getTypeString (ff-pointer self)))


(cl:defclass fgaiship(FGAIBase)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgaiship) &key (ot cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGAIShip ot)))

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

(cl:defmethod read-from-scenario ((self fgaiship) scFileNode)
  (FGAIShip_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod init ((self fgaiship) (search_in_AI_path t))
  (FGAIShip_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaiship))
  (FGAIShip_init (ff-pointer self)))

(cl:defmethod bind ((self fgaiship))
  (FGAIShip_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaiship))
  (FGAIShip_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaiship) (dt cl:number))
  (FGAIShip_update (ff-pointer self) dt))

(cl:defmethod set-flight-plan ((self fgaiship) f)
  (FGAIShip_setFlightPlan (ff-pointer self) f))

(cl:defmethod set-rudder ((self fgaiship) (r cl:number))
  (FGAIShip_setRudder (ff-pointer self) r))

(cl:defmethod set-roll ((self fgaiship) (rl cl:number))
  (FGAIShip_setRoll (ff-pointer self) rl))

(cl:defmethod process-flight-plan ((self fgaiship) (dt cl:number))
  (FGAIShip_ProcessFlightPlan (ff-pointer self) dt))

(cl:defmethod accel-to ((self fgaiship) (speed cl:number))
  (FGAIShip_AccelTo (ff-pointer self) speed))

(cl:defmethod pitch-to ((self fgaiship) (angle cl:number))
  (FGAIShip_PitchTo (ff-pointer self) angle))

(cl:defmethod roll-to ((self fgaiship) (angle cl:number))
  (FGAIShip_RollTo (ff-pointer self) angle))

(cl:defmethod yaw-to ((self fgaiship) (angle cl:number))
  (FGAIShip_YawTo (ff-pointer self) angle))

(cl:defmethod climb-to ((self fgaiship) (altitude cl:number))
  (FGAIShip_ClimbTo (ff-pointer self) altitude))

(cl:defmethod turn-to ((self fgaiship) (heading cl:number))
  (FGAIShip_TurnTo (ff-pointer self) heading))

(cl:defmethod set-curr-name ((self fgaiship) arg1)
  (FGAIShip_setCurrName (ff-pointer self) arg1))

(cl:defmethod set-next-name ((self fgaiship) arg1)
  (FGAIShip_setNextName (ff-pointer self) arg1))

(cl:defmethod set-prev-name ((self fgaiship) arg1)
  (FGAIShip_setPrevName (ff-pointer self) arg1))

(cl:defmethod set-lead-angle-gain ((self fgaiship) (g cl:number))
  (FGAIShip_setLeadAngleGain (ff-pointer self) g))

(cl:defmethod set-lead-angle-limit ((self fgaiship) (l cl:number))
  (FGAIShip_setLeadAngleLimit (ff-pointer self) l))

(cl:defmethod set-lead-angle-prop ((self fgaiship) (p cl:number))
  (FGAIShip_setLeadAngleProp (ff-pointer self) p))

(cl:defmethod set-rudder-constant ((self fgaiship) (rc cl:number))
  (FGAIShip_setRudderConstant (ff-pointer self) rc))

(cl:defmethod set-speed-constant ((self fgaiship) (sc cl:number))
  (FGAIShip_setSpeedConstant (ff-pointer self) sc))

(cl:defmethod set-fixed-turn-radius ((self fgaiship) (ft cl:number))
  (FGAIShip_setFixedTurnRadius (ff-pointer self) ft))

(cl:defmethod set-tunnel ((self fgaiship) (t-arg1 t))
  (FGAIShip_setTunnel (ff-pointer self) t-arg1))

(cl:defmethod set-initial-tunnel ((self fgaiship) (t-arg1 t))
  (FGAIShip_setInitialTunnel (ff-pointer self) t-arg1))

(cl:defmethod set-wpnames ((self fgaiship))
  (FGAIShip_setWPNames (ff-pointer self)))

(cl:defmethod set-wppos ((self fgaiship))
  (FGAIShip_setWPPos (ff-pointer self)))

(cl:defmethod sign ((self fgaiship) (x cl:number))
  (FGAIShip_sign (ff-pointer self) x))

(cl:defmethod (cl:setf _hdg_lock) (arg0 (obj fgaiship))
  (FGAIShip__hdg_lock_set (ff-pointer obj) arg0))

(cl:defmethod _hdg_lock ((obj fgaiship))
  (FGAIShip__hdg_lock_get (ff-pointer obj)))

(cl:defmethod (cl:setf _serviceable) (arg0 (obj fgaiship))
  (FGAIShip__serviceable_set (ff-pointer obj) arg0))

(cl:defmethod _serviceable ((obj fgaiship))
  (FGAIShip__serviceable_get (ff-pointer obj)))

(cl:defmethod (cl:setf _waiting) (arg0 (obj fgaiship))
  (FGAIShip__waiting_set (ff-pointer obj) arg0))

(cl:defmethod _waiting ((obj fgaiship))
  (FGAIShip__waiting_get (ff-pointer obj)))

(cl:defmethod (cl:setf _new_waypoint) (arg0 (obj fgaiship))
  (FGAIShip__new_waypoint_set (ff-pointer obj) arg0))

(cl:defmethod _new_waypoint ((obj fgaiship))
  (FGAIShip__new_waypoint_get (ff-pointer obj)))

(cl:defmethod (cl:setf _tunnel) (arg0 (obj fgaiship))
  (FGAIShip__tunnel_set (ff-pointer obj) arg0))

(cl:defmethod _tunnel ((obj fgaiship))
  (FGAIShip__tunnel_get (ff-pointer obj)))

(cl:defmethod (cl:setf _initial_tunnel) (arg0 (obj fgaiship))
  (FGAIShip__initial_tunnel_set (ff-pointer obj) arg0))

(cl:defmethod _initial_tunnel ((obj fgaiship))
  (FGAIShip__initial_tunnel_get (ff-pointer obj)))

(cl:defmethod (cl:setf _restart) (arg0 (obj fgaiship))
  (FGAIShip__restart_set (ff-pointer obj) arg0))

(cl:defmethod _restart ((obj fgaiship))
  (FGAIShip__restart_get (ff-pointer obj)))

(cl:defmethod get-type-string ((self fgaiship))
  (FGAIShip_getTypeString (ff-pointer self)))

(cl:defmethod (cl:setf _rudder_constant) (arg0 (obj fgaiship))
  (FGAIShip__rudder_constant_set (ff-pointer obj) arg0))

(cl:defmethod _rudder_constant ((obj fgaiship))
  (FGAIShip__rudder_constant_get (ff-pointer obj)))

(cl:defmethod (cl:setf _speed_constant) (arg0 (obj fgaiship))
  (FGAIShip__speed_constant_set (ff-pointer obj) arg0))

(cl:defmethod _speed_constant ((obj fgaiship))
  (FGAIShip__speed_constant_get (ff-pointer obj)))

(cl:defmethod (cl:setf _hdg_constant) (arg0 (obj fgaiship))
  (FGAIShip__hdg_constant_set (ff-pointer obj) arg0))

(cl:defmethod _hdg_constant ((obj fgaiship))
  (FGAIShip__hdg_constant_get (ff-pointer obj)))

(cl:defmethod (cl:setf _limit) (arg0 (obj fgaiship))
  (FGAIShip__limit_set (ff-pointer obj) arg0))

(cl:defmethod _limit ((obj fgaiship))
  (FGAIShip__limit_get (ff-pointer obj)))

(cl:defmethod (cl:setf _elevation_m) (arg0 (obj fgaiship))
  (FGAIShip__elevation_m_set (ff-pointer obj) arg0))

(cl:defmethod _elevation_m ((obj fgaiship))
  (FGAIShip__elevation_m_get (ff-pointer obj)))

(cl:defmethod (cl:setf _elevation_ft) (arg0 (obj fgaiship))
  (FGAIShip__elevation_ft_set (ff-pointer obj) arg0))

(cl:defmethod _elevation_ft ((obj fgaiship))
  (FGAIShip__elevation_ft_get (ff-pointer obj)))

(cl:defmethod (cl:setf _missed_range) (arg0 (obj fgaiship))
  (FGAIShip__missed_range_set (ff-pointer obj) arg0))

(cl:defmethod _missed_range ((obj fgaiship))
  (FGAIShip__missed_range_get (ff-pointer obj)))

(cl:defmethod (cl:setf _tow_angle) (arg0 (obj fgaiship))
  (FGAIShip__tow_angle_set (ff-pointer obj) arg0))

(cl:defmethod _tow_angle ((obj fgaiship))
  (FGAIShip__tow_angle_get (ff-pointer obj)))

(cl:defmethod (cl:setf _wait_count) (arg0 (obj fgaiship))
  (FGAIShip__wait_count_set (ff-pointer obj) arg0))

(cl:defmethod _wait_count ((obj fgaiship))
  (FGAIShip__wait_count_get (ff-pointer obj)))

(cl:defmethod (cl:setf _missed_count) (arg0 (obj fgaiship))
  (FGAIShip__missed_count_set (ff-pointer obj) arg0))

(cl:defmethod _missed_count ((obj fgaiship))
  (FGAIShip__missed_count_get (ff-pointer obj)))

(cl:defmethod (cl:setf _wp_range) (arg0 (obj fgaiship))
  (FGAIShip__wp_range_set (ff-pointer obj) arg0))

(cl:defmethod _wp_range ((obj fgaiship))
  (FGAIShip__wp_range_get (ff-pointer obj)))

(cl:defmethod (cl:setf _dt_count) (arg0 (obj fgaiship))
  (FGAIShip__dt_count_set (ff-pointer obj) arg0))

(cl:defmethod _dt_count ((obj fgaiship))
  (FGAIShip__dt_count_get (ff-pointer obj)))

(cl:defmethod (cl:setf _next_run) (arg0 (obj fgaiship))
  (FGAIShip__next_run_set (ff-pointer obj) arg0))

(cl:defmethod _next_run ((obj fgaiship))
  (FGAIShip__next_run_get (ff-pointer obj)))

(cl:defmethod (cl:setf prev) (arg0 (obj fgaiship))
  (FGAIShip_prev_set (ff-pointer obj) arg0))

(cl:defmethod prev ((obj fgaiship))
  (FGAIShip_prev_get (ff-pointer obj)))

(cl:defmethod (cl:setf curr) (arg0 (obj fgaiship))
  (FGAIShip_curr_set (ff-pointer obj) arg0))

(cl:defmethod curr ((obj fgaiship))
  (FGAIShip_curr_get (ff-pointer obj)))

(cl:defmethod (cl:setf next) (arg0 (obj fgaiship))
  (FGAIShip_next_set (ff-pointer obj) arg0))

(cl:defmethod next ((obj fgaiship))
  (FGAIShip_next_get (ff-pointer obj)))


(cl:defclass fgaistatic(FGAIBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod init ((self fgaistatic) (search_in_AI_path t))
  (FGAIStatic_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaistatic))
  (FGAIStatic_init (ff-pointer self)))

(cl:defmethod bind ((self fgaistatic))
  (FGAIStatic_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaistatic))
  (FGAIStatic_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaistatic) (dt cl:number))
  (FGAIStatic_update (ff-pointer self) dt))

(cl:defmethod get-type-string ((self fgaistatic))
  (FGAIStatic_getTypeString (ff-pointer self)))


(cl:defclass fgaistorm(FGAIBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod read-from-scenario ((self fgaistorm) scFileNode)
  (FGAIStorm_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod init ((self fgaistorm) (search_in_AI_path t))
  (FGAIStorm_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaistorm))
  (FGAIStorm_init (ff-pointer self)))

(cl:defmethod bind ((self fgaistorm))
  (FGAIStorm_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaistorm))
  (FGAIStorm_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaistorm) (dt cl:number))
  (FGAIStorm_update (ff-pointer self) dt))

(cl:defmethod set-strength-norm ((self fgaistorm) (s cl:number))
  (FGAIStorm_setStrengthNorm (ff-pointer self) s))

(cl:defmethod set-diameter ((self fgaistorm) (d cl:number))
  (FGAIStorm_setDiameter (ff-pointer self) d))

(cl:defmethod set-height ((self fgaistorm) (h cl:number))
  (FGAIStorm_setHeight (ff-pointer self) h))

(cl:defmethod get-strength-norm ((self fgaistorm))
  (FGAIStorm_getStrengthNorm (ff-pointer self)))

(cl:defmethod get-diameter ((self fgaistorm))
  (FGAIStorm_getDiameter (ff-pointer self)))

(cl:defmethod get-height ((self fgaistorm))
  (FGAIStorm_getHeight (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaistorm))
  (FGAIStorm_getTypeString (ff-pointer self)))


(cl:defclass fgaitanker(FGAIAircraft)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgaitanker) &key ref)
  (setf (slot-value obj 'ff-pointer) (new_FGAITanker ref)))

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

(cl:defmethod read-from-scenario ((self fgaitanker) scFileNode)
  (FGAITanker_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod bind ((self fgaitanker))
  (FGAITanker_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaitanker))
  (FGAITanker_unbind (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaitanker))
  (FGAITanker_getTypeString (ff-pointer self)))

(cl:defmethod set-tacanchannel-id ((self fgaitanker) id)
  (FGAITanker_setTACANChannelID (ff-pointer self) id))


(cl:defclass fgaithermal(FGAIBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod read-from-scenario ((self fgaithermal) scFileNode)
  (FGAIThermal_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod init ((self fgaithermal) (search_in_AI_path t))
  (FGAIThermal_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaithermal))
  (FGAIThermal_init (ff-pointer self)))

(cl:defmethod bind ((self fgaithermal))
  (FGAIThermal_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaithermal))
  (FGAIThermal_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaithermal) (dt cl:number))
  (FGAIThermal_update (ff-pointer self) dt))

(cl:defmethod set-max-strength ((self fgaithermal) (s cl:number))
  (FGAIThermal_setMaxStrength (ff-pointer self) s))

(cl:defmethod set-diameter ((self fgaithermal) (d cl:number))
  (FGAIThermal_setDiameter (ff-pointer self) d))

(cl:defmethod set-height ((self fgaithermal) (h cl:number))
  (FGAIThermal_setHeight (ff-pointer self) h))

(cl:defmethod set-max-updraft ((self fgaithermal) (lift cl:number))
  (FGAIThermal_setMaxUpdraft (ff-pointer self) lift))

(cl:defmethod set-min-updraft ((self fgaithermal) (sink cl:number))
  (FGAIThermal_setMinUpdraft (ff-pointer self) sink))

(cl:defmethod set-r-up-frac ((self fgaithermal) (r cl:number))
  (FGAIThermal_setR_up_frac (ff-pointer self) r))

(cl:defmethod get-strength ((self fgaithermal))
  (FGAIThermal_getStrength (ff-pointer self)))

(cl:defmethod get-diameter ((self fgaithermal))
  (FGAIThermal_getDiameter (ff-pointer self)))

(cl:defmethod get-height ((self fgaithermal))
  (FGAIThermal_getHeight (ff-pointer self)))

(cl:defmethod get-v-up-max ((self fgaithermal))
  (FGAIThermal_getV_up_max (ff-pointer self)))

(cl:defmethod get-v-up-min ((self fgaithermal))
  (FGAIThermal_getV_up_min (ff-pointer self)))

(cl:defmethod get-r-up-frac ((self fgaithermal))
  (FGAIThermal_getR_up_frac (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaithermal))
  (FGAIThermal_getTypeString (ff-pointer self)))

(cl:defmethod get-ground-elev ((self fgaithermal) (dt cl:number))
  (FGAIThermal_getGroundElev (ff-pointer self) dt))


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

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

(cl:defmethod read-from-scenario ((self fgaiwingman) scFileNode)
  (FGAIWingman_readFromScenario (ff-pointer self) scFileNode))

(cl:defmethod bind ((self fgaiwingman))
  (FGAIWingman_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaiwingman))
  (FGAIWingman_unbind (ff-pointer self)))

(cl:defmethod get-type-string ((self fgaiwingman))
  (FGAIWingman_getTypeString (ff-pointer self)))

(cl:defmethod init ((self fgaiwingman) (search_in_AI_path t))
  (FGAIWingman_init (ff-pointer self) search_in_AI_path))

(cl:defmethod init ((self fgaiwingman))
  (FGAIWingman_init (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj performance-data) &key (acceleration cl:number) (deceleration cl:number) (climbRate cl:number) (descentRate cl:number) (vRotate cl:number) (vTakeOff cl:number) (vClimb cl:number) (vCruise cl:number) (vDescent cl:number) (vApproach cl:number) (vTouchdown cl:number) (vTaxi cl:number))
  (setf (slot-value obj 'ff-pointer) (new_PerformanceData acceleration deceleration climbRate descentRate vRotate vTakeOff vClimb vCruise vDescent vApproach vTouchdown vTaxi)))

(cl:defmethod initialize-instance :after ((obj performance-data) &key filename)
  (setf (slot-value obj 'ff-pointer) (new_PerformanceData filename)))

(cl:defmethod actual-speed ((self performance-data) (ac fgaiaircraft) (tgt_speed cl:number) (dt cl:number))
  (PerformanceData_actualSpeed (ff-pointer self) ac tgt_speed dt))

(cl:defmethod actual-bank-angle ((self performance-data) (ac fgaiaircraft) (tgt_roll cl:number) (dt cl:number))
  (PerformanceData_actualBankAngle (ff-pointer self) ac tgt_roll dt))

(cl:defmethod actual-pitch ((self performance-data) (ac fgaiaircraft) (tgt_pitch cl:number) (dt cl:number))
  (PerformanceData_actualPitch (ff-pointer self) ac tgt_pitch dt))

(cl:defmethod actual-heading ((self performance-data) (ac fgaiaircraft) (tgt_heading cl:number) (dt cl:number))
  (PerformanceData_actualHeading (ff-pointer self) ac tgt_heading dt))

(cl:defmethod actual-altitude ((self performance-data) (ac fgaiaircraft) (tgt_altitude cl:number) (dt cl:number))
  (PerformanceData_actualAltitude (ff-pointer self) ac tgt_altitude dt))

(cl:defmethod actual-vertical-speed ((self performance-data) (ac fgaiaircraft) (tgt_vs cl:number) (dt cl:number))
  (PerformanceData_actualVerticalSpeed (ff-pointer self) ac tgt_vs dt))

(cl:defmethod gear-extensible ((self performance-data) (ac fgaiaircraft))
  (PerformanceData_gearExtensible (ff-pointer self) ac))

(cl:defmethod climb-rate ((self performance-data))
  (PerformanceData_climbRate (ff-pointer self)))

(cl:defmethod descent-rate ((self performance-data))
  (PerformanceData_descentRate (ff-pointer self)))

(cl:defmethod v-rotate ((self performance-data))
  (PerformanceData_vRotate (ff-pointer self)))

(cl:defmethod maximum-bank-angle ((self performance-data))
  (PerformanceData_maximumBankAngle (ff-pointer self)))

(cl:defmethod acceleration ((self performance-data))
  (PerformanceData_acceleration (ff-pointer self)))

(cl:defmethod v-taxi ((self performance-data))
  (PerformanceData_vTaxi (ff-pointer self)))

(cl:defmethod v-takeoff ((self performance-data))
  (PerformanceData_vTakeoff (ff-pointer self)))

(cl:defmethod v-climb ((self performance-data))
  (PerformanceData_vClimb (ff-pointer self)))

(cl:defmethod v-descent ((self performance-data))
  (PerformanceData_vDescent (ff-pointer self)))

(cl:defmethod v-approach ((self performance-data))
  (PerformanceData_vApproach (ff-pointer self)))

(cl:defmethod v-touchdown ((self performance-data))
  (PerformanceData_vTouchdown (ff-pointer self)))

(cl:defmethod v-cruise ((self performance-data))
  (PerformanceData_vCruise (ff-pointer self)))


(cl:defclass performance-db()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj performance-db) &key)
  (setf (slot-value obj 'ff-pointer) (new_PerformanceDB)))

(cl:defmethod register-performance-data ((self performance-db) id (data performance-data))
  (PerformanceDB_registerPerformanceData (ff-pointer self) id data))

(cl:defmethod register-performance-data ((self performance-db) id filename)
  (PerformanceDB_registerPerformanceData (ff-pointer self) id filename))

(cl:defmethod get-data-for ((self performance-db) id)
  (PerformanceDB_getDataFor (ff-pointer self) id))

(cl:defmethod load ((self performance-db) path)
  (PerformanceDB_load (ff-pointer self) path))


(cl:defclass fgsubmodel-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgsubmodel-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGSubmodelMgr)))

(cl:defmethod load ((self fgsubmodel-mgr))
  (FGSubmodelMgr_load (ff-pointer self)))

(cl:defmethod init ((self fgsubmodel-mgr))
  (FGSubmodelMgr_init (ff-pointer self)))

(cl:defmethod postinit ((self fgsubmodel-mgr))
  (FGSubmodelMgr_postinit (ff-pointer self)))

(cl:defmethod bind ((self fgsubmodel-mgr))
  (FGSubmodelMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgsubmodel-mgr))
  (FGSubmodelMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self fgsubmodel-mgr) (dt cl:number))
  (FGSubmodelMgr_update (ff-pointer self) dt))

(cl:defmethod updatelat ((self fgsubmodel-mgr) (lat cl:number))
  (FGSubmodelMgr_updatelat (ff-pointer self) lat))


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

(cl:defmethod initialize-instance :after ((obj fgatis-manager) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGAtisManager)))

(cl:defmethod init ((self fgatis-manager))
  (FGAtisManager_init (ff-pointer self)))

(cl:defmethod update ((self fgatis-manager) (time cl:number))
  (FGAtisManager_update (ff-pointer self) time))


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

(cl:defmethod init ((self fgatc))
  (FGATC_Init (ff-pointer self)))

(cl:defmethod update ((self fgatc) (dt cl:number))
  (FGATC_Update (ff-pointer self) dt))

(cl:defmethod receive-user-callback ((self fgatc) (code cl:integer))
  (FGATC_ReceiveUserCallback (ff-pointer self) code))

(cl:defmethod set-display ((self fgatc))
  (FGATC_SetDisplay (ff-pointer self)))

(cl:defmethod set-no-display ((self fgatc))
  (FGATC_SetNoDisplay (ff-pointer self)))

(cl:defmethod gen-text ((self fgatc) m (c cl:integer))
  (FGATC_GenText (ff-pointer self) m c))

(cl:defmethod get-freq-clear ((self fgatc))
  (FGATC_GetFreqClear (ff-pointer self)))

(cl:defmethod set-freq-in-use ((self fgatc))
  (FGATC_SetFreqInUse (ff-pointer self)))

(cl:defmethod set-response-reqd ((self fgatc) rid)
  (FGATC_SetResponseReqd (ff-pointer self) rid))

(cl:defmethod notify-transmission-finished ((self fgatc) rid)
  (FGATC_NotifyTransmissionFinished (ff-pointer self) rid))

(cl:defmethod release-freq ((self fgatc))
  (FGATC_ReleaseFreq (ff-pointer self)))

(cl:defmethod get-type ((self fgatc))
  (FGATC_GetType (ff-pointer self)))

(cl:defmethod set-data ((self fgatc) d)
  (FGATC_SetData (ff-pointer self) d))

(cl:defmethod get-freq ((self fgatc))
  (FGATC_get_freq (ff-pointer self)))

(cl:defmethod set-freq ((self fgatc) (fq cl:integer))
  (FGATC_set_freq (ff-pointer self) fq))

(cl:defmethod get-range ((self fgatc))
  (FGATC_get_range (ff-pointer self)))

(cl:defmethod set-range ((self fgatc) (rg cl:integer))
  (FGATC_set_range (ff-pointer self) rg))

(cl:defmethod get-ident ((self fgatc))
  (FGATC_get_ident (ff-pointer self)))

(cl:defmethod set-ident ((self fgatc) id)
  (FGATC_set_ident (ff-pointer self) id))

(cl:defmethod get-name ((self fgatc))
  (FGATC_get_name (ff-pointer self)))

(cl:defmethod set-name ((self fgatc) nm)
  (FGATC_set_name (ff-pointer self) nm))


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

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

(cl:defmethod init ((self fgatcdialog))
  (FGATCDialog_Init (ff-pointer self)))

(cl:defmethod update ((self fgatcdialog) (dt cl:number))
  (FGATCDialog_Update (ff-pointer self) dt))

(cl:defmethod popup-dialog ((self fgatcdialog))
  (FGATCDialog_PopupDialog (ff-pointer self)))

(cl:defmethod popup-callback ((self fgatcdialog) (arg1 cl:integer))
  (FGATCDialog_PopupCallback (ff-pointer self) arg1))

(cl:defmethod add-entry ((self fgatcdialog) station transmission menutext (type cl:integer) (code cl:integer))
  (FGATCDialog_add_entry (ff-pointer self) station transmission menutext type code))

(cl:defmethod remove-entry ((self fgatcdialog) station trans (type cl:integer))
  (FGATCDialog_remove_entry (ff-pointer self) station trans type))

(cl:defmethod remove-entry ((self fgatcdialog) station (code cl:integer) (type cl:integer))
  (FGATCDialog_remove_entry (ff-pointer self) station code type))

(cl:defmethod trans-reg ((self fgatcdialog) station trans (type cl:integer))
  (FGATCDialog_trans_reg (ff-pointer self) station trans type))

(cl:defmethod trans-reg ((self fgatcdialog) station (code cl:integer) (type cl:integer))
  (FGATCDialog_trans_reg (ff-pointer self) station code type))

(cl:defmethod freq-dialog ((self fgatcdialog))
  (FGATCDialog_FreqDialog (ff-pointer self)))

(cl:defmethod freq-display ((self fgatcdialog) ident)
  (FGATCDialog_FreqDisplay (ff-pointer self) ident))


(cl:defclass fgatcaligned-projection()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgatcaligned-projection) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGATCAlignedProjection)))

(cl:defmethod initialize-instance :after ((obj fgatcaligned-projection) &key centre (heading cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGATCAlignedProjection centre heading)))

(cl:defmethod init ((self fgatcaligned-projection) centre (heading cl:number))
  (FGATCAlignedProjection_Init (ff-pointer self) centre heading))

(cl:defmethod convert-to-local ((self fgatcaligned-projection) pt)
  (FGATCAlignedProjection_ConvertToLocal (ff-pointer self) pt))

(cl:defmethod convert-from-local ((self fgatcaligned-projection) pt)
  (FGATCAlignedProjection_ConvertFromLocal (ff-pointer self) pt))


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

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

(cl:defmethod load-voice ((self fgatcvoice) voice)
  (FGATCVoice_LoadVoice (ff-pointer self) voice))

(cl:defmethod write-message ((self fgatcvoice) message len)
  (FGATCVoice_WriteMessage (ff-pointer self) message len))


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

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

(cl:defmethod init ((self fgatcmgr))
  (FGATCMgr_init (ff-pointer self)))

(cl:defmethod bind ((self fgatcmgr))
  (FGATCMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgatcmgr))
  (FGATCMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self fgatcmgr) (dt cl:number))
  (FGATCMgr_update (ff-pointer self) dt))

(cl:defmethod get-airport-atcdetails ((self fgatcmgr) icao a)
  (FGATCMgr_GetAirportATCDetails (ff-pointer self) icao a))

(cl:defmethod get-voice-pointer ((self fgatcmgr) type)
  (FGATCMgr_GetVoicePointer (ff-pointer self) type))

(cl:defmethod get-comm1-atctype ((self fgatcmgr))
  (FGATCMgr_GetComm1ATCType (ff-pointer self)))

(cl:defmethod get-comm1-atcpointer ((self fgatcmgr))
  (FGATCMgr_GetComm1ATCPointer (ff-pointer self)))

(cl:defmethod get-comm2-atctype ((self fgatcmgr))
  (FGATCMgr_GetComm2ATCType (ff-pointer self)))

(cl:defmethod get-comm2-atcpointer ((self fgatcmgr))
  (FGATCMgr_GetComm2ATCPointer (ff-pointer self)))

(cl:defmethod get-frequency ((self fgatcmgr) ident tp)
  (FGATCMgr_GetFrequency (ff-pointer self) ident tp))

(cl:defmethod comm-register-airport ((self fgatcmgr) ident (chan cl:integer) tp)
  (FGATCMgr_CommRegisterAirport (ff-pointer self) ident chan tp))


(cl:defclass fgatis(FGATC)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod init ((self fgatis))
  (FGATIS_Init (ff-pointer self)))

(cl:defmethod attend ((self fgatis) (arg1 cl:integer))
  (FGATIS_attend (ff-pointer self) arg1))

(cl:defmethod update ((self fgatis) (dt cl:number))
  (FGATIS_Update (ff-pointer self) dt))

(cl:defmethod get-trans-ident ((self fgatis))
  (FGATIS_get_trans_ident (ff-pointer self)))

(cl:defmethod set-refname ((self fgatis) r)
  (FGATIS_set_refname (ff-pointer self) r))


(cl:defclass fgcomm-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgcomm-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGCommList)))

(cl:defmethod init ((self fgcomm-list) path)
  (FGCommList_init (ff-pointer self) path))

(cl:defmethod find-by-freq ((self fgcomm-list) aPos (freq cl:number) ad (tp cl:integer))
  (FGCommList_FindByFreq (ff-pointer self) aPos freq ad tp))

(cl:defmethod find-by-freq ((self fgcomm-list) aPos (freq cl:number) ad)
  (FGCommList_FindByFreq (ff-pointer self) aPos freq ad))

(cl:defmethod find-by-pos ((self fgcomm-list) aPos (range cl:number) stations (tp cl:integer))
  (FGCommList_FindByPos (ff-pointer self) aPos range stations tp))

(cl:defmethod find-by-pos ((self fgcomm-list) aPos (range cl:number) stations)
  (FGCommList_FindByPos (ff-pointer self) aPos range stations))

(cl:defmethod find-closest ((self fgcomm-list) aPos ad (tp cl:integer) (max_range cl:number))
  (FGCommList_FindClosest (ff-pointer self) aPos ad tp max_range))

(cl:defmethod find-closest ((self fgcomm-list) aPos ad (tp cl:integer))
  (FGCommList_FindClosest (ff-pointer self) aPos ad tp))

(cl:defmethod find-closest ((self fgcomm-list) aPos ad)
  (FGCommList_FindClosest (ff-pointer self) aPos ad))

(cl:defmethod find-by-code ((self fgcomm-list) ICAO ad (tp cl:integer))
  (FGCommList_FindByCode (ff-pointer self) ICAO ad tp))

(cl:defmethod find-by-code ((self fgcomm-list) ICAO ad)
  (FGCommList_FindByCode (ff-pointer self) ICAO ad))

(cl:defmethod get-atis-sequence ((self fgcomm-list) apt_id (tstamp cl:number) (interval cl:integer) (flush cl:integer))
  (FGCommList_GetAtisSequence (ff-pointer self) apt_id tstamp interval flush))

(cl:defmethod get-atis-sequence ((self fgcomm-list) apt_id (tstamp cl:number) (interval cl:integer))
  (FGCommList_GetAtisSequence (ff-pointer self) apt_id tstamp interval))

(cl:defmethod (cl:setf commlist_freq) (arg0 (obj fgcomm-list))
  (FGCommList_commlist_freq_set (ff-pointer obj) arg0))

(cl:defmethod commlist_freq ((obj fgcomm-list))
  (FGCommList_commlist_freq_get (ff-pointer obj)))

(cl:defmethod (cl:setf commlist_bck) (arg0 (obj fgcomm-list))
  (FGCommList_commlist_bck_set (ff-pointer obj) arg0))

(cl:defmethod commlist_bck ((obj fgcomm-list))
  (FGCommList_commlist_bck_get (ff-pointer obj)))


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

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

(cl:defmethod init ((self fgcontrols))
  (FGControls_init (ff-pointer self)))

(cl:defmethod bind ((self fgcontrols))
  (FGControls_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgcontrols))
  (FGControls_unbind (ff-pointer self)))

(cl:defmethod update ((self fgcontrols) (dt cl:number))
  (FGControls_update (ff-pointer self) dt))

(cl:defmethod reset-all ((self fgcontrols))
  (FGControls_reset_all (ff-pointer self)))

(cl:defmethod get-aileron ((self fgcontrols))
  (FGControls_get_aileron (ff-pointer self)))

(cl:defmethod get-aileron-trim ((self fgcontrols))
  (FGControls_get_aileron_trim (ff-pointer self)))

(cl:defmethod get-elevator ((self fgcontrols))
  (FGControls_get_elevator (ff-pointer self)))

(cl:defmethod get-elevator-trim ((self fgcontrols))
  (FGControls_get_elevator_trim (ff-pointer self)))

(cl:defmethod get-rudder ((self fgcontrols))
  (FGControls_get_rudder (ff-pointer self)))

(cl:defmethod get-rudder-trim ((self fgcontrols))
  (FGControls_get_rudder_trim (ff-pointer self)))

(cl:defmethod get-flaps ((self fgcontrols))
  (FGControls_get_flaps (ff-pointer self)))

(cl:defmethod get-slats ((self fgcontrols))
  (FGControls_get_slats (ff-pointer self)))

(cl:defmethod get-blc ((self fgcontrols))
  (FGControls_get_BLC (ff-pointer self)))

(cl:defmethod get-spoilers ((self fgcontrols))
  (FGControls_get_spoilers (ff-pointer self)))

(cl:defmethod get-speedbrake ((self fgcontrols))
  (FGControls_get_speedbrake (ff-pointer self)))

(cl:defmethod get-wing-sweep ((self fgcontrols))
  (FGControls_get_wing_sweep (ff-pointer self)))

(cl:defmethod get-wing-fold ((self fgcontrols))
  (FGControls_get_wing_fold (ff-pointer self)))

(cl:defmethod get-drag-chute ((self fgcontrols))
  (FGControls_get_drag_chute (ff-pointer self)))

(cl:defmethod get-throttle-idle ((self fgcontrols))
  (FGControls_get_throttle_idle (ff-pointer self)))

(cl:defmethod get-throttle ((self fgcontrols) (engine cl:integer))
  (FGControls_get_throttle (ff-pointer self) engine))

(cl:defmethod get-starter ((self fgcontrols) (engine cl:integer))
  (FGControls_get_starter (ff-pointer self) engine))

(cl:defmethod get-fuel-pump ((self fgcontrols) (engine cl:integer))
  (FGControls_get_fuel_pump (ff-pointer self) engine))

(cl:defmethod get-fire-switch ((self fgcontrols) (engine cl:integer))
  (FGControls_get_fire_switch (ff-pointer self) engine))

(cl:defmethod get-fire-bottle-discharge ((self fgcontrols) (engine cl:integer))
  (FGControls_get_fire_bottle_discharge (ff-pointer self) engine))

(cl:defmethod get-cutoff ((self fgcontrols) (engine cl:integer))
  (FGControls_get_cutoff (ff-pointer self) engine))

(cl:defmethod get-mixture ((self fgcontrols) (engine cl:integer))
  (FGControls_get_mixture (ff-pointer self) engine))

(cl:defmethod get-prop-advance ((self fgcontrols) (engine cl:integer))
  (FGControls_get_prop_advance (ff-pointer self) engine))

(cl:defmethod get-magnetos ((self fgcontrols) (engine cl:integer))
  (FGControls_get_magnetos (ff-pointer self) engine))

(cl:defmethod get-feed-tank ((self fgcontrols) (engine cl:integer))
  (FGControls_get_feed_tank (ff-pointer self) engine))

(cl:defmethod get-nitrous-injection ((self fgcontrols) (engine cl:integer))
  (FGControls_get_nitrous_injection (ff-pointer self) engine))

(cl:defmethod get-cowl-flaps-norm ((self fgcontrols) (engine cl:integer))
  (FGControls_get_cowl_flaps_norm (ff-pointer self) engine))

(cl:defmethod get-feather ((self fgcontrols) (engine cl:integer))
  (FGControls_get_feather (ff-pointer self) engine))

(cl:defmethod get-ignition ((self fgcontrols) (engine cl:integer))
  (FGControls_get_ignition (ff-pointer self) engine))

(cl:defmethod get-augmentation ((self fgcontrols) (engine cl:integer))
  (FGControls_get_augmentation (ff-pointer self) engine))

(cl:defmethod get-reverser ((self fgcontrols) (engine cl:integer))
  (FGControls_get_reverser (ff-pointer self) engine))

(cl:defmethod get-water-injection ((self fgcontrols) (engine cl:integer))
  (FGControls_get_water_injection (ff-pointer self) engine))

(cl:defmethod get-condition ((self fgcontrols) (engine cl:integer))
  (FGControls_get_condition (ff-pointer self) engine))

(cl:defmethod get-dump-valve ((self fgcontrols))
  (FGControls_get_dump_valve (ff-pointer self)))

(cl:defmethod get-fuel-selector ((self fgcontrols) (tank cl:integer))
  (FGControls_get_fuel_selector (ff-pointer self) tank))

(cl:defmethod get-to-engine ((self fgcontrols) (tank cl:integer))
  (FGControls_get_to_engine (ff-pointer self) tank))

(cl:defmethod get-to-tank ((self fgcontrols) (tank cl:integer))
  (FGControls_get_to_tank (ff-pointer self) tank))

(cl:defmethod get-boost-pump ((self fgcontrols) (index cl:integer))
  (FGControls_get_boost_pump (ff-pointer self) index))

(cl:defmethod get-brake-left ((self fgcontrols))
  (FGControls_get_brake_left (ff-pointer self)))

(cl:defmethod get-brake-right ((self fgcontrols))
  (FGControls_get_brake_right (ff-pointer self)))

(cl:defmethod get-copilot-brake-left ((self fgcontrols))
  (FGControls_get_copilot_brake_left (ff-pointer self)))

(cl:defmethod get-copilot-brake-right ((self fgcontrols))
  (FGControls_get_copilot_brake_right (ff-pointer self)))

(cl:defmethod get-brake-parking ((self fgcontrols))
  (FGControls_get_brake_parking (ff-pointer self)))

(cl:defmethod get-steering ((self fgcontrols))
  (FGControls_get_steering (ff-pointer self)))

(cl:defmethod get-nose-wheel-steering ((self fgcontrols))
  (FGControls_get_nose_wheel_steering (ff-pointer self)))

(cl:defmethod get-gear-down ((self fgcontrols))
  (FGControls_get_gear_down (ff-pointer self)))

(cl:defmethod get-antiskid ((self fgcontrols))
  (FGControls_get_antiskid (ff-pointer self)))

(cl:defmethod get-tailhook ((self fgcontrols))
  (FGControls_get_tailhook (ff-pointer self)))

(cl:defmethod get-launchbar ((self fgcontrols))
  (FGControls_get_launchbar (ff-pointer self)))

(cl:defmethod get-catapult-launch-cmd ((self fgcontrols))
  (FGControls_get_catapult_launch_cmd (ff-pointer self)))

(cl:defmethod get-tailwheel-lock ((self fgcontrols))
  (FGControls_get_tailwheel_lock (ff-pointer self)))

(cl:defmethod get-alternate-extension ((self fgcontrols) (wheel cl:integer))
  (FGControls_get_alternate_extension (ff-pointer self) wheel))

(cl:defmethod get-wing-heat ((self fgcontrols))
  (FGControls_get_wing_heat (ff-pointer self)))

(cl:defmethod get-pitot-heat ((self fgcontrols))
  (FGControls_get_pitot_heat (ff-pointer self)))

(cl:defmethod get-wiper ((self fgcontrols))
  (FGControls_get_wiper (ff-pointer self)))

(cl:defmethod get-window-heat ((self fgcontrols))
  (FGControls_get_window_heat (ff-pointer self)))

(cl:defmethod get-carb-heat ((self fgcontrols) (engine cl:integer))
  (FGControls_get_carb_heat (ff-pointer self) engine))

(cl:defmethod get-inlet-heat ((self fgcontrols) (engine cl:integer))
  (FGControls_get_inlet_heat (ff-pointer self) engine))

(cl:defmethod get-engine-pump ((self fgcontrols) (system cl:integer))
  (FGControls_get_engine_pump (ff-pointer self) system))

(cl:defmethod get-electric-pump ((self fgcontrols) (system cl:integer))
  (FGControls_get_electric_pump (ff-pointer self) system))

(cl:defmethod get-battery-switch ((self fgcontrols))
  (FGControls_get_battery_switch (ff-pointer self)))

(cl:defmethod get-external-power ((self fgcontrols))
  (FGControls_get_external_power (ff-pointer self)))

(cl:defmethod get-apu-generator ((self fgcontrols))
  (FGControls_get_APU_generator (ff-pointer self)))

(cl:defmethod get-generator-breaker ((self fgcontrols) (engine cl:integer))
  (FGControls_get_generator_breaker (ff-pointer self) engine))

(cl:defmethod get-bus-tie ((self fgcontrols) (engine cl:integer))
  (FGControls_get_bus_tie (ff-pointer self) engine))

(cl:defmethod get-apu-bleed ((self fgcontrols))
  (FGControls_get_APU_bleed (ff-pointer self)))

(cl:defmethod get-engine-bleed ((self fgcontrols) (engine cl:integer))
  (FGControls_get_engine_bleed (ff-pointer self) engine))

(cl:defmethod get-mode ((self fgcontrols))
  (FGControls_get_mode (ff-pointer self)))

(cl:defmethod get-outflow-valve ((self fgcontrols))
  (FGControls_get_outflow_valve (ff-pointer self)))

(cl:defmethod get-dump ((self fgcontrols))
  (FGControls_get_dump (ff-pointer self)))

(cl:defmethod get-pack-on ((self fgcontrols) (pack cl:integer))
  (FGControls_get_pack_on (ff-pointer self) pack))

(cl:defmethod get-landing-lights ((self fgcontrols))
  (FGControls_get_landing_lights (ff-pointer self)))

(cl:defmethod get-turn-off-lights ((self fgcontrols))
  (FGControls_get_turn_off_lights (ff-pointer self)))

(cl:defmethod get-taxi-light ((self fgcontrols))
  (FGControls_get_taxi_light (ff-pointer self)))

(cl:defmethod get-logo-lights ((self fgcontrols))
  (FGControls_get_logo_lights (ff-pointer self)))

(cl:defmethod get-nav-lights ((self fgcontrols))
  (FGControls_get_nav_lights (ff-pointer self)))

(cl:defmethod get-beacon ((self fgcontrols))
  (FGControls_get_beacon (ff-pointer self)))

(cl:defmethod get-strobe ((self fgcontrols))
  (FGControls_get_strobe (ff-pointer self)))

(cl:defmethod get-panel-norm ((self fgcontrols))
  (FGControls_get_panel_norm (ff-pointer self)))

(cl:defmethod get-instruments-norm ((self fgcontrols))
  (FGControls_get_instruments_norm (ff-pointer self)))

(cl:defmethod get-dome-norm ((self fgcontrols))
  (FGControls_get_dome_norm (ff-pointer self)))

(cl:defmethod get-master-arm ((self fgcontrols))
  (FGControls_get_master_arm (ff-pointer self)))

(cl:defmethod get-station-select ((self fgcontrols))
  (FGControls_get_station_select (ff-pointer self)))

(cl:defmethod get-release-all ((self fgcontrols))
  (FGControls_get_release_ALL (ff-pointer self)))

(cl:defmethod get-stick-size ((self fgcontrols) (station cl:integer))
  (FGControls_get_stick_size (ff-pointer self) station))

(cl:defmethod get-release-stick ((self fgcontrols) (station cl:integer))
  (FGControls_get_release_stick (ff-pointer self) station))

(cl:defmethod get-release-all ((self fgcontrols) (station cl:integer))
  (FGControls_get_release_all (ff-pointer self) station))

(cl:defmethod get-jettison-all ((self fgcontrols) (station cl:integer))
  (FGControls_get_jettison_all (ff-pointer self) station))

(cl:defmethod get-vertical-adjust ((self fgcontrols))
  (FGControls_get_vertical_adjust (ff-pointer self)))

(cl:defmethod get-fore-aft-adjust ((self fgcontrols))
  (FGControls_get_fore_aft_adjust (ff-pointer self)))

(cl:defmethod get-ejection-seat ((self fgcontrols) (which_seat cl:integer))
  (FGControls_get_ejection_seat (ff-pointer self) which_seat))

(cl:defmethod get-eseat-status ((self fgcontrols) (which_seat cl:integer))
  (FGControls_get_eseat_status (ff-pointer self) which_seat))

(cl:defmethod get-cmd-selector-valve ((self fgcontrols))
  (FGControls_get_cmd_selector_valve (ff-pointer self)))

(cl:defmethod get-off-start-run ((self fgcontrols))
  (FGControls_get_off_start_run (ff-pointer self)))

(cl:defmethod get-apu-fire-switch ((self fgcontrols))
  (FGControls_get_APU_fire_switch (ff-pointer self)))

(cl:defmethod get-autothrottle-arm ((self fgcontrols))
  (FGControls_get_autothrottle_arm (ff-pointer self)))

(cl:defmethod get-autothrottle-engage ((self fgcontrols))
  (FGControls_get_autothrottle_engage (ff-pointer self)))

(cl:defmethod get-heading-select ((self fgcontrols))
  (FGControls_get_heading_select (ff-pointer self)))

(cl:defmethod get-altitude-select ((self fgcontrols))
  (FGControls_get_altitude_select (ff-pointer self)))

(cl:defmethod get-bank-angle-select ((self fgcontrols))
  (FGControls_get_bank_angle_select (ff-pointer self)))

(cl:defmethod get-vertical-speed-select ((self fgcontrols))
  (FGControls_get_vertical_speed_select (ff-pointer self)))

(cl:defmethod get-speed-select ((self fgcontrols))
  (FGControls_get_speed_select (ff-pointer self)))

(cl:defmethod get-mach-select ((self fgcontrols))
  (FGControls_get_mach_select (ff-pointer self)))

(cl:defmethod get-vertical-mode ((self fgcontrols))
  (FGControls_get_vertical_mode (ff-pointer self)))

(cl:defmethod get-lateral-mode ((self fgcontrols))
  (FGControls_get_lateral_mode (ff-pointer self)))

(cl:defmethod get-autopilot-engage ((self fgcontrols) (ap cl:integer))
  (FGControls_get_autopilot_engage (ff-pointer self) ap))

(cl:defmethod set-aileron ((self fgcontrols) (pos cl:number))
  (FGControls_set_aileron (ff-pointer self) pos))

(cl:defmethod move-aileron ((self fgcontrols) (amt cl:number))
  (FGControls_move_aileron (ff-pointer self) amt))

(cl:defmethod set-aileron-trim ((self fgcontrols) (pos cl:number))
  (FGControls_set_aileron_trim (ff-pointer self) pos))

(cl:defmethod move-aileron-trim ((self fgcontrols) (amt cl:number))
  (FGControls_move_aileron_trim (ff-pointer self) amt))

(cl:defmethod set-elevator ((self fgcontrols) (pos cl:number))
  (FGControls_set_elevator (ff-pointer self) pos))

(cl:defmethod move-elevator ((self fgcontrols) (amt cl:number))
  (FGControls_move_elevator (ff-pointer self) amt))

(cl:defmethod set-elevator-trim ((self fgcontrols) (pos cl:number))
  (FGControls_set_elevator_trim (ff-pointer self) pos))

(cl:defmethod move-elevator-trim ((self fgcontrols) (amt cl:number))
  (FGControls_move_elevator_trim (ff-pointer self) amt))

(cl:defmethod set-rudder ((self fgcontrols) (pos cl:number))
  (FGControls_set_rudder (ff-pointer self) pos))

(cl:defmethod move-rudder ((self fgcontrols) (amt cl:number))
  (FGControls_move_rudder (ff-pointer self) amt))

(cl:defmethod set-rudder-trim ((self fgcontrols) (pos cl:number))
  (FGControls_set_rudder_trim (ff-pointer self) pos))

(cl:defmethod move-rudder-trim ((self fgcontrols) (amt cl:number))
  (FGControls_move_rudder_trim (ff-pointer self) amt))

(cl:defmethod set-flaps ((self fgcontrols) (pos cl:number))
  (FGControls_set_flaps (ff-pointer self) pos))

(cl:defmethod move-flaps ((self fgcontrols) (amt cl:number))
  (FGControls_move_flaps (ff-pointer self) amt))

(cl:defmethod set-slats ((self fgcontrols) (pos cl:number))
  (FGControls_set_slats (ff-pointer self) pos))

(cl:defmethod move-slats ((self fgcontrols) (amt cl:number))
  (FGControls_move_slats (ff-pointer self) amt))

(cl:defmethod set-blc ((self fgcontrols) (val t))
  (FGControls_set_BLC (ff-pointer self) val))

(cl:defmethod set-spoilers ((self fgcontrols) (pos cl:number))
  (FGControls_set_spoilers (ff-pointer self) pos))

(cl:defmethod move-spoilers ((self fgcontrols) (amt cl:number))
  (FGControls_move_spoilers (ff-pointer self) amt))

(cl:defmethod set-speedbrake ((self fgcontrols) (pos cl:number))
  (FGControls_set_speedbrake (ff-pointer self) pos))

(cl:defmethod move-speedbrake ((self fgcontrols) (amt cl:number))
  (FGControls_move_speedbrake (ff-pointer self) amt))

(cl:defmethod set-wing-sweep ((self fgcontrols) (pos cl:number))
  (FGControls_set_wing_sweep (ff-pointer self) pos))

(cl:defmethod move-wing-sweep ((self fgcontrols) (amt cl:number))
  (FGControls_move_wing_sweep (ff-pointer self) amt))

(cl:defmethod set-wing-fold ((self fgcontrols) (val t))
  (FGControls_set_wing_fold (ff-pointer self) val))

(cl:defmethod set-drag-chute ((self fgcontrols) (val t))
  (FGControls_set_drag_chute (ff-pointer self) val))

(cl:defmethod set-throttle-idle ((self fgcontrols) (val t))
  (FGControls_set_throttle_idle (ff-pointer self) val))

(cl:defmethod set-throttle ((self fgcontrols) (engine cl:integer) (pos cl:number))
  (FGControls_set_throttle (ff-pointer self) engine pos))

(cl:defmethod move-throttle ((self fgcontrols) (engine cl:integer) (amt cl:number))
  (FGControls_move_throttle (ff-pointer self) engine amt))

(cl:defmethod set-starter ((self fgcontrols) (engine cl:integer) (flag t))
  (FGControls_set_starter (ff-pointer self) engine flag))

(cl:defmethod set-fuel-pump ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_fuel_pump (ff-pointer self) engine val))

(cl:defmethod set-fire-switch ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_fire_switch (ff-pointer self) engine val))

(cl:defmethod set-fire-bottle-discharge ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_fire_bottle_discharge (ff-pointer self) engine val))

(cl:defmethod set-cutoff ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_cutoff (ff-pointer self) engine val))

(cl:defmethod set-mixture ((self fgcontrols) (engine cl:integer) (pos cl:number))
  (FGControls_set_mixture (ff-pointer self) engine pos))

(cl:defmethod move-mixture ((self fgcontrols) (engine cl:integer) (amt cl:number))
  (FGControls_move_mixture (ff-pointer self) engine amt))

(cl:defmethod set-prop-advance ((self fgcontrols) (engine cl:integer) (pos cl:number))
  (FGControls_set_prop_advance (ff-pointer self) engine pos))

(cl:defmethod move-prop-advance ((self fgcontrols) (engine cl:integer) (amt cl:number))
  (FGControls_move_prop_advance (ff-pointer self) engine amt))

(cl:defmethod set-magnetos ((self fgcontrols) (engine cl:integer) (pos cl:integer))
  (FGControls_set_magnetos (ff-pointer self) engine pos))

(cl:defmethod move-magnetos ((self fgcontrols) (engine cl:integer) (amt cl:integer))
  (FGControls_move_magnetos (ff-pointer self) engine amt))

(cl:defmethod set-feed-tank ((self fgcontrols) (engine cl:integer) (tank cl:integer))
  (FGControls_set_feed_tank (ff-pointer self) engine tank))

(cl:defmethod set-nitrous-injection ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_nitrous_injection (ff-pointer self) engine val))

(cl:defmethod set-cowl-flaps-norm ((self fgcontrols) (engine cl:integer) (pos cl:number))
  (FGControls_set_cowl_flaps_norm (ff-pointer self) engine pos))

(cl:defmethod move-cowl-flaps-norm ((self fgcontrols) (engine cl:integer) (amt cl:number))
  (FGControls_move_cowl_flaps_norm (ff-pointer self) engine amt))

(cl:defmethod set-feather ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_feather (ff-pointer self) engine val))

(cl:defmethod set-ignition ((self fgcontrols) (engine cl:integer) (val cl:integer))
  (FGControls_set_ignition (ff-pointer self) engine val))

(cl:defmethod set-augmentation ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_augmentation (ff-pointer self) engine val))

(cl:defmethod set-reverser ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_reverser (ff-pointer self) engine val))

(cl:defmethod set-water-injection ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_water_injection (ff-pointer self) engine val))

(cl:defmethod set-condition ((self fgcontrols) (engine cl:integer) (val cl:number))
  (FGControls_set_condition (ff-pointer self) engine val))

(cl:defmethod set-dump-valve ((self fgcontrols) (val t))
  (FGControls_set_dump_valve (ff-pointer self) val))

(cl:defmethod set-fuel-selector ((self fgcontrols) (tank cl:integer) (pos t))
  (FGControls_set_fuel_selector (ff-pointer self) tank pos))

(cl:defmethod set-to-engine ((self fgcontrols) (tank cl:integer) (engine cl:integer))
  (FGControls_set_to_engine (ff-pointer self) tank engine))

(cl:defmethod set-to-tank ((self fgcontrols) (tank cl:integer) (dest_tank cl:integer))
  (FGControls_set_to_tank (ff-pointer self) tank dest_tank))

(cl:defmethod set-boost-pump ((self fgcontrols) (index cl:integer) (val t))
  (FGControls_set_boost_pump (ff-pointer self) index val))

(cl:defmethod set-brake-left ((self fgcontrols) (pos cl:number))
  (FGControls_set_brake_left (ff-pointer self) pos))

(cl:defmethod move-brake-left ((self fgcontrols) (amt cl:number))
  (FGControls_move_brake_left (ff-pointer self) amt))

(cl:defmethod set-brake-right ((self fgcontrols) (pos cl:number))
  (FGControls_set_brake_right (ff-pointer self) pos))

(cl:defmethod move-brake-right ((self fgcontrols) (amt cl:number))
  (FGControls_move_brake_right (ff-pointer self) amt))

(cl:defmethod set-copilot-brake-left ((self fgcontrols) (pos cl:number))
  (FGControls_set_copilot_brake_left (ff-pointer self) pos))

(cl:defmethod set-copilot-brake-right ((self fgcontrols) (pos cl:number))
  (FGControls_set_copilot_brake_right (ff-pointer self) pos))

(cl:defmethod set-brake-parking ((self fgcontrols) (pos cl:number))
  (FGControls_set_brake_parking (ff-pointer self) pos))

(cl:defmethod set-steering ((self fgcontrols) (pos cl:number))
  (FGControls_set_steering (ff-pointer self) pos))

(cl:defmethod move-steering ((self fgcontrols) (amt cl:number))
  (FGControls_move_steering (ff-pointer self) amt))

(cl:defmethod set-nose-wheel-steering ((self fgcontrols) (nws t))
  (FGControls_set_nose_wheel_steering (ff-pointer self) nws))

(cl:defmethod set-gear-down ((self fgcontrols) (gear t))
  (FGControls_set_gear_down (ff-pointer self) gear))

(cl:defmethod set-antiskid ((self fgcontrols) (val t))
  (FGControls_set_antiskid (ff-pointer self) val))

(cl:defmethod set-tailhook ((self fgcontrols) (val t))
  (FGControls_set_tailhook (ff-pointer self) val))

(cl:defmethod set-launchbar ((self fgcontrols) (val t))
  (FGControls_set_launchbar (ff-pointer self) val))

(cl:defmethod set-catapult-launch-cmd ((self fgcontrols) (val t))
  (FGControls_set_catapult_launch_cmd (ff-pointer self) val))

(cl:defmethod set-tailwheel-lock ((self fgcontrols) (val t))
  (FGControls_set_tailwheel_lock (ff-pointer self) val))

(cl:defmethod set-alternate-extension ((self fgcontrols) (wheel cl:integer) (val t))
  (FGControls_set_alternate_extension (ff-pointer self) wheel val))

(cl:defmethod set-wing-heat ((self fgcontrols) (val t))
  (FGControls_set_wing_heat (ff-pointer self) val))

(cl:defmethod set-pitot-heat ((self fgcontrols) (val t))
  (FGControls_set_pitot_heat (ff-pointer self) val))

(cl:defmethod set-wiper ((self fgcontrols) (speed cl:integer))
  (FGControls_set_wiper (ff-pointer self) speed))

(cl:defmethod set-window-heat ((self fgcontrols) (val t))
  (FGControls_set_window_heat (ff-pointer self) val))

(cl:defmethod set-carb-heat ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_carb_heat (ff-pointer self) engine val))

(cl:defmethod set-inlet-heat ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_inlet_heat (ff-pointer self) engine val))

(cl:defmethod set-engine-pump ((self fgcontrols) (system cl:integer) (val t))
  (FGControls_set_engine_pump (ff-pointer self) system val))

(cl:defmethod set-electric-pump ((self fgcontrols) (system cl:integer) (val t))
  (FGControls_set_electric_pump (ff-pointer self) system val))

(cl:defmethod set-battery-switch ((self fgcontrols) (val t))
  (FGControls_set_battery_switch (ff-pointer self) val))

(cl:defmethod set-external-power ((self fgcontrols) (val t))
  (FGControls_set_external_power (ff-pointer self) val))

(cl:defmethod set-apu-generator ((self fgcontrols) (val t))
  (FGControls_set_APU_generator (ff-pointer self) val))

(cl:defmethod set-generator-breaker ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_generator_breaker (ff-pointer self) engine val))

(cl:defmethod set-bus-tie ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_bus_tie (ff-pointer self) engine val))

(cl:defmethod set-apu-bleed ((self fgcontrols) (val t))
  (FGControls_set_APU_bleed (ff-pointer self) val))

(cl:defmethod set-engine-bleed ((self fgcontrols) (engine cl:integer) (val t))
  (FGControls_set_engine_bleed (ff-pointer self) engine val))

(cl:defmethod set-mode ((self fgcontrols) (mode cl:integer))
  (FGControls_set_mode (ff-pointer self) mode))

(cl:defmethod set-outflow-valve ((self fgcontrols) (pos cl:number))
  (FGControls_set_outflow_valve (ff-pointer self) pos))

(cl:defmethod move-outflow-valve ((self fgcontrols) (amt cl:number))
  (FGControls_move_outflow_valve (ff-pointer self) amt))

(cl:defmethod set-dump ((self fgcontrols) (val t))
  (FGControls_set_dump (ff-pointer self) val))

(cl:defmethod set-pack-on ((self fgcontrols) (pack cl:integer) (val t))
  (FGControls_set_pack_on (ff-pointer self) pack val))

(cl:defmethod set-landing-lights ((self fgcontrols) (val t))
  (FGControls_set_landing_lights (ff-pointer self) val))

(cl:defmethod set-turn-off-lights ((self fgcontrols) (val t))
  (FGControls_set_turn_off_lights (ff-pointer self) val))

(cl:defmethod set-taxi-light ((self fgcontrols) (val t))
  (FGControls_set_taxi_light (ff-pointer self) val))

(cl:defmethod set-logo-lights ((self fgcontrols) (val t))
  (FGControls_set_logo_lights (ff-pointer self) val))

(cl:defmethod set-nav-lights ((self fgcontrols) (val t))
  (FGControls_set_nav_lights (ff-pointer self) val))

(cl:defmethod set-beacon ((self fgcontrols) (val t))
  (FGControls_set_beacon (ff-pointer self) val))

(cl:defmethod set-strobe ((self fgcontrols) (val t))
  (FGControls_set_strobe (ff-pointer self) val))

(cl:defmethod set-panel-norm ((self fgcontrols) (intensity cl:number))
  (FGControls_set_panel_norm (ff-pointer self) intensity))

(cl:defmethod move-panel-norm ((self fgcontrols) (amt cl:number))
  (FGControls_move_panel_norm (ff-pointer self) amt))

(cl:defmethod set-instruments-norm ((self fgcontrols) (intensity cl:number))
  (FGControls_set_instruments_norm (ff-pointer self) intensity))

(cl:defmethod move-instruments-norm ((self fgcontrols) (amt cl:number))
  (FGControls_move_instruments_norm (ff-pointer self) amt))

(cl:defmethod set-dome-norm ((self fgcontrols) (intensity cl:number))
  (FGControls_set_dome_norm (ff-pointer self) intensity))

(cl:defmethod move-dome-norm ((self fgcontrols) (amt cl:number))
  (FGControls_move_dome_norm (ff-pointer self) amt))

(cl:defmethod set-master-arm ((self fgcontrols) (val t))
  (FGControls_set_master_arm (ff-pointer self) val))

(cl:defmethod set-station-select ((self fgcontrols) (station cl:integer))
  (FGControls_set_station_select (ff-pointer self) station))

(cl:defmethod set-release-all ((self fgcontrols) (val t))
  (FGControls_set_release_ALL (ff-pointer self) val))

(cl:defmethod set-stick-size ((self fgcontrols) (station cl:integer) (size cl:integer))
  (FGControls_set_stick_size (ff-pointer self) station size))

(cl:defmethod set-release-stick ((self fgcontrols) (station cl:integer) (val t))
  (FGControls_set_release_stick (ff-pointer self) station val))

(cl:defmethod set-release-all ((self fgcontrols) (station cl:integer) (val t))
  (FGControls_set_release_all (ff-pointer self) station val))

(cl:defmethod set-jettison-all ((self fgcontrols) (station cl:integer) (val t))
  (FGControls_set_jettison_all (ff-pointer self) station val))

(cl:defmethod set-vertical-adjust ((self fgcontrols) (pos cl:number))
  (FGControls_set_vertical_adjust (ff-pointer self) pos))

(cl:defmethod move-vertical-adjust ((self fgcontrols) (amt cl:number))
  (FGControls_move_vertical_adjust (ff-pointer self) amt))

(cl:defmethod set-fore-aft-adjust ((self fgcontrols) (pos cl:number))
  (FGControls_set_fore_aft_adjust (ff-pointer self) pos))

(cl:defmethod move-fore-aft-adjust ((self fgcontrols) (amt cl:number))
  (FGControls_move_fore_aft_adjust (ff-pointer self) amt))

(cl:defmethod set-ejection-seat ((self fgcontrols) (which_seat cl:integer) (val t))
  (FGControls_set_ejection_seat (ff-pointer self) which_seat val))

(cl:defmethod set-eseat-status ((self fgcontrols) (which_seat cl:integer) (val cl:integer))
  (FGControls_set_eseat_status (ff-pointer self) which_seat val))

(cl:defmethod set-cmd-selector-valve ((self fgcontrols) (val cl:integer))
  (FGControls_set_cmd_selector_valve (ff-pointer self) val))

(cl:defmethod set-off-start-run ((self fgcontrols) (pos cl:integer))
  (FGControls_set_off_start_run (ff-pointer self) pos))

(cl:defmethod set-apu-fire-switch ((self fgcontrols) (val t))
  (FGControls_set_APU_fire_switch (ff-pointer self) val))

(cl:defmethod set-autothrottle-arm ((self fgcontrols) (val t))
  (FGControls_set_autothrottle_arm (ff-pointer self) val))

(cl:defmethod set-autothrottle-engage ((self fgcontrols) (val t))
  (FGControls_set_autothrottle_engage (ff-pointer self) val))

(cl:defmethod set-heading-select ((self fgcontrols) (heading cl:number))
  (FGControls_set_heading_select (ff-pointer self) heading))

(cl:defmethod move-heading-select ((self fgcontrols) (amt cl:number))
  (FGControls_move_heading_select (ff-pointer self) amt))

(cl:defmethod set-altitude-select ((self fgcontrols) (altitude cl:number))
  (FGControls_set_altitude_select (ff-pointer self) altitude))

(cl:defmethod move-altitude-select ((self fgcontrols) (amt cl:number))
  (FGControls_move_altitude_select (ff-pointer self) amt))

(cl:defmethod set-bank-angle-select ((self fgcontrols) (angle cl:number))
  (FGControls_set_bank_angle_select (ff-pointer self) angle))

(cl:defmethod move-bank-angle-select ((self fgcontrols) (amt cl:number))
  (FGControls_move_bank_angle_select (ff-pointer self) amt))

(cl:defmethod set-vertical-speed-select ((self fgcontrols) (vs cl:number))
  (FGControls_set_vertical_speed_select (ff-pointer self) vs))

(cl:defmethod move-vertical-speed-select ((self fgcontrols) (amt cl:number))
  (FGControls_move_vertical_speed_select (ff-pointer self) amt))

(cl:defmethod set-speed-select ((self fgcontrols) (speed cl:number))
  (FGControls_set_speed_select (ff-pointer self) speed))

(cl:defmethod move-speed-select ((self fgcontrols) (amt cl:number))
  (FGControls_move_speed_select (ff-pointer self) amt))

(cl:defmethod set-mach-select ((self fgcontrols) (mach cl:number))
  (FGControls_set_mach_select (ff-pointer self) mach))

(cl:defmethod move-mach-select ((self fgcontrols) (amt cl:number))
  (FGControls_move_mach_select (ff-pointer self) amt))

(cl:defmethod set-vertical-mode ((self fgcontrols) (mode cl:integer))
  (FGControls_set_vertical_mode (ff-pointer self) mode))

(cl:defmethod set-lateral-mode ((self fgcontrols) (mode cl:integer))
  (FGControls_set_lateral_mode (ff-pointer self) mode))

(cl:defmethod set-autopilot-engage ((self fgcontrols) (ap cl:integer) (val t))
  (FGControls_set_autopilot_engage (ff-pointer self) ap val))


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

(cl:defmethod (cl:setf sim_time) (arg0 (obj fgreplay-data))
  (FGReplayData_sim_time_set (ff-pointer obj) arg0))

(cl:defmethod sim_time ((obj fgreplay-data))
  (FGReplayData_sim_time_get (ff-pointer obj)))

(cl:defmethod (cl:setf fdm) (arg0 (obj fgreplay-data))
  (FGReplayData_fdm_set (ff-pointer obj) arg0))

(cl:defmethod fdm ((obj fgreplay-data))
  (FGReplayData_fdm_get (ff-pointer obj)))

(cl:defmethod (cl:setf ctrls) (arg0 (obj fgreplay-data))
  (FGReplayData_ctrls_set (ff-pointer obj) arg0))

(cl:defmethod ctrls ((obj fgreplay-data))
  (FGReplayData_ctrls_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj fgreplay-data) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGReplayData)))


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

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

(cl:defmethod init ((self fgreplay))
  (FGReplay_init (ff-pointer self)))

(cl:defmethod reinit ((self fgreplay))
  (FGReplay_reinit (ff-pointer self)))

(cl:defmethod bind ((self fgreplay))
  (FGReplay_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgreplay))
  (FGReplay_unbind (ff-pointer self)))

(cl:defmethod update ((self fgreplay) (dt cl:number))
  (FGReplay_update (ff-pointer self) dt))

(cl:defmethod replay ((self fgreplay) (time cl:number))
  (FGReplay_replay (ff-pointer self) time))

(cl:defmethod get-start-time ((self fgreplay))
  (FGReplay_get_start_time (ff-pointer self)))

(cl:defmethod get-end-time ((self fgreplay))
  (FGReplay_get_end_time (ff-pointer self)))


(cl:defclass fgairport-dynamics-xmlloader()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgairport-dynamics-xmlloader) &key dyn)
  (setf (slot-value obj 'ff-pointer) (new_FGAirportDynamicsXMLLoader dyn)))


(cl:defclass fgairport-dynamics()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgairport-dynamics) &key ap)
  (setf (slot-value obj 'ff-pointer) (new_FGAirportDynamics ap)))

(cl:defmethod initialize-instance :after ((obj fgairport-dynamics) &key (other fgairport-dynamics))
  (setf (slot-value obj 'ff-pointer) (new_FGAirportDynamics (ff-pointer other))))

(cl:defmethod add-awos-freq ((self fgairport-dynamics) (val cl:integer))
  (FGAirportDynamics_addAwosFreq (ff-pointer self) val))

(cl:defmethod add-unicom-freq ((self fgairport-dynamics) (val cl:integer))
  (FGAirportDynamics_addUnicomFreq (ff-pointer self) val))

(cl:defmethod add-clearance-freq ((self fgairport-dynamics) (val cl:integer))
  (FGAirportDynamics_addClearanceFreq (ff-pointer self) val))

(cl:defmethod add-ground-freq ((self fgairport-dynamics) (val cl:integer))
  (FGAirportDynamics_addGroundFreq (ff-pointer self) val))

(cl:defmethod add-tower-freq ((self fgairport-dynamics) (val cl:integer))
  (FGAirportDynamics_addTowerFreq (ff-pointer self) val))

(cl:defmethod add-approach-freq ((self fgairport-dynamics) (val cl:integer))
  (FGAirportDynamics_addApproachFreq (ff-pointer self) val))

(cl:defmethod init ((self fgairport-dynamics))
  (FGAirportDynamics_init (ff-pointer self)))

(cl:defmethod get-longitude ((self fgairport-dynamics))
  (FGAirportDynamics_getLongitude (ff-pointer self)))

(cl:defmethod get-latitude ((self fgairport-dynamics))
  (FGAirportDynamics_getLatitude (ff-pointer self)))

(cl:defmethod get-elevation ((self fgairport-dynamics))
  (FGAirportDynamics_getElevation (ff-pointer self)))

(cl:defmethod get-id ((self fgairport-dynamics))
  (FGAirportDynamics_getId (ff-pointer self)))

(cl:defmethod get-active-runway ((self fgairport-dynamics) trafficType (action cl:integer) runway (heading cl:number))
  (FGAirportDynamics_getActiveRunway (ff-pointer self) trafficType action runway heading))

(cl:defmethod add-parking ((self fgairport-dynamics) park)
  (FGAirportDynamics_addParking (ff-pointer self) park))

(cl:defmethod get-available-parking ((self fgairport-dynamics) lat lon heading gate (rad cl:number) fltype acType airline)
  (FGAirportDynamics_getAvailableParking (ff-pointer self) lat lon heading gate rad fltype acType airline))

(cl:defmethod get-parking ((self fgairport-dynamics) (id cl:integer) lat lon heading)
  (FGAirportDynamics_getParking (ff-pointer self) id lat lon heading))

(cl:defmethod get-parking ((self fgairport-dynamics) (i cl:integer))
  (FGAirportDynamics_getParking (ff-pointer self) i))

(cl:defmethod release-parking ((self fgairport-dynamics) (id cl:integer))
  (FGAirportDynamics_releaseParking (ff-pointer self) id))

(cl:defmethod get-parking-name ((self fgairport-dynamics) (i cl:integer))
  (FGAirportDynamics_getParkingName (ff-pointer self) i))

(cl:defmethod get-nr-of-parkings ((self fgairport-dynamics))
  (FGAirportDynamics_getNrOfParkings (ff-pointer self)))

(cl:defmethod get-sids ((self fgairport-dynamics))
  (FGAirportDynamics_getSIDs (ff-pointer self)))

(cl:defmethod get-sid ((self fgairport-dynamics) activeRunway (heading cl:number))
  (FGAirportDynamics_getSID (ff-pointer self) activeRunway heading))

(cl:defmethod get-startup-controller ((self fgairport-dynamics))
  (FGAirportDynamics_getStartupController (ff-pointer self)))

(cl:defmethod get-ground-network ((self fgairport-dynamics))
  (FGAirportDynamics_getGroundNetwork (ff-pointer self)))

(cl:defmethod get-tower-controller ((self fgairport-dynamics))
  (FGAirportDynamics_getTowerController (ff-pointer self)))

(cl:defmethod get-approach-controller ((self fgairport-dynamics))
  (FGAirportDynamics_getApproachController (ff-pointer self)))

(cl:defmethod get-atis-information ((self fgairport-dynamics))
  (FGAirportDynamics_getAtisInformation (ff-pointer self)))

(cl:defmethod get-ground-frequency ((self fgairport-dynamics) (leg cl:integer))
  (FGAirportDynamics_getGroundFrequency (ff-pointer self) leg))

(cl:defmethod set-rwy-use ((self fgairport-dynamics) ref)
  (FGAirportDynamics_setRwyUse (ff-pointer self) ref))


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

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

(cl:defmethod initialize-instance :after ((obj fgtaxi-node) &key (other fgtaxi-node))
  (setf (slot-value obj 'ff-pointer) (new_FGTaxiNode (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self fgtaxi-node) (other fgtaxi-node))
  (FGTaxiNode___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod set-index ((self fgtaxi-node) (idx cl:integer))
  (FGTaxiNode_setIndex (ff-pointer self) idx))

(cl:defmethod set-latitude ((self fgtaxi-node) (val cl:number))
  (FGTaxiNode_setLatitude (ff-pointer self) val))

(cl:defmethod set-longitude ((self fgtaxi-node) (val cl:number))
  (FGTaxiNode_setLongitude (ff-pointer self) val))

(cl:defmethod set-latitude ((self fgtaxi-node) val)
  (FGTaxiNode_setLatitude (ff-pointer self) val))

(cl:defmethod set-longitude ((self fgtaxi-node) val)
  (FGTaxiNode_setLongitude (ff-pointer self) val))

(cl:defmethod add-segment ((self fgtaxi-node) segment)
  (FGTaxiNode_addSegment (ff-pointer self) segment))

(cl:defmethod set-hold-point-type ((self fgtaxi-node) (val cl:integer))
  (FGTaxiNode_setHoldPointType (ff-pointer self) val))

(cl:defmethod set-on-runway ((self fgtaxi-node) (val t))
  (FGTaxiNode_setOnRunway (ff-pointer self) val))

(cl:defmethod set-path-score ((self fgtaxi-node) (val cl:number))
  (FGTaxiNode_setPathScore (ff-pointer self) val))

(cl:defmethod set-previous-node ((self fgtaxi-node) (val fgtaxi-node))
  (FGTaxiNode_setPreviousNode (ff-pointer self) (ff-pointer val)))

(cl:defmethod set-previous-seg ((self fgtaxi-node) val)
  (FGTaxiNode_setPreviousSeg (ff-pointer self) val))

(cl:defmethod get-previous-node ((self fgtaxi-node))
  (FGTaxiNode_getPreviousNode (ff-pointer self)))

(cl:defmethod get-previous-segment ((self fgtaxi-node))
  (FGTaxiNode_getPreviousSegment (ff-pointer self)))

(cl:defmethod get-path-score ((self fgtaxi-node))
  (FGTaxiNode_getPathScore (ff-pointer self)))

(cl:defmethod get-latitude ((self fgtaxi-node))
  (FGTaxiNode_getLatitude (ff-pointer self)))

(cl:defmethod get-longitude ((self fgtaxi-node))
  (FGTaxiNode_getLongitude (ff-pointer self)))

(cl:defmethod get-geod ((self fgtaxi-node))
  (FGTaxiNode_getGeod (ff-pointer self)))

(cl:defmethod get-index ((self fgtaxi-node))
  (FGTaxiNode_getIndex (ff-pointer self)))

(cl:defmethod get-hold-point-type ((self fgtaxi-node))
  (FGTaxiNode_getHoldPointType (ff-pointer self)))

(cl:defmethod get-is-on-runway ((self fgtaxi-node))
  (FGTaxiNode_getIsOnRunway (ff-pointer self)))

(cl:defmethod get-address ((self fgtaxi-node))
  (FGTaxiNode_getAddress (ff-pointer self)))

(cl:defmethod get-begin-route ((self fgtaxi-node))
  (FGTaxiNode_getBeginRoute (ff-pointer self)))

(cl:defmethod get-end-route ((self fgtaxi-node))
  (FGTaxiNode_getEndRoute (ff-pointer self)))

(cl:shadow "<")
(cl:defmethod < ((self fgtaxi-node) (other fgtaxi-node))
  (FGTaxiNode___lt__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod sort-end-segments ((self fgtaxi-node) (arg1 t))
  (FGTaxiNode_sortEndSegments (ff-pointer self) arg1))


(cl:defclass fgtaxi-segment()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgtaxi-segment) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTaxiSegment)))

(cl:defmethod initialize-instance :after ((obj fgtaxi-segment) &key (other fgtaxi-segment))
  (setf (slot-value obj 'ff-pointer) (new_FGTaxiSegment (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self fgtaxi-segment) (other fgtaxi-segment))
  (FGTaxiSegment___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod set-index ((self fgtaxi-segment) (val cl:integer))
  (FGTaxiSegment_setIndex (ff-pointer self) val))

(cl:defmethod set-start-node-ref ((self fgtaxi-segment) (val cl:integer))
  (FGTaxiSegment_setStartNodeRef (ff-pointer self) val))

(cl:defmethod set-end-node-ref ((self fgtaxi-segment) (val cl:integer))
  (FGTaxiSegment_setEndNodeRef (ff-pointer self) val))

(cl:defmethod set-opposite ((self fgtaxi-segment) (opp fgtaxi-segment))
  (FGTaxiSegment_setOpposite (ff-pointer self) (ff-pointer opp)))

(cl:defmethod set-start ((self fgtaxi-segment) nodes)
  (FGTaxiSegment_setStart (ff-pointer self) nodes))

(cl:defmethod set-end ((self fgtaxi-segment) nodes)
  (FGTaxiSegment_setEnd (ff-pointer self) nodes))

(cl:defmethod set-push-back-type ((self fgtaxi-segment) (val t))
  (FGTaxiSegment_setPushBackType (ff-pointer self) val))

(cl:defmethod set-track-distance ((self fgtaxi-segment))
  (FGTaxiSegment_setTrackDistance (ff-pointer self)))

(cl:defmethod get-end ((self fgtaxi-segment))
  (FGTaxiSegment_getEnd (ff-pointer self)))

(cl:defmethod get-start ((self fgtaxi-segment))
  (FGTaxiSegment_getStart (ff-pointer self)))

(cl:defmethod get-length ((self fgtaxi-segment))
  (FGTaxiSegment_getLength (ff-pointer self)))

(cl:defmethod get-index ((self fgtaxi-segment))
  (FGTaxiSegment_getIndex (ff-pointer self)))

(cl:defmethod is-push-back ((self fgtaxi-segment))
  (FGTaxiSegment_isPushBack (ff-pointer self)))

(cl:defmethod get-penalty ((self fgtaxi-segment) (nGates cl:integer))
  (FGTaxiSegment_getPenalty (ff-pointer self) nGates))

(cl:defmethod get-address ((self fgtaxi-segment))
  (FGTaxiSegment_getAddress (ff-pointer self)))

(cl:shadow "<")
(cl:defmethod < ((self fgtaxi-segment) (other fgtaxi-segment))
  (FGTaxiSegment___lt__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod has-smaller-heading-diff ((self fgtaxi-segment) (other fgtaxi-segment))
  (FGTaxiSegment_hasSmallerHeadingDiff (ff-pointer self) (ff-pointer other)))

(cl:defmethod opposite ((self fgtaxi-segment))
  (FGTaxiSegment_opposite (ff-pointer self)))

(cl:defmethod set-course-diff ((self fgtaxi-segment) (crse cl:number))
  (FGTaxiSegment_setCourseDiff (ff-pointer self) crse))


(cl:defclass fgtaxi-route()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgtaxi-route) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTaxiRoute)))

(cl:defmethod initialize-instance :after ((obj fgtaxi-route) &key nds rts (dist cl:number) (dpth cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTaxiRoute nds rts dist dpth)))

(cl:shadow "=")
(cl:defmethod = ((self fgtaxi-route) (other fgtaxi-route))
  (FGTaxiRoute___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod initialize-instance :after ((obj fgtaxi-route) &key (copy fgtaxi-route))
  (setf (slot-value obj 'ff-pointer) (new_FGTaxiRoute (ff-pointer copy))))

(cl:shadow "<")
(cl:defmethod < ((self fgtaxi-route) (other fgtaxi-route))
  (FGTaxiRoute___lt__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod empty ((self fgtaxi-route))
  (FGTaxiRoute_empty (ff-pointer self)))

(cl:defmethod next ((self fgtaxi-route) nde)
  (FGTaxiRoute_next (ff-pointer self) nde))

(cl:defmethod next ((self fgtaxi-route) nde rte)
  (FGTaxiRoute_next (ff-pointer self) nde rte))

(cl:defmethod rewind ((self fgtaxi-route) (legNr cl:integer))
  (FGTaxiRoute_rewind (ff-pointer self) legNr))

(cl:defmethod first ((self fgtaxi-route))
  (FGTaxiRoute_first (ff-pointer self)))

(cl:defmethod size ((self fgtaxi-route))
  (FGTaxiRoute_size (ff-pointer self)))


(cl:defclass fgground-network()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgground-network) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGGroundNetwork)))

(cl:defmethod add-node ((self fgground-network) (node fgtaxi-node))
  (FGGroundNetwork_addNode (ff-pointer self) node))

(cl:defmethod add-nodes ((self fgground-network) parkings)
  (FGGroundNetwork_addNodes (ff-pointer self) parkings))

(cl:defmethod add-segment ((self fgground-network) (seg fgtaxi-segment))
  (FGGroundNetwork_addSegment (ff-pointer self) seg))

(cl:defmethod init ((self fgground-network))
  (FGGroundNetwork_init (ff-pointer self)))

(cl:defmethod exists ((self fgground-network))
  (FGGroundNetwork_exists (ff-pointer self)))

(cl:defmethod set-tower-controller ((self fgground-network) twrCtrlr)
  (FGGroundNetwork_setTowerController (ff-pointer self) twrCtrlr))

(cl:defmethod find-nearest-node ((self fgground-network) (lat cl:number) (lon cl:number))
  (FGGroundNetwork_findNearestNode (ff-pointer self) lat lon))

(cl:defmethod find-nearest-node ((self fgground-network) aGeod)
  (FGGroundNetwork_findNearestNode (ff-pointer self) aGeod))

(cl:defmethod find-node ((self fgground-network) (idx cl:integer))
  (FGGroundNetwork_findNode (ff-pointer self) idx))

(cl:defmethod find-segment ((self fgground-network) (idx cl:integer))
  (FGGroundNetwork_findSegment (ff-pointer self) idx))

(cl:defmethod find-shortest-route ((self fgground-network) (start cl:integer) (end cl:integer) (fullSearch t))
  (FGGroundNetwork_findShortestRoute (ff-pointer self) start end fullSearch))

(cl:defmethod find-shortest-route ((self fgground-network) (start cl:integer) (end cl:integer))
  (FGGroundNetwork_findShortestRoute (ff-pointer self) start end))

(cl:defmethod get-nr-of-nodes ((self fgground-network))
  (FGGroundNetwork_getNrOfNodes (ff-pointer self)))

(cl:defmethod set-parent ((self fgground-network) par)
  (FGGroundNetwork_setParent (ff-pointer self) par))

(cl:defmethod announce-position ((self fgground-network) (id cl:integer) intendedRoute (currentRoute cl:integer) (lat cl:number) (lon cl:number) (hdg cl:number) (spd cl:number) (alt cl:number) (radius cl:number) (leg cl:integer) (aircraft fgaiaircraft))
  (FGGroundNetwork_announcePosition (ff-pointer self) id intendedRoute currentRoute lat lon hdg spd alt radius leg aircraft))

(cl:defmethod sign-off ((self fgground-network) (id cl:integer))
  (FGGroundNetwork_signOff (ff-pointer self) id))

(cl:defmethod update ((self fgground-network) (id cl:integer) (lat cl:number) (lon cl:number) (heading cl:number) (speed cl:number) (alt cl:number) (dt cl:number))
  (FGGroundNetwork_update (ff-pointer self) id lat lon heading speed alt dt))

(cl:defmethod has-instruction ((self fgground-network) (id cl:integer))
  (FGGroundNetwork_hasInstruction (ff-pointer self) id))

(cl:defmethod get-instruction ((self fgground-network) (id cl:integer))
  (FGGroundNetwork_getInstruction (ff-pointer self) id))

(cl:defmethod check-for-circular-waits ((self fgground-network) (id cl:integer))
  (FGGroundNetwork_checkForCircularWaits (ff-pointer self) id))


(cl:defclass fgparking(FGTaxiNode)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod initialize-instance :after ((obj fgparking) &key (other fgparking))
  (setf (slot-value obj 'ff-pointer) (new_FGParking (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self fgparking) (other fgparking))
  (FGParking___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod set-heading ((self fgparking) (hdg cl:number))
  (FGParking_setHeading (ff-pointer self) hdg))

(cl:defmethod set-radius ((self fgparking) (rad cl:number))
  (FGParking_setRadius (ff-pointer self) rad))

(cl:defmethod set-name ((self fgparking) name)
  (FGParking_setName (ff-pointer self) name))

(cl:defmethod set-type ((self fgparking) tpe)
  (FGParking_setType (ff-pointer self) tpe))

(cl:defmethod set-codes ((self fgparking) codes)
  (FGParking_setCodes (ff-pointer self) codes))

(cl:defmethod set-push-back-route ((self fgparking) (val fgtaxi-route))
  (FGParking_setPushBackRoute (ff-pointer self) val))

(cl:defmethod set-push-back-point ((self fgparking) (val cl:integer))
  (FGParking_setPushBackPoint (ff-pointer self) val))

(cl:defmethod is-available ((self fgparking))
  (FGParking_isAvailable (ff-pointer self)))

(cl:defmethod set-available ((self fgparking) (val t))
  (FGParking_setAvailable (ff-pointer self) val))

(cl:defmethod get-heading ((self fgparking))
  (FGParking_getHeading (ff-pointer self)))

(cl:defmethod get-radius ((self fgparking))
  (FGParking_getRadius (ff-pointer self)))

(cl:defmethod get-type ((self fgparking))
  (FGParking_getType (ff-pointer self)))

(cl:defmethod get-codes ((self fgparking))
  (FGParking_getCodes (ff-pointer self)))

(cl:defmethod get-name ((self fgparking))
  (FGParking_getName (ff-pointer self)))

(cl:defmethod get-push-back-route ((self fgparking))
  (FGParking_getPushBackRoute (ff-pointer self)))

(cl:defmethod get-push-back-point ((self fgparking))
  (FGParking_getPushBackPoint (ff-pointer self)))

(cl:shadow "<")
(cl:defmethod < ((self fgparking) (other fgparking))
  (FGParking___lt__ (ff-pointer self) (ff-pointer other)))


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

(cl:defmethod initialize-instance :after ((obj fgpavement) &key aIdent aPos)
  (setf (slot-value obj 'ff-pointer) (new_FGPavement aIdent aPos)))

(cl:defmethod add-node ((self fgpavement) aPos (aClose t))
  (FGPavement_addNode (ff-pointer self) aPos aClose))

(cl:defmethod add-node ((self fgpavement) aPos)
  (FGPavement_addNode (ff-pointer self) aPos))

(cl:defmethod add-bezier-node ((self fgpavement) aPos aCtrlPt (aClose t))
  (FGPavement_addBezierNode (ff-pointer self) aPos aCtrlPt aClose))

(cl:defmethod add-bezier-node ((self fgpavement) aPos aCtrlPt)
  (FGPavement_addBezierNode (ff-pointer self) aPos aCtrlPt))

(cl:defmethod get-node-list ((self fgpavement))
  (FGPavement_getNodeList (ff-pointer self)))


(cl:defclass fgrunway-preference-xmlloader()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgrunway-preference-xmlloader) &key p)
  (setf (slot-value obj 'ff-pointer) (new_FGRunwayPreferenceXMLLoader p)))


(cl:defclass schedule-time()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj schedule-time) &key)
  (setf (slot-value obj 'ff-pointer) (new_ScheduleTime)))

(cl:defmethod initialize-instance :after ((obj schedule-time) &key (other schedule-time))
  (setf (slot-value obj 'ff-pointer) (new_ScheduleTime (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self schedule-time) (other schedule-time))
  (ScheduleTime___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod get-name ((self schedule-time) dayStart)
  (ScheduleTime_getName (ff-pointer self) dayStart))

(cl:defmethod clear ((self schedule-time))
  (ScheduleTime_clear (ff-pointer self)))

(cl:defmethod add-start-time ((self schedule-time) time)
  (ScheduleTime_addStartTime (ff-pointer self) time))

(cl:defmethod add-end-time ((self schedule-time) time)
  (ScheduleTime_addEndTime (ff-pointer self) time))

(cl:defmethod add-schedule-name ((self schedule-time) sched)
  (ScheduleTime_addScheduleName (ff-pointer self) sched))

(cl:defmethod set-tail-wind ((self schedule-time) (wnd cl:number))
  (ScheduleTime_setTailWind (ff-pointer self) wnd))

(cl:defmethod set-cross-wind ((self schedule-time) (wnd cl:number))
  (ScheduleTime_setCrossWind (ff-pointer self) wnd))

(cl:defmethod get-tail-wind ((self schedule-time))
  (ScheduleTime_getTailWind (ff-pointer self)))

(cl:defmethod get-cross-wind ((self schedule-time))
  (ScheduleTime_getCrossWind (ff-pointer self)))


(cl:defclass runway-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj runway-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_RunwayList)))

(cl:defmethod initialize-instance :after ((obj runway-list) &key (other runway-list))
  (setf (slot-value obj 'ff-pointer) (new_RunwayList (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self runway-list) (other runway-list))
  (RunwayList___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod set ((self runway-list) arg1 arg2)
  (RunwayList_set (ff-pointer self) arg1 arg2))

(cl:defmethod clear ((self runway-list))
  (RunwayList_clear (ff-pointer self)))

(cl:defmethod get-type ((self runway-list))
  (RunwayList_getType (ff-pointer self)))

(cl:defmethod get-rwy-list ((self runway-list))
  (RunwayList_getRwyList (ff-pointer self)))

(cl:defmethod get-rwy-list ((self runway-list) (j cl:integer))
  (RunwayList_getRwyList (ff-pointer self) j))


(cl:defclass runway-group()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj runway-group) &key)
  (setf (slot-value obj 'ff-pointer) (new_RunwayGroup)))

(cl:defmethod initialize-instance :after ((obj runway-group) &key (other runway-group))
  (setf (slot-value obj 'ff-pointer) (new_RunwayGroup (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self runway-group) (other runway-group))
  (RunwayGroup___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod set-name ((self runway-group) nm)
  (RunwayGroup_setName (ff-pointer self) nm))

(cl:defmethod add ((self runway-group) (list runway-list))
  (RunwayGroup_add (ff-pointer self) list))

(cl:defmethod set-active ((self runway-group) airport (windSpeed cl:number) (windHeading cl:number) (maxTail cl:number) (maxCross cl:number) curr)
  (RunwayGroup_setActive (ff-pointer self) airport windSpeed windHeading maxTail maxCross curr))

(cl:defmethod get-nr-active-runways ((self runway-group))
  (RunwayGroup_getNrActiveRunways (ff-pointer self)))

(cl:defmethod get-active ((self runway-group) (i cl:integer) name type)
  (RunwayGroup_getActive (ff-pointer self) i name type))

(cl:defmethod get-name ((self runway-group))
  (RunwayGroup_getName (ff-pointer self)))

(cl:defmethod clear ((self runway-group))
  (RunwayGroup_clear (ff-pointer self)))


(cl:defclass fgrunway-preference()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgrunway-preference) &key ap)
  (setf (slot-value obj 'ff-pointer) (new_FGRunwayPreference ap)))

(cl:defmethod initialize-instance :after ((obj fgrunway-preference) &key (other fgrunway-preference))
  (setf (slot-value obj 'ff-pointer) (new_FGRunwayPreference (ff-pointer other))))

(cl:shadow "=")
(cl:defmethod = ((self fgrunway-preference) (other fgrunway-preference))
  (FGRunwayPreference___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod get-schedule ((self fgrunway-preference) (trafficType cl:string))
  (FGRunwayPreference_getSchedule (ff-pointer self) trafficType))

(cl:defmethod get-group ((self fgrunway-preference) groupName)
  (FGRunwayPreference_getGroup (ff-pointer self) groupName))

(cl:defmethod get-id ((self fgrunway-preference))
  (FGRunwayPreference_getId (ff-pointer self)))

(cl:defmethod available ((self fgrunway-preference))
  (FGRunwayPreference_available (ff-pointer self)))

(cl:defmethod set-initialized ((self fgrunway-preference) (state t))
  (FGRunwayPreference_setInitialized (ff-pointer self) state))

(cl:defmethod set-mil-times ((self fgrunway-preference) (t-arg1 schedule-time))
  (FGRunwayPreference_setMilTimes (ff-pointer self) t-arg1))

(cl:defmethod set-gen-times ((self fgrunway-preference) (t-arg1 schedule-time))
  (FGRunwayPreference_setGenTimes (ff-pointer self) t-arg1))

(cl:defmethod set-com-times ((self fgrunway-preference) (t-arg1 schedule-time))
  (FGRunwayPreference_setComTimes (ff-pointer self) t-arg1))

(cl:defmethod set-ultimes ((self fgrunway-preference) (t-arg1 schedule-time))
  (FGRunwayPreference_setULTimes (ff-pointer self) t-arg1))

(cl:defmethod add-runway-group ((self fgrunway-preference) (g runway-group))
  (FGRunwayPreference_addRunwayGroup (ff-pointer self) g))


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

(cl:defmethod initialize-instance :after ((obj fgrunway) &key aAirport rwy_no aGeod (heading cl:number) (length cl:number) (width cl:number) (displ_thresh cl:number) (stopway cl:number) (surface_code cl:integer) (reciprocal t))
  (setf (slot-value obj 'ff-pointer) (new_FGRunway aAirport rwy_no aGeod heading length width displ_thresh stopway surface_code reciprocal)))

(cl:defmethod score ((self fgrunway) (aLengthWt cl:number) (aWidthWt cl:number) (aSurfaceWt cl:number))
  (FGRunway_score (ff-pointer self) aLengthWt aWidthWt aSurfaceWt))

(cl:defmethod is-reciprocal ((self fgrunway))
  (FGRunway_isReciprocal (ff-pointer self)))

(cl:defmethod begin ((self fgrunway))
  (FGRunway_begin (ff-pointer self)))

(cl:defmethod threshold ((self fgrunway))
  (FGRunway_threshold (ff-pointer self)))

(cl:defmethod end ((self fgrunway))
  (FGRunway_end (ff-pointer self)))

(cl:defmethod displaced-threshold-m ((self fgrunway))
  (FGRunway_displacedThresholdM (ff-pointer self)))

(cl:defmethod stopway-m ((self fgrunway))
  (FGRunway_stopwayM (ff-pointer self)))

(cl:defmethod airport ((self fgrunway))
  (FGRunway_airport (ff-pointer self)))

(cl:defmethod set-airport ((self fgrunway) aAirport)
  (FGRunway_setAirport (ff-pointer self) aAirport))

(cl:defmethod ils ((self fgrunway))
  (FGRunway_ILS (ff-pointer self)))

(cl:defmethod set-ils ((self fgrunway) nav)
  (FGRunway_setILS (ff-pointer self) nav))

(cl:defmethod reciprocal-runway ((self fgrunway))
  (FGRunway_reciprocalRunway (ff-pointer self)))

(cl:defmethod set-reciprocal-runway ((self fgrunway) (other fgrunway))
  (FGRunway_setReciprocalRunway (ff-pointer self) (ff-pointer other)))

(cl:defmethod process-threshold ((self fgrunway) aThreshold)
  (FGRunway_processThreshold (ff-pointer self) aThreshold))

(cl:defmethod get-sids ((self fgrunway))
  (FGRunway_getSIDs (ff-pointer self)))

(cl:defmethod get-stars ((self fgrunway))
  (FGRunway_getSTARs (ff-pointer self)))


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

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

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

(cl:defmethod get-id ((self fgsid-star))
  (FGSidStar_getId (ff-pointer self)))

(cl:defmethod load ((self fgsid-star) path)
  (FGSidStar_load (ff-pointer self) path))

(cl:defmethod get-best ((self fgsid-star) activeRunway (heading cl:number))
  (FGSidStar_getBest (ff-pointer self) activeRunway heading))


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

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


(cl:defclass analog-component(FGXMLAutopilot::Component)
  ((ff-pointer :reader ff-pointer)))


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

(cl:defmethod initialize-instance :after ((obj autopilot) &key rootNode configNode)
  (setf (slot-value obj 'ff-pointer) (new_Autopilot rootNode configNode)))

(cl:defmethod initialize-instance :after ((obj autopilot) &key rootNode)
  (setf (slot-value obj 'ff-pointer) (new_Autopilot rootNode)))

(cl:defmethod bind ((self autopilot))
  (Autopilot_bind (ff-pointer self)))

(cl:defmethod unbind ((self autopilot))
  (Autopilot_unbind (ff-pointer self)))

(cl:defmethod update ((self autopilot) (dt cl:number))
  (Autopilot_update (ff-pointer self) dt))

(cl:defmethod set-serviceable ((self autopilot) (value t))
  (Autopilot_set_serviceable (ff-pointer self) value))

(cl:defmethod is-serviceable ((self autopilot))
  (Autopilot_is_serviceable (ff-pointer self)))

(cl:defmethod get-name ((self autopilot))
  (Autopilot_get_name (ff-pointer self)))

(cl:defmethod set-name ((self autopilot) name)
  (Autopilot_set_name (ff-pointer self) name))

(cl:defmethod add-component ((self autopilot) component)
  (Autopilot_add_component (ff-pointer self) component))


(cl:defclass fgxmlautopilot-group()
  ((ff-pointer :reader ff-pointer)))


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

(cl:defmethod configure ((self component) configNode)
  (Component_configure (ff-pointer self) configNode))

(cl:defmethod get-name ((self component))
  (Component_get_name (ff-pointer self)))

(cl:defmethod set-name ((self component) name)
  (Component_set_name (ff-pointer self) name))

(cl:defmethod is-property-enabled ((self component))
  (Component_isPropertyEnabled (ff-pointer self)))


(cl:defclass digital-output()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj digital-output) &key)
  (setf (slot-value obj 'ff-pointer) (new_DigitalOutput)))

(cl:defmethod set-property ((self digital-output) node)
  (DigitalOutput_setProperty (ff-pointer self) node))

(cl:defmethod set-inverted ((self digital-output) (value t))
  (DigitalOutput_setInverted (ff-pointer self) value))

(cl:defmethod is-inverted ((self digital-output))
  (DigitalOutput_isInverted (ff-pointer self)))

(cl:defmethod get-value ((self digital-output))
  (DigitalOutput_getValue (ff-pointer self)))

(cl:defmethod set-value ((self digital-output) (value t))
  (DigitalOutput_setValue (ff-pointer self) value))


(cl:defclass digital-component(FGXMLAutopilot::Component)
  ((ff-pointer :reader ff-pointer)))


(cl:defclass digital-filter-implementation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize ((self digital-filter-implementation) (output cl:number))
  (DigitalFilterImplementation_initialize (ff-pointer self) output))

(cl:defmethod compute ((self digital-filter-implementation) (dt cl:number) (input cl:number))
  (DigitalFilterImplementation_compute (ff-pointer self) dt input))

(cl:defmethod configure ((self digital-filter-implementation) configNode)
  (DigitalFilterImplementation_configure (ff-pointer self) configNode))


(cl:defclass digital-filter(FGXMLAutopilot::AnalogComponent)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj digital-filter) &key)
  (setf (slot-value obj 'ff-pointer) (new_DigitalFilter)))


(cl:defclass flip-flop-implementation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod get-state ((self flip-flop-implementation) (dt cl:number) input q)
  (FlipFlopImplementation_getState (ff-pointer self) dt input q))

(cl:defmethod configure ((self flip-flop-implementation) configNode)
  (FlipFlopImplementation_configure (ff-pointer self) configNode))

(cl:defmethod initialize-instance :after ((obj flip-flop-implementation) &key)
  (setf (slot-value obj 'ff-pointer) (new_FlipFlopImplementation)))


(cl:defclass flip-flop()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj flip-flop) &key)
  (setf (slot-value obj 'ff-pointer) (new_FlipFlop)))


(cl:defclass periodical-value()
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod normalize ((self periodical-value) (value cl:number))
  (PeriodicalValue_normalize (ff-pointer self) value))


(cl:defclass input-value()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj input-value) &key node (value cl:number) (offset cl:number) (scale cl:number))
  (setf (slot-value obj 'ff-pointer) (new_InputValue node value offset scale)))

(cl:defmethod initialize-instance :after ((obj input-value) &key node (value cl:number) (offset cl:number))
  (setf (slot-value obj 'ff-pointer) (new_InputValue node value offset)))

(cl:defmethod initialize-instance :after ((obj input-value) &key node (value cl:number))
  (setf (slot-value obj 'ff-pointer) (new_InputValue node value)))

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

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

(cl:defmethod parse ((self input-value) arg1 (value cl:number) (offset cl:number) (scale cl:number))
  (InputValue_parse (ff-pointer self) arg1 value offset scale))

(cl:defmethod parse ((self input-value) arg1 (value cl:number) (offset cl:number))
  (InputValue_parse (ff-pointer self) arg1 value offset))

(cl:defmethod parse ((self input-value) arg1 (value cl:number))
  (InputValue_parse (ff-pointer self) arg1 value))

(cl:defmethod parse ((self input-value) arg1)
  (InputValue_parse (ff-pointer self) arg1))

(cl:defmethod get-value ((self input-value))
  (InputValue_get_value (ff-pointer self)))

(cl:defmethod set-value ((self input-value) (value cl:number))
  (InputValue_set_value (ff-pointer self) value))

(cl:defmethod get-scale ((self input-value))
  (InputValue_get_scale (ff-pointer self)))

(cl:defmethod get-offset ((self input-value))
  (InputValue_get_offset (ff-pointer self)))

(cl:defmethod is-enabled ((self input-value))
  (InputValue_is_enabled (ff-pointer self)))


(cl:defclass input-value-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj input-value-list) &key (def cl:number))
  (setf (slot-value obj 'ff-pointer) (new_InputValueList def)))

(cl:defmethod initialize-instance :after ((obj input-value-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_InputValueList)))

(cl:defmethod get-active ((self input-value-list))
  (InputValueList_get_active (ff-pointer self)))

(cl:defmethod get-value ((self input-value-list))
  (InputValueList_get_value (ff-pointer self)))


(cl:defclass logic(FGXMLAutopilot::DigitalComponent)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod get-input ((self logic))
  (Logic_get_input (ff-pointer self)))

(cl:defmethod set-output ((self logic) (value t))
  (Logic_set_output (ff-pointer self) value))

(cl:defmethod get-output ((self logic))
  (Logic_get_output (ff-pointer self)))

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


(cl:defclass pidcontroller(FGXMLAutopilot::AnalogComponent)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod update ((self pidcontroller) (firstTime t) (dt cl:number))
  (PIDController_update (ff-pointer self) firstTime dt))


(cl:defclass pisimple-controller(FGXMLAutopilot::AnalogComponent)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj pisimple-controller) &key)
  (setf (slot-value obj 'ff-pointer) (new_PISimpleController)))

(cl:defmethod update ((self pisimple-controller) (firstTime t) (dt cl:number))
  (PISimpleController_update (ff-pointer self) firstTime dt))


(cl:defclass predictor(FGXMLAutopilot::AnalogComponent)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod update ((self predictor) (firstTime t) (dt cl:number))
  (Predictor_update (ff-pointer self) firstTime dt))


(cl:defclass fgroute-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgroute-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGRouteMgr)))

(cl:defmethod init ((self fgroute-mgr))
  (FGRouteMgr_init (ff-pointer self)))

(cl:defmethod postinit ((self fgroute-mgr))
  (FGRouteMgr_postinit (ff-pointer self)))

(cl:defmethod bind ((self fgroute-mgr))
  (FGRouteMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgroute-mgr))
  (FGRouteMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self fgroute-mgr) (dt cl:number))
  (FGRouteMgr_update (ff-pointer self) dt))

(cl:defmethod insert-waypt-at-index ((self fgroute-mgr) aWpt (aIndex cl:integer))
  (FGRouteMgr_insertWayptAtIndex (ff-pointer self) aWpt aIndex))

(cl:defmethod remove-waypt-at-index ((self fgroute-mgr) (index cl:integer))
  (FGRouteMgr_removeWayptAtIndex (ff-pointer self) index))

(cl:defmethod clear-route ((self fgroute-mgr))
  (FGRouteMgr_clearRoute (ff-pointer self)))

(cl:defmethod route-to-index ((self fgroute-mgr) (index cl:integer) (aRouteType cl:integer))
  (FGRouteMgr_routeToIndex (ff-pointer self) index aRouteType))

(cl:defmethod auto-route ((self fgroute-mgr))
  (FGRouteMgr_autoRoute (ff-pointer self)))

(cl:defmethod is-route-active ((self fgroute-mgr))
  (FGRouteMgr_isRouteActive (ff-pointer self)))

(cl:defmethod current-index ((self fgroute-mgr))
  (FGRouteMgr_currentIndex (ff-pointer self)))

(cl:defmethod current-waypt ((self fgroute-mgr))
  (FGRouteMgr_currentWaypt (ff-pointer self)))

(cl:defmethod next-waypt ((self fgroute-mgr))
  (FGRouteMgr_nextWaypt (ff-pointer self)))

(cl:defmethod previous-waypt ((self fgroute-mgr))
  (FGRouteMgr_previousWaypt (ff-pointer self)))

(cl:defmethod waypts ((self fgroute-mgr))
  (FGRouteMgr_waypts (ff-pointer self)))

(cl:defmethod num-waypts ((self fgroute-mgr))
  (FGRouteMgr_numWaypts (ff-pointer self)))

(cl:defmethod waypt-at-index ((self fgroute-mgr) (index cl:integer))
  (FGRouteMgr_wayptAtIndex (ff-pointer self) index))

(cl:defmethod find-waypt-index ((self fgroute-mgr) aPos)
  (FGRouteMgr_findWayptIndex (ff-pointer self) aPos))

(cl:defmethod activate ((self fgroute-mgr))
  (FGRouteMgr_activate (ff-pointer self)))

(cl:defmethod sequence ((self fgroute-mgr))
  (FGRouteMgr_sequence (ff-pointer self)))

(cl:defmethod jump-to-index ((self fgroute-mgr) (index cl:integer))
  (FGRouteMgr_jumpToIndex (ff-pointer self) index))

(cl:defmethod save-route ((self fgroute-mgr))
  (FGRouteMgr_saveRoute (ff-pointer self)))

(cl:defmethod load-route ((self fgroute-mgr))
  (FGRouteMgr_loadRoute (ff-pointer self)))

(cl:defmethod init-at-position ((self fgroute-mgr))
  (FGRouteMgr_initAtPosition (ff-pointer self)))


(cl:defclass fgmag-ribbon()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgmag-ribbon) &key (w cl:integer) (h cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGMagRibbon w h)))

(cl:defmethod draw ((self fgmag-ribbon) state)
  (FGMagRibbon_draw (ff-pointer self) state))


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

(cl:defmethod initialize-instance :after ((obj fgtexture-manager) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTextureManager)))


(cl:defclass fgcropped-texture()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgcropped-texture) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGCroppedTexture)))

(cl:defmethod initialize-instance :after ((obj fgcropped-texture) &key path (_minX cl:number) (_minY cl:number) (_maxX cl:number) (_maxY cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGCroppedTexture path _minX _minY _maxX _maxY)))

(cl:defmethod initialize-instance :after ((obj fgcropped-texture) &key path (_minX cl:number) (_minY cl:number) (_maxX cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGCroppedTexture path _minX _minY _maxX)))

(cl:defmethod initialize-instance :after ((obj fgcropped-texture) &key path (_minX cl:number) (_minY cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGCroppedTexture path _minX _minY)))

(cl:defmethod initialize-instance :after ((obj fgcropped-texture) &key path (_minX cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGCroppedTexture path _minX)))

(cl:defmethod initialize-instance :after ((obj fgcropped-texture) &key path)
  (setf (slot-value obj 'ff-pointer) (new_FGCroppedTexture path)))

(cl:defmethod set-path ((self fgcropped-texture) path)
  (FGCroppedTexture_setPath (ff-pointer self) path))

(cl:defmethod get-path ((self fgcropped-texture))
  (FGCroppedTexture_getPath (ff-pointer self)))

(cl:defmethod get-texture ((self fgcropped-texture))
  (FGCroppedTexture_getTexture (ff-pointer self)))

(cl:defmethod set-crop ((self fgcropped-texture) (minX cl:number) (minY cl:number) (maxX cl:number) (maxY cl:number))
  (FGCroppedTexture_setCrop (ff-pointer self) minX minY maxX maxY))

(cl:defmethod get-min-x ((self fgcropped-texture))
  (FGCroppedTexture_getMinX (ff-pointer self)))

(cl:defmethod get-min-y ((self fgcropped-texture))
  (FGCroppedTexture_getMinY (ff-pointer self)))

(cl:defmethod get-max-x ((self fgcropped-texture))
  (FGCroppedTexture_getMaxX (ff-pointer self)))

(cl:defmethod get-max-y ((self fgcropped-texture))
  (FGCroppedTexture_getMaxY (ff-pointer self)))


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

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

(cl:defmethod init ((self fgpanel))
  (FGPanel_init (ff-pointer self)))

(cl:defmethod bind ((self fgpanel))
  (FGPanel_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgpanel))
  (FGPanel_unbind (ff-pointer self)))

(cl:defmethod draw ((self fgpanel) state)
  (FGPanel_draw (ff-pointer self) state))

(cl:defmethod update ((self fgpanel) (arg1 cl:number))
  (FGPanel_update (ff-pointer self) arg1))

(cl:defmethod update ((self fgpanel) state)
  (FGPanel_update (ff-pointer self) state))

(cl:defmethod update ((self fgpanel) state winx winw winy winh)
  (FGPanel_update (ff-pointer self) state winx winw winy winh))

(cl:defmethod update-mouse-delay ((self fgpanel))
  (FGPanel_updateMouseDelay (ff-pointer self)))

(cl:defmethod add-instrument ((self fgpanel) instrument)
  (FGPanel_addInstrument (ff-pointer self) instrument))

(cl:defmethod set-background ((self fgpanel) texture)
  (FGPanel_setBackground (ff-pointer self) texture))

(cl:defmethod set-multi-background ((self fgpanel) texture (idx cl:integer))
  (FGPanel_setMultiBackground (ff-pointer self) texture idx))

(cl:defmethod get-visibility ((self fgpanel))
  (FGPanel_getVisibility (ff-pointer self)))

(cl:defmethod set-visibility ((self fgpanel) (visibility t))
  (FGPanel_setVisibility (ff-pointer self) visibility))

(cl:defmethod set-width ((self fgpanel) (width cl:integer))
  (FGPanel_setWidth (ff-pointer self) width))

(cl:defmethod get-width ((self fgpanel))
  (FGPanel_getWidth (ff-pointer self)))

(cl:defmethod set-height ((self fgpanel) (height cl:integer))
  (FGPanel_setHeight (ff-pointer self) height))

(cl:defmethod get-height ((self fgpanel))
  (FGPanel_getHeight (ff-pointer self)))

(cl:defmethod set-xoffset ((self fgpanel) (offset cl:integer))
  (FGPanel_setXOffset (ff-pointer self) offset))

(cl:defmethod get-xoffset ((self fgpanel))
  (FGPanel_getXOffset (ff-pointer self)))

(cl:defmethod set-yoffset ((self fgpanel) (offset cl:integer))
  (FGPanel_setYOffset (ff-pointer self) offset))

(cl:defmethod get-yoffset ((self fgpanel))
  (FGPanel_getYOffset (ff-pointer self)))

(cl:defmethod set-view-height ((self fgpanel) (height cl:integer))
  (FGPanel_setViewHeight (ff-pointer self) height))

(cl:defmethod get-view-height ((self fgpanel))
  (FGPanel_getViewHeight (ff-pointer self)))

(cl:defmethod do-mouse-action ((self fgpanel) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (FGPanel_doMouseAction (ff-pointer self) button updown x y))

(cl:defmethod do-local-mouse-action ((self fgpanel) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (FGPanel_doLocalMouseAction (ff-pointer self) button updown x y))

(cl:defmethod set-depth-test ((self fgpanel) (enable t))
  (FGPanel_setDepthTest (ff-pointer self) enable))

(cl:defmethod get-autohide ((self fgpanel))
  (FGPanel_getAutohide (ff-pointer self)))

(cl:defmethod set-autohide ((self fgpanel) (enable t))
  (FGPanel_setAutohide (ff-pointer self) enable))


(cl:defclass fgpanel-action()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgpanel-action) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGPanelAction)))

(cl:defmethod initialize-instance :after ((obj fgpanel-action) &key (button cl:integer) (x cl:integer) (y cl:integer) (w cl:integer) (h cl:integer) (repeatable t))
  (setf (slot-value obj 'ff-pointer) (new_FGPanelAction button x y w h repeatable)))

(cl:defmethod get-button ((self fgpanel-action))
  (FGPanelAction_getButton (ff-pointer self)))

(cl:defmethod get-x ((self fgpanel-action))
  (FGPanelAction_getX (ff-pointer self)))

(cl:defmethod get-y ((self fgpanel-action))
  (FGPanelAction_getY (ff-pointer self)))

(cl:defmethod get-width ((self fgpanel-action))
  (FGPanelAction_getWidth (ff-pointer self)))

(cl:defmethod get-height ((self fgpanel-action))
  (FGPanelAction_getHeight (ff-pointer self)))

(cl:defmethod add-binding ((self fgpanel-action) binding (updown cl:integer))
  (FGPanelAction_addBinding (ff-pointer self) binding updown))

(cl:defmethod set-button ((self fgpanel-action) (button cl:integer))
  (FGPanelAction_setButton (ff-pointer self) button))

(cl:defmethod set-x ((self fgpanel-action) (x cl:integer))
  (FGPanelAction_setX (ff-pointer self) x))

(cl:defmethod set-y ((self fgpanel-action) (y cl:integer))
  (FGPanelAction_setY (ff-pointer self) y))

(cl:defmethod set-width ((self fgpanel-action) (w cl:integer))
  (FGPanelAction_setWidth (ff-pointer self) w))

(cl:defmethod set-height ((self fgpanel-action) (h cl:integer))
  (FGPanelAction_setHeight (ff-pointer self) h))

(cl:defmethod in-area ((self fgpanel-action) (button cl:integer) (x cl:integer) (y cl:integer))
  (FGPanelAction_inArea (ff-pointer self) button x y))

(cl:defmethod do-action ((self fgpanel-action) (updown cl:integer))
  (FGPanelAction_doAction (ff-pointer self) updown))


(cl:defclass fgpanel-transformation()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgpanel-transformation) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGPanelTransformation)))

(cl:defmethod (cl:setf type) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_type_set (ff-pointer obj) arg0))

(cl:defmethod type ((obj fgpanel-transformation))
  (FGPanelTransformation_type_get (ff-pointer obj)))

(cl:defmethod (cl:setf node) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_node_set (ff-pointer obj) arg0))

(cl:defmethod node ((obj fgpanel-transformation))
  (FGPanelTransformation_node_get (ff-pointer obj)))

(cl:defmethod (cl:setf min) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_min_set (ff-pointer obj) arg0))

(cl:defmethod min ((obj fgpanel-transformation))
  (FGPanelTransformation_min_get (ff-pointer obj)))

(cl:defmethod (cl:setf max) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_max_set (ff-pointer obj) arg0))

(cl:defmethod max ((obj fgpanel-transformation))
  (FGPanelTransformation_max_get (ff-pointer obj)))

(cl:defmethod (cl:setf has_mod) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_has_mod_set (ff-pointer obj) arg0))

(cl:defmethod has_mod ((obj fgpanel-transformation))
  (FGPanelTransformation_has_mod_get (ff-pointer obj)))

(cl:defmethod (cl:setf mod) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_mod_set (ff-pointer obj) arg0))

(cl:defmethod mod ((obj fgpanel-transformation))
  (FGPanelTransformation_mod_get (ff-pointer obj)))

(cl:defmethod (cl:setf factor) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_factor_set (ff-pointer obj) arg0))

(cl:defmethod factor ((obj fgpanel-transformation))
  (FGPanelTransformation_factor_get (ff-pointer obj)))

(cl:defmethod (cl:setf offset) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_offset_set (ff-pointer obj) arg0))

(cl:defmethod offset ((obj fgpanel-transformation))
  (FGPanelTransformation_offset_get (ff-pointer obj)))

(cl:defmethod (cl:setf table) (arg0 (obj fgpanel-transformation))
  (FGPanelTransformation_table_set (ff-pointer obj) arg0))

(cl:defmethod table ((obj fgpanel-transformation))
  (FGPanelTransformation_table_get (ff-pointer obj)))


(cl:defclass fginstrument-layer()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod draw ((self fginstrument-layer) state)
  (FGInstrumentLayer_draw (ff-pointer self) state))

(cl:defmethod transform ((self fginstrument-layer))
  (FGInstrumentLayer_transform (ff-pointer self)))

(cl:defmethod get-width ((self fginstrument-layer))
  (FGInstrumentLayer_getWidth (ff-pointer self)))

(cl:defmethod get-height ((self fginstrument-layer))
  (FGInstrumentLayer_getHeight (ff-pointer self)))

(cl:defmethod set-width ((self fginstrument-layer) (w cl:integer))
  (FGInstrumentLayer_setWidth (ff-pointer self) w))

(cl:defmethod set-height ((self fginstrument-layer) (h cl:integer))
  (FGInstrumentLayer_setHeight (ff-pointer self) h))

(cl:defmethod add-transformation ((self fginstrument-layer) (transformation fgpanel-transformation))
  (FGInstrumentLayer_addTransformation (ff-pointer self) transformation))


(cl:defclass fgpanel-instrument()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod draw ((self fgpanel-instrument) state)
  (FGPanelInstrument_draw (ff-pointer self) state))

(cl:defmethod draw-hotspots ((self fgpanel-instrument) state)
  (FGPanelInstrument_drawHotspots (ff-pointer self) state))

(cl:defmethod set-position ((self fgpanel-instrument) (x cl:integer) (y cl:integer))
  (FGPanelInstrument_setPosition (ff-pointer self) x y))

(cl:defmethod set-size ((self fgpanel-instrument) (w cl:integer) (h cl:integer))
  (FGPanelInstrument_setSize (ff-pointer self) w h))

(cl:defmethod get-xpos ((self fgpanel-instrument))
  (FGPanelInstrument_getXPos (ff-pointer self)))

(cl:defmethod get-ypos ((self fgpanel-instrument))
  (FGPanelInstrument_getYPos (ff-pointer self)))

(cl:defmethod get-width ((self fgpanel-instrument))
  (FGPanelInstrument_getWidth (ff-pointer self)))

(cl:defmethod get-height ((self fgpanel-instrument))
  (FGPanelInstrument_getHeight (ff-pointer self)))

(cl:defmethod add-action ((self fgpanel-instrument) (action fgpanel-action))
  (FGPanelInstrument_addAction (ff-pointer self) action))

(cl:defmethod do-mouse-action ((self fgpanel-instrument) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (FGPanelInstrument_doMouseAction (ff-pointer self) button updown x y))


(cl:defclass fglayered-instrument(FGPanelInstrument)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fglayered-instrument) &key (x cl:integer) (y cl:integer) (w cl:integer) (h cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGLayeredInstrument x y w h)))

(cl:defmethod draw ((self fglayered-instrument) state)
  (FGLayeredInstrument_draw (ff-pointer self) state))

(cl:defmethod add-layer ((self fglayered-instrument) (layer fginstrument-layer))
  (FGLayeredInstrument_addLayer (ff-pointer self) layer))

(cl:defmethod add-layer ((self fglayered-instrument) (texture fgcropped-texture) (w cl:integer) (h cl:integer))
  (FGLayeredInstrument_addLayer (ff-pointer self) texture w h))

(cl:defmethod add-layer ((self fglayered-instrument) (texture fgcropped-texture) (w cl:integer))
  (FGLayeredInstrument_addLayer (ff-pointer self) texture w))

(cl:defmethod add-layer ((self fglayered-instrument) (texture fgcropped-texture))
  (FGLayeredInstrument_addLayer (ff-pointer self) texture))

(cl:defmethod add-transformation ((self fglayered-instrument) (transformation fgpanel-transformation))
  (FGLayeredInstrument_addTransformation (ff-pointer self) transformation))


(cl:defclass fgspecial-instrument(FGPanelInstrument)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgspecial-instrument) &key sb)
  (setf (slot-value obj 'ff-pointer) (new_FGSpecialInstrument sb)))

(cl:defmethod draw ((self fgspecial-instrument) state)
  (FGSpecialInstrument_draw (ff-pointer self) state))


(cl:defclass fggroup-layer(FGInstrumentLayer)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fggroup-layer) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGGroupLayer)))

(cl:defmethod draw ((self fggroup-layer) state)
  (FGGroupLayer_draw (ff-pointer self) state))

(cl:defmethod add-layer ((self fggroup-layer) (layer fginstrument-layer))
  (FGGroupLayer_addLayer (ff-pointer self) layer))


(cl:defclass fgtextured-layer(FGInstrumentLayer)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgtextured-layer) &key (w cl:integer) (h cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTexturedLayer w h)))

(cl:defmethod initialize-instance :after ((obj fgtextured-layer) &key (w cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTexturedLayer w)))

(cl:defmethod initialize-instance :after ((obj fgtextured-layer) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTexturedLayer)))

(cl:defmethod initialize-instance :after ((obj fgtextured-layer) &key (texture fgcropped-texture) (w cl:integer) (h cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTexturedLayer texture w h)))

(cl:defmethod initialize-instance :after ((obj fgtextured-layer) &key (texture fgcropped-texture) (w cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTexturedLayer texture w)))

(cl:defmethod initialize-instance :after ((obj fgtextured-layer) &key (texture fgcropped-texture))
  (setf (slot-value obj 'ff-pointer) (new_FGTexturedLayer texture)))

(cl:defmethod draw ((self fgtextured-layer) state)
  (FGTexturedLayer_draw (ff-pointer self) state))

(cl:defmethod set-texture ((self fgtextured-layer) (texture fgcropped-texture))
  (FGTexturedLayer_setTexture (ff-pointer self) texture))

(cl:defmethod get-texture ((self fgtextured-layer))
  (FGTexturedLayer_getTexture (ff-pointer self)))

(cl:defmethod get-texture ((self fgtextured-layer))
  (FGTexturedLayer_getTexture (ff-pointer self)))

(cl:defmethod set-emissive ((self fgtextured-layer) (e t))
  (FGTexturedLayer_setEmissive (ff-pointer self) e))


(cl:defclass fgtext-layer(FGInstrumentLayer)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgtext-layer) &key (w cl:integer) (h cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTextLayer w h)))

(cl:defmethod initialize-instance :after ((obj fgtext-layer) &key (w cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGTextLayer w)))

(cl:defmethod initialize-instance :after ((obj fgtext-layer) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTextLayer)))

(cl:defmethod draw ((self fgtext-layer) state)
  (FGTextLayer_draw (ff-pointer self) state))

(cl:defmethod add-chunk ((self fgtext-layer) chunk)
  (FGTextLayer_addChunk (ff-pointer self) chunk))

(cl:defmethod set-color ((self fgtext-layer) (r cl:number) (g cl:number) (b cl:number))
  (FGTextLayer_setColor (ff-pointer self) r g b))

(cl:defmethod set-point-size ((self fgtext-layer) (size cl:number))
  (FGTextLayer_setPointSize (ff-pointer self) size))

(cl:defmethod set-font-name ((self fgtext-layer) name)
  (FGTextLayer_setFontName (ff-pointer self) name))

(cl:defmethod set-font ((self fgtext-layer) font)
  (FGTextLayer_setFont (ff-pointer self) font))


(cl:defclass fgswitch-layer(FGGroupLayer)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgswitch-layer) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGSwitchLayer)))

(cl:defmethod draw ((self fgswitch-layer) state)
  (FGSwitchLayer_draw (ff-pointer self) state))


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

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

(cl:defmethod initialize-instance :after ((obj fgenvironment) &key (environment fgenvironment))
  (setf (slot-value obj 'ff-pointer) (new_FGEnvironment (ff-pointer environment))))

(cl:shadow "=")
(cl:defmethod = ((self fgenvironment) (other fgenvironment))
  (FGEnvironment___assign__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod read ((self fgenvironment) node)
  (FGEnvironment_read (ff-pointer self) node))

(cl:defmethod tie ((self fgenvironment) base (setArchivable t))
  (FGEnvironment_Tie (ff-pointer self) base setArchivable))

(cl:defmethod tie ((self fgenvironment) base)
  (FGEnvironment_Tie (ff-pointer self) base))

(cl:defmethod untie ((self fgenvironment))
  (FGEnvironment_Untie (ff-pointer self)))

(cl:defmethod get-visibility-m ((self fgenvironment))
  (FGEnvironment_get_visibility_m (ff-pointer self)))

(cl:defmethod get-temperature-sea-level-degc ((self fgenvironment))
  (FGEnvironment_get_temperature_sea_level_degc (ff-pointer self)))

(cl:defmethod get-temperature-degc ((self fgenvironment))
  (FGEnvironment_get_temperature_degc (ff-pointer self)))

(cl:defmethod get-temperature-degf ((self fgenvironment))
  (FGEnvironment_get_temperature_degf (ff-pointer self)))

(cl:defmethod get-dewpoint-sea-level-degc ((self fgenvironment))
  (FGEnvironment_get_dewpoint_sea_level_degc (ff-pointer self)))

(cl:defmethod get-dewpoint-degc ((self fgenvironment))
  (FGEnvironment_get_dewpoint_degc (ff-pointer self)))

(cl:defmethod get-pressure-sea-level-inhg ((self fgenvironment))
  (FGEnvironment_get_pressure_sea_level_inhg (ff-pointer self)))

(cl:defmethod get-pressure-inhg ((self fgenvironment))
  (FGEnvironment_get_pressure_inhg (ff-pointer self)))

(cl:defmethod get-density-slugft3 ((self fgenvironment))
  (FGEnvironment_get_density_slugft3 (ff-pointer self)))

(cl:defmethod get-relative-humidity ((self fgenvironment))
  (FGEnvironment_get_relative_humidity (ff-pointer self)))

(cl:defmethod get-density-tropo-avg-kgm3 ((self fgenvironment))
  (FGEnvironment_get_density_tropo_avg_kgm3 (ff-pointer self)))

(cl:defmethod get-altitude-half-to-sun-m ((self fgenvironment))
  (FGEnvironment_get_altitude_half_to_sun_m (ff-pointer self)))

(cl:defmethod get-altitude-tropo-top-m ((self fgenvironment))
  (FGEnvironment_get_altitude_tropo_top_m (ff-pointer self)))

(cl:defmethod get-wind-from-heading-deg ((self fgenvironment))
  (FGEnvironment_get_wind_from_heading_deg (ff-pointer self)))

(cl:defmethod get-wind-speed-kt ((self fgenvironment))
  (FGEnvironment_get_wind_speed_kt (ff-pointer self)))

(cl:defmethod get-wind-from-north-fps ((self fgenvironment))
  (FGEnvironment_get_wind_from_north_fps (ff-pointer self)))

(cl:defmethod get-wind-from-east-fps ((self fgenvironment))
  (FGEnvironment_get_wind_from_east_fps (ff-pointer self)))

(cl:defmethod get-wind-from-down-fps ((self fgenvironment))
  (FGEnvironment_get_wind_from_down_fps (ff-pointer self)))

(cl:defmethod get-turbulence-magnitude-norm ((self fgenvironment))
  (FGEnvironment_get_turbulence_magnitude_norm (ff-pointer self)))

(cl:defmethod get-turbulence-rate-hz ((self fgenvironment))
  (FGEnvironment_get_turbulence_rate_hz (ff-pointer self)))

(cl:defmethod set-visibility-m ((self fgenvironment) (v cl:number))
  (FGEnvironment_set_visibility_m (ff-pointer self) v))

(cl:defmethod set-temperature-sea-level-degc ((self fgenvironment) (t-arg1 cl:number))
  (FGEnvironment_set_temperature_sea_level_degc (ff-pointer self) t-arg1))

(cl:defmethod set-temperature-degc ((self fgenvironment) (t-arg1 cl:number))
  (FGEnvironment_set_temperature_degc (ff-pointer self) t-arg1))

(cl:defmethod set-dewpoint-sea-level-degc ((self fgenvironment) (d cl:number))
  (FGEnvironment_set_dewpoint_sea_level_degc (ff-pointer self) d))

(cl:defmethod set-dewpoint-degc ((self fgenvironment) (d cl:number))
  (FGEnvironment_set_dewpoint_degc (ff-pointer self) d))

(cl:defmethod set-pressure-sea-level-inhg ((self fgenvironment) (p cl:number))
  (FGEnvironment_set_pressure_sea_level_inhg (ff-pointer self) p))

(cl:defmethod set-pressure-inhg ((self fgenvironment) (p cl:number))
  (FGEnvironment_set_pressure_inhg (ff-pointer self) p))

(cl:defmethod set-wind-from-heading-deg ((self fgenvironment) (h cl:number))
  (FGEnvironment_set_wind_from_heading_deg (ff-pointer self) h))

(cl:defmethod set-wind-speed-kt ((self fgenvironment) (s cl:number))
  (FGEnvironment_set_wind_speed_kt (ff-pointer self) s))

(cl:defmethod set-wind-from-north-fps ((self fgenvironment) (n cl:number))
  (FGEnvironment_set_wind_from_north_fps (ff-pointer self) n))

(cl:defmethod set-wind-from-east-fps ((self fgenvironment) (e cl:number))
  (FGEnvironment_set_wind_from_east_fps (ff-pointer self) e))

(cl:defmethod set-wind-from-down-fps ((self fgenvironment) (d cl:number))
  (FGEnvironment_set_wind_from_down_fps (ff-pointer self) d))

(cl:defmethod set-turbulence-magnitude-norm ((self fgenvironment) (t-arg1 cl:number))
  (FGEnvironment_set_turbulence_magnitude_norm (ff-pointer self) t-arg1))

(cl:defmethod set-turbulence-rate-hz ((self fgenvironment) (t-arg1 cl:number))
  (FGEnvironment_set_turbulence_rate_hz (ff-pointer self) t-arg1))

(cl:defmethod get-elevation-ft ((self fgenvironment))
  (FGEnvironment_get_elevation_ft (ff-pointer self)))

(cl:defmethod set-elevation-ft ((self fgenvironment) (elevation_ft cl:number))
  (FGEnvironment_set_elevation_ft (ff-pointer self) elevation_ft))

(cl:defmethod set-altitude-half-to-sun-m ((self fgenvironment) (alt cl:number))
  (FGEnvironment_set_altitude_half_to_sun_m (ff-pointer self) alt))

(cl:defmethod set-altitude-tropo-top-m ((self fgenvironment) (alt cl:number))
  (FGEnvironment_set_altitude_tropo_top_m (ff-pointer self) alt))

(cl:defmethod set-live-update ((self fgenvironment) (live_update t))
  (FGEnvironment_set_live_update (ff-pointer self) live_update))

(cl:defmethod interpolate ((self fgenvironment) (env2 fgenvironment) (fraction cl:number) (result fgenvironment))
  (FGEnvironment_interpolate (ff-pointer self) (ff-pointer env2) fraction (ff-pointer result)))


(cl:defclass fgenvironment-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgenvironment-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGEnvironmentMgr)))

(cl:defmethod init ((self fgenvironment-mgr))
  (FGEnvironmentMgr_init (ff-pointer self)))

(cl:defmethod reinit ((self fgenvironment-mgr))
  (FGEnvironmentMgr_reinit (ff-pointer self)))

(cl:defmethod bind ((self fgenvironment-mgr))
  (FGEnvironmentMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgenvironment-mgr))
  (FGEnvironmentMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self fgenvironment-mgr) (dt cl:number))
  (FGEnvironmentMgr_update (ff-pointer self) dt))

(cl:defmethod get-environment ((self fgenvironment-mgr))
  (FGEnvironmentMgr_getEnvironment (ff-pointer self)))

(cl:defmethod get-environment ((self fgenvironment-mgr) (lat cl:number) (lon cl:number) (alt cl:number))
  (FGEnvironmentMgr_getEnvironment (ff-pointer self) lat lon alt))

(cl:defmethod get-environment ((self fgenvironment-mgr) aPos)
  (FGEnvironmentMgr_getEnvironment (ff-pointer self) aPos))


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

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

(cl:defmethod bind ((self ephemeris))
  (Ephemeris_bind (ff-pointer self)))

(cl:defmethod unbind ((self ephemeris))
  (Ephemeris_unbind (ff-pointer self)))

(cl:defmethod update ((self ephemeris) (dt cl:number))
  (Ephemeris_update (ff-pointer self) dt))

(cl:defmethod init ((self ephemeris))
  (Ephemeris_init (ff-pointer self)))

(cl:defmethod postinit ((self ephemeris))
  (Ephemeris_postinit (ff-pointer self)))


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

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

(cl:defmethod init ((self fgclouds))
  (FGClouds_init (ff-pointer self)))

(cl:defmethod get-update-event ((self fgclouds))
  (FGClouds_get_update_event (ff-pointer self)))

(cl:defmethod set-update-event ((self fgclouds) (count cl:integer))
  (FGClouds_set_update_event (ff-pointer self) count))

(cl:defmethod get-3d-clouds ((self fgclouds))
  (FGClouds_get_3dClouds (ff-pointer self)))

(cl:defmethod set-3d-clouds ((self fgclouds) (enable t))
  (FGClouds_set_3dClouds (ff-pointer self) enable))


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

(cl:defmethod initialize-instance :after ((obj fgmetar) &key icao proxy port auth)
  (setf (slot-value obj 'ff-pointer) (new_FGMetar icao proxy port auth)))

(cl:defmethod initialize-instance :after ((obj fgmetar) &key icao proxy port)
  (setf (slot-value obj 'ff-pointer) (new_FGMetar icao proxy port)))

(cl:defmethod initialize-instance :after ((obj fgmetar) &key icao proxy)
  (setf (slot-value obj 'ff-pointer) (new_FGMetar icao proxy)))

(cl:defmethod initialize-instance :after ((obj fgmetar) &key icao)
  (setf (slot-value obj 'ff-pointer) (new_FGMetar icao)))

(cl:defmethod get-age-min ((self fgmetar))
  (FGMetar_getAge_min (ff-pointer self)))

(cl:defmethod get-time ((self fgmetar))
  (FGMetar_getTime (ff-pointer self)))

(cl:defmethod get-rain ((self fgmetar))
  (FGMetar_getRain (ff-pointer self)))

(cl:defmethod get-hail ((self fgmetar))
  (FGMetar_getHail (ff-pointer self)))

(cl:defmethod get-snow ((self fgmetar))
  (FGMetar_getSnow (ff-pointer self)))

(cl:defmethod get-snow-cover ((self fgmetar))
  (FGMetar_getSnowCover (ff-pointer self)))


(cl:defclass fgwind-modulator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod update ((self fgwind-modulator) (dt cl:number))
  (FGWindModulator_update (ff-pointer self) dt))

(cl:defmethod get-direction-offset-norm ((self fgwind-modulator))
  (FGWindModulator_get_direction_offset_norm (ff-pointer self)))

(cl:defmethod get-magnitude-factor-norm ((self fgwind-modulator))
  (FGWindModulator_get_magnitude_factor_norm (ff-pointer self)))


(cl:defclass fgbasic-wind-modulator(FGWindModulator)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgbasic-wind-modulator) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGBasicWindModulator)))

(cl:defmethod update ((self fgbasic-wind-modulator) (dt cl:number))
  (FGBasicWindModulator_update (ff-pointer self) dt))

(cl:defmethod set-direction-period ((self fgbasic-wind-modulator) (_direction_period cl:number))
  (FGBasicWindModulator_set_direction_period (ff-pointer self) _direction_period))

(cl:defmethod get-direction-period ((self fgbasic-wind-modulator))
  (FGBasicWindModulator_get_direction_period (ff-pointer self)))

(cl:defmethod set-speed-period ((self fgbasic-wind-modulator) (_speed_period cl:number))
  (FGBasicWindModulator_set_speed_period (ff-pointer self) _speed_period))

(cl:defmethod get-speed-period ((self fgbasic-wind-modulator))
  (FGBasicWindModulator_get_speed_period (ff-pointer self)))


(cl:defclass metar-airport-filter()
  ((ff-pointer :reader ff-pointer)))


(cl:defclass metar-properties()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj metar-properties) &key rootNode)
  (setf (slot-value obj 'ff-pointer) (new_MetarProperties rootNode)))

(cl:defmethod get-root-node ((self metar-properties))
  (MetarProperties_get_root_node (ff-pointer self)))

(cl:defmethod is-valid ((self metar-properties))
  (MetarProperties_isValid (ff-pointer self)))

(cl:defmethod get-station-id ((self metar-properties))
  (MetarProperties_getStationId (ff-pointer self)))

(cl:defmethod set-station-id ((self metar-properties) value)
  (MetarProperties_setStationId (ff-pointer self) value))

(cl:defmethod set-metar ((self metar-properties) value)
  (MetarProperties_setMetar (ff-pointer self) value))


(cl:defclass fgprecipitation-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgprecipitation-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGPrecipitationMgr)))

(cl:defmethod init ((self fgprecipitation-mgr))
  (FGPrecipitationMgr_init (ff-pointer self)))

(cl:defmethod update ((self fgprecipitation-mgr) (dt cl:number))
  (FGPrecipitationMgr_update (ff-pointer self) dt))

(cl:defmethod set-precipitation-level ((self fgprecipitation-mgr) (l cl:number))
  (FGPrecipitationMgr_setPrecipitationLevel (ff-pointer self) l))

(cl:defmethod get-object ((self fgprecipitation-mgr))
  (FGPrecipitationMgr_getObject (ff-pointer self)))


(cl:defclass preset-base()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj preset-base) &key (overrideNodePath cl:string))
  (setf (slot-value obj 'ff-pointer) (new_PresetBase overrideNodePath)))

(cl:defmethod disable-preset ((self preset-base))
  (PresetBase_disablePreset (ff-pointer self)))


(cl:defclass ceiling(Environment::Presets::PresetBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod preset ((self ceiling) (elevation cl:number) (thickness cl:number))
  (Ceiling_preset (ff-pointer self) elevation thickness))


(cl:defclass turbulence(Environment::Presets::PresetBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod preset ((self turbulence) (magnitude_norm cl:number))
  (Turbulence_preset (ff-pointer self) magnitude_norm))


(cl:defclass wind(Environment::Presets::PresetBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod preset ((self wind) (min_hdg cl:number) (max_hdg cl:number) (speed cl:number) (gust cl:number))
  (Wind_preset (ff-pointer self) min_hdg max_hdg speed gust))


(cl:defclass visibility(Environment::Presets::PresetBase)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod preset ((self visibility) (visibility_m cl:number))
  (Visibility_preset (ff-pointer self) visibility_m))


(cl:defclass fgridge-lift()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgridge-lift) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGRidgeLift)))

(cl:defmethod bind ((self fgridge-lift))
  (FGRidgeLift_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgridge-lift))
  (FGRidgeLift_unbind (ff-pointer self)))

(cl:defmethod update ((self fgridge-lift) (dt cl:number))
  (FGRidgeLift_update (ff-pointer self) dt))

(cl:defmethod init ((self fgridge-lift))
  (FGRidgeLift_init (ff-pointer self)))

(cl:defmethod get-strength ((self fgridge-lift))
  (FGRidgeLift_getStrength (ff-pointer self)))

(cl:defmethod get-probe-elev-m ((self fgridge-lift) (index cl:integer))
  (FGRidgeLift_get_probe_elev_m (ff-pointer self) index))

(cl:defmethod get-probe-lat-deg ((self fgridge-lift) (index cl:integer))
  (FGRidgeLift_get_probe_lat_deg (ff-pointer self) index))

(cl:defmethod get-probe-lon-deg ((self fgridge-lift) (index cl:integer))
  (FGRidgeLift_get_probe_lon_deg (ff-pointer self) index))

(cl:defmethod get-slope ((self fgridge-lift) (index cl:integer))
  (FGRidgeLift_get_slope (ff-pointer self) index))


(cl:defclass terrain-sampler()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj terrain-sampler) &key)
  (setf (slot-value obj 'ff-pointer) (new_TerrainSampler)))


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

(cl:defmethod initialize-instance :after ((obj fgexternal-net) &key (dt cl:number) host (dop cl:integer) (dip cl:integer) (cp cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGExternalNet dt host dop dip cp)))

(cl:defmethod init ((self fgexternal-net))
  (FGExternalNet_init (ff-pointer self)))

(cl:defmethod update ((self fgexternal-net) (dt cl:number))
  (FGExternalNet_update (ff-pointer self) dt))


(cl:defclass fgexternal-pipe()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgexternal-pipe) &key (dt cl:number) fifo_name protocol)
  (setf (slot-value obj 'ff-pointer) (new_FGExternalPipe dt fifo_name protocol)))

(cl:defmethod init ((self fgexternal-pipe))
  (FGExternalPipe_init (ff-pointer self)))

(cl:defmethod update ((self fgexternal-pipe) (dt cl:number))
  (FGExternalPipe_update (ff-pointer self) dt))


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

(cl:defmethod initialize-instance :after ((obj fgjsbsim) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGJSBsim dt)))

(cl:defmethod copy-to-jsbsim ((self fgjsbsim))
  (FGJSBsim_copy_to_JSBsim (ff-pointer self)))

(cl:defmethod copy-from-jsbsim ((self fgjsbsim))
  (FGJSBsim_copy_from_JSBsim (ff-pointer self)))

(cl:defmethod init ((self fgjsbsim))
  (FGJSBsim_init (ff-pointer self)))

(cl:defmethod unbind ((self fgjsbsim))
  (FGJSBsim_unbind (ff-pointer self)))

(cl:defmethod suspend ((self fgjsbsim))
  (FGJSBsim_suspend (ff-pointer self)))

(cl:defmethod resume ((self fgjsbsim))
  (FGJSBsim_resume (ff-pointer self)))

(cl:defmethod set-latitude ((self fgjsbsim) (lat cl:number))
  (FGJSBsim_set_Latitude (ff-pointer self) lat))

(cl:defmethod set-longitude ((self fgjsbsim) (lon cl:number))
  (FGJSBsim_set_Longitude (ff-pointer self) lon))

(cl:defmethod set-altitude ((self fgjsbsim) (alt cl:number))
  (FGJSBsim_set_Altitude (ff-pointer self) alt))

(cl:defmethod set-v-calibrated-kts ((self fgjsbsim) (vc cl:number))
  (FGJSBsim_set_V_calibrated_kts (ff-pointer self) vc))

(cl:defmethod set-mach-number ((self fgjsbsim) (mach cl:number))
  (FGJSBsim_set_Mach_number (ff-pointer self) mach))

(cl:defmethod set-velocities-local ((self fgjsbsim) (north cl:number) (east cl:number) (down cl:number))
  (FGJSBsim_set_Velocities_Local (ff-pointer self) north east down))

(cl:defmethod set-velocities-wind-body ((self fgjsbsim) (u cl:number) (v cl:number) (w cl:number))
  (FGJSBsim_set_Velocities_Wind_Body (ff-pointer self) u v w))

(cl:defmethod set-euler-angles ((self fgjsbsim) (phi cl:number) (theta cl:number) (psi cl:number))
  (FGJSBsim_set_Euler_Angles (ff-pointer self) phi theta psi))

(cl:defmethod set-climb-rate ((self fgjsbsim) (roc cl:number))
  (FGJSBsim_set_Climb_Rate (ff-pointer self) roc))

(cl:defmethod set-gamma-vert-rad ((self fgjsbsim) (gamma cl:number))
  (FGJSBsim_set_Gamma_vert_rad (ff-pointer self) gamma))

(cl:defmethod update ((self fgjsbsim) (dt cl:number))
  (FGJSBsim_update (ff-pointer self) dt))

(cl:defmethod toggle-data-logging ((self fgjsbsim) (state t))
  (FGJSBsim_ToggleDataLogging (ff-pointer self) state))

(cl:defmethod toggle-data-logging ((self fgjsbsim))
  (FGJSBsim_ToggleDataLogging (ff-pointer self)))

(cl:defmethod do-trim ((self fgjsbsim))
  (FGJSBsim_do_trim (ff-pointer self)))

(cl:defmethod update-ic ((self fgjsbsim))
  (FGJSBsim_update_ic (ff-pointer self)))

(cl:defmethod get-agl-ft ((self fgjsbsim) (t-arg1 cl:number) pt (alt_off cl:number) contact normal vel angularVel agl)
  (FGJSBsim_get_agl_ft (ff-pointer self) t-arg1 pt alt_off contact normal vel angularVel agl))


(cl:defclass fgnet-fdm()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf version) (arg0 (obj fgnet-fdm))
  (FGNetFDM_version_set (ff-pointer obj) arg0))

(cl:defmethod version ((obj fgnet-fdm))
  (FGNetFDM_version_get (ff-pointer obj)))

(cl:defmethod (cl:setf padding) (arg0 (obj fgnet-fdm))
  (FGNetFDM_padding_set (ff-pointer obj) arg0))

(cl:defmethod padding ((obj fgnet-fdm))
  (FGNetFDM_padding_get (ff-pointer obj)))

(cl:defmethod (cl:setf longitude) (arg0 (obj fgnet-fdm))
  (FGNetFDM_longitude_set (ff-pointer obj) arg0))

(cl:defmethod longitude ((obj fgnet-fdm))
  (FGNetFDM_longitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf latitude) (arg0 (obj fgnet-fdm))
  (FGNetFDM_latitude_set (ff-pointer obj) arg0))

(cl:defmethod latitude ((obj fgnet-fdm))
  (FGNetFDM_latitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf altitude) (arg0 (obj fgnet-fdm))
  (FGNetFDM_altitude_set (ff-pointer obj) arg0))

(cl:defmethod altitude ((obj fgnet-fdm))
  (FGNetFDM_altitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf agl) (arg0 (obj fgnet-fdm))
  (FGNetFDM_agl_set (ff-pointer obj) arg0))

(cl:defmethod agl ((obj fgnet-fdm))
  (FGNetFDM_agl_get (ff-pointer obj)))

(cl:defmethod (cl:setf phi) (arg0 (obj fgnet-fdm))
  (FGNetFDM_phi_set (ff-pointer obj) arg0))

(cl:defmethod phi ((obj fgnet-fdm))
  (FGNetFDM_phi_get (ff-pointer obj)))

(cl:defmethod (cl:setf theta) (arg0 (obj fgnet-fdm))
  (FGNetFDM_theta_set (ff-pointer obj) arg0))

(cl:defmethod theta ((obj fgnet-fdm))
  (FGNetFDM_theta_get (ff-pointer obj)))

(cl:defmethod (cl:setf psi) (arg0 (obj fgnet-fdm))
  (FGNetFDM_psi_set (ff-pointer obj) arg0))

(cl:defmethod psi ((obj fgnet-fdm))
  (FGNetFDM_psi_get (ff-pointer obj)))

(cl:defmethod (cl:setf alpha) (arg0 (obj fgnet-fdm))
  (FGNetFDM_alpha_set (ff-pointer obj) arg0))

(cl:defmethod alpha ((obj fgnet-fdm))
  (FGNetFDM_alpha_get (ff-pointer obj)))

(cl:defmethod (cl:setf beta) (arg0 (obj fgnet-fdm))
  (FGNetFDM_beta_set (ff-pointer obj) arg0))

(cl:defmethod beta ((obj fgnet-fdm))
  (FGNetFDM_beta_get (ff-pointer obj)))

(cl:defmethod (cl:setf phidot) (arg0 (obj fgnet-fdm))
  (FGNetFDM_phidot_set (ff-pointer obj) arg0))

(cl:defmethod phidot ((obj fgnet-fdm))
  (FGNetFDM_phidot_get (ff-pointer obj)))

(cl:defmethod (cl:setf thetadot) (arg0 (obj fgnet-fdm))
  (FGNetFDM_thetadot_set (ff-pointer obj) arg0))

(cl:defmethod thetadot ((obj fgnet-fdm))
  (FGNetFDM_thetadot_get (ff-pointer obj)))

(cl:defmethod (cl:setf psidot) (arg0 (obj fgnet-fdm))
  (FGNetFDM_psidot_set (ff-pointer obj) arg0))

(cl:defmethod psidot ((obj fgnet-fdm))
  (FGNetFDM_psidot_get (ff-pointer obj)))

(cl:defmethod (cl:setf vcas) (arg0 (obj fgnet-fdm))
  (FGNetFDM_vcas_set (ff-pointer obj) arg0))

(cl:defmethod vcas ((obj fgnet-fdm))
  (FGNetFDM_vcas_get (ff-pointer obj)))

(cl:defmethod (cl:setf climb_rate) (arg0 (obj fgnet-fdm))
  (FGNetFDM_climb_rate_set (ff-pointer obj) arg0))

(cl:defmethod climb_rate ((obj fgnet-fdm))
  (FGNetFDM_climb_rate_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_north) (arg0 (obj fgnet-fdm))
  (FGNetFDM_v_north_set (ff-pointer obj) arg0))

(cl:defmethod v_north ((obj fgnet-fdm))
  (FGNetFDM_v_north_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_east) (arg0 (obj fgnet-fdm))
  (FGNetFDM_v_east_set (ff-pointer obj) arg0))

(cl:defmethod v_east ((obj fgnet-fdm))
  (FGNetFDM_v_east_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_down) (arg0 (obj fgnet-fdm))
  (FGNetFDM_v_down_set (ff-pointer obj) arg0))

(cl:defmethod v_down ((obj fgnet-fdm))
  (FGNetFDM_v_down_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_wind_body_north) (arg0 (obj fgnet-fdm))
  (FGNetFDM_v_wind_body_north_set (ff-pointer obj) arg0))

(cl:defmethod v_wind_body_north ((obj fgnet-fdm))
  (FGNetFDM_v_wind_body_north_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_wind_body_east) (arg0 (obj fgnet-fdm))
  (FGNetFDM_v_wind_body_east_set (ff-pointer obj) arg0))

(cl:defmethod v_wind_body_east ((obj fgnet-fdm))
  (FGNetFDM_v_wind_body_east_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_wind_body_down) (arg0 (obj fgnet-fdm))
  (FGNetFDM_v_wind_body_down_set (ff-pointer obj) arg0))

(cl:defmethod v_wind_body_down ((obj fgnet-fdm))
  (FGNetFDM_v_wind_body_down_get (ff-pointer obj)))

(cl:defmethod (cl:setf A_X_pilot) (arg0 (obj fgnet-fdm))
  (FGNetFDM_A_X_pilot_set (ff-pointer obj) arg0))

(cl:defmethod A_X_pilot ((obj fgnet-fdm))
  (FGNetFDM_A_X_pilot_get (ff-pointer obj)))

(cl:defmethod (cl:setf A_Y_pilot) (arg0 (obj fgnet-fdm))
  (FGNetFDM_A_Y_pilot_set (ff-pointer obj) arg0))

(cl:defmethod A_Y_pilot ((obj fgnet-fdm))
  (FGNetFDM_A_Y_pilot_get (ff-pointer obj)))

(cl:defmethod (cl:setf A_Z_pilot) (arg0 (obj fgnet-fdm))
  (FGNetFDM_A_Z_pilot_set (ff-pointer obj) arg0))

(cl:defmethod A_Z_pilot ((obj fgnet-fdm))
  (FGNetFDM_A_Z_pilot_get (ff-pointer obj)))

(cl:defmethod (cl:setf stall_warning) (arg0 (obj fgnet-fdm))
  (FGNetFDM_stall_warning_set (ff-pointer obj) arg0))

(cl:defmethod stall_warning ((obj fgnet-fdm))
  (FGNetFDM_stall_warning_get (ff-pointer obj)))

(cl:defmethod (cl:setf slip_deg) (arg0 (obj fgnet-fdm))
  (FGNetFDM_slip_deg_set (ff-pointer obj) arg0))

(cl:defmethod slip_deg ((obj fgnet-fdm))
  (FGNetFDM_slip_deg_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_engines) (arg0 (obj fgnet-fdm))
  (FGNetFDM_num_engines_set (ff-pointer obj) arg0))

(cl:defmethod num_engines ((obj fgnet-fdm))
  (FGNetFDM_num_engines_get (ff-pointer obj)))

(cl:defmethod (cl:setf eng_state) (arg0 (obj fgnet-fdm))
  (FGNetFDM_eng_state_set (ff-pointer obj) arg0))

(cl:defmethod eng_state ((obj fgnet-fdm))
  (FGNetFDM_eng_state_get (ff-pointer obj)))

(cl:defmethod (cl:setf rpm) (arg0 (obj fgnet-fdm))
  (FGNetFDM_rpm_set (ff-pointer obj) arg0))

(cl:defmethod rpm ((obj fgnet-fdm))
  (FGNetFDM_rpm_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_flow) (arg0 (obj fgnet-fdm))
  (FGNetFDM_fuel_flow_set (ff-pointer obj) arg0))

(cl:defmethod fuel_flow ((obj fgnet-fdm))
  (FGNetFDM_fuel_flow_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_px) (arg0 (obj fgnet-fdm))
  (FGNetFDM_fuel_px_set (ff-pointer obj) arg0))

(cl:defmethod fuel_px ((obj fgnet-fdm))
  (FGNetFDM_fuel_px_get (ff-pointer obj)))

(cl:defmethod (cl:setf egt) (arg0 (obj fgnet-fdm))
  (FGNetFDM_egt_set (ff-pointer obj) arg0))

(cl:defmethod egt ((obj fgnet-fdm))
  (FGNetFDM_egt_get (ff-pointer obj)))

(cl:defmethod (cl:setf cht) (arg0 (obj fgnet-fdm))
  (FGNetFDM_cht_set (ff-pointer obj) arg0))

(cl:defmethod cht ((obj fgnet-fdm))
  (FGNetFDM_cht_get (ff-pointer obj)))

(cl:defmethod (cl:setf mp_osi) (arg0 (obj fgnet-fdm))
  (FGNetFDM_mp_osi_set (ff-pointer obj) arg0))

(cl:defmethod mp_osi ((obj fgnet-fdm))
  (FGNetFDM_mp_osi_get (ff-pointer obj)))

(cl:defmethod (cl:setf tit) (arg0 (obj fgnet-fdm))
  (FGNetFDM_tit_set (ff-pointer obj) arg0))

(cl:defmethod tit ((obj fgnet-fdm))
  (FGNetFDM_tit_get (ff-pointer obj)))

(cl:defmethod (cl:setf oil_temp) (arg0 (obj fgnet-fdm))
  (FGNetFDM_oil_temp_set (ff-pointer obj) arg0))

(cl:defmethod oil_temp ((obj fgnet-fdm))
  (FGNetFDM_oil_temp_get (ff-pointer obj)))

(cl:defmethod (cl:setf oil_px) (arg0 (obj fgnet-fdm))
  (FGNetFDM_oil_px_set (ff-pointer obj) arg0))

(cl:defmethod oil_px ((obj fgnet-fdm))
  (FGNetFDM_oil_px_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_tanks) (arg0 (obj fgnet-fdm))
  (FGNetFDM_num_tanks_set (ff-pointer obj) arg0))

(cl:defmethod num_tanks ((obj fgnet-fdm))
  (FGNetFDM_num_tanks_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_quantity) (arg0 (obj fgnet-fdm))
  (FGNetFDM_fuel_quantity_set (ff-pointer obj) arg0))

(cl:defmethod fuel_quantity ((obj fgnet-fdm))
  (FGNetFDM_fuel_quantity_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_wheels) (arg0 (obj fgnet-fdm))
  (FGNetFDM_num_wheels_set (ff-pointer obj) arg0))

(cl:defmethod num_wheels ((obj fgnet-fdm))
  (FGNetFDM_num_wheels_get (ff-pointer obj)))

(cl:defmethod (cl:setf wow) (arg0 (obj fgnet-fdm))
  (FGNetFDM_wow_set (ff-pointer obj) arg0))

(cl:defmethod wow ((obj fgnet-fdm))
  (FGNetFDM_wow_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_pos) (arg0 (obj fgnet-fdm))
  (FGNetFDM_gear_pos_set (ff-pointer obj) arg0))

(cl:defmethod gear_pos ((obj fgnet-fdm))
  (FGNetFDM_gear_pos_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_steer) (arg0 (obj fgnet-fdm))
  (FGNetFDM_gear_steer_set (ff-pointer obj) arg0))

(cl:defmethod gear_steer ((obj fgnet-fdm))
  (FGNetFDM_gear_steer_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_compression) (arg0 (obj fgnet-fdm))
  (FGNetFDM_gear_compression_set (ff-pointer obj) arg0))

(cl:defmethod gear_compression ((obj fgnet-fdm))
  (FGNetFDM_gear_compression_get (ff-pointer obj)))

(cl:defmethod (cl:setf cur_time) (arg0 (obj fgnet-fdm))
  (FGNetFDM_cur_time_set (ff-pointer obj) arg0))

(cl:defmethod cur_time ((obj fgnet-fdm))
  (FGNetFDM_cur_time_get (ff-pointer obj)))

(cl:defmethod (cl:setf warp) (arg0 (obj fgnet-fdm))
  (FGNetFDM_warp_set (ff-pointer obj) arg0))

(cl:defmethod warp ((obj fgnet-fdm))
  (FGNetFDM_warp_get (ff-pointer obj)))

(cl:defmethod (cl:setf visibility) (arg0 (obj fgnet-fdm))
  (FGNetFDM_visibility_set (ff-pointer obj) arg0))

(cl:defmethod visibility ((obj fgnet-fdm))
  (FGNetFDM_visibility_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevator) (arg0 (obj fgnet-fdm))
  (FGNetFDM_elevator_set (ff-pointer obj) arg0))

(cl:defmethod elevator ((obj fgnet-fdm))
  (FGNetFDM_elevator_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevator_trim_tab) (arg0 (obj fgnet-fdm))
  (FGNetFDM_elevator_trim_tab_set (ff-pointer obj) arg0))

(cl:defmethod elevator_trim_tab ((obj fgnet-fdm))
  (FGNetFDM_elevator_trim_tab_get (ff-pointer obj)))

(cl:defmethod (cl:setf left_flap) (arg0 (obj fgnet-fdm))
  (FGNetFDM_left_flap_set (ff-pointer obj) arg0))

(cl:defmethod left_flap ((obj fgnet-fdm))
  (FGNetFDM_left_flap_get (ff-pointer obj)))

(cl:defmethod (cl:setf right_flap) (arg0 (obj fgnet-fdm))
  (FGNetFDM_right_flap_set (ff-pointer obj) arg0))

(cl:defmethod right_flap ((obj fgnet-fdm))
  (FGNetFDM_right_flap_get (ff-pointer obj)))

(cl:defmethod (cl:setf left_aileron) (arg0 (obj fgnet-fdm))
  (FGNetFDM_left_aileron_set (ff-pointer obj) arg0))

(cl:defmethod left_aileron ((obj fgnet-fdm))
  (FGNetFDM_left_aileron_get (ff-pointer obj)))

(cl:defmethod (cl:setf right_aileron) (arg0 (obj fgnet-fdm))
  (FGNetFDM_right_aileron_set (ff-pointer obj) arg0))

(cl:defmethod right_aileron ((obj fgnet-fdm))
  (FGNetFDM_right_aileron_get (ff-pointer obj)))

(cl:defmethod (cl:setf rudder) (arg0 (obj fgnet-fdm))
  (FGNetFDM_rudder_set (ff-pointer obj) arg0))

(cl:defmethod rudder ((obj fgnet-fdm))
  (FGNetFDM_rudder_get (ff-pointer obj)))

(cl:defmethod (cl:setf nose_wheel) (arg0 (obj fgnet-fdm))
  (FGNetFDM_nose_wheel_set (ff-pointer obj) arg0))

(cl:defmethod nose_wheel ((obj fgnet-fdm))
  (FGNetFDM_nose_wheel_get (ff-pointer obj)))

(cl:defmethod (cl:setf speedbrake) (arg0 (obj fgnet-fdm))
  (FGNetFDM_speedbrake_set (ff-pointer obj) arg0))

(cl:defmethod speedbrake ((obj fgnet-fdm))
  (FGNetFDM_speedbrake_get (ff-pointer obj)))

(cl:defmethod (cl:setf spoilers) (arg0 (obj fgnet-fdm))
  (FGNetFDM_spoilers_set (ff-pointer obj) arg0))

(cl:defmethod spoilers ((obj fgnet-fdm))
  (FGNetFDM_spoilers_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj fgnet-fdm) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNetFDM)))


(cl:defclass fgnew-engine()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnew-engine) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNewEngine)))

(cl:defmethod init ((self fgnew-engine) (dt cl:number))
  (FGNewEngine_init (ff-pointer self) dt))

(cl:defmethod update ((self fgnew-engine))
  (FGNewEngine_update (ff-pointer self)))

(cl:defmethod set-ias ((self fgnew-engine) (value cl:number))
  (FGNewEngine_set_IAS (ff-pointer self) value))

(cl:defmethod set-throttle-lever-pos ((self fgnew-engine) (value cl:number))
  (FGNewEngine_set_Throttle_Lever_Pos (ff-pointer self) value))

(cl:defmethod set-propeller-lever-pos ((self fgnew-engine) (value cl:number))
  (FGNewEngine_set_Propeller_Lever_Pos (ff-pointer self) value))

(cl:defmethod set-mixture-lever-pos ((self fgnew-engine) (value cl:number))
  (FGNewEngine_set_Mixture_Lever_Pos (ff-pointer self) value))

(cl:defmethod set-magneto-switch-pos ((self fgnew-engine) (value cl:integer))
  (FGNewEngine_set_Magneto_Switch_Pos (ff-pointer self) value))

(cl:defmethod set-starter-flag ((self fgnew-engine) (flag t))
  (FGNewEngine_setStarterFlag (ff-pointer self) flag))

(cl:defmethod set-p-amb ((self fgnew-engine) (value cl:number))
  (FGNewEngine_set_p_amb (ff-pointer self) value))

(cl:defmethod set-t-amb ((self fgnew-engine) (value cl:number))
  (FGNewEngine_set_T_amb (ff-pointer self) value))

(cl:defmethod get-rpm ((self fgnew-engine))
  (FGNewEngine_get_RPM (ff-pointer self)))

(cl:defmethod get-manifold-pressure ((self fgnew-engine))
  (FGNewEngine_get_Manifold_Pressure (ff-pointer self)))

(cl:defmethod get-max-hp ((self fgnew-engine))
  (FGNewEngine_get_MaxHP (ff-pointer self)))

(cl:defmethod get-percentage-power ((self fgnew-engine))
  (FGNewEngine_get_Percentage_Power (ff-pointer self)))

(cl:defmethod get-egt ((self fgnew-engine))
  (FGNewEngine_get_EGT (ff-pointer self)))

(cl:defmethod get-cht ((self fgnew-engine))
  (FGNewEngine_get_CHT (ff-pointer self)))

(cl:defmethod get-prop-thrust-si ((self fgnew-engine))
  (FGNewEngine_get_prop_thrust_SI (ff-pointer self)))

(cl:defmethod get-prop-thrust-lbs ((self fgnew-engine))
  (FGNewEngine_get_prop_thrust_lbs (ff-pointer self)))

(cl:defmethod get-fuel-flow-gals-hr ((self fgnew-engine))
  (FGNewEngine_get_fuel_flow_gals_hr (ff-pointer self)))

(cl:defmethod get-oil-temp ((self fgnew-engine))
  (FGNewEngine_get_oil_temp (ff-pointer self)))

(cl:defmethod get-running-flag ((self fgnew-engine))
  (FGNewEngine_getRunningFlag (ff-pointer self)))

(cl:defmethod get-cranking-flag ((self fgnew-engine))
  (FGNewEngine_getCrankingFlag (ff-pointer self)))

(cl:defmethod get-starter-flag ((self fgnew-engine))
  (FGNewEngine_getStarterFlag (ff-pointer self)))


(cl:defclass fgla-rcsim()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgla-rcsim) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGLaRCsim dt)))

(cl:defmethod copy-to-la-rcsim ((self fgla-rcsim))
  (FGLaRCsim_copy_to_LaRCsim (ff-pointer self)))

(cl:defmethod copy-from-la-rcsim ((self fgla-rcsim))
  (FGLaRCsim_copy_from_LaRCsim (ff-pointer self)))

(cl:defmethod init ((self fgla-rcsim))
  (FGLaRCsim_init (ff-pointer self)))

(cl:defmethod update ((self fgla-rcsim) (dt cl:number))
  (FGLaRCsim_update (ff-pointer self) dt))

(cl:defmethod set-latitude ((self fgla-rcsim) (lat cl:number))
  (FGLaRCsim_set_Latitude (ff-pointer self) lat))

(cl:defmethod set-longitude ((self fgla-rcsim) (lon cl:number))
  (FGLaRCsim_set_Longitude (ff-pointer self) lon))

(cl:defmethod set-altitude ((self fgla-rcsim) (alt cl:number))
  (FGLaRCsim_set_Altitude (ff-pointer self) alt))

(cl:defmethod set-altitude-agl ((self fgla-rcsim) (altagl cl:number))
  (FGLaRCsim_set_AltitudeAGL (ff-pointer self) altagl))

(cl:defmethod set-v-calibrated-kts ((self fgla-rcsim) (vc cl:number))
  (FGLaRCsim_set_V_calibrated_kts (ff-pointer self) vc))

(cl:defmethod set-mach-number ((self fgla-rcsim) (mach cl:number))
  (FGLaRCsim_set_Mach_number (ff-pointer self) mach))

(cl:defmethod set-velocities-local ((self fgla-rcsim) (north cl:number) (east cl:number) (down cl:number))
  (FGLaRCsim_set_Velocities_Local (ff-pointer self) north east down))

(cl:defmethod set-velocities-wind-body ((self fgla-rcsim) (u cl:number) (v cl:number) (w cl:number))
  (FGLaRCsim_set_Velocities_Wind_Body (ff-pointer self) u v w))

(cl:defmethod set-euler-angles ((self fgla-rcsim) (phi cl:number) (theta cl:number) (psi cl:number))
  (FGLaRCsim_set_Euler_Angles (ff-pointer self) phi theta psi))

(cl:defmethod set-climb-rate ((self fgla-rcsim) (roc cl:number))
  (FGLaRCsim_set_Climb_Rate (ff-pointer self) roc))

(cl:defmethod set-gamma-vert-rad ((self fgla-rcsim) (gamma cl:number))
  (FGLaRCsim_set_Gamma_vert_rad (ff-pointer self) gamma))

(cl:defmethod set-static-pressure ((self fgla-rcsim) (p cl:number))
  (FGLaRCsim_set_Static_pressure (ff-pointer self) p))

(cl:defmethod set-static-temperature ((self fgla-rcsim) (t-arg1 cl:number))
  (FGLaRCsim_set_Static_temperature (ff-pointer self) t-arg1))

(cl:defmethod set-density ((self fgla-rcsim) (rho cl:number))
  (FGLaRCsim_set_Density (ff-pointer self) rho))

(cl:defmethod get-mass ((self fgla-rcsim))
  (FGLaRCsim_get_Mass (ff-pointer self)))

(cl:defmethod get-i-xx ((self fgla-rcsim))
  (FGLaRCsim_get_I_xx (ff-pointer self)))

(cl:defmethod get-i-yy ((self fgla-rcsim))
  (FGLaRCsim_get_I_yy (ff-pointer self)))

(cl:defmethod get-i-zz ((self fgla-rcsim))
  (FGLaRCsim_get_I_zz (ff-pointer self)))

(cl:defmethod get-i-xz ((self fgla-rcsim))
  (FGLaRCsim_get_I_xz (ff-pointer self)))

(cl:defmethod -set-inertias ((self fgla-rcsim) (m cl:number) (xx cl:number) (yy cl:number) (zz cl:number) (xz cl:number))
  (FGLaRCsim__set_Inertias (ff-pointer self) m xx yy zz xz))


(cl:defclass la-rcsim-ic()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj la-rcsim-ic) &key)
  (setf (slot-value obj 'ff-pointer) (new_LaRCsimIC)))

(cl:defmethod set-vcalibrated-kts-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetVcalibratedKtsIC (ff-pointer self) tt))

(cl:defmethod set-mach-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetMachIC (ff-pointer self) tt))

(cl:defmethod set-vtrue-fps-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetVtrueFpsIC (ff-pointer self) tt))

(cl:defmethod set-vequivalent-kts-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetVequivalentKtsIC (ff-pointer self) tt))

(cl:defmethod set-uvwfps-ic ((self la-rcsim-ic) vu vv vw)
  (LaRCsimIC_SetUVWFpsIC (ff-pointer self) vu vv vw))

(cl:defmethod set-vnedfps-ic ((self la-rcsim-ic) north east down)
  (LaRCsimIC_SetVNEDFpsIC (ff-pointer self) north east down))

(cl:defmethod set-vnedairmass-fps-ic ((self la-rcsim-ic) north east down)
  (LaRCsimIC_SetVNEDAirmassFpsIC (ff-pointer self) north east down))

(cl:defmethod set-altitude-ft-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetAltitudeFtIC (ff-pointer self) tt))

(cl:defmethod set-altitude-aglft-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetAltitudeAGLFtIC (ff-pointer self) tt))

(cl:defmethod set-flight-path-angle-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetFlightPathAngleDegIC (ff-pointer self) tt))

(cl:defmethod set-flight-path-angle-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetFlightPathAngleRadIC (ff-pointer self) tt))

(cl:defmethod set-climb-rate-fpm-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetClimbRateFpmIC (ff-pointer self) tt))

(cl:defmethod set-climb-rate-fps-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetClimbRateFpsIC (ff-pointer self) tt))

(cl:defmethod set-alpha-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetAlphaDegIC (ff-pointer self) tt))

(cl:defmethod set-alpha-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetAlphaRadIC (ff-pointer self) tt))

(cl:defmethod set-pitch-angle-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetPitchAngleDegIC (ff-pointer self) tt))

(cl:defmethod set-pitch-angle-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetPitchAngleRadIC (ff-pointer self) tt))

(cl:defmethod set-beta-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetBetaDegIC (ff-pointer self) tt))

(cl:defmethod set-beta-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetBetaRadIC (ff-pointer self) tt))

(cl:defmethod set-roll-angle-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetRollAngleDegIC (ff-pointer self) tt))

(cl:defmethod set-roll-angle-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetRollAngleRadIC (ff-pointer self) tt))

(cl:defmethod set-heading-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetHeadingDegIC (ff-pointer self) tt))

(cl:defmethod set-heading-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetHeadingRadIC (ff-pointer self) tt))

(cl:defmethod set-latitude-gddeg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetLatitudeGDDegIC (ff-pointer self) tt))

(cl:defmethod set-latitude-gdrad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetLatitudeGDRadIC (ff-pointer self) tt))

(cl:defmethod set-longitude-deg-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetLongitudeDegIC (ff-pointer self) tt))

(cl:defmethod set-longitude-rad-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetLongitudeRadIC (ff-pointer self) tt))

(cl:defmethod set-runway-altitude-ft-ic ((self la-rcsim-ic) tt)
  (LaRCsimIC_SetRunwayAltitudeFtIC (ff-pointer self) tt))

(cl:defmethod get-vcalibrated-kts-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVcalibratedKtsIC (ff-pointer self)))

(cl:defmethod get-vequivalent-kts-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVequivalentKtsIC (ff-pointer self)))

(cl:defmethod get-vtrue-kts-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVtrueKtsIC (ff-pointer self)))

(cl:defmethod get-vtrue-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVtrueFpsIC (ff-pointer self)))

(cl:defmethod get-mach-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetMachIC (ff-pointer self)))

(cl:defmethod get-altitude-ft-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetAltitudeFtIC (ff-pointer self)))

(cl:defmethod get-altitude-aglft-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetAltitudeAGLFtIC (ff-pointer self)))

(cl:defmethod get-runway-altitude-ft-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetRunwayAltitudeFtIC (ff-pointer self)))

(cl:defmethod get-flight-path-angle-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetFlightPathAngleDegIC (ff-pointer self)))

(cl:defmethod get-flight-path-angle-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetFlightPathAngleRadIC (ff-pointer self)))

(cl:defmethod get-climb-rate-fpm-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetClimbRateFpmIC (ff-pointer self)))

(cl:defmethod get-climb-rate-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetClimbRateFpsIC (ff-pointer self)))

(cl:defmethod get-alpha-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetAlphaDegIC (ff-pointer self)))

(cl:defmethod get-alpha-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetAlphaRadIC (ff-pointer self)))

(cl:defmethod get-pitch-angle-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetPitchAngleDegIC (ff-pointer self)))

(cl:defmethod get-pitch-angle-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetPitchAngleRadIC (ff-pointer self)))

(cl:defmethod get-beta-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetBetaDegIC (ff-pointer self)))

(cl:defmethod get-beta-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetBetaRadIC (ff-pointer self)))

(cl:defmethod get-roll-angle-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetRollAngleDegIC (ff-pointer self)))

(cl:defmethod get-roll-angle-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetRollAngleRadIC (ff-pointer self)))

(cl:defmethod get-heading-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetHeadingDegIC (ff-pointer self)))

(cl:defmethod get-heading-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetHeadingRadIC (ff-pointer self)))

(cl:defmethod get-latitude-gddeg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetLatitudeGDDegIC (ff-pointer self)))

(cl:defmethod get-latitude-gdrad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetLatitudeGDRadIC (ff-pointer self)))

(cl:defmethod get-longitude-deg-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetLongitudeDegIC (ff-pointer self)))

(cl:defmethod get-longitude-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetLongitudeRadIC (ff-pointer self)))

(cl:defmethod get-ubody-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetUBodyFpsIC (ff-pointer self)))

(cl:defmethod get-vbody-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVBodyFpsIC (ff-pointer self)))

(cl:defmethod get-wbody-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetWBodyFpsIC (ff-pointer self)))

(cl:defmethod get-vnorth-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVnorthFpsIC (ff-pointer self)))

(cl:defmethod get-veast-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVeastFpsIC (ff-pointer self)))

(cl:defmethod get-vdown-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVdownFpsIC (ff-pointer self)))

(cl:defmethod get-vnorth-airmass-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVnorthAirmassFpsIC (ff-pointer self)))

(cl:defmethod get-veast-airmass-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVeastAirmassFpsIC (ff-pointer self)))

(cl:defmethod get-vdown-airmass-fps-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetVdownAirmassFpsIC (ff-pointer self)))

(cl:defmethod get-theta-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetThetaRadIC (ff-pointer self)))

(cl:defmethod get-phi-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetPhiRadIC (ff-pointer self)))

(cl:defmethod get-psi-rad-ic ((self la-rcsim-ic))
  (LaRCsimIC_GetPsiRadIC (ff-pointer self)))


(cl:defclass fgnull-fdm()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnull-fdm) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGNullFDM dt)))

(cl:defmethod init ((self fgnull-fdm))
  (FGNullFDM_init (ff-pointer self)))

(cl:defmethod update ((self fgnull-fdm) (dt cl:number))
  (FGNullFDM_update (ff-pointer self) dt))


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

(cl:defmethod initialize-instance :after ((obj fgacms) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGACMS dt)))

(cl:defmethod init ((self fgacms))
  (FGACMS_init (ff-pointer self)))

(cl:defmethod update ((self fgacms) (dt cl:number))
  (FGACMS_update (ff-pointer self) dt))


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

(cl:defmethod initialize-instance :after ((obj fgada) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGADA dt)))

(cl:defmethod init ((self fgada))
  (FGADA_init (ff-pointer self)))

(cl:defmethod update ((self fgada) (dt cl:number))
  (FGADA_update (ff-pointer self) dt))


(cl:defclass fgmagic-carpet()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgmagic-carpet) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGMagicCarpet dt)))

(cl:defmethod init ((self fgmagic-carpet))
  (FGMagicCarpet_init (ff-pointer self)))

(cl:defmethod update ((self fgmagic-carpet) (dt cl:number))
  (FGMagicCarpet_update (ff-pointer self) dt))


(cl:defclass tank-properties()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj tank-properties) &key rootNode)
  (setf (slot-value obj 'ff-pointer) (new_TankProperties rootNode)))

(cl:defmethod initialize-instance :after ((obj tank-properties) &key (arg0 tank-properties))
  (setf (slot-value obj 'ff-pointer) (new_TankProperties (ff-pointer arg0))))

(cl:shadow "=")
(cl:defmethod = ((self tank-properties) (arg1 tank-properties))
  (TankProperties___assign__ (ff-pointer self) (ff-pointer arg1)))

(cl:defmethod bind ((self tank-properties))
  (TankProperties_bind (ff-pointer self)))

(cl:defmethod unbind ((self tank-properties))
  (TankProperties_unbind (ff-pointer self)))

(cl:defmethod get-content-kg ((self tank-properties))
  (TankProperties_getContent_kg (ff-pointer self)))

(cl:defmethod set-content-kg ((self tank-properties) (value cl:number))
  (TankProperties_setContent_kg (ff-pointer self) value))

(cl:defmethod get-density-kgpm3 ((self tank-properties))
  (TankProperties_getDensity_kgpm3 (ff-pointer self)))

(cl:defmethod set-density-kgpm3 ((self tank-properties) (value cl:number))
  (TankProperties_setDensity_kgpm3 (ff-pointer self) value))

(cl:defmethod get-density-ppg ((self tank-properties))
  (TankProperties_getDensity_ppg (ff-pointer self)))

(cl:defmethod set-density-ppg ((self tank-properties) (value cl:number))
  (TankProperties_setDensity_ppg (ff-pointer self) value))

(cl:defmethod get-content-lbs ((self tank-properties))
  (TankProperties_getContent_lbs (ff-pointer self)))

(cl:defmethod set-content-lbs ((self tank-properties) (value cl:number))
  (TankProperties_setContent_lbs (ff-pointer self) value))

(cl:defmethod get-content-m3 ((self tank-properties))
  (TankProperties_getContent_m3 (ff-pointer self)))

(cl:defmethod set-content-m3 ((self tank-properties) (value cl:number))
  (TankProperties_setContent_m3 (ff-pointer self) value))

(cl:defmethod get-content-gal-us ((self tank-properties))
  (TankProperties_getContent_gal_us (ff-pointer self)))

(cl:defmethod set-content-gal-us ((self tank-properties) (value cl:number))
  (TankProperties_setContent_gal_us (ff-pointer self) value))

(cl:defmethod get-content-gal-imp ((self tank-properties))
  (TankProperties_getContent_gal_imp (ff-pointer self)))

(cl:defmethod set-content-gal-imp ((self tank-properties) (value cl:number))
  (TankProperties_setContent_gal_imp (ff-pointer self) value))

(cl:defmethod get-capacity-m3 ((self tank-properties))
  (TankProperties_getCapacity_m3 (ff-pointer self)))

(cl:defmethod set-capacity-m3 ((self tank-properties) (value cl:number))
  (TankProperties_setCapacity_m3 (ff-pointer self) value))

(cl:defmethod get-capacity-gal-us ((self tank-properties))
  (TankProperties_getCapacity_gal_us (ff-pointer self)))

(cl:defmethod set-capacity-gal-us ((self tank-properties) (value cl:number))
  (TankProperties_setCapacity_gal_us (ff-pointer self) value))

(cl:defmethod get-capacity-gal-imp ((self tank-properties))
  (TankProperties_getCapacity_gal_imp (ff-pointer self)))

(cl:defmethod set-capacity-gal-imp ((self tank-properties) (value cl:number))
  (TankProperties_setCapacity_gal_imp (ff-pointer self) value))

(cl:defmethod get-unusable-m3 ((self tank-properties))
  (TankProperties_getUnusable_m3 (ff-pointer self)))

(cl:defmethod set-unusable-m3 ((self tank-properties) (value cl:number))
  (TankProperties_setUnusable_m3 (ff-pointer self) value))

(cl:defmethod get-unusable-gal-us ((self tank-properties))
  (TankProperties_getUnusable_gal_us (ff-pointer self)))

(cl:defmethod set-unusable-gal-us ((self tank-properties) (value cl:number))
  (TankProperties_setUnusable_gal_us (ff-pointer self) value))

(cl:defmethod get-unusable-gal-imp ((self tank-properties))
  (TankProperties_getUnusable_gal_imp (ff-pointer self)))

(cl:defmethod set-unusable-gal-imp ((self tank-properties) (value cl:number))
  (TankProperties_setUnusable_gal_imp (ff-pointer self) value))

(cl:defmethod get-content-norm ((self tank-properties))
  (TankProperties_getContent_norm (ff-pointer self)))

(cl:defmethod set-content-norm ((self tank-properties) (value cl:number))
  (TankProperties_setContent_norm (ff-pointer self) value))

(cl:defmethod get-empty ((self tank-properties))
  (TankProperties_getEmpty (ff-pointer self)))


(cl:defclass tank-properties-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj tank-properties-list) &key rootNode)
  (setf (slot-value obj 'ff-pointer) (new_TankPropertiesList rootNode)))

(cl:defmethod bind ((self tank-properties-list))
  (TankPropertiesList_bind (ff-pointer self)))

(cl:defmethod unbind ((self tank-properties-list))
  (TankPropertiesList_unbind (ff-pointer self)))

(cl:defmethod get-total-content-lbs ((self tank-properties-list))
  (TankPropertiesList_getTotalContent_lbs (ff-pointer self)))

(cl:defmethod get-total-content-kg ((self tank-properties-list))
  (TankPropertiesList_getTotalContent_kg (ff-pointer self)))

(cl:defmethod get-total-content-gal-us ((self tank-properties-list))
  (TankPropertiesList_getTotalContent_gal_us (ff-pointer self)))

(cl:defmethod get-total-content-gal-imp ((self tank-properties-list))
  (TankPropertiesList_getTotalContent_gal_imp (ff-pointer self)))

(cl:defmethod get-total-content-m3 ((self tank-properties-list))
  (TankPropertiesList_getTotalContent_m3 (ff-pointer self)))

(cl:defmethod get-total-content-norm ((self tank-properties-list))
  (TankPropertiesList_getTotalContent_norm (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fgufo) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGUFO dt)))

(cl:defmethod init ((self fgufo))
  (FGUFO_init (ff-pointer self)))

(cl:defmethod update ((self fgufo) (dt cl:number))
  (FGUFO_update (ff-pointer self) dt))


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

(cl:defmethod initialize-instance :after ((obj yasim) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_YASim dt)))

(cl:defmethod init ((self yasim))
  (YASim_init (ff-pointer self)))

(cl:defmethod bind ((self yasim))
  (YASim_bind (ff-pointer self)))

(cl:defmethod update ((self yasim) (dt cl:number))
  (YASim_update (ff-pointer self) dt))


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

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

(cl:defmethod init ((self fdmshell))
  (FDMShell_init (ff-pointer self)))

(cl:defmethod reinit ((self fdmshell))
  (FDMShell_reinit (ff-pointer self)))

(cl:defmethod bind ((self fdmshell))
  (FDMShell_bind (ff-pointer self)))

(cl:defmethod unbind ((self fdmshell))
  (FDMShell_unbind (ff-pointer self)))

(cl:defmethod update ((self fdmshell) (dt cl:number))
  (FDMShell_update (ff-pointer self) dt))

(cl:defmethod get-fdm ((self fdmshell))
  (FDMShell_getFDM (ff-pointer self)))


(cl:defclass track-computer()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj track-computer) &key track position)
  (setf (slot-value obj 'ff-pointer) (new_TrackComputer track position)))


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

(cl:defmethod -setup ((self fginterface))
  (FGInterface__setup (ff-pointer self)))

(cl:defmethod -busdump ((self fginterface))
  (FGInterface__busdump (ff-pointer self)))

(cl:defmethod -update-position-m ((self fginterface) cartPos)
  (FGInterface__updatePositionM (ff-pointer self) cartPos))

(cl:defmethod -update-position-ft ((self fginterface) cartPos)
  (FGInterface__updatePositionFt (ff-pointer self) cartPos))

(cl:defmethod -update-position ((self fginterface) geod)
  (FGInterface__updatePosition (ff-pointer self) geod))

(cl:defmethod -update-position ((self fginterface) geoc)
  (FGInterface__updatePosition (ff-pointer self) geoc))

(cl:defmethod -update-geodetic-position ((self fginterface) (lat cl:number) (lon cl:number) (alt cl:number))
  (FGInterface__updateGeodeticPosition (ff-pointer self) lat lon alt))

(cl:defmethod -update-geocentric-position ((self fginterface) (lat_geoc cl:number) (lon cl:number) (alt cl:number))
  (FGInterface__updateGeocentricPosition (ff-pointer self) lat_geoc lon alt))

(cl:defmethod -update-ground-elev-at-pos ((self fginterface))
  (FGInterface__update_ground_elev_at_pos (ff-pointer self)))

(cl:defmethod -set-cg-position ((self fginterface) (dx cl:number) (dy cl:number) (dz cl:number))
  (FGInterface__set_CG_Position (ff-pointer self) dx dy dz))

(cl:defmethod -set-accels-local ((self fginterface) (north cl:number) (east cl:number) (down cl:number))
  (FGInterface__set_Accels_Local (ff-pointer self) north east down))

(cl:defmethod -set-accels-body ((self fginterface) (u cl:number) (v cl:number) (w cl:number))
  (FGInterface__set_Accels_Body (ff-pointer self) u v w))

(cl:defmethod -set-accels-cg-body ((self fginterface) (x cl:number) (y cl:number) (z cl:number))
  (FGInterface__set_Accels_CG_Body (ff-pointer self) x y z))

(cl:defmethod -set-accels-pilot-body ((self fginterface) (x cl:number) (y cl:number) (z cl:number))
  (FGInterface__set_Accels_Pilot_Body (ff-pointer self) x y z))

(cl:defmethod -set-accels-cg-body-n ((self fginterface) (x cl:number) (y cl:number) (z cl:number))
  (FGInterface__set_Accels_CG_Body_N (ff-pointer self) x y z))

(cl:defmethod -set-nlf ((self fginterface) (n cl:number))
  (FGInterface__set_Nlf (ff-pointer self) n))

(cl:defmethod -set-velocities-local ((self fginterface) (north cl:number) (east cl:number) (down cl:number))
  (FGInterface__set_Velocities_Local (ff-pointer self) north east down))

(cl:defmethod -set-velocities-ground ((self fginterface) (north cl:number) (east cl:number) (down cl:number))
  (FGInterface__set_Velocities_Ground (ff-pointer self) north east down))

(cl:defmethod -set-velocities-local-airmass ((self fginterface) (north cl:number) (east cl:number) (down cl:number))
  (FGInterface__set_Velocities_Local_Airmass (ff-pointer self) north east down))

(cl:defmethod -set-velocities-wind-body ((self fginterface) (u cl:number) (v cl:number) (w cl:number))
  (FGInterface__set_Velocities_Wind_Body (ff-pointer self) u v w))

(cl:defmethod -set-v-rel-wind ((self fginterface) (vt cl:number))
  (FGInterface__set_V_rel_wind (ff-pointer self) vt))

(cl:defmethod -set-v-ground-speed ((self fginterface) (v cl:number))
  (FGInterface__set_V_ground_speed (ff-pointer self) v))

(cl:defmethod -set-v-equiv-kts ((self fginterface) (kts cl:number))
  (FGInterface__set_V_equiv_kts (ff-pointer self) kts))

(cl:defmethod -set-v-calibrated-kts ((self fginterface) (kts cl:number))
  (FGInterface__set_V_calibrated_kts (ff-pointer self) kts))

(cl:defmethod -set-omega-body ((self fginterface) (p cl:number) (q cl:number) (r cl:number))
  (FGInterface__set_Omega_Body (ff-pointer self) p q r))

(cl:defmethod -set-euler-rates ((self fginterface) (phi cl:number) (theta cl:number) (psi cl:number))
  (FGInterface__set_Euler_Rates (ff-pointer self) phi theta psi))

(cl:defmethod set-phi-dot-degps ((self fginterface) (x cl:number))
  (FGInterface_set_Phi_dot_degps (ff-pointer self) x))

(cl:defmethod set-theta-dot-degps ((self fginterface) (x cl:number))
  (FGInterface_set_Theta_dot_degps (ff-pointer self) x))

(cl:defmethod set-psi-dot-degps ((self fginterface) (x cl:number))
  (FGInterface_set_Psi_dot_degps (ff-pointer self) x))

(cl:defmethod -set-geocentric-rates ((self fginterface) (lat cl:number) (lon cl:number) (rad cl:number))
  (FGInterface__set_Geocentric_Rates (ff-pointer self) lat lon rad))

(cl:defmethod -set-geocentric-position ((self fginterface) (lat cl:number) (lon cl:number) (rad cl:number))
  (FGInterface__set_Geocentric_Position (ff-pointer self) lat lon rad))

(cl:defmethod -set-altitude ((self fginterface) (altitude cl:number))
  (FGInterface__set_Altitude (ff-pointer self) altitude))

(cl:defmethod -set-altitude-agl ((self fginterface) (agl cl:number))
  (FGInterface__set_Altitude_AGL (ff-pointer self) agl))

(cl:defmethod -set-geodetic-position ((self fginterface) (lat cl:number) (lon cl:number))
  (FGInterface__set_Geodetic_Position (ff-pointer self) lat lon))

(cl:defmethod -set-geodetic-position ((self fginterface) (lat cl:number) (lon cl:number) (alt cl:number))
  (FGInterface__set_Geodetic_Position (ff-pointer self) lat lon alt))

(cl:defmethod -set-euler-angles ((self fginterface) (phi cl:number) (theta cl:number) (psi cl:number))
  (FGInterface__set_Euler_Angles (ff-pointer self) phi theta psi))

(cl:defmethod -set-t-local-to-body ((self fginterface) (i cl:integer) (j cl:integer) (value cl:number))
  (FGInterface__set_T_Local_to_Body (ff-pointer self) i j value))

(cl:defmethod -set-alpha ((self fginterface) (a cl:number))
  (FGInterface__set_Alpha (ff-pointer self) a))

(cl:defmethod -set-beta ((self fginterface) (b cl:number))
  (FGInterface__set_Beta (ff-pointer self) b))

(cl:defmethod set-alpha-deg ((self fginterface) (a cl:number))
  (FGInterface_set_Alpha_deg (ff-pointer self) a))

(cl:defmethod -set-gamma-vert-rad ((self fginterface) (gv cl:number))
  (FGInterface__set_Gamma_vert_rad (ff-pointer self) gv))

(cl:defmethod -set-density ((self fginterface) (d cl:number))
  (FGInterface__set_Density (ff-pointer self) d))

(cl:defmethod -set-mach-number ((self fginterface) (m cl:number))
  (FGInterface__set_Mach_number (ff-pointer self) m))

(cl:defmethod -set-static-pressure ((self fginterface) (sp cl:number))
  (FGInterface__set_Static_pressure (ff-pointer self) sp))

(cl:defmethod -set-static-temperature ((self fginterface) (t-arg1 cl:number))
  (FGInterface__set_Static_temperature (ff-pointer self) t-arg1))

(cl:defmethod -set-total-temperature ((self fginterface) (tat cl:number))
  (FGInterface__set_Total_temperature (ff-pointer self) tat))

(cl:defmethod -set-sea-level-radius ((self fginterface) (r cl:number))
  (FGInterface__set_Sea_level_radius (ff-pointer self) r))

(cl:defmethod -set-earth-position-angle ((self fginterface) (a cl:number))
  (FGInterface__set_Earth_position_angle (ff-pointer self) a))

(cl:defmethod -set-runway-altitude ((self fginterface) (alt cl:number))
  (FGInterface__set_Runway_altitude (ff-pointer self) alt))

(cl:defmethod -set-climb-rate ((self fginterface) (rate cl:number))
  (FGInterface__set_Climb_Rate (ff-pointer self) rate))

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

(cl:defmethod initialize-instance :after ((obj fginterface) &key (dt cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGInterface dt)))

(cl:defmethod init ((self fginterface))
  (FGInterface_init (ff-pointer self)))

(cl:defmethod bind ((self fginterface))
  (FGInterface_bind (ff-pointer self)))

(cl:defmethod unbind ((self fginterface))
  (FGInterface_unbind (ff-pointer self)))

(cl:defmethod update ((self fginterface) (dt cl:number))
  (FGInterface_update (ff-pointer self) dt))

(cl:defmethod toggle-data-logging ((self fginterface) (state t))
  (FGInterface_ToggleDataLogging (ff-pointer self) state))

(cl:defmethod toggle-data-logging ((self fginterface))
  (FGInterface_ToggleDataLogging (ff-pointer self)))

(cl:defmethod get-inited ((self fginterface))
  (FGInterface_get_inited (ff-pointer self)))

(cl:defmethod set-inited ((self fginterface) (value t))
  (FGInterface_set_inited (ff-pointer self) value))

(cl:defmethod get-bound ((self fginterface))
  (FGInterface_get_bound (ff-pointer self)))

(cl:defmethod common-init ((self fginterface))
  (FGInterface_common_init (ff-pointer self)))

(cl:defmethod set-latitude ((self fginterface) (lat cl:number))
  (FGInterface_set_Latitude (ff-pointer self) lat))

(cl:defmethod set-longitude ((self fginterface) (lon cl:number))
  (FGInterface_set_Longitude (ff-pointer self) lon))

(cl:defmethod set-altitude ((self fginterface) (alt cl:number))
  (FGInterface_set_Altitude (ff-pointer self) alt))

(cl:defmethod set-altitude-agl ((self fginterface) (altagl cl:number))
  (FGInterface_set_AltitudeAGL (ff-pointer self) altagl))

(cl:defmethod set-latitude-deg ((self fginterface) (lat cl:number))
  (FGInterface_set_Latitude_deg (ff-pointer self) lat))

(cl:defmethod set-longitude-deg ((self fginterface) (lon cl:number))
  (FGInterface_set_Longitude_deg (ff-pointer self) lon))

(cl:defmethod set-v-calibrated-kts ((self fginterface) (vc cl:number))
  (FGInterface_set_V_calibrated_kts (ff-pointer self) vc))

(cl:defmethod set-mach-number ((self fginterface) (mach cl:number))
  (FGInterface_set_Mach_number (ff-pointer self) mach))

(cl:defmethod set-velocities-local ((self fginterface) (north cl:number) (east cl:number) (down cl:number))
  (FGInterface_set_Velocities_Local (ff-pointer self) north east down))

(cl:defmethod set-v-north ((self fginterface) (north cl:number))
  (FGInterface_set_V_north (ff-pointer self) north))

(cl:defmethod set-v-east ((self fginterface) (east cl:number))
  (FGInterface_set_V_east (ff-pointer self) east))

(cl:defmethod set-v-down ((self fginterface) (down cl:number))
  (FGInterface_set_V_down (ff-pointer self) down))

(cl:defmethod set-velocities-wind-body ((self fginterface) (u cl:number) (v cl:number) (w cl:number))
  (FGInterface_set_Velocities_Wind_Body (ff-pointer self) u v w))

(cl:defmethod set-u-body ((self fginterface) (uBody cl:number))
  (FGInterface_set_uBody (ff-pointer self) uBody))

(cl:defmethod set-v-body ((self fginterface) (vBody cl:number))
  (FGInterface_set_vBody (ff-pointer self) vBody))

(cl:defmethod set-w-body ((self fginterface) (wBody cl:number))
  (FGInterface_set_wBody (ff-pointer self) wBody))

(cl:defmethod set-euler-angles ((self fginterface) (phi cl:number) (theta cl:number) (psi cl:number))
  (FGInterface_set_Euler_Angles (ff-pointer self) phi theta psi))

(cl:defmethod set-phi ((self fginterface) (phi cl:number))
  (FGInterface_set_Phi (ff-pointer self) phi))

(cl:defmethod set-theta ((self fginterface) (theta cl:number))
  (FGInterface_set_Theta (ff-pointer self) theta))

(cl:defmethod set-psi ((self fginterface) (psi cl:number))
  (FGInterface_set_Psi (ff-pointer self) psi))

(cl:defmethod set-phi-deg ((self fginterface) (phi cl:number))
  (FGInterface_set_Phi_deg (ff-pointer self) phi))

(cl:defmethod set-theta-deg ((self fginterface) (theta cl:number))
  (FGInterface_set_Theta_deg (ff-pointer self) theta))

(cl:defmethod set-psi-deg ((self fginterface) (psi cl:number))
  (FGInterface_set_Psi_deg (ff-pointer self) psi))

(cl:defmethod set-climb-rate ((self fginterface) (roc cl:number))
  (FGInterface_set_Climb_Rate (ff-pointer self) roc))

(cl:defmethod set-gamma-vert-rad ((self fginterface) (gamma cl:number))
  (FGInterface_set_Gamma_vert_rad (ff-pointer self) gamma))

(cl:defmethod set-static-pressure ((self fginterface) (p cl:number))
  (FGInterface_set_Static_pressure (ff-pointer self) p))

(cl:defmethod set-static-temperature ((self fginterface) (t-arg1 cl:number))
  (FGInterface_set_Static_temperature (ff-pointer self) t-arg1))

(cl:defmethod set-density ((self fginterface) (rho cl:number))
  (FGInterface_set_Density (ff-pointer self) rho))

(cl:defmethod set-velocities-local-airmass ((self fginterface) (wnorth cl:number) (weast cl:number) (wdown cl:number))
  (FGInterface_set_Velocities_Local_Airmass (ff-pointer self) wnorth weast wdown))

(cl:defmethod get-dx-cg ((self fginterface))
  (FGInterface_get_Dx_cg (ff-pointer self)))

(cl:defmethod get-dy-cg ((self fginterface))
  (FGInterface_get_Dy_cg (ff-pointer self)))

(cl:defmethod get-dz-cg ((self fginterface))
  (FGInterface_get_Dz_cg (ff-pointer self)))

(cl:defmethod get-v-dot-north ((self fginterface))
  (FGInterface_get_V_dot_north (ff-pointer self)))

(cl:defmethod get-v-dot-east ((self fginterface))
  (FGInterface_get_V_dot_east (ff-pointer self)))

(cl:defmethod get-v-dot-down ((self fginterface))
  (FGInterface_get_V_dot_down (ff-pointer self)))

(cl:defmethod get-u-dot-body ((self fginterface))
  (FGInterface_get_U_dot_body (ff-pointer self)))

(cl:defmethod get-v-dot-body ((self fginterface))
  (FGInterface_get_V_dot_body (ff-pointer self)))

(cl:defmethod get-w-dot-body ((self fginterface))
  (FGInterface_get_W_dot_body (ff-pointer self)))

(cl:defmethod get-a-x-cg ((self fginterface))
  (FGInterface_get_A_X_cg (ff-pointer self)))

(cl:defmethod get-a-y-cg ((self fginterface))
  (FGInterface_get_A_Y_cg (ff-pointer self)))

(cl:defmethod get-a-z-cg ((self fginterface))
  (FGInterface_get_A_Z_cg (ff-pointer self)))

(cl:defmethod get-a-x-pilot ((self fginterface))
  (FGInterface_get_A_X_pilot (ff-pointer self)))

(cl:defmethod get-a-y-pilot ((self fginterface))
  (FGInterface_get_A_Y_pilot (ff-pointer self)))

(cl:defmethod get-a-z-pilot ((self fginterface))
  (FGInterface_get_A_Z_pilot (ff-pointer self)))

(cl:defmethod get-n-x-cg ((self fginterface))
  (FGInterface_get_N_X_cg (ff-pointer self)))

(cl:defmethod get-n-y-cg ((self fginterface))
  (FGInterface_get_N_Y_cg (ff-pointer self)))

(cl:defmethod get-n-z-cg ((self fginterface))
  (FGInterface_get_N_Z_cg (ff-pointer self)))

(cl:defmethod get-nlf ((self fginterface))
  (FGInterface_get_Nlf (ff-pointer self)))

(cl:defmethod get-v-north ((self fginterface))
  (FGInterface_get_V_north (ff-pointer self)))

(cl:defmethod get-v-east ((self fginterface))
  (FGInterface_get_V_east (ff-pointer self)))

(cl:defmethod get-v-down ((self fginterface))
  (FGInterface_get_V_down (ff-pointer self)))

(cl:defmethod get-u-body ((self fginterface))
  (FGInterface_get_uBody (ff-pointer self)))

(cl:defmethod get-v-body ((self fginterface))
  (FGInterface_get_vBody (ff-pointer self)))

(cl:defmethod get-w-body ((self fginterface))
  (FGInterface_get_wBody (ff-pointer self)))

(cl:defmethod get-v-north-rel-ground ((self fginterface))
  (FGInterface_get_V_north_rel_ground (ff-pointer self)))

(cl:defmethod get-v-east-rel-ground ((self fginterface))
  (FGInterface_get_V_east_rel_ground (ff-pointer self)))

(cl:defmethod get-v-down-rel-ground ((self fginterface))
  (FGInterface_get_V_down_rel_ground (ff-pointer self)))

(cl:defmethod get-v-north-airmass ((self fginterface))
  (FGInterface_get_V_north_airmass (ff-pointer self)))

(cl:defmethod get-v-east-airmass ((self fginterface))
  (FGInterface_get_V_east_airmass (ff-pointer self)))

(cl:defmethod get-v-down-airmass ((self fginterface))
  (FGInterface_get_V_down_airmass (ff-pointer self)))

(cl:defmethod get-u-body ((self fginterface))
  (FGInterface_get_U_body (ff-pointer self)))

(cl:defmethod get-v-body ((self fginterface))
  (FGInterface_get_V_body (ff-pointer self)))

(cl:defmethod get-w-body ((self fginterface))
  (FGInterface_get_W_body (ff-pointer self)))

(cl:defmethod get-v-rel-wind ((self fginterface))
  (FGInterface_get_V_rel_wind (ff-pointer self)))

(cl:defmethod get-v-true-kts ((self fginterface))
  (FGInterface_get_V_true_kts (ff-pointer self)))

(cl:defmethod get-v-ground-speed ((self fginterface))
  (FGInterface_get_V_ground_speed (ff-pointer self)))

(cl:defmethod get-v-ground-speed-kt ((self fginterface))
  (FGInterface_get_V_ground_speed_kt (ff-pointer self)))

(cl:defmethod get-v-equiv-kts ((self fginterface))
  (FGInterface_get_V_equiv_kts (ff-pointer self)))

(cl:defmethod get-v-calibrated-kts ((self fginterface))
  (FGInterface_get_V_calibrated_kts (ff-pointer self)))

(cl:defmethod get-p-body ((self fginterface))
  (FGInterface_get_P_body (ff-pointer self)))

(cl:defmethod get-q-body ((self fginterface))
  (FGInterface_get_Q_body (ff-pointer self)))

(cl:defmethod get-r-body ((self fginterface))
  (FGInterface_get_R_body (ff-pointer self)))

(cl:defmethod get-phi-dot ((self fginterface))
  (FGInterface_get_Phi_dot (ff-pointer self)))

(cl:defmethod get-theta-dot ((self fginterface))
  (FGInterface_get_Theta_dot (ff-pointer self)))

(cl:defmethod get-psi-dot ((self fginterface))
  (FGInterface_get_Psi_dot (ff-pointer self)))

(cl:defmethod get-phi-dot-degps ((self fginterface))
  (FGInterface_get_Phi_dot_degps (ff-pointer self)))

(cl:defmethod get-theta-dot-degps ((self fginterface))
  (FGInterface_get_Theta_dot_degps (ff-pointer self)))

(cl:defmethod get-psi-dot-degps ((self fginterface))
  (FGInterface_get_Psi_dot_degps (ff-pointer self)))

(cl:defmethod get-latitude-dot ((self fginterface))
  (FGInterface_get_Latitude_dot (ff-pointer self)))

(cl:defmethod get-longitude-dot ((self fginterface))
  (FGInterface_get_Longitude_dot (ff-pointer self)))

(cl:defmethod get-radius-dot ((self fginterface))
  (FGInterface_get_Radius_dot (ff-pointer self)))

(cl:defmethod get-lat-geocentric ((self fginterface))
  (FGInterface_get_Lat_geocentric (ff-pointer self)))

(cl:defmethod get-lon-geocentric ((self fginterface))
  (FGInterface_get_Lon_geocentric (ff-pointer self)))

(cl:defmethod get-radius-to-vehicle ((self fginterface))
  (FGInterface_get_Radius_to_vehicle (ff-pointer self)))

(cl:defmethod get-position ((self fginterface))
  (FGInterface_getPosition (ff-pointer self)))

(cl:defmethod get-geoc-position ((self fginterface))
  (FGInterface_getGeocPosition (ff-pointer self)))

(cl:defmethod get-cart-position ((self fginterface))
  (FGInterface_getCartPosition (ff-pointer self)))

(cl:defmethod get-latitude ((self fginterface))
  (FGInterface_get_Latitude (ff-pointer self)))

(cl:defmethod get-longitude ((self fginterface))
  (FGInterface_get_Longitude (ff-pointer self)))

(cl:defmethod get-altitude ((self fginterface))
  (FGInterface_get_Altitude (ff-pointer self)))

(cl:defmethod get-altitude-agl ((self fginterface))
  (FGInterface_get_Altitude_AGL (ff-pointer self)))

(cl:defmethod get-track ((self fginterface))
  (FGInterface_get_Track (ff-pointer self)))

(cl:defmethod get-latitude-deg ((self fginterface))
  (FGInterface_get_Latitude_deg (ff-pointer self)))

(cl:defmethod get-longitude-deg ((self fginterface))
  (FGInterface_get_Longitude_deg (ff-pointer self)))

(cl:defmethod get-phi ((self fginterface))
  (FGInterface_get_Phi (ff-pointer self)))

(cl:defmethod get-theta ((self fginterface))
  (FGInterface_get_Theta (ff-pointer self)))

(cl:defmethod get-psi ((self fginterface))
  (FGInterface_get_Psi (ff-pointer self)))

(cl:defmethod get-phi-deg ((self fginterface))
  (FGInterface_get_Phi_deg (ff-pointer self)))

(cl:defmethod get-theta-deg ((self fginterface))
  (FGInterface_get_Theta_deg (ff-pointer self)))

(cl:defmethod get-psi-deg ((self fginterface))
  (FGInterface_get_Psi_deg (ff-pointer self)))

(cl:defmethod get-alpha ((self fginterface))
  (FGInterface_get_Alpha (ff-pointer self)))

(cl:defmethod get-alpha-deg ((self fginterface))
  (FGInterface_get_Alpha_deg (ff-pointer self)))

(cl:defmethod get-beta ((self fginterface))
  (FGInterface_get_Beta (ff-pointer self)))

(cl:defmethod get-beta-deg ((self fginterface))
  (FGInterface_get_Beta_deg (ff-pointer self)))

(cl:defmethod get-gamma-vert-rad ((self fginterface))
  (FGInterface_get_Gamma_vert_rad (ff-pointer self)))

(cl:defmethod get-density ((self fginterface))
  (FGInterface_get_Density (ff-pointer self)))

(cl:defmethod get-mach-number ((self fginterface))
  (FGInterface_get_Mach_number (ff-pointer self)))

(cl:defmethod get-static-pressure ((self fginterface))
  (FGInterface_get_Static_pressure (ff-pointer self)))

(cl:defmethod get-total-pressure ((self fginterface))
  (FGInterface_get_Total_pressure (ff-pointer self)))

(cl:defmethod get-dynamic-pressure ((self fginterface))
  (FGInterface_get_Dynamic_pressure (ff-pointer self)))

(cl:defmethod get-static-temperature ((self fginterface))
  (FGInterface_get_Static_temperature (ff-pointer self)))

(cl:defmethod get-total-temperature ((self fginterface))
  (FGInterface_get_Total_temperature (ff-pointer self)))

(cl:defmethod get-sea-level-radius ((self fginterface))
  (FGInterface_get_Sea_level_radius (ff-pointer self)))

(cl:defmethod get-earth-position-angle ((self fginterface))
  (FGInterface_get_Earth_position_angle (ff-pointer self)))

(cl:defmethod get-runway-altitude ((self fginterface))
  (FGInterface_get_Runway_altitude (ff-pointer self)))

(cl:defmethod get-runway-altitude-m ((self fginterface))
  (FGInterface_get_Runway_altitude_m (ff-pointer self)))

(cl:defmethod get-climb-rate ((self fginterface))
  (FGInterface_get_Climb_Rate (ff-pointer self)))

(cl:defmethod get-ground-elev-ft ((self fginterface))
  (FGInterface_get_ground_elev_ft (ff-pointer self)))

(cl:defmethod prepare-ground-cache-m ((self fginterface) (startSimTime cl:number) (endSimTime cl:number) pt (rad cl:number))
  (FGInterface_prepare_ground_cache_m (ff-pointer self) startSimTime endSimTime pt rad))

(cl:defmethod prepare-ground-cache-ft ((self fginterface) (startSimTime cl:number) (endSimTime cl:number) pt (rad cl:number))
  (FGInterface_prepare_ground_cache_ft (ff-pointer self) startSimTime endSimTime pt rad))

(cl:defmethod is-valid-m ((self fginterface) ref_time pt rad)
  (FGInterface_is_valid_m (ff-pointer self) ref_time pt rad))

(cl:defmethod is-valid-ft ((self fginterface) ref_time pt rad)
  (FGInterface_is_valid_ft (ff-pointer self) ref_time pt rad))

(cl:defmethod get-cat-m ((self fginterface) (t-arg1 cl:number) pt end vel)
  (FGInterface_get_cat_m (ff-pointer self) t-arg1 pt end vel))

(cl:defmethod get-cat-ft ((self fginterface) (t-arg1 cl:number) pt end vel)
  (FGInterface_get_cat_ft (ff-pointer self) t-arg1 pt end vel))

(cl:defmethod get-body-m ((self fginterface) (t-arg1 cl:number) id bodyToWorld linearVel angularVel)
  (FGInterface_get_body_m (ff-pointer self) t-arg1 id bodyToWorld linearVel angularVel))

(cl:defmethod get-agl-m ((self fginterface) (t-arg1 cl:number) pt (max_altoff cl:number) contact normal linearVel angularVel material id)
  (FGInterface_get_agl_m (ff-pointer self) t-arg1 pt max_altoff contact normal linearVel angularVel material id))

(cl:defmethod get-agl-ft ((self fginterface) (t-arg1 cl:number) pt (max_altoff cl:number) contact normal linearVel angularVel material id)
  (FGInterface_get_agl_ft (ff-pointer self) t-arg1 pt max_altoff contact normal linearVel angularVel material id))

(cl:defmethod get-groundlevel-m ((self fginterface) (lat cl:number) (lon cl:number) (alt cl:number))
  (FGInterface_get_groundlevel_m (ff-pointer self) lat lon alt))

(cl:defmethod get-groundlevel-m ((self fginterface) geod)
  (FGInterface_get_groundlevel_m (ff-pointer self) geod))

(cl:defmethod get-nearest-m ((self fginterface) (t-arg1 cl:number) pt (maxDist cl:number) contact normal linearVel angularVel material id)
  (FGInterface_get_nearest_m (ff-pointer self) t-arg1 pt maxDist contact normal linearVel angularVel material id))

(cl:defmethod get-nearest-ft ((self fginterface) (t-arg1 cl:number) pt (maxDist cl:number) contact normal linearVel angularVel material id)
  (FGInterface_get_nearest_ft (ff-pointer self) t-arg1 pt maxDist contact normal linearVel angularVel material id))

(cl:defmethod caught-wire-m ((self fginterface) (t-arg1 cl:number) pt)
  (FGInterface_caught_wire_m (ff-pointer self) t-arg1 pt))

(cl:defmethod caught-wire-ft ((self fginterface) (t-arg1 cl:number) pt)
  (FGInterface_caught_wire_ft (ff-pointer self) t-arg1 pt))

(cl:defmethod get-wire-ends-m ((self fginterface) (t-arg1 cl:number) end vel)
  (FGInterface_get_wire_ends_m (ff-pointer self) t-arg1 end vel))

(cl:defmethod get-wire-ends-ft ((self fginterface) (t-arg1 cl:number) end vel)
  (FGInterface_get_wire_ends_ft (ff-pointer self) t-arg1 end vel))

(cl:defmethod release-wire ((self fginterface))
  (FGInterface_release_wire (ff-pointer self)))


(cl:defclass flight-properties()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj flight-properties) &key aRoot)
  (setf (slot-value obj 'ff-pointer) (new_FlightProperties aRoot)))

(cl:defmethod initialize-instance :after ((obj flight-properties) &key)
  (setf (slot-value obj 'ff-pointer) (new_FlightProperties)))

(cl:defmethod get-v-north ((self flight-properties))
  (FlightProperties_get_V_north (ff-pointer self)))

(cl:defmethod get-v-east ((self flight-properties))
  (FlightProperties_get_V_east (ff-pointer self)))

(cl:defmethod get-v-down ((self flight-properties))
  (FlightProperties_get_V_down (ff-pointer self)))

(cl:defmethod get-u-body ((self flight-properties))
  (FlightProperties_get_uBody (ff-pointer self)))

(cl:defmethod get-v-body ((self flight-properties))
  (FlightProperties_get_vBody (ff-pointer self)))

(cl:defmethod get-w-body ((self flight-properties))
  (FlightProperties_get_wBody (ff-pointer self)))

(cl:defmethod get-a-x-pilot ((self flight-properties))
  (FlightProperties_get_A_X_pilot (ff-pointer self)))

(cl:defmethod get-a-y-pilot ((self flight-properties))
  (FlightProperties_get_A_Y_pilot (ff-pointer self)))

(cl:defmethod get-a-z-pilot ((self flight-properties))
  (FlightProperties_get_A_Z_pilot (ff-pointer self)))

(cl:defmethod get-p-body ((self flight-properties))
  (FlightProperties_get_P_body (ff-pointer self)))

(cl:defmethod get-q-body ((self flight-properties))
  (FlightProperties_get_Q_body (ff-pointer self)))

(cl:defmethod get-r-body ((self flight-properties))
  (FlightProperties_get_R_body (ff-pointer self)))

(cl:defmethod get-position ((self flight-properties))
  (FlightProperties_getPosition (ff-pointer self)))

(cl:defmethod get-latitude ((self flight-properties))
  (FlightProperties_get_Latitude (ff-pointer self)))

(cl:defmethod get-longitude ((self flight-properties))
  (FlightProperties_get_Longitude (ff-pointer self)))

(cl:defmethod get-altitude ((self flight-properties))
  (FlightProperties_get_Altitude (ff-pointer self)))

(cl:defmethod get-altitude-agl ((self flight-properties))
  (FlightProperties_get_Altitude_AGL (ff-pointer self)))

(cl:defmethod get-track ((self flight-properties))
  (FlightProperties_get_Track (ff-pointer self)))

(cl:defmethod get-latitude-deg ((self flight-properties))
  (FlightProperties_get_Latitude_deg (ff-pointer self)))

(cl:defmethod get-longitude-deg ((self flight-properties))
  (FlightProperties_get_Longitude_deg (ff-pointer self)))

(cl:defmethod get-phi-deg ((self flight-properties))
  (FlightProperties_get_Phi_deg (ff-pointer self)))

(cl:defmethod get-theta-deg ((self flight-properties))
  (FlightProperties_get_Theta_deg (ff-pointer self)))

(cl:defmethod get-psi-deg ((self flight-properties))
  (FlightProperties_get_Psi_deg (ff-pointer self)))

(cl:defmethod get-phi ((self flight-properties))
  (FlightProperties_get_Phi (ff-pointer self)))

(cl:defmethod get-theta ((self flight-properties))
  (FlightProperties_get_Theta (ff-pointer self)))

(cl:defmethod get-psi ((self flight-properties))
  (FlightProperties_get_Psi (ff-pointer self)))

(cl:defmethod get-phi-dot ((self flight-properties))
  (FlightProperties_get_Phi_dot (ff-pointer self)))

(cl:defmethod get-theta-dot ((self flight-properties))
  (FlightProperties_get_Theta_dot (ff-pointer self)))

(cl:defmethod get-psi-dot ((self flight-properties))
  (FlightProperties_get_Psi_dot (ff-pointer self)))

(cl:defmethod get-alpha ((self flight-properties))
  (FlightProperties_get_Alpha (ff-pointer self)))

(cl:defmethod get-beta ((self flight-properties))
  (FlightProperties_get_Beta (ff-pointer self)))

(cl:defmethod get-phi-dot-degps ((self flight-properties))
  (FlightProperties_get_Phi_dot_degps (ff-pointer self)))

(cl:defmethod get-theta-dot-degps ((self flight-properties))
  (FlightProperties_get_Theta_dot_degps (ff-pointer self)))

(cl:defmethod get-psi-dot-degps ((self flight-properties))
  (FlightProperties_get_Psi_dot_degps (ff-pointer self)))

(cl:defmethod get-v-ground-speed ((self flight-properties))
  (FlightProperties_get_V_ground_speed (ff-pointer self)))

(cl:defmethod get-v-equiv-kts ((self flight-properties))
  (FlightProperties_get_V_equiv_kts (ff-pointer self)))

(cl:defmethod get-v-calibrated-kts ((self flight-properties))
  (FlightProperties_get_V_calibrated_kts (ff-pointer self)))

(cl:defmethod get-climb-rate ((self flight-properties))
  (FlightProperties_get_Climb_Rate (ff-pointer self)))

(cl:defmethod get-runway-altitude-m ((self flight-properties))
  (FlightProperties_get_Runway_altitude_m (ff-pointer self)))

(cl:defmethod get-total-temperature ((self flight-properties))
  (FlightProperties_get_Total_temperature (ff-pointer self)))

(cl:defmethod get-total-pressure ((self flight-properties))
  (FlightProperties_get_Total_pressure (ff-pointer self)))

(cl:defmethod get-dynamic-pressure ((self flight-properties))
  (FlightProperties_get_Dynamic_pressure (ff-pointer self)))

(cl:defmethod set-longitude ((self flight-properties) (l cl:number))
  (FlightProperties_set_Longitude (ff-pointer self) l))

(cl:defmethod set-latitude ((self flight-properties) (l cl:number))
  (FlightProperties_set_Latitude (ff-pointer self) l))

(cl:defmethod set-altitude ((self flight-properties) (ft cl:number))
  (FlightProperties_set_Altitude (ff-pointer self) ft))

(cl:defmethod set-euler-angles ((self flight-properties) (phi cl:number) (theta cl:number) (psi cl:number))
  (FlightProperties_set_Euler_Angles (ff-pointer self) phi theta psi))

(cl:defmethod set-euler-rates ((self flight-properties) (x cl:number) (y cl:number) (z cl:number))
  (FlightProperties_set_Euler_Rates (ff-pointer self) x y z))

(cl:defmethod set-alpha ((self flight-properties) (a cl:number))
  (FlightProperties_set_Alpha (ff-pointer self) a))

(cl:defmethod set-beta ((self flight-properties) (b cl:number))
  (FlightProperties_set_Beta (ff-pointer self) b))

(cl:defmethod set-altitude-agl ((self flight-properties) (ft cl:number))
  (FlightProperties_set_Altitude_AGL (ff-pointer self) ft))

(cl:defmethod set-v-calibrated-kts ((self flight-properties) (kts cl:number))
  (FlightProperties_set_V_calibrated_kts (ff-pointer self) kts))

(cl:defmethod set-climb-rate ((self flight-properties) (fps cl:number))
  (FlightProperties_set_Climb_Rate (ff-pointer self) fps))

(cl:defmethod set-velocities-local ((self flight-properties) (x cl:number) (y cl:number) (z cl:number))
  (FlightProperties_set_Velocities_Local (ff-pointer self) x y z))

(cl:defmethod set-velocities-wind-body ((self flight-properties) (x cl:number) (y cl:number) (z cl:number))
  (FlightProperties_set_Velocities_Wind_Body (ff-pointer self) x y z))

(cl:defmethod set-accels-pilot-body ((self flight-properties) (x cl:number) (y cl:number) (z cl:number))
  (FlightProperties_set_Accels_Pilot_Body (ff-pointer self) x y z))


(cl:defclass fgground-cache()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgground-cache) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGGroundCache)))

(cl:defmethod prepare-ground-cache ((self fgground-cache) (startSimTime cl:number) (endSimTime cl:number) pt (rad cl:number))
  (FGGroundCache_prepare_ground_cache (ff-pointer self) startSimTime endSimTime pt rad))

(cl:defmethod is-valid ((self fgground-cache) ref_time pt rad)
  (FGGroundCache_is_valid (ff-pointer self) ref_time pt rad))

(cl:defmethod get-down ((self fgground-cache))
  (FGGroundCache_get_down (ff-pointer self)))

(cl:defmethod get-cache-time-offset ((self fgground-cache))
  (FGGroundCache_get_cache_time_offset (ff-pointer self)))

(cl:defmethod set-cache-time-offset ((self fgground-cache) (time_offset cl:number))
  (FGGroundCache_set_cache_time_offset (ff-pointer self) time_offset))

(cl:defmethod get-body ((self fgground-cache) (t-arg1 cl:number) bodyToWorld linearVel angularVel id)
  (FGGroundCache_get_body (ff-pointer self) t-arg1 bodyToWorld linearVel angularVel id))

(cl:defmethod get-cat ((self fgground-cache) (t-arg1 cl:number) pt end vel)
  (FGGroundCache_get_cat (ff-pointer self) t-arg1 pt end vel))

(cl:defmethod get-agl ((self fgground-cache) (t-arg1 cl:number) pt contact normal linearVel angularVel id material)
  (FGGroundCache_get_agl (ff-pointer self) t-arg1 pt contact normal linearVel angularVel id material))

(cl:defmethod get-nearest ((self fgground-cache) (t-arg1 cl:number) pt (maxDist cl:number) contact linearVel angularVel id material)
  (FGGroundCache_get_nearest (ff-pointer self) t-arg1 pt maxDist contact linearVel angularVel id material))

(cl:defmethod caught-wire ((self fgground-cache) (t-arg1 cl:number) pt)
  (FGGroundCache_caught_wire (ff-pointer self) t-arg1 pt))

(cl:defmethod get-wire-ends ((self fgground-cache) (t-arg1 cl:number) end vel)
  (FGGroundCache_get_wire_ends (ff-pointer self) t-arg1 end vel))

(cl:defmethod release-wire ((self fgground-cache))
  (FGGroundCache_release_wire (ff-pointer self)))


(cl:defclass airport-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj airport-list) &key (x cl:integer) (y cl:integer) (width cl:integer) (height cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_AirportList x y width height)))

(cl:defmethod create-list ((self airport-list))
  (AirportList_create_list (ff-pointer self)))

(cl:defmethod destroy-list ((self airport-list))
  (AirportList_destroy_list (ff-pointer self)))

(cl:defmethod set-value ((self airport-list) (arg1 cl:string))
  (AirportList_setValue (ff-pointer self) arg1))


(cl:defclass map-widget()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj map-widget) &key (x cl:integer) (y cl:integer) (width cl:integer) (height cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_MapWidget x y width height)))

(cl:defmethod set-size ((self map-widget) (width cl:integer) (height cl:integer))
  (MapWidget_setSize (ff-pointer self) width height))

(cl:defmethod do-hit ((self map-widget) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (MapWidget_doHit (ff-pointer self) button updown x y))

(cl:defmethod draw ((self map-widget) (dx cl:integer) (dy cl:integer))
  (MapWidget_draw (ff-pointer self) dx dy))

(cl:defmethod check-key ((self map-widget) (key cl:integer) (updown cl:integer))
  (MapWidget_checkKey (ff-pointer self) key updown))

(cl:defmethod set-property ((self map-widget) prop)
  (MapWidget_setProperty (ff-pointer self) prop))


(cl:defclass waypoint-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj waypoint-list) &key (x cl:integer) (y cl:integer) (width cl:integer) (height cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_WaypointList x y width height)))

(cl:defmethod set-size ((self waypoint-list) (width cl:integer) (height cl:integer))
  (WaypointList_setSize (ff-pointer self) width height))

(cl:defmethod check-hit ((self waypoint-list) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (WaypointList_checkHit (ff-pointer self) button updown x y))

(cl:defmethod do-hit ((self waypoint-list) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (WaypointList_doHit (ff-pointer self) button updown x y))

(cl:defmethod draw ((self waypoint-list) (dx cl:integer) (dy cl:integer))
  (WaypointList_draw (ff-pointer self) dx dy))

(cl:defmethod check-key ((self waypoint-list) (key cl:integer) (updown cl:integer))
  (WaypointList_checkKey (ff-pointer self) key updown))

(cl:defmethod invoke-down-callback ((self waypoint-list))
  (WaypointList_invokeDownCallback (ff-pointer self)))

(cl:defmethod set-selected ((self waypoint-list) (rowIndex cl:integer))
  (WaypointList_setSelected (ff-pointer self) rowIndex))

(cl:defmethod get-selected ((self waypoint-list))
  (WaypointList_getSelected (ff-pointer self)))

(cl:defmethod wants-vscroll ((self waypoint-list))
  (WaypointList_wantsVScroll (ff-pointer self)))

(cl:defmethod get-vscroll-percent ((self waypoint-list))
  (WaypointList_getVScrollPercent (ff-pointer self)))

(cl:defmethod set-vscroll-percent ((self waypoint-list) (perc cl:number))
  (WaypointList_setVScrollPercent (ff-pointer self) perc))

(cl:defmethod get-vscroll-thumb-percent ((self waypoint-list))
  (WaypointList_getVScrollThumbPercent (ff-pointer self)))

(cl:defmethod num-visible-rows ((self waypoint-list))
  (WaypointList_numVisibleRows (ff-pointer self)))

(cl:defmethod ensure-row-visible ((self waypoint-list) (row cl:integer))
  (WaypointList_ensureRowVisible (ff-pointer self) row))

(cl:defmethod set-update-callback ((self waypoint-list) cb)
  (WaypointList_setUpdateCallback (ff-pointer self) cb))

(cl:defmethod set-scroll-callback ((self waypoint-list) cb)
  (WaypointList_setScrollCallback (ff-pointer self) cb))

(cl:defmethod set-model ((self waypoint-list) model)
  (WaypointList_setModel (ff-pointer self) model))

(cl:defmethod num-waypoints ((self waypoint-list))
  (WaypointList_numWaypoints (ff-pointer self)))


(cl:defclass scrolled-waypoint-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj scrolled-waypoint-list) &key (x cl:integer) (y cl:integer) (width cl:integer) (height cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_ScrolledWaypointList x y width height)))

(cl:defmethod set-size ((self scrolled-waypoint-list) (width cl:integer) (height cl:integer))
  (ScrolledWaypointList_setSize (ff-pointer self) width height))

(cl:defmethod set-scroll-percent ((self scrolled-waypoint-list) (v cl:number))
  (ScrolledWaypointList_setScrollPercent (ff-pointer self) v))

(cl:defmethod set-value ((self scrolled-waypoint-list) (v cl:number))
  (ScrolledWaypointList_setValue (ff-pointer self) v))

(cl:defmethod set-value ((self scrolled-waypoint-list) (v cl:integer))
  (ScrolledWaypointList_setValue (ff-pointer self) v))


(cl:defclass gui-id()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj gui-id) &key (id cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_GUI_ID id)))

(cl:defmethod (cl:setf id) (arg0 (obj gui-id))
  (GUI_ID_id_set (ff-pointer obj) arg0))

(cl:defmethod id ((obj gui-id))
  (GUI_ID_id_get (ff-pointer obj)))


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

(cl:defmethod initialize-instance :after ((obj fgdialog) &key props)
  (setf (slot-value obj 'ff-pointer) (new_FGDialog props)))

(cl:defmethod update-values ((self fgdialog) (objectName cl:string))
  (FGDialog_updateValues (ff-pointer self) objectName))

(cl:defmethod update-values ((self fgdialog))
  (FGDialog_updateValues (ff-pointer self)))

(cl:defmethod apply-values ((self fgdialog) (objectName cl:string))
  (FGDialog_applyValues (ff-pointer self) objectName))

(cl:defmethod apply-values ((self fgdialog))
  (FGDialog_applyValues (ff-pointer self)))

(cl:defmethod update ((self fgdialog))
  (FGDialog_update (ff-pointer self)))

(cl:defmethod relayout ((self fgdialog))
  (FGDialog_relayout (ff-pointer self)))

(cl:defmethod set-needs-layout ((self fgdialog))
  (FGDialog_setNeedsLayout (ff-pointer self)))


(cl:defclass fg-popup()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fg-popup) &key (x cl:integer) (y cl:integer) (r t) (d t))
  (setf (slot-value obj 'ff-pointer) (new_fgPopup x y r d)))

(cl:defmethod initialize-instance :after ((obj fg-popup) &key (x cl:integer) (y cl:integer) (r t))
  (setf (slot-value obj 'ff-pointer) (new_fgPopup x y r)))

(cl:defmethod initialize-instance :after ((obj fg-popup) &key (x cl:integer) (y cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_fgPopup x y)))

(cl:defmethod check-hit ((self fg-popup) (b cl:integer) (up cl:integer) (x cl:integer) (y cl:integer))
  (fgPopup_checkHit (ff-pointer self) b up x y))

(cl:defmethod check-key ((self fg-popup) (key cl:integer) (updown cl:integer))
  (fgPopup_checkKey (ff-pointer self) key updown))

(cl:defmethod get-hit-objects ((self fg-popup) arg1 (x cl:integer) (y cl:integer))
  (fgPopup_getHitObjects (ff-pointer self) arg1 x y))

(cl:defmethod get-key-object ((self fg-popup) arg1 (key cl:integer))
  (fgPopup_getKeyObject (ff-pointer self) arg1 key))

(cl:defmethod get-active-input-field ((self fg-popup) arg1)
  (fgPopup_getActiveInputField (ff-pointer self) arg1))

(cl:defmethod apply-size ((self fg-popup) arg1)
  (fgPopup_applySize (ff-pointer self) arg1))


(cl:defclass fg-value-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fg-value-list) &key p)
  (setf (slot-value obj 'ff-pointer) (new_fgValueList p)))

(cl:defmethod update ((self fg-value-list))
  (fgValueList_update (ff-pointer self)))


(cl:defclass fg-list(fgValueListGUI_ID)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fg-list) &key (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer) p (sw cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_fgList x1 y1 x2 y2 p sw)))

(cl:defmethod update ((self fg-list))
  (fgList_update (ff-pointer self)))


(cl:defclass fg-combo-box(fgValueList)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fg-combo-box) &key (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer) p (editable t))
  (setf (slot-value obj 'ff-pointer) (new_fgComboBox x1 y1 x2 y2 p editable)))

(cl:defmethod update ((self fg-combo-box))
  (fgComboBox_update (ff-pointer self)))

(cl:defmethod set-size ((self fg-combo-box) (w cl:integer) (h cl:integer))
  (fgComboBox_setSize (ff-pointer self) w h))

(cl:defmethod check-hit ((self fg-combo-box) (b cl:integer) (up cl:integer) (x cl:integer) (y cl:integer))
  (fgComboBox_checkHit (ff-pointer self) b up x y))

(cl:defmethod recalc-bbox ((self fg-combo-box))
  (fgComboBox_recalc_bbox (ff-pointer self)))


(cl:defclass fg-select-box(fgValueList)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fg-select-box) &key (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer) p)
  (setf (slot-value obj 'ff-pointer) (new_fgSelectBox x1 y1 x2 y2 p)))


(cl:defclass layout-widget()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj layout-widget) &key)
  (setf (slot-value obj 'ff-pointer) (new_LayoutWidget)))

(cl:defmethod initialize-instance :after ((obj layout-widget) &key p)
  (setf (slot-value obj 'ff-pointer) (new_LayoutWidget p)))

(cl:defmethod type ((self layout-widget))
  (LayoutWidget_type (ff-pointer self)))

(cl:defmethod has-parent ((self layout-widget))
  (LayoutWidget_hasParent (ff-pointer self)))

(cl:defmethod parent ((self layout-widget))
  (LayoutWidget_parent (ff-pointer self)))

(cl:defmethod n-children ((self layout-widget))
  (LayoutWidget_nChildren (ff-pointer self)))

(cl:defmethod get-child ((self layout-widget) (i cl:integer))
  (LayoutWidget_getChild (ff-pointer self) i))

(cl:defmethod has-field ((self layout-widget) (f cl:string))
  (LayoutWidget_hasField (ff-pointer self) f))

(cl:defmethod get-num ((self layout-widget) (f cl:string))
  (LayoutWidget_getNum (ff-pointer self) f))

(cl:defmethod get-bool ((self layout-widget) (f cl:string) (dflt t))
  (LayoutWidget_getBool (ff-pointer self) f dflt))

(cl:defmethod get-bool ((self layout-widget) (f cl:string))
  (LayoutWidget_getBool (ff-pointer self) f))

(cl:defmethod get-str ((self layout-widget) (f cl:string))
  (LayoutWidget_getStr (ff-pointer self) f))

(cl:defmethod set-num ((self layout-widget) (f cl:string) (num cl:integer))
  (LayoutWidget_setNum (ff-pointer self) f num))

(cl:defmethod calc-pref-size ((self layout-widget) w h)
  (LayoutWidget_calcPrefSize (ff-pointer self) w h))

(cl:defmethod layout ((self layout-widget) (x cl:integer) (y cl:integer) (w cl:integer) (h cl:integer))
  (LayoutWidget_layout (ff-pointer self) x y w h))


(cl:defclass fgmenu-bar()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgmenu-bar) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGMenuBar)))

(cl:defmethod init ((self fgmenu-bar))
  (FGMenuBar_init (ff-pointer self)))

(cl:defmethod show ((self fgmenu-bar))
  (FGMenuBar_show (ff-pointer self)))

(cl:defmethod hide ((self fgmenu-bar))
  (FGMenuBar_hide (ff-pointer self)))

(cl:defmethod is-visible ((self fgmenu-bar))
  (FGMenuBar_isVisible (ff-pointer self)))

(cl:defmethod fire-item ((self fgmenu-bar) item)
  (FGMenuBar_fireItem (ff-pointer self) item))

(cl:defmethod make-menubar ((self fgmenu-bar) props)
  (FGMenuBar_make_menubar (ff-pointer self) props))

(cl:defmethod destroy-menubar ((self fgmenu-bar))
  (FGMenuBar_destroy_menubar (ff-pointer self)))

(cl:defmethod enable-item ((self fgmenu-bar) item (state t))
  (FGMenuBar_enable_item (ff-pointer self) item state))


(cl:defclass new-gui()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj new-gui) &key)
  (setf (slot-value obj 'ff-pointer) (new_NewGUI)))

(cl:defmethod init ((self new-gui))
  (NewGUI_init (ff-pointer self)))

(cl:defmethod reinit ((self new-gui))
  (NewGUI_reinit (ff-pointer self)))

(cl:defmethod bind ((self new-gui))
  (NewGUI_bind (ff-pointer self)))

(cl:defmethod unbind ((self new-gui))
  (NewGUI_unbind (ff-pointer self)))

(cl:defmethod update ((self new-gui) (delta_time_sec cl:number))
  (NewGUI_update (ff-pointer self) delta_time_sec))

(cl:defmethod redraw ((self new-gui))
  (NewGUI_redraw (ff-pointer self)))

(cl:defmethod new-dialog ((self new-gui) node)
  (NewGUI_newDialog (ff-pointer self) node))

(cl:defmethod show-dialog ((self new-gui) name)
  (NewGUI_showDialog (ff-pointer self) name))

(cl:defmethod close-active-dialog ((self new-gui))
  (NewGUI_closeActiveDialog (ff-pointer self)))

(cl:defmethod close-dialog ((self new-gui) name)
  (NewGUI_closeDialog (ff-pointer self) name))

(cl:defmethod get-dialog-properties ((self new-gui) name)
  (NewGUI_getDialogProperties (ff-pointer self) name))

(cl:defmethod get-menu-bar ((self new-gui))
  (NewGUI_getMenuBar (ff-pointer self)))

(cl:defmethod set-active-dialog ((self new-gui) (dialog fgdialog))
  (NewGUI_setActiveDialog (ff-pointer self) dialog))

(cl:defmethod get-active-dialog ((self new-gui))
  (NewGUI_getActiveDialog (ff-pointer self)))

(cl:defmethod get-dialog ((self new-gui) name)
  (NewGUI_getDialog (ff-pointer self) name))

(cl:defmethod get-color ((self new-gui) (name cl:string))
  (NewGUI_getColor (ff-pointer self) name))

(cl:defmethod get-color ((self new-gui) name)
  (NewGUI_getColor (ff-pointer self) name))

(cl:defmethod get-default-font ((self new-gui))
  (NewGUI_getDefaultFont (ff-pointer self)))


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

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

(cl:defmethod initialize-instance :after ((obj fgcolor) &key (r cl:number) (g cl:number) (b cl:number) (a cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGColor r g b a)))

(cl:defmethod initialize-instance :after ((obj fgcolor) &key (r cl:number) (g cl:number) (b cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGColor r g b)))

(cl:defmethod initialize-instance :after ((obj fgcolor) &key prop)
  (setf (slot-value obj 'ff-pointer) (new_FGColor prop)))

(cl:defmethod initialize-instance :after ((obj fgcolor) &key (c fgcolor))
  (setf (slot-value obj 'ff-pointer) (new_FGColor (ff-pointer c))))

(cl:defmethod clear ((self fgcolor))
  (FGColor_clear (ff-pointer self)))

(cl:defmethod merge ((self fgcolor) prop)
  (FGColor_merge (ff-pointer self) prop))

(cl:defmethod merge ((self fgcolor) (color fgcolor))
  (FGColor_merge (ff-pointer self) (ff-pointer color)))

(cl:defmethod set ((self fgcolor) prop)
  (FGColor_set (ff-pointer self) prop))

(cl:defmethod set ((self fgcolor) (color fgcolor))
  (FGColor_set (ff-pointer self) (ff-pointer color)))

(cl:defmethod set ((self fgcolor) (r cl:number) (g cl:number) (b cl:number) (a cl:number))
  (FGColor_set (ff-pointer self) r g b a))

(cl:defmethod set ((self fgcolor) (r cl:number) (g cl:number) (b cl:number))
  (FGColor_set (ff-pointer self) r g b))

(cl:defmethod is-valid ((self fgcolor))
  (FGColor_isValid (ff-pointer self)))

(cl:defmethod print ((self fgcolor))
  (FGColor_print (ff-pointer self)))

(cl:defmethod set-red ((self fgcolor) (red cl:number))
  (FGColor_setRed (ff-pointer self) red))

(cl:defmethod set-green ((self fgcolor) (green cl:number))
  (FGColor_setGreen (ff-pointer self) green))

(cl:defmethod set-blue ((self fgcolor) (blue cl:number))
  (FGColor_setBlue (ff-pointer self) blue))

(cl:defmethod set-alpha ((self fgcolor) (alpha cl:number))
  (FGColor_setAlpha (ff-pointer self) alpha))

(cl:defmethod red ((self fgcolor))
  (FGColor_red (ff-pointer self)))

(cl:defmethod green ((self fgcolor))
  (FGColor_green (ff-pointer self)))

(cl:defmethod blue ((self fgcolor))
  (FGColor_blue (ff-pointer self)))

(cl:defmethod alpha ((self fgcolor))
  (FGColor_alpha (ff-pointer self)))


(cl:defclass fgfont-cache()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgfont-cache) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGFontCache)))

(cl:defmethod get ((self fgfont-cache) (name cl:string) (size cl:number) (slant cl:number))
  (FGFontCache_get (ff-pointer self) name size slant))

(cl:defmethod get ((self fgfont-cache) (name cl:string) (size cl:number))
  (FGFontCache_get (ff-pointer self) name size))

(cl:defmethod get ((self fgfont-cache) (name cl:string))
  (FGFontCache_get (ff-pointer self) name))

(cl:defmethod get ((self fgfont-cache) node)
  (FGFontCache_get (ff-pointer self) node))

(cl:defmethod get-tex-font ((self fgfont-cache) (name cl:string) (size cl:number) (slant cl:number))
  (FGFontCache_getTexFont (ff-pointer self) name size slant))

(cl:defmethod get-tex-font ((self fgfont-cache) (name cl:string) (size cl:number))
  (FGFontCache_getTexFont (ff-pointer self) name size))

(cl:defmethod get-tex-font ((self fgfont-cache) (name cl:string))
  (FGFontCache_getTexFont (ff-pointer self) name))

(cl:defmethod getfntpath ((self fgfont-cache) (name cl:string))
  (FGFontCache_getfntpath (ff-pointer self) name))

(cl:defmethod initialize-fonts ((self fgfont-cache))
  (FGFontCache_initializeFonts (ff-pointer self)))


(cl:defclass property-list(GUI_ID)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj property-list) &key (minx cl:integer) (miny cl:integer) (maxx cl:integer) (maxy cl:integer) arg4)
  (setf (slot-value obj 'ff-pointer) (new_PropertyList minx miny maxx maxy arg4)))

(cl:defmethod update ((self property-list) (restore_slider_pos t))
  (PropertyList_update (ff-pointer self) restore_slider_pos))

(cl:defmethod update ((self property-list))
  (PropertyList_update (ff-pointer self)))

(cl:defmethod set-current ((self property-list) p)
  (PropertyList_setCurrent (ff-pointer self) p))

(cl:defmethod get-current ((self property-list))
  (PropertyList_getCurrent (ff-pointer self)))

(cl:defmethod publish ((self property-list) p)
  (PropertyList_publish (ff-pointer self) p))

(cl:defmethod toggle-verbosity ((self property-list))
  (PropertyList_toggleVerbosity (ff-pointer self)))

(cl:defmethod get-string-value ((self property-list))
  (PropertyList_getStringValue (ff-pointer self)))

(cl:defmethod set-value ((self property-list) (arg1 cl:string))
  (PropertyList_setValue (ff-pointer self) arg1))

(cl:defmethod value-changed ((self property-list) node)
  (PropertyList_valueChanged (ff-pointer self) node))


(cl:defclass fg-callback()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod clone ((self fg-callback))
  (fgCallback_clone (ff-pointer self)))

(cl:shadow "()")
(cl:defmethod () ((self fg-callback))
  (fgCallback___funcall__ (ff-pointer self)))


(cl:defclass fgcommon-input()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgcommon-input) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGCommonInput)))


(cl:defclass fgdevice-configuration-map()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgdevice-configuration-map) &key (relative_path cl:string) base (childname cl:string))
  (setf (slot-value obj 'ff-pointer) (new_FGDeviceConfigurationMap relative_path base childname)))


(cl:defclass fgjoystick-input()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgjoystick-input) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGJoystickInput)))

(cl:defmethod init ((self fgjoystick-input))
  (FGJoystickInput_init (ff-pointer self)))

(cl:defmethod postinit ((self fgjoystick-input))
  (FGJoystickInput_postinit (ff-pointer self)))

(cl:defmethod reinit ((self fgjoystick-input))
  (FGJoystickInput_reinit (ff-pointer self)))

(cl:defmethod update ((self fgjoystick-input) (dt cl:number))
  (FGJoystickInput_update (ff-pointer self) dt))


(cl:defclass fgkeyboard-input()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgkeyboard-input) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGKeyboardInput)))

(cl:defmethod init ((self fgkeyboard-input))
  (FGKeyboardInput_init (ff-pointer self)))

(cl:defmethod postinit ((self fgkeyboard-input))
  (FGKeyboardInput_postinit (ff-pointer self)))

(cl:defmethod bind ((self fgkeyboard-input))
  (FGKeyboardInput_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgkeyboard-input))
  (FGKeyboardInput_unbind (ff-pointer self)))

(cl:defmethod update ((self fgkeyboard-input) (dt cl:number))
  (FGKeyboardInput_update (ff-pointer self) dt))


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

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


(cl:defclass clip-box()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj clip-box) &key arg0 (xoffset cl:number) (yoffset cl:number))
  (setf (slot-value obj 'ff-pointer) (new_ClipBox arg0 xoffset yoffset)))

(cl:defmethod initialize-instance :after ((obj clip-box) &key arg0 (xoffset cl:number))
  (setf (slot-value obj 'ff-pointer) (new_ClipBox arg0 xoffset)))

(cl:defmethod initialize-instance :after ((obj clip-box) &key arg0)
  (setf (slot-value obj 'ff-pointer) (new_ClipBox arg0)))

(cl:defmethod set ((self clip-box))
  (ClipBox_set (ff-pointer self)))

(cl:defmethod unset ((self clip-box))
  (ClipBox_unset (ff-pointer self)))


(cl:defclass line-segment()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj line-segment) &key x0 y0 x1 y1)
  (setf (slot-value obj 'ff-pointer) (new_LineSegment x0 y0 x1 y1)))

(cl:defmethod draw ((self line-segment))
  (LineSegment_draw (ff-pointer self)))


(cl:defclass line-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod add ((self line-list) (seg line-segment))
  (LineList_add (ff-pointer self) seg))

(cl:defmethod erase ((self line-list))
  (LineList_erase (ff-pointer self)))

(cl:defmethod size ((self line-list))
  (LineList_size (ff-pointer self)))

(cl:defmethod draw ((self line-list))
  (LineList_draw (ff-pointer self)))

(cl:defmethod initialize-instance :after ((obj line-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_LineList)))


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

(cl:defmethod initialize-instance :after ((obj hudtext) &key f (x cl:number) (y cl:number) (s cl:string) (align cl:integer) (digits cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_HUDText f x y s align digits)))

(cl:defmethod initialize-instance :after ((obj hudtext) &key f (x cl:number) (y cl:number) (s cl:string) (align cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_HUDText f x y s align)))

(cl:defmethod initialize-instance :after ((obj hudtext) &key f (x cl:number) (y cl:number) (s cl:string))
  (setf (slot-value obj 'ff-pointer) (new_HUDText f x y s)))

(cl:defmethod draw ((self hudtext))
  (HUDText_draw (ff-pointer self)))


(cl:defclass text-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj text-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_TextList)))

(cl:defmethod set-font ((self text-list) Renderer)
  (TextList_setFont (ff-pointer self) Renderer))

(cl:defmethod add ((self text-list) (x cl:number) (y cl:number) (s cl:string) (align cl:integer) (digit cl:integer))
  (TextList_add (ff-pointer self) x y s align digit))

(cl:defmethod add ((self text-list) (x cl:number) (y cl:number) (s cl:string) (align cl:integer))
  (TextList_add (ff-pointer self) x y s align))

(cl:defmethod add ((self text-list) (x cl:number) (y cl:number) (s cl:string))
  (TextList_add (ff-pointer self) x y s))

(cl:defmethod erase ((self text-list))
  (TextList_erase (ff-pointer self)))

(cl:defmethod align ((self text-list) (s cl:string) (align cl:integer) x y l r b t-arg8)
  (TextList_align (ff-pointer self) s align x y l r b t-arg8))

(cl:defmethod draw ((self text-list))
  (TextList_draw (ff-pointer self)))


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

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

(cl:defmethod init ((self hud))
  (HUD_init (ff-pointer self)))

(cl:defmethod update ((self hud) (arg1 cl:number))
  (HUD_update (ff-pointer self) arg1))

(cl:defmethod reinit ((self hud))
  (HUD_reinit (ff-pointer self)))

(cl:defmethod draw ((self hud) arg1)
  (HUD_draw (ff-pointer self) arg1))

(cl:defmethod value-changed ((self hud) arg1)
  (HUD_valueChanged (ff-pointer self) arg1))

(cl:defmethod set-color ((self hud))
  (HUD_setColor (ff-pointer self)))

(cl:defmethod is-visible ((self hud))
  (HUD_isVisible (ff-pointer self)))

(cl:defmethod is-antialiased ((self hud))
  (HUD_isAntialiased (ff-pointer self)))

(cl:defmethod is-transparent ((self hud))
  (HUD_isTransparent (ff-pointer self)))

(cl:defmethod is3-d ((self hud))
  (HUD_is3D (ff-pointer self)))

(cl:defmethod alpha-clamp ((self hud))
  (HUD_alphaClamp (ff-pointer self)))

(cl:defmethod timer ((self hud))
  (HUD_timer (ff-pointer self)))

(cl:defmethod get-units ((self hud))
  (HUD_getUnits (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj kln89) &key instrument)
  (setf (slot-value obj 'ff-pointer) (new_KLN89 instrument)))

(cl:defmethod bind ((self kln89))
  (KLN89_bind (ff-pointer self)))

(cl:defmethod unbind ((self kln89))
  (KLN89_unbind (ff-pointer self)))

(cl:defmethod init ((self kln89))
  (KLN89_init (ff-pointer self)))

(cl:defmethod update ((self kln89) (dt cl:number))
  (KLN89_update (ff-pointer self) dt))

(cl:defmethod set-alt-units-si ((self kln89) (b t))
  (KLN89_SetAltUnitsSI (ff-pointer self) b))

(cl:defmethod get-alt-units-si ((self kln89))
  (KLN89_GetAltUnitsSI (ff-pointer self)))

(cl:defmethod set-dist-vel-units-si ((self kln89) (b t))
  (KLN89_SetDistVelUnitsSI (ff-pointer self) b))

(cl:defmethod get-dist-vel-units-si ((self kln89))
  (KLN89_GetDistVelUnitsSI (ff-pointer self)))

(cl:defmethod set-baro-units ((self kln89) (n cl:integer) (wrap t))
  (KLN89_SetBaroUnits (ff-pointer self) n wrap))

(cl:defmethod set-baro-units ((self kln89) (n cl:integer))
  (KLN89_SetBaroUnits (ff-pointer self) n))

(cl:defmethod get-baro-units ((self kln89))
  (KLN89_GetBaroUnits (ff-pointer self)))

(cl:defmethod set-turn-anticipation ((self kln89) (b t))
  (KLN89_SetTurnAnticipation (ff-pointer self) b))

(cl:defmethod get-turn-anticipation ((self kln89))
  (KLN89_GetTurnAnticipation (ff-pointer self)))

(cl:defmethod set-sua-alert-enabled ((self kln89) (b t))
  (KLN89_SetSuaAlertEnabled (ff-pointer self) b))

(cl:defmethod get-sua-alert-enabled ((self kln89))
  (KLN89_GetSuaAlertEnabled (ff-pointer self)))

(cl:defmethod set-alt-alert-enabled ((self kln89) (b t))
  (KLN89_SetAltAlertEnabled (ff-pointer self) b))

(cl:defmethod get-alt-alert-enabled ((self kln89))
  (KLN89_GetAltAlertEnabled (ff-pointer self)))

(cl:defmethod set-min-display-brightness ((self kln89) (n cl:integer))
  (KLN89_SetMinDisplayBrightness (ff-pointer self) n))

(cl:defmethod decrement-min-display-brightness ((self kln89))
  (KLN89_DecrementMinDisplayBrightness (ff-pointer self)))

(cl:defmethod increment-min-display-brightness ((self kln89))
  (KLN89_IncrementMinDisplayBrightness (ff-pointer self)))

(cl:defmethod get-min-display-brightness ((self kln89))
  (KLN89_GetMinDisplayBrightness (ff-pointer self)))

(cl:defmethod get-msg-alert ((self kln89))
  (KLN89_GetMsgAlert (ff-pointer self)))

(cl:defmethod knob1-right1 ((self kln89))
  (KLN89_Knob1Right1 (ff-pointer self)))

(cl:defmethod knob1-left1 ((self kln89))
  (KLN89_Knob1Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89))
  (KLN89_Knob2Right1 (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89))
  (KLN89_Knob2Left1 (ff-pointer self)))

(cl:defmethod crsr-pressed ((self kln89))
  (KLN89_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89))
  (KLN89_EntPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89))
  (KLN89_ClrPressed (ff-pointer self)))

(cl:defmethod dto-pressed ((self kln89))
  (KLN89_DtoPressed (ff-pointer self)))

(cl:defmethod nrst-pressed ((self kln89))
  (KLN89_NrstPressed (ff-pointer self)))

(cl:defmethod alt-pressed ((self kln89))
  (KLN89_AltPressed (ff-pointer self)))

(cl:defmethod obspressed ((self kln89))
  (KLN89_OBSPressed (ff-pointer self)))

(cl:defmethod msg-pressed ((self kln89))
  (KLN89_MsgPressed (ff-pointer self)))

(cl:defmethod create-default-flight-plans ((self kln89))
  (KLN89_CreateDefaultFlightPlans (ff-pointer self)))


(cl:defclass kln89-page()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89Page parent)))

(cl:defmethod update ((self kln89-page) (dt cl:number))
  (KLN89Page_Update (ff-pointer self) dt))

(cl:defmethod knob1-left1 ((self kln89-page))
  (KLN89Page_Knob1Left1 (ff-pointer self)))

(cl:defmethod knob1-right1 ((self kln89-page))
  (KLN89Page_Knob1Right1 (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-page))
  (KLN89Page_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-page))
  (KLN89Page_Knob2Right1 (ff-pointer self)))

(cl:defmethod crsr-pressed ((self kln89-page))
  (KLN89Page_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-page))
  (KLN89Page_EntPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-page))
  (KLN89Page_ClrPressed (ff-pointer self)))

(cl:defmethod dto-pressed ((self kln89-page))
  (KLN89Page_DtoPressed (ff-pointer self)))

(cl:defmethod nrst-pressed ((self kln89-page))
  (KLN89Page_NrstPressed (ff-pointer self)))

(cl:defmethod alt-pressed ((self kln89-page))
  (KLN89Page_AltPressed (ff-pointer self)))

(cl:defmethod obspressed ((self kln89-page))
  (KLN89Page_OBSPressed (ff-pointer self)))

(cl:defmethod msg-pressed ((self kln89-page))
  (KLN89Page_MsgPressed (ff-pointer self)))

(cl:defmethod clean-up ((self kln89-page))
  (KLN89Page_CleanUp (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-page))
  (KLN89Page_LooseFocus (ff-pointer self)))

(cl:defmethod set-ent-invert ((self kln89-page) (b t))
  (KLN89Page_SetEntInvert (ff-pointer self) b))

(cl:defmethod set-id ((self kln89-page) s)
  (KLN89Page_SetId (ff-pointer self) s))

(cl:defmethod get-id ((self kln89-page))
  (KLN89Page_GetId (ff-pointer self)))

(cl:defmethod get-sub-page ((self kln89-page))
  (KLN89Page_GetSubPage (ff-pointer self)))

(cl:defmethod set-sub-page ((self kln89-page) (n cl:integer))
  (KLN89Page_SetSubPage (ff-pointer self) n))

(cl:defmethod get-nsub-pages ((self kln89-page))
  (KLN89Page_GetNSubPages (ff-pointer self)))

(cl:defmethod get-name ((self kln89-page))
  (KLN89Page_GetName (ff-pointer self)))


(cl:defclass kln89-act-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-act-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89ActPage parent)))

(cl:defmethod update ((self kln89-act-page) (dt cl:number))
  (KLN89ActPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-act-page))
  (KLN89ActPage_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-act-page))
  (KLN89ActPage_EntPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-act-page))
  (KLN89ActPage_ClrPressed (ff-pointer self)))

(cl:defmethod knob1-left1 ((self kln89-act-page))
  (KLN89ActPage_Knob1Left1 (ff-pointer self)))

(cl:defmethod knob1-right1 ((self kln89-act-page))
  (KLN89ActPage_Knob1Right1 (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-act-page))
  (KLN89ActPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-act-page))
  (KLN89ActPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-act-page))
  (KLN89ActPage_LooseFocus (ff-pointer self)))


(cl:defclass kln89-alt-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-alt-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89AltPage parent)))

(cl:defmethod update ((self kln89-alt-page) (dt cl:number))
  (KLN89AltPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-alt-page))
  (KLN89AltPage_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-alt-page))
  (KLN89AltPage_EntPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-alt-page))
  (KLN89AltPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-alt-page))
  (KLN89AltPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-alt-page))
  (KLN89AltPage_LooseFocus (ff-pointer self)))


(cl:defclass kln89-apt-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-apt-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89AptPage parent)))

(cl:defmethod update ((self kln89-apt-page) (dt cl:number))
  (KLN89AptPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-apt-page))
  (KLN89AptPage_CrsrPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-apt-page))
  (KLN89AptPage_ClrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-apt-page))
  (KLN89AptPage_EntPressed (ff-pointer self)))

(cl:defmethod knob1-left1 ((self kln89-apt-page))
  (KLN89AptPage_Knob1Left1 (ff-pointer self)))

(cl:defmethod knob1-right1 ((self kln89-apt-page))
  (KLN89AptPage_Knob1Right1 (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-apt-page))
  (KLN89AptPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-apt-page))
  (KLN89AptPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod set-id ((self kln89-apt-page) s)
  (KLN89AptPage_SetId (ff-pointer self) s))


(cl:defclass kln89-cal-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-cal-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89CalPage parent)))

(cl:defmethod update ((self kln89-cal-page) (dt cl:number))
  (KLN89CalPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-cal-page))
  (KLN89CalPage_CrsrPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-cal-page))
  (KLN89CalPage_ClrPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-cal-page))
  (KLN89CalPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-cal-page))
  (KLN89CalPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-cal-page))
  (KLN89CalPage_LooseFocus (ff-pointer self)))


(cl:defclass kln89-dir-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-dir-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89DirPage parent)))

(cl:defmethod update ((self kln89-dir-page) (dt cl:number))
  (KLN89DirPage_Update (ff-pointer self) dt))

(cl:defmethod set-id ((self kln89-dir-page) s)
  (KLN89DirPage_SetId (ff-pointer self) s))

(cl:defmethod crsr-pressed ((self kln89-dir-page))
  (KLN89DirPage_CrsrPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-dir-page))
  (KLN89DirPage_ClrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-dir-page))
  (KLN89DirPage_EntPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-dir-page))
  (KLN89DirPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-dir-page))
  (KLN89DirPage_Knob2Right1 (ff-pointer self)))


(cl:defclass kln89-fpl-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-fpl-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89FplPage parent)))

(cl:defmethod update ((self kln89-fpl-page) (dt cl:number))
  (KLN89FplPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-fpl-page))
  (KLN89FplPage_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-fpl-page))
  (KLN89FplPage_EntPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-fpl-page))
  (KLN89FplPage_ClrPressed (ff-pointer self)))

(cl:defmethod knob1-left1 ((self kln89-fpl-page))
  (KLN89FplPage_Knob1Left1 (ff-pointer self)))

(cl:defmethod knob1-right1 ((self kln89-fpl-page))
  (KLN89FplPage_Knob1Right1 (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-fpl-page))
  (KLN89FplPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-fpl-page))
  (KLN89FplPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod clean-up ((self kln89-fpl-page))
  (KLN89FplPage_CleanUp (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-fpl-page))
  (KLN89FplPage_LooseFocus (ff-pointer self)))

(cl:defmethod get-id ((self kln89-fpl-page))
  (KLN89FplPage_GetId (ff-pointer self)))


(cl:defclass kln89-int-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-int-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89IntPage parent)))

(cl:defmethod update ((self kln89-int-page) (dt cl:number))
  (KLN89IntPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-int-page))
  (KLN89IntPage_CrsrPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-int-page))
  (KLN89IntPage_ClrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-int-page))
  (KLN89IntPage_EntPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-int-page))
  (KLN89IntPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-int-page))
  (KLN89IntPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod set-id ((self kln89-int-page) s)
  (KLN89IntPage_SetId (ff-pointer self) s))


(cl:defclass kln89-nav-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-nav-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89NavPage parent)))

(cl:defmethod update ((self kln89-nav-page) (dt cl:number))
  (KLN89NavPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-nav-page))
  (KLN89NavPage_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-nav-page))
  (KLN89NavPage_EntPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-nav-page))
  (KLN89NavPage_ClrPressed (ff-pointer self)))

(cl:defmethod knob1-left1 ((self kln89-nav-page))
  (KLN89NavPage_Knob1Left1 (ff-pointer self)))

(cl:defmethod knob1-right1 ((self kln89-nav-page))
  (KLN89NavPage_Knob1Right1 (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-nav-page))
  (KLN89NavPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-nav-page))
  (KLN89NavPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-nav-page))
  (KLN89NavPage_LooseFocus (ff-pointer self)))

(cl:defmethod get-nav4-wp-id ((self kln89-nav-page))
  (KLN89NavPage_GetNav4WpId (ff-pointer self)))


(cl:defclass kln89-ndbpage(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-ndbpage) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89NDBPage parent)))

(cl:defmethod update ((self kln89-ndbpage) (dt cl:number))
  (KLN89NDBPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-ndbpage))
  (KLN89NDBPage_CrsrPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-ndbpage))
  (KLN89NDBPage_ClrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-ndbpage))
  (KLN89NDBPage_EntPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-ndbpage))
  (KLN89NDBPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-ndbpage))
  (KLN89NDBPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod set-id ((self kln89-ndbpage) s)
  (KLN89NDBPage_SetId (ff-pointer self) s))


(cl:defclass kln89-nrst-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-nrst-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89NrstPage parent)))

(cl:defmethod update ((self kln89-nrst-page) (dt cl:number))
  (KLN89NrstPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-nrst-page))
  (KLN89NrstPage_CrsrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-nrst-page))
  (KLN89NrstPage_EntPressed (ff-pointer self)))

(cl:defmethod loose-focus ((self kln89-nrst-page))
  (KLN89NrstPage_LooseFocus (ff-pointer self)))


(cl:defclass kln89-oth-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-oth-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89OthPage parent)))

(cl:defmethod update ((self kln89-oth-page) (dt cl:number))
  (KLN89OthPage_Update (ff-pointer self) dt))


(cl:defclass kln89-set-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-set-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89SetPage parent)))

(cl:defmethod update ((self kln89-set-page) (dt cl:number))
  (KLN89SetPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-set-page))
  (KLN89SetPage_CrsrPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-set-page))
  (KLN89SetPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-set-page))
  (KLN89SetPage_Knob2Right1 (ff-pointer self)))


(cl:defclass kln89-usr-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-usr-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89UsrPage parent)))

(cl:defmethod update ((self kln89-usr-page) (dt cl:number))
  (KLN89UsrPage_Update (ff-pointer self) dt))


(cl:defclass kln89-vor-page(KLN89Page)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj kln89-vor-page) &key (parent kln89))
  (setf (slot-value obj 'ff-pointer) (new_KLN89VorPage parent)))

(cl:defmethod update ((self kln89-vor-page) (dt cl:number))
  (KLN89VorPage_Update (ff-pointer self) dt))

(cl:defmethod crsr-pressed ((self kln89-vor-page))
  (KLN89VorPage_CrsrPressed (ff-pointer self)))

(cl:defmethod clr-pressed ((self kln89-vor-page))
  (KLN89VorPage_ClrPressed (ff-pointer self)))

(cl:defmethod ent-pressed ((self kln89-vor-page))
  (KLN89VorPage_EntPressed (ff-pointer self)))

(cl:defmethod knob2-left1 ((self kln89-vor-page))
  (KLN89VorPage_Knob2Left1 (ff-pointer self)))

(cl:defmethod knob2-right1 ((self kln89-vor-page))
  (KLN89VorPage_Knob2Right1 (ff-pointer self)))

(cl:defmethod set-id ((self kln89-vor-page) s)
  (KLN89VorPage_SetId (ff-pointer self) s))


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

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

(cl:defmethod init ((self adf))
  (ADF_init (ff-pointer self)))

(cl:defmethod update ((self adf) (delta_time_sec cl:number))
  (ADF_update (ff-pointer self) delta_time_sec))


(cl:defclass ag-radar()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj ag-radar) &key node)
  (setf (slot-value obj 'ff-pointer) (new_agRadar node)))

(cl:defmethod initialize-instance :after ((obj ag-radar) &key)
  (setf (slot-value obj 'ff-pointer) (new_agRadar)))

(cl:defmethod init ((self ag-radar))
  (agRadar_init (ff-pointer self)))

(cl:defmethod update ((self ag-radar) (dt cl:number))
  (agRadar_update (ff-pointer self) dt))

(cl:defmethod set-user-pos ((self ag-radar))
  (agRadar_setUserPos (ff-pointer self)))

(cl:defmethod set-user-vec ((self ag-radar) (az cl:number) (el cl:number))
  (agRadar_setUserVec (ff-pointer self) az el))

(cl:defmethod update-terrain ((self ag-radar))
  (agRadar_update_terrain (ff-pointer self)))

(cl:defmethod set-antenna-pos ((self ag-radar))
  (agRadar_setAntennaPos (ff-pointer self)))

(cl:defmethod get-material ((self ag-radar))
  (agRadar_getMaterial (ff-pointer self)))

(cl:defmethod (cl:setf _load_resistance) (arg0 (obj ag-radar))
  (agRadar__load_resistance_set (ff-pointer obj) arg0))

(cl:defmethod _load_resistance ((obj ag-radar))
  (agRadar__load_resistance_get (ff-pointer obj)))

(cl:defmethod (cl:setf _frictionFactor) (arg0 (obj ag-radar))
  (agRadar__frictionFactor_set (ff-pointer obj) arg0))

(cl:defmethod _frictionFactor ((obj ag-radar))
  (agRadar__frictionFactor_get (ff-pointer obj)))

(cl:defmethod (cl:setf _bumpinessFactor) (arg0 (obj ag-radar))
  (agRadar__bumpinessFactor_set (ff-pointer obj) arg0))

(cl:defmethod _bumpinessFactor ((obj ag-radar))
  (agRadar__bumpinessFactor_get (ff-pointer obj)))

(cl:defmethod (cl:setf _elevation_m) (arg0 (obj ag-radar))
  (agRadar__elevation_m_set (ff-pointer obj) arg0))

(cl:defmethod _elevation_m ((obj ag-radar))
  (agRadar__elevation_m_get (ff-pointer obj)))

(cl:defmethod (cl:setf _solid) (arg0 (obj ag-radar))
  (agRadar__solid_set (ff-pointer obj) arg0))

(cl:defmethod _solid ((obj ag-radar))
  (agRadar__solid_get (ff-pointer obj)))

(cl:defmethod (cl:setf _material) (arg0 (obj ag-radar))
  (agRadar__material_set (ff-pointer obj) arg0))

(cl:defmethod _material ((obj ag-radar))
  (agRadar__material_get (ff-pointer obj)))

(cl:defmethod (cl:setf _mat_name) (arg0 (obj ag-radar))
  (agRadar__mat_name_set (ff-pointer obj) arg0))

(cl:defmethod _mat_name ((obj ag-radar))
  (agRadar__mat_name_get (ff-pointer obj)))

(cl:defmethod get-cart-user-pos ((self ag-radar))
  (agRadar_getCartUserPos (ff-pointer self)))

(cl:defmethod get-cart-antenna-pos ((self ag-radar))
  (agRadar_getCartAntennaPos (ff-pointer self)))

(cl:defmethod (cl:setf uservec) (arg0 (obj ag-radar))
  (agRadar_uservec_set (ff-pointer obj) arg0))

(cl:defmethod uservec ((obj ag-radar))
  (agRadar_uservec_get (ff-pointer obj)))

(cl:defmethod (cl:setf _user_hdg_deg_node) (arg0 (obj ag-radar))
  (agRadar__user_hdg_deg_node_set (ff-pointer obj) arg0))

(cl:defmethod _user_hdg_deg_node ((obj ag-radar))
  (agRadar__user_hdg_deg_node_get (ff-pointer obj)))

(cl:defmethod (cl:setf _user_roll_deg_node) (arg0 (obj ag-radar))
  (agRadar__user_roll_deg_node_set (ff-pointer obj) arg0))

(cl:defmethod _user_roll_deg_node ((obj ag-radar))
  (agRadar__user_roll_deg_node_get (ff-pointer obj)))

(cl:defmethod (cl:setf _user_pitch_deg_node) (arg0 (obj ag-radar))
  (agRadar__user_pitch_deg_node_set (ff-pointer obj) arg0))

(cl:defmethod _user_pitch_deg_node ((obj ag-radar))
  (agRadar__user_pitch_deg_node_get (ff-pointer obj)))

(cl:defmethod (cl:setf _terrain_warning_node) (arg0 (obj ag-radar))
  (agRadar__terrain_warning_node_set (ff-pointer obj) arg0))

(cl:defmethod _terrain_warning_node ((obj ag-radar))
  (agRadar__terrain_warning_node_get (ff-pointer obj)))

(cl:defmethod (cl:setf _xOffsetMNode) (arg0 (obj ag-radar))
  (agRadar__xOffsetMNode_set (ff-pointer obj) arg0))

(cl:defmethod _xOffsetMNode ((obj ag-radar))
  (agRadar__xOffsetMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _yOffsetMNode) (arg0 (obj ag-radar))
  (agRadar__yOffsetMNode_set (ff-pointer obj) arg0))

(cl:defmethod _yOffsetMNode ((obj ag-radar))
  (agRadar__yOffsetMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _zOffsetMNode) (arg0 (obj ag-radar))
  (agRadar__zOffsetMNode_set (ff-pointer obj) arg0))

(cl:defmethod _zOffsetMNode ((obj ag-radar))
  (agRadar__zOffsetMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _elevLimitDegNode) (arg0 (obj ag-radar))
  (agRadar__elevLimitDegNode_set (ff-pointer obj) arg0))

(cl:defmethod _elevLimitDegNode ((obj ag-radar))
  (agRadar__elevLimitDegNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _elevStepDegNode) (arg0 (obj ag-radar))
  (agRadar__elevStepDegNode_set (ff-pointer obj) arg0))

(cl:defmethod _elevStepDegNode ((obj ag-radar))
  (agRadar__elevStepDegNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _azLimitDegNode) (arg0 (obj ag-radar))
  (agRadar__azLimitDegNode_set (ff-pointer obj) arg0))

(cl:defmethod _azLimitDegNode ((obj ag-radar))
  (agRadar__azLimitDegNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _azStepDegNode) (arg0 (obj ag-radar))
  (agRadar__azStepDegNode_set (ff-pointer obj) arg0))

(cl:defmethod _azStepDegNode ((obj ag-radar))
  (agRadar__azStepDegNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _maxRangeMNode) (arg0 (obj ag-radar))
  (agRadar__maxRangeMNode_set (ff-pointer obj) arg0))

(cl:defmethod _maxRangeMNode ((obj ag-radar))
  (agRadar__maxRangeMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _minRangeMNode) (arg0 (obj ag-radar))
  (agRadar__minRangeMNode_set (ff-pointer obj) arg0))

(cl:defmethod _minRangeMNode ((obj ag-radar))
  (agRadar__minRangeMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _tiltNode) (arg0 (obj ag-radar))
  (agRadar__tiltNode_set (ff-pointer obj) arg0))

(cl:defmethod _tiltNode ((obj ag-radar))
  (agRadar__tiltNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _brgDegNode) (arg0 (obj ag-radar))
  (agRadar__brgDegNode_set (ff-pointer obj) arg0))

(cl:defmethod _brgDegNode ((obj ag-radar))
  (agRadar__brgDegNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _rangeMNode) (arg0 (obj ag-radar))
  (agRadar__rangeMNode_set (ff-pointer obj) arg0))

(cl:defmethod _rangeMNode ((obj ag-radar))
  (agRadar__rangeMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _elevationMNode) (arg0 (obj ag-radar))
  (agRadar__elevationMNode_set (ff-pointer obj) arg0))

(cl:defmethod _elevationMNode ((obj ag-radar))
  (agRadar__elevationMNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _materialNode) (arg0 (obj ag-radar))
  (agRadar__materialNode_set (ff-pointer obj) arg0))

(cl:defmethod _materialNode ((obj ag-radar))
  (agRadar__materialNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _bumpinessNode) (arg0 (obj ag-radar))
  (agRadar__bumpinessNode_set (ff-pointer obj) arg0))

(cl:defmethod _bumpinessNode ((obj ag-radar))
  (agRadar__bumpinessNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _rollStabNode) (arg0 (obj ag-radar))
  (agRadar__rollStabNode_set (ff-pointer obj) arg0))

(cl:defmethod _rollStabNode ((obj ag-radar))
  (agRadar__rollStabNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf _pitchStabNode) (arg0 (obj ag-radar))
  (agRadar__pitchStabNode_set (ff-pointer obj) arg0))

(cl:defmethod _pitchStabNode ((obj ag-radar))
  (agRadar__pitchStabNode_get (ff-pointer obj)))

(cl:defmethod (cl:setf userpos) (arg0 (obj ag-radar))
  (agRadar_userpos_set (ff-pointer obj) arg0))

(cl:defmethod userpos ((obj ag-radar))
  (agRadar_userpos_get (ff-pointer obj)))

(cl:defmethod (cl:setf hitpos) (arg0 (obj ag-radar))
  (agRadar_hitpos_set (ff-pointer obj) arg0))

(cl:defmethod hitpos ((obj ag-radar))
  (agRadar_hitpos_get (ff-pointer obj)))

(cl:defmethod (cl:setf antennapos) (arg0 (obj ag-radar))
  (agRadar_antennapos_set (ff-pointer obj) arg0))

(cl:defmethod antennapos ((obj ag-radar))
  (agRadar_antennapos_get (ff-pointer obj)))


(cl:defclass airspeed-indicator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj airspeed-indicator) &key node)
  (setf (slot-value obj 'ff-pointer) (new_AirspeedIndicator node)))

(cl:defmethod init ((self airspeed-indicator))
  (AirspeedIndicator_init (ff-pointer self)))

(cl:defmethod update ((self airspeed-indicator) (dt cl:number))
  (AirspeedIndicator_update (ff-pointer self) dt))


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

(cl:defmethod initialize-instance :after ((obj altimeter) &key node (quantum cl:number))
  (setf (slot-value obj 'ff-pointer) (new_Altimeter node quantum)))

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

(cl:defmethod init ((self altimeter))
  (Altimeter_init (ff-pointer self)))

(cl:defmethod update ((self altimeter) (dt cl:number))
  (Altimeter_update (ff-pointer self) dt))


(cl:defclass attitude-indicator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj attitude-indicator) &key node)
  (setf (slot-value obj 'ff-pointer) (new_AttitudeIndicator node)))

(cl:defmethod init ((self attitude-indicator))
  (AttitudeIndicator_init (ff-pointer self)))

(cl:defmethod bind ((self attitude-indicator))
  (AttitudeIndicator_bind (ff-pointer self)))

(cl:defmethod unbind ((self attitude-indicator))
  (AttitudeIndicator_unbind (ff-pointer self)))

(cl:defmethod update ((self attitude-indicator) (dt cl:number))
  (AttitudeIndicator_update (ff-pointer self) dt))


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

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

(cl:defmethod init ((self clock))
  (Clock_init (ff-pointer self)))

(cl:defmethod update ((self clock) (dt cl:number))
  (Clock_update (ff-pointer self) dt))


(cl:defclass gpsflight-plan()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf waypoints) (arg0 (obj gpsflight-plan))
  (GPSFlightPlan_waypoints_set (ff-pointer obj) arg0))

(cl:defmethod waypoints ((obj gpsflight-plan))
  (GPSFlightPlan_waypoints_get (ff-pointer obj)))

(cl:defmethod is-empty ((self gpsflight-plan))
  (GPSFlightPlan_IsEmpty (ff-pointer self)))

(cl:defmethod initialize-instance :after ((obj gpsflight-plan) &key)
  (setf (slot-value obj 'ff-pointer) (new_GPSFlightPlan)))


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

(cl:defmethod (cl:setf _aptIdent) (arg0 (obj fgiap))
  (FGIAP__aptIdent_set (ff-pointer obj) arg0))

(cl:defmethod _aptIdent ((obj fgiap))
  (FGIAP__aptIdent_get (ff-pointer obj)))

(cl:defmethod (cl:setf _ident) (arg0 (obj fgiap))
  (FGIAP__ident_set (ff-pointer obj) arg0))

(cl:defmethod _ident ((obj fgiap))
  (FGIAP__ident_get (ff-pointer obj)))

(cl:defmethod (cl:setf _name) (arg0 (obj fgiap))
  (FGIAP__name_set (ff-pointer obj) arg0))

(cl:defmethod _name ((obj fgiap))
  (FGIAP__name_get (ff-pointer obj)))

(cl:defmethod (cl:setf _rwyStr) (arg0 (obj fgiap))
  (FGIAP__rwyStr_set (ff-pointer obj) arg0))

(cl:defmethod _rwyStr ((obj fgiap))
  (FGIAP__rwyStr_get (ff-pointer obj)))

(cl:defmethod (cl:setf _precision) (arg0 (obj fgiap))
  (FGIAP__precision_set (ff-pointer obj) arg0))

(cl:defmethod _precision ((obj fgiap))
  (FGIAP__precision_get (ff-pointer obj)))


(cl:defclass fgnpiap(FGIAP)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod (cl:setf _approachRoutes) (arg0 (obj fgnpiap))
  (FGNPIAP__approachRoutes_set (ff-pointer obj) arg0))

(cl:defmethod _approachRoutes ((obj fgnpiap))
  (FGNPIAP__approachRoutes_get (ff-pointer obj)))

(cl:defmethod (cl:setf _IAP) (arg0 (obj fgnpiap))
  (FGNPIAP__IAP_set (ff-pointer obj) arg0))

(cl:defmethod _IAP ((obj fgnpiap))
  (FGNPIAP__IAP_get (ff-pointer obj)))


(cl:defclass clock-time()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj clock-time) &key)
  (setf (slot-value obj 'ff-pointer) (new_ClockTime)))

(cl:defmethod initialize-instance :after ((obj clock-time) &key (hr cl:integer) (min cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_ClockTime hr min)))

(cl:defmethod set-hr ((self clock-time) (hr cl:integer))
  (ClockTime_set_hr (ff-pointer self) hr))

(cl:defmethod hr ((self clock-time))
  (ClockTime_hr (ff-pointer self)))

(cl:defmethod set-min ((self clock-time) (min cl:integer))
  (ClockTime_set_min (ff-pointer self) min))

(cl:defmethod min ((self clock-time))
  (ClockTime_min (ff-pointer self)))

(cl:shadow "+")
(cl:defmethod + ((self clock-time) (t-arg1 clock-time))
  (ClockTime___add__ (ff-pointer self) (ff-pointer t-arg1)))

(cl:shadow "-")
(cl:defmethod - ((self clock-time) (t-arg1 clock-time))
  (ClockTime___sub__ (ff-pointer self) (ff-pointer t-arg1)))


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

(cl:defmethod draw ((self dclgps) state)
  (DCLGPS_draw (ff-pointer self) state))

(cl:defmethod init ((self dclgps))
  (DCLGPS_init (ff-pointer self)))

(cl:defmethod bind ((self dclgps))
  (DCLGPS_bind (ff-pointer self)))

(cl:defmethod unbind ((self dclgps))
  (DCLGPS_unbind (ff-pointer self)))

(cl:defmethod update ((self dclgps) (dt cl:number))
  (DCLGPS_update (ff-pointer self) dt))

(cl:defmethod expand-siapident ((self dclgps) ident)
  (DCLGPS_ExpandSIAPIdent (ff-pointer self) ident))

(cl:defmethod draw-text ((self dclgps) s (field cl:integer) (px cl:integer) (py cl:integer) (bold t))
  (DCLGPS_DrawText (ff-pointer self) s field px py bold))

(cl:defmethod draw-text ((self dclgps) s (field cl:integer) (px cl:integer) (py cl:integer))
  (DCLGPS_DrawText (ff-pointer self) s field px py))

(cl:defmethod draw-char ((self dclgps) (c cl:character) (field cl:integer) (px cl:integer) (py cl:integer) (bold t))
  (DCLGPS_DrawChar (ff-pointer self) c field px py bold))

(cl:defmethod draw-char ((self dclgps) (c cl:character) (field cl:integer) (px cl:integer) (py cl:integer))
  (DCLGPS_DrawChar (ff-pointer self) c field px py))

(cl:defmethod toggle-obsmode ((self dclgps))
  (DCLGPS_ToggleOBSMode (ff-pointer self)))

(cl:defmethod set-num-fields ((self dclgps) (n cl:integer))
  (DCLGPS_SetNumFields (ff-pointer self) n))

(cl:defmethod cdifsdincrease ((self dclgps))
  (DCLGPS_CDIFSDIncrease (ff-pointer self)))

(cl:defmethod cdifsddecrease ((self dclgps))
  (DCLGPS_CDIFSDDecrease (ff-pointer self)))

(cl:defmethod create-default-flight-plans ((self dclgps))
  (DCLGPS_CreateDefaultFlightPlans (ff-pointer self)))

(cl:defmethod set-obsfrom-waypoint ((self dclgps))
  (DCLGPS_SetOBSFromWaypoint (ff-pointer self)))

(cl:defmethod get-active-waypoint ((self dclgps))
  (DCLGPS_GetActiveWaypoint (ff-pointer self)))

(cl:defmethod get-active-waypoint-index ((self dclgps))
  (DCLGPS_GetActiveWaypointIndex (ff-pointer self)))

(cl:defmethod get-waypoint-index ((self dclgps) id)
  (DCLGPS_GetWaypointIndex (ff-pointer self) id))

(cl:defmethod get-dist-to-active-waypoint ((self dclgps))
  (DCLGPS_GetDistToActiveWaypoint (ff-pointer self)))

(cl:defmethod get-heading-to-active-waypoint ((self dclgps))
  (DCLGPS_GetHeadingToActiveWaypoint (ff-pointer self)))

(cl:defmethod get-heading-from-active-waypoint ((self dclgps))
  (DCLGPS_GetHeadingFromActiveWaypoint (ff-pointer self)))

(cl:defmethod get-time-to-active-waypoint ((self dclgps))
  (DCLGPS_GetTimeToActiveWaypoint (ff-pointer self)))

(cl:defmethod get-ete ((self dclgps))
  (DCLGPS_GetETE (ff-pointer self)))

(cl:defmethod get-time-to-waypoint ((self dclgps) id)
  (DCLGPS_GetTimeToWaypoint (ff-pointer self) id))

(cl:defmethod get-waypoint-alert ((self dclgps))
  (DCLGPS_GetWaypointAlert (ff-pointer self)))

(cl:defmethod get-obsmode ((self dclgps))
  (DCLGPS_GetOBSMode (ff-pointer self)))

(cl:defmethod get-leg-mode ((self dclgps))
  (DCLGPS_GetLegMode (ff-pointer self)))

(cl:defmethod clear-flight-plan ((self dclgps) (n cl:integer))
  (DCLGPS_ClearFlightPlan (ff-pointer self) n))

(cl:defmethod clear-flight-plan ((self dclgps) (fp gpsflight-plan))
  (DCLGPS_ClearFlightPlan (ff-pointer self) fp))

(cl:defmethod approach-loaded ((self dclgps))
  (DCLGPS_ApproachLoaded (ff-pointer self)))

(cl:defmethod get-approach-arm ((self dclgps))
  (DCLGPS_GetApproachArm (ff-pointer self)))

(cl:defmethod get-approach-active ((self dclgps))
  (DCLGPS_GetApproachActive (ff-pointer self)))

(cl:defmethod get-cdideflection ((self dclgps))
  (DCLGPS_GetCDIDeflection (ff-pointer self)))

(cl:defmethod get-to-flag ((self dclgps))
  (DCLGPS_GetToFlag (ff-pointer self)))

(cl:defmethod dto-initiate ((self dclgps) id)
  (DCLGPS_DtoInitiate (ff-pointer self) id))

(cl:defmethod dto-cancel ((self dclgps))
  (DCLGPS_DtoCancel (ff-pointer self)))

(cl:defmethod reset-power-on-timer ((self dclgps))
  (DCLGPS_ResetPowerOnTimer (ff-pointer self)))

(cl:defmethod set-alarm ((self dclgps) (hr cl:integer) (min cl:integer))
  (DCLGPS_SetAlarm (ff-pointer self) hr min))


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

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

(cl:defmethod init ((self dme))
  (DME_init (ff-pointer self)))

(cl:defmethod update ((self dme) (delta_time_sec cl:number))
  (DME_update (ff-pointer self) delta_time_sec))


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

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

(cl:defmethod init ((self sggeod-property) base (lonStr cl:string) (latStr cl:string) (altStr cl:string))
  (SGGeodProperty_init (ff-pointer self) base lonStr latStr altStr))

(cl:defmethod init ((self sggeod-property) base (lonStr cl:string) (latStr cl:string))
  (SGGeodProperty_init (ff-pointer self) base lonStr latStr))

(cl:defmethod init ((self sggeod-property) (lonStr cl:string) (latStr cl:string) (altStr cl:string))
  (SGGeodProperty_init (ff-pointer self) lonStr latStr altStr))

(cl:defmethod init ((self sggeod-property) (lonStr cl:string) (latStr cl:string))
  (SGGeodProperty_init (ff-pointer self) lonStr latStr))

(cl:defmethod clear ((self sggeod-property))
  (SGGeodProperty_clear (ff-pointer self)))

(cl:shadow "=")
(cl:defmethod = ((self sggeod-property) geod)
  (SGGeodProperty___assign__ (ff-pointer self) geod))

(cl:defmethod get ((self sggeod-property))
  (SGGeodProperty_get (ff-pointer self)))


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

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

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

(cl:defmethod init ((self gps))
  (GPS_init (ff-pointer self)))

(cl:defmethod update ((self gps) (delta_time_sec cl:number))
  (GPS_update (ff-pointer self) delta_time_sec))

(cl:defmethod bind ((self gps))
  (GPS_bind (ff-pointer self)))

(cl:defmethod unbind ((self gps))
  (GPS_unbind (ff-pointer self)))

(cl:defmethod position ((self gps))
  (GPS_position (ff-pointer self)))

(cl:defmethod track-deg ((self gps))
  (GPS_trackDeg (ff-pointer self)))

(cl:defmethod ground-speed-kts ((self gps))
  (GPS_groundSpeedKts (ff-pointer self)))

(cl:defmethod vspeed-fpm ((self gps))
  (GPS_vspeedFPM (ff-pointer self)))

(cl:defmethod magvar-deg ((self gps))
  (GPS_magvarDeg (ff-pointer self)))

(cl:defmethod selected-mag-course ((self gps))
  (GPS_selectedMagCourse (ff-pointer self)))

(cl:defmethod overflight-arm-distance-m ((self gps))
  (GPS_overflightArmDistanceM (ff-pointer self)))


(cl:defclass ground-radar()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj ground-radar) &key node)
  (setf (slot-value obj 'ff-pointer) (new_GroundRadar node)))

(cl:defmethod update-texture ((self ground-radar))
  (GroundRadar_updateTexture (ff-pointer self)))

(cl:defmethod value-changed ((self ground-radar) arg1)
  (GroundRadar_valueChanged (ff-pointer self) arg1))


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

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

(cl:defmethod init ((self gsdi))
  (GSDI_init (ff-pointer self)))

(cl:defmethod update ((self gsdi) (dt cl:number))
  (GSDI_update (ff-pointer self) dt))


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

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

(cl:defmethod update ((self gyro) (delta_time_sec cl:number))
  (Gyro_update (ff-pointer self) delta_time_sec))

(cl:defmethod set-power-norm ((self gyro) (power_norm cl:number))
  (Gyro_set_power_norm (ff-pointer self) power_norm))

(cl:defmethod get-spin-norm ((self gyro))
  (Gyro_get_spin_norm (ff-pointer self)))

(cl:defmethod set-spin-norm ((self gyro) (spin_norm cl:number))
  (Gyro_set_spin_norm (ff-pointer self) spin_norm))

(cl:defmethod is-serviceable ((self gyro))
  (Gyro_is_serviceable (ff-pointer self)))

(cl:defmethod set-serviceable ((self gyro) (serviceable t))
  (Gyro_set_serviceable (ff-pointer self) serviceable))


(cl:defclass heading-indicator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj heading-indicator) &key node)
  (setf (slot-value obj 'ff-pointer) (new_HeadingIndicator node)))

(cl:defmethod initialize-instance :after ((obj heading-indicator) &key)
  (setf (slot-value obj 'ff-pointer) (new_HeadingIndicator)))

(cl:defmethod init ((self heading-indicator))
  (HeadingIndicator_init (ff-pointer self)))

(cl:defmethod bind ((self heading-indicator))
  (HeadingIndicator_bind (ff-pointer self)))

(cl:defmethod unbind ((self heading-indicator))
  (HeadingIndicator_unbind (ff-pointer self)))

(cl:defmethod update ((self heading-indicator) (dt cl:number))
  (HeadingIndicator_update (ff-pointer self) dt))


(cl:defclass heading-indicator-dg()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj heading-indicator-dg) &key node)
  (setf (slot-value obj 'ff-pointer) (new_HeadingIndicatorDG node)))

(cl:defmethod initialize-instance :after ((obj heading-indicator-dg) &key)
  (setf (slot-value obj 'ff-pointer) (new_HeadingIndicatorDG)))

(cl:defmethod init ((self heading-indicator-dg))
  (HeadingIndicatorDG_init (ff-pointer self)))

(cl:defmethod bind ((self heading-indicator-dg))
  (HeadingIndicatorDG_bind (ff-pointer self)))

(cl:defmethod unbind ((self heading-indicator-dg))
  (HeadingIndicatorDG_unbind (ff-pointer self)))

(cl:defmethod update ((self heading-indicator-dg) (dt cl:number))
  (HeadingIndicatorDG_update (ff-pointer self) dt))


(cl:defclass heading-indicator-fg()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj heading-indicator-fg) &key node)
  (setf (slot-value obj 'ff-pointer) (new_HeadingIndicatorFG node)))

(cl:defmethod initialize-instance :after ((obj heading-indicator-fg) &key)
  (setf (slot-value obj 'ff-pointer) (new_HeadingIndicatorFG)))

(cl:defmethod init ((self heading-indicator-fg))
  (HeadingIndicatorFG_init (ff-pointer self)))

(cl:defmethod bind ((self heading-indicator-fg))
  (HeadingIndicatorFG_bind (ff-pointer self)))

(cl:defmethod unbind ((self heading-indicator-fg))
  (HeadingIndicatorFG_unbind (ff-pointer self)))

(cl:defmethod update ((self heading-indicator-fg) (dt cl:number))
  (HeadingIndicatorFG_update (ff-pointer self) dt))


(cl:defclass inst-vertical-speed-indicator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj inst-vertical-speed-indicator) &key node)
  (setf (slot-value obj 'ff-pointer) (new_InstVerticalSpeedIndicator node)))

(cl:defmethod init ((self inst-vertical-speed-indicator))
  (InstVerticalSpeedIndicator_init (ff-pointer self)))

(cl:defmethod update ((self inst-vertical-speed-indicator) (dt cl:number))
  (InstVerticalSpeedIndicator_update (ff-pointer self) dt))


(cl:defclass fginstrument-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fginstrument-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGInstrumentMgr)))

(cl:defmethod init ((self fginstrument-mgr))
  (FGInstrumentMgr_init (ff-pointer self)))

(cl:defmethod reinit ((self fginstrument-mgr))
  (FGInstrumentMgr_reinit (ff-pointer self)))


(cl:defclass fgkr-87()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgkr-87) &key node)
  (setf (slot-value obj 'ff-pointer) (new_FGKR_87 node)))

(cl:defmethod init ((self fgkr-87))
  (FGKR_87_init (ff-pointer self)))

(cl:defmethod bind ((self fgkr-87))
  (FGKR_87_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgkr-87))
  (FGKR_87_unbind (ff-pointer self)))

(cl:defmethod update ((self fgkr-87) (dt_sec cl:number))
  (FGKR_87_update (ff-pointer self) dt_sec))

(cl:defmethod search ((self fgkr-87))
  (FGKR_87_search (ff-pointer self)))

(cl:defmethod get-ident ((self fgkr-87))
  (FGKR_87_get_ident (ff-pointer self)))

(cl:defmethod get-valid ((self fgkr-87))
  (FGKR_87_get_valid (ff-pointer self)))

(cl:defmethod get-inrange ((self fgkr-87))
  (FGKR_87_get_inrange (ff-pointer self)))

(cl:defmethod get-stn-lon ((self fgkr-87))
  (FGKR_87_get_stn_lon (ff-pointer self)))

(cl:defmethod get-stn-lat ((self fgkr-87))
  (FGKR_87_get_stn_lat (ff-pointer self)))

(cl:defmethod get-dist ((self fgkr-87))
  (FGKR_87_get_dist (ff-pointer self)))

(cl:defmethod get-heading ((self fgkr-87))
  (FGKR_87_get_heading (ff-pointer self)))

(cl:defmethod has-power ((self fgkr-87))
  (FGKR_87_has_power (ff-pointer self)))

(cl:defmethod get-ant-mode ((self fgkr-87))
  (FGKR_87_get_ant_mode (ff-pointer self)))

(cl:defmethod get-stby-mode ((self fgkr-87))
  (FGKR_87_get_stby_mode (ff-pointer self)))

(cl:defmethod get-timer-mode ((self fgkr-87))
  (FGKR_87_get_timer_mode (ff-pointer self)))

(cl:defmethod get-count-mode ((self fgkr-87))
  (FGKR_87_get_count_mode (ff-pointer self)))

(cl:defmethod get-rotation ((self fgkr-87))
  (FGKR_87_get_rotation (ff-pointer self)))

(cl:defmethod set-rotation ((self fgkr-87) (rot cl:number))
  (FGKR_87_set_rotation (ff-pointer self) rot))

(cl:defmethod get-power-btn ((self fgkr-87))
  (FGKR_87_get_power_btn (ff-pointer self)))

(cl:defmethod set-power-btn ((self fgkr-87) (val t))
  (FGKR_87_set_power_btn (ff-pointer self) val))

(cl:defmethod get-audio-btn ((self fgkr-87))
  (FGKR_87_get_audio_btn (ff-pointer self)))

(cl:defmethod set-audio-btn ((self fgkr-87) (val t))
  (FGKR_87_set_audio_btn (ff-pointer self) val))

(cl:defmethod get-vol-btn ((self fgkr-87))
  (FGKR_87_get_vol_btn (ff-pointer self)))

(cl:defmethod set-vol-btn ((self fgkr-87) (val cl:number))
  (FGKR_87_set_vol_btn (ff-pointer self) val))

(cl:defmethod get-adf-btn ((self fgkr-87))
  (FGKR_87_get_adf_btn (ff-pointer self)))

(cl:defmethod set-adf-btn ((self fgkr-87) (val t))
  (FGKR_87_set_adf_btn (ff-pointer self) val))

(cl:defmethod get-bfo-btn ((self fgkr-87))
  (FGKR_87_get_bfo_btn (ff-pointer self)))

(cl:defmethod set-bfo-btn ((self fgkr-87) (val t))
  (FGKR_87_set_bfo_btn (ff-pointer self) val))

(cl:defmethod get-frq-btn ((self fgkr-87))
  (FGKR_87_get_frq_btn (ff-pointer self)))

(cl:defmethod set-frq-btn ((self fgkr-87) (val t))
  (FGKR_87_set_frq_btn (ff-pointer self) val))

(cl:defmethod get-flt-et-btn ((self fgkr-87))
  (FGKR_87_get_flt_et_btn (ff-pointer self)))

(cl:defmethod set-flt-et-btn ((self fgkr-87) (val t))
  (FGKR_87_set_flt_et_btn (ff-pointer self) val))

(cl:defmethod get-set-rst-btn ((self fgkr-87))
  (FGKR_87_get_set_rst_btn (ff-pointer self)))

(cl:defmethod set-set-rst-btn ((self fgkr-87) (val t))
  (FGKR_87_set_set_rst_btn (ff-pointer self) val))

(cl:defmethod get-freq ((self fgkr-87))
  (FGKR_87_get_freq (ff-pointer self)))

(cl:defmethod set-freq ((self fgkr-87) (f cl:integer))
  (FGKR_87_set_freq (ff-pointer self) f))

(cl:defmethod get-stby-freq ((self fgkr-87))
  (FGKR_87_get_stby_freq (ff-pointer self)))

(cl:defmethod set-stby-freq ((self fgkr-87) (f cl:integer))
  (FGKR_87_set_stby_freq (ff-pointer self) f))

(cl:defmethod get-needle-deg ((self fgkr-87))
  (FGKR_87_get_needle_deg (ff-pointer self)))

(cl:defmethod get-flight-timer ((self fgkr-87))
  (FGKR_87_get_flight_timer (ff-pointer self)))

(cl:defmethod get-elapsed-timer ((self fgkr-87))
  (FGKR_87_get_elapsed_timer (ff-pointer self)))

(cl:defmethod set-elapsed-timer ((self fgkr-87) (val cl:number))
  (FGKR_87_set_elapsed_timer (ff-pointer self) val))

(cl:defmethod get-ant-ann ((self fgkr-87))
  (FGKR_87_get_ant_ann (ff-pointer self)))

(cl:defmethod get-adf-ann ((self fgkr-87))
  (FGKR_87_get_adf_ann (ff-pointer self)))

(cl:defmethod get-bfo-ann ((self fgkr-87))
  (FGKR_87_get_bfo_ann (ff-pointer self)))

(cl:defmethod get-frq-ann ((self fgkr-87))
  (FGKR_87_get_frq_ann (ff-pointer self)))

(cl:defmethod get-flt-ann ((self fgkr-87))
  (FGKR_87_get_flt_ann (ff-pointer self)))

(cl:defmethod get-et-ann ((self fgkr-87))
  (FGKR_87_get_et_ann (ff-pointer self)))


(cl:defclass fgkt-70()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgkt-70) &key node)
  (setf (slot-value obj 'ff-pointer) (new_FGKT_70 node)))

(cl:defmethod init ((self fgkt-70))
  (FGKT_70_init (ff-pointer self)))

(cl:defmethod bind ((self fgkt-70))
  (FGKT_70_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgkt-70))
  (FGKT_70_unbind (ff-pointer self)))

(cl:defmethod update ((self fgkt-70) (dt cl:number))
  (FGKT_70_update (ff-pointer self) dt))

(cl:defmethod search ((self fgkt-70))
  (FGKT_70_search (ff-pointer self)))

(cl:defmethod has-power ((self fgkt-70))
  (FGKT_70_has_power (ff-pointer self)))

(cl:defmethod get-ident-btn ((self fgkt-70))
  (FGKT_70_get_ident_btn (ff-pointer self)))

(cl:defmethod set-ident-btn ((self fgkt-70) (val t))
  (FGKT_70_set_ident_btn (ff-pointer self) val))

(cl:defmethod get-digit1 ((self fgkt-70))
  (FGKT_70_get_digit1 (ff-pointer self)))

(cl:defmethod set-digit1 ((self fgkt-70) (val cl:integer))
  (FGKT_70_set_digit1 (ff-pointer self) val))

(cl:defmethod get-digit2 ((self fgkt-70))
  (FGKT_70_get_digit2 (ff-pointer self)))

(cl:defmethod set-digit2 ((self fgkt-70) (val cl:integer))
  (FGKT_70_set_digit2 (ff-pointer self) val))

(cl:defmethod get-digit3 ((self fgkt-70))
  (FGKT_70_get_digit3 (ff-pointer self)))

(cl:defmethod set-digit3 ((self fgkt-70) (val cl:integer))
  (FGKT_70_set_digit3 (ff-pointer self) val))

(cl:defmethod get-digit4 ((self fgkt-70))
  (FGKT_70_get_digit4 (ff-pointer self)))

(cl:defmethod set-digit4 ((self fgkt-70) (val cl:integer))
  (FGKT_70_set_digit4 (ff-pointer self) val))

(cl:defmethod get-func-knob ((self fgkt-70))
  (FGKT_70_get_func_knob (ff-pointer self)))

(cl:defmethod set-func-knob ((self fgkt-70) (val cl:integer))
  (FGKT_70_set_func_knob (ff-pointer self) val))

(cl:defmethod get-id-code ((self fgkt-70))
  (FGKT_70_get_id_code (ff-pointer self)))

(cl:defmethod set-id-code ((self fgkt-70) (c cl:integer))
  (FGKT_70_set_id_code (ff-pointer self) c))

(cl:defmethod get-flight-level ((self fgkt-70))
  (FGKT_70_get_flight_level (ff-pointer self)))

(cl:defmethod get-fl-ann ((self fgkt-70))
  (FGKT_70_get_fl_ann (ff-pointer self)))

(cl:defmethod get-alt-ann ((self fgkt-70))
  (FGKT_70_get_alt_ann (ff-pointer self)))

(cl:defmethod get-gnd-ann ((self fgkt-70))
  (FGKT_70_get_gnd_ann (ff-pointer self)))

(cl:defmethod get-on-ann ((self fgkt-70))
  (FGKT_70_get_on_ann (ff-pointer self)))

(cl:defmethod get-sby-ann ((self fgkt-70))
  (FGKT_70_get_sby_ann (ff-pointer self)))

(cl:defmethod get-reply-ann ((self fgkt-70))
  (FGKT_70_get_reply_ann (ff-pointer self)))


(cl:defclass mag-compass()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj mag-compass) &key node)
  (setf (slot-value obj 'ff-pointer) (new_MagCompass node)))

(cl:defmethod initialize-instance :after ((obj mag-compass) &key)
  (setf (slot-value obj 'ff-pointer) (new_MagCompass)))

(cl:defmethod init ((self mag-compass))
  (MagCompass_init (ff-pointer self)))

(cl:defmethod update ((self mag-compass) (dt cl:number))
  (MagCompass_update (ff-pointer self) dt))


(cl:defclass fgmarker-beacon()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgmarker-beacon) &key node)
  (setf (slot-value obj 'ff-pointer) (new_FGMarkerBeacon node)))

(cl:defmethod init ((self fgmarker-beacon))
  (FGMarkerBeacon_init (ff-pointer self)))

(cl:defmethod bind ((self fgmarker-beacon))
  (FGMarkerBeacon_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgmarker-beacon))
  (FGMarkerBeacon_unbind (ff-pointer self)))

(cl:defmethod update ((self fgmarker-beacon) (dt cl:number))
  (FGMarkerBeacon_update (ff-pointer self) dt))

(cl:defmethod search ((self fgmarker-beacon))
  (FGMarkerBeacon_search (ff-pointer self)))

(cl:defmethod get-inner-blink ((self fgmarker-beacon))
  (FGMarkerBeacon_get_inner_blink (ff-pointer self)))

(cl:defmethod get-middle-blink ((self fgmarker-beacon))
  (FGMarkerBeacon_get_middle_blink (ff-pointer self)))

(cl:defmethod get-outer-blink ((self fgmarker-beacon))
  (FGMarkerBeacon_get_outer_blink (ff-pointer self)))

(cl:defmethod has-power ((self fgmarker-beacon))
  (FGMarkerBeacon_has_power (ff-pointer self)))


(cl:defclass master-reference-gyro()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj master-reference-gyro) &key node)
  (setf (slot-value obj 'ff-pointer) (new_MasterReferenceGyro node)))

(cl:defmethod initialize-instance :after ((obj master-reference-gyro) &key)
  (setf (slot-value obj 'ff-pointer) (new_MasterReferenceGyro)))

(cl:defmethod init ((self master-reference-gyro))
  (MasterReferenceGyro_init (ff-pointer self)))

(cl:defmethod bind ((self master-reference-gyro))
  (MasterReferenceGyro_bind (ff-pointer self)))

(cl:defmethod unbind ((self master-reference-gyro))
  (MasterReferenceGyro_unbind (ff-pointer self)))

(cl:defmethod update ((self master-reference-gyro) (dt cl:number))
  (MasterReferenceGyro_update (ff-pointer self) dt))


(cl:defclass fgnav-radio()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnav-radio) &key node)
  (setf (slot-value obj 'ff-pointer) (new_FGNavRadio node)))

(cl:defmethod init ((self fgnav-radio))
  (FGNavRadio_init (ff-pointer self)))

(cl:defmethod bind ((self fgnav-radio))
  (FGNavRadio_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgnav-radio))
  (FGNavRadio_unbind (ff-pointer self)))

(cl:defmethod update ((self fgnav-radio) (dt cl:number))
  (FGNavRadio_update (ff-pointer self) dt))

(cl:defmethod search ((self fgnav-radio))
  (FGNavRadio_search (ff-pointer self)))


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

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

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

(cl:defmethod init ((self fgodgauge))
  (FGODGauge_init (ff-pointer self)))

(cl:defmethod update ((self fgodgauge) (dt cl:number))
  (FGODGauge_update (ff-pointer self) dt))

(cl:defmethod set-size ((self fgodgauge) (viewSize cl:integer))
  (FGODGauge_setSize (ff-pointer self) viewSize))

(cl:defmethod serviceable ((self fgodgauge))
  (FGODGauge_serviceable (ff-pointer self)))

(cl:defmethod set-texture ((self fgodgauge) (name cl:string) new_texture)
  (FGODGauge_set_texture (ff-pointer self) name new_texture))

(cl:defmethod get-camera ((self fgodgauge))
  (FGODGauge_getCamera (ff-pointer self)))

(cl:defmethod get-texture ((self fgodgauge))
  (FGODGauge_getTexture (ff-pointer self)))

(cl:defmethod set-texture ((self fgodgauge) t-arg1)
  (FGODGauge_setTexture (ff-pointer self) t-arg1))

(cl:defmethod alloc-rt ((self fgodgauge))
  (FGODGauge_allocRT (ff-pointer self)))


(cl:defclass rad-alt(agRadar)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj rad-alt) &key node)
  (setf (slot-value obj 'ff-pointer) (new_radAlt node)))

(cl:defmethod initialize-instance :after ((obj rad-alt) &key)
  (setf (slot-value obj 'ff-pointer) (new_radAlt)))


(cl:defclass render-area2-d()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj render-area2-d) &key (logx cl:integer) (logy cl:integer) (sizex cl:integer) (sizey cl:integer) (posx cl:integer) (posy cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_RenderArea2D logx logy sizex sizey posx posy)))

(cl:defmethod set-pixel-color ((self render-area2-d) rgba)
  (RenderArea2D_SetPixelColor (ff-pointer self) rgba))

(cl:defmethod set-background-color ((self render-area2-d) rgba)
  (RenderArea2D_SetBackgroundColor (ff-pointer self) rgba))

(cl:defmethod set-position ((self render-area2-d) (posx cl:integer) (posy cl:integer))
  (RenderArea2D_SetPosition (ff-pointer self) posx posy))

(cl:defmethod set-logical-size ((self render-area2-d) (logx cl:integer) (logy cl:integer))
  (RenderArea2D_SetLogicalSize (ff-pointer self) logx logy))

(cl:defmethod set-actual-size ((self render-area2-d) (sizex cl:integer) (sizey cl:integer))
  (RenderArea2D_SetActualSize (ff-pointer self) sizex sizey))

(cl:defmethod set-clip-region ((self render-area2-d) (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer))
  (RenderArea2D_SetClipRegion (ff-pointer self) x1 y1 x2 y2))

(cl:defmethod reset-clip-region ((self render-area2-d))
  (RenderArea2D_ResetClipRegion (ff-pointer self)))

(cl:defmethod draw-pixel ((self render-area2-d) (x cl:integer) (y cl:integer) (invert t))
  (RenderArea2D_DrawPixel (ff-pointer self) x y invert))

(cl:defmethod draw-pixel ((self render-area2-d) (x cl:integer) (y cl:integer))
  (RenderArea2D_DrawPixel (ff-pointer self) x y))

(cl:defmethod draw-line ((self render-area2-d) (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer))
  (RenderArea2D_DrawLine (ff-pointer self) x1 y1 x2 y2))

(cl:defmethod draw-quad ((self render-area2-d) (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer) (invert t))
  (RenderArea2D_DrawQuad (ff-pointer self) x1 y1 x2 y2 invert))

(cl:defmethod draw-quad ((self render-area2-d) (x1 cl:integer) (y1 cl:integer) (x2 cl:integer) (y2 cl:integer))
  (RenderArea2D_DrawQuad (ff-pointer self) x1 y1 x2 y2))

(cl:defmethod draw-background ((self render-area2-d))
  (RenderArea2D_DrawBackground (ff-pointer self)))

(cl:defmethod draw ((self render-area2-d) state)
  (RenderArea2D_Draw (ff-pointer self) state))

(cl:defmethod flush ((self render-area2-d))
  (RenderArea2D_Flush (ff-pointer self)))

(cl:defmethod set-debugging ((self render-area2-d) (b t))
  (RenderArea2D_SetDebugging (ff-pointer self) b))


(cl:defclass slip-skid-ball()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj slip-skid-ball) &key node)
  (setf (slot-value obj 'ff-pointer) (new_SlipSkidBall node)))

(cl:defmethod init ((self slip-skid-ball))
  (SlipSkidBall_init (ff-pointer self)))

(cl:defmethod update ((self slip-skid-ball) (dt cl:number))
  (SlipSkidBall_update (ff-pointer self) dt))


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

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

(cl:defmethod init ((self tacan))
  (TACAN_init (ff-pointer self)))

(cl:defmethod update ((self tacan) (delta_time_sec cl:number))
  (TACAN_update (ff-pointer self) delta_time_sec))


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

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

(cl:defmethod init ((self transponder))
  (Transponder_init (ff-pointer self)))

(cl:defmethod update ((self transponder) (dt cl:number))
  (Transponder_update (ff-pointer self) dt))


(cl:defclass turn-indicator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj turn-indicator) &key node)
  (setf (slot-value obj 'ff-pointer) (new_TurnIndicator node)))

(cl:defmethod init ((self turn-indicator))
  (TurnIndicator_init (ff-pointer self)))

(cl:defmethod bind ((self turn-indicator))
  (TurnIndicator_bind (ff-pointer self)))

(cl:defmethod unbind ((self turn-indicator))
  (TurnIndicator_unbind (ff-pointer self)))

(cl:defmethod update ((self turn-indicator) (dt cl:number))
  (TurnIndicator_update (ff-pointer self) dt))


(cl:defclass vertical-speed-indicator()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj vertical-speed-indicator) &key node)
  (setf (slot-value obj 'ff-pointer) (new_VerticalSpeedIndicator node)))

(cl:defmethod init ((self vertical-speed-indicator))
  (VerticalSpeedIndicator_init (ff-pointer self)))

(cl:defmethod update ((self vertical-speed-indicator) (dt cl:number))
  (VerticalSpeedIndicator_update (ff-pointer self) dt))


(cl:defclass wx-radar-bg()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj wx-radar-bg) &key node)
  (setf (slot-value obj 'ff-pointer) (new_wxRadarBg node)))

(cl:defmethod initialize-instance :after ((obj wx-radar-bg) &key)
  (setf (slot-value obj 'ff-pointer) (new_wxRadarBg)))

(cl:defmethod init ((self wx-radar-bg))
  (wxRadarBg_init (ff-pointer self)))

(cl:defmethod update ((self wx-radar-bg) (dt cl:number))
  (wxRadarBg_update (ff-pointer self) dt))

(cl:defmethod value-changed ((self wx-radar-bg) arg1)
  (wxRadarBg_valueChanged (ff-pointer self) arg1))


(cl:defclass camera-group()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj camera-group) &key viewer)
  (setf (slot-value obj 'ff-pointer) (new_CameraGroup viewer)))

(cl:defmethod get-viewer ((self camera-group))
  (CameraGroup_getViewer (ff-pointer self)))

(cl:defmethod add-camera ((self camera-group) (flags cl:integer) camera projection view (useMasterSceneData t))
  (CameraGroup_addCamera (ff-pointer self) flags camera projection view useMasterSceneData))

(cl:defmethod add-camera ((self camera-group) (flags cl:integer) camera projection view)
  (CameraGroup_addCamera (ff-pointer self) flags camera projection view))

(cl:defmethod build-camera ((self camera-group) cameraNode)
  (CameraGroup_buildCamera (ff-pointer self) cameraNode))

(cl:defmethod build-guicamera ((self camera-group) cameraNode window)
  (CameraGroup_buildGUICamera (ff-pointer self) cameraNode window))

(cl:defmethod build-guicamera ((self camera-group) cameraNode)
  (CameraGroup_buildGUICamera (ff-pointer self) cameraNode))

(cl:defmethod update ((self camera-group) position orientation)
  (CameraGroup_update (ff-pointer self) position orientation))

(cl:defmethod set-camera-parameters ((self camera-group) (vfov cl:number) (aspectRatio cl:number))
  (CameraGroup_setCameraParameters (ff-pointer self) vfov aspectRatio))

(cl:defmethod cameras-begin ((self camera-group))
  (CameraGroup_camerasBegin (ff-pointer self)))

(cl:defmethod cameras-end ((self camera-group))
  (CameraGroup_camerasEnd (ff-pointer self)))

(cl:defmethod cameras-begin ((self camera-group))
  (CameraGroup_camerasBegin (ff-pointer self)))

(cl:defmethod cameras-end ((self camera-group))
  (CameraGroup_camerasEnd (ff-pointer self)))

(cl:defmethod set-camera-cull-masks ((self camera-group) nm)
  (CameraGroup_setCameraCullMasks (ff-pointer self) nm))

(cl:defmethod resized ((self camera-group))
  (CameraGroup_resized (ff-pointer self)))

(cl:defmethod build-distortion-camera ((self camera-group) psNode camera)
  (CameraGroup_buildDistortionCamera (ff-pointer self) psNode camera))


(cl:defclass fgevent-handler()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgevent-handler) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGEventHandler)))

(cl:defmethod class-name ((self fgevent-handler))
  (FGEventHandler_className (ff-pointer self)))

(cl:defmethod handle ((self fgevent-handler) ea us)
  (FGEventHandler_handle (ff-pointer self) ea us))

(cl:defmethod set-idle-handler ((self fgevent-handler) idleHandler)
  (FGEventHandler_setIdleHandler (ff-pointer self) idleHandler))

(cl:defmethod get-idle-handler ((self fgevent-handler))
  (FGEventHandler_getIdleHandler (ff-pointer self)))

(cl:defmethod set-draw-handler ((self fgevent-handler) drawHandler)
  (FGEventHandler_setDrawHandler (ff-pointer self) drawHandler))

(cl:defmethod get-draw-handler ((self fgevent-handler))
  (FGEventHandler_getDrawHandler (ff-pointer self)))

(cl:defmethod set-window-resize-handler ((self fgevent-handler) windowResizeHandler)
  (FGEventHandler_setWindowResizeHandler (ff-pointer self) windowResizeHandler))

(cl:defmethod get-window-resize-handler ((self fgevent-handler))
  (FGEventHandler_getWindowResizeHandler (ff-pointer self)))

(cl:defmethod set-key-handler ((self fgevent-handler) keyHandler)
  (FGEventHandler_setKeyHandler (ff-pointer self) keyHandler))

(cl:defmethod get-key-handler ((self fgevent-handler))
  (FGEventHandler_getKeyHandler (ff-pointer self)))

(cl:defmethod set-mouse-click-handler ((self fgevent-handler) mouseClickHandler)
  (FGEventHandler_setMouseClickHandler (ff-pointer self) mouseClickHandler))

(cl:defmethod get-mouse-click-handler ((self fgevent-handler))
  (FGEventHandler_getMouseClickHandler (ff-pointer self)))

(cl:defmethod set-mouse-motion-handler ((self fgevent-handler) mouseMotionHandler)
  (FGEventHandler_setMouseMotionHandler (ff-pointer self) mouseMotionHandler))

(cl:defmethod get-mouse-motion-handler ((self fgevent-handler))
  (FGEventHandler_getMouseMotionHandler (ff-pointer self)))

(cl:defmethod get-current-modifiers ((self fgevent-handler))
  (FGEventHandler_getCurrentModifiers (ff-pointer self)))

(cl:defmethod set-mouse-warped ((self fgevent-handler))
  (FGEventHandler_setMouseWarped (ff-pointer self)))

(cl:defmethod get-resizable ((self fgevent-handler))
  (FGEventHandler_getResizable (ff-pointer self)))

(cl:defmethod set-resizable ((self fgevent-handler) (_resizable t))
  (FGEventHandler_setResizable (ff-pointer self) _resizable))


(cl:defclass window-builder()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod build-window ((self window-builder) winNode)
  (WindowBuilder_buildWindow (ff-pointer self) winNode))

(cl:defmethod get-default-window ((self window-builder))
  (WindowBuilder_getDefaultWindow (ff-pointer self)))

(cl:defmethod get-default-window-name ((self window-builder))
  (WindowBuilder_getDefaultWindowName (ff-pointer self)))


(cl:defclass graphics-window()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj graphics-window) &key gc_ name_ (id_ cl:integer) (flags_ cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_GraphicsWindow gc_ name_ id_ flags_)))

(cl:defmethod initialize-instance :after ((obj graphics-window) &key gc_ name_ (id_ cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_GraphicsWindow gc_ name_ id_)))

(cl:defmethod (cl:setf gc) (arg0 (obj graphics-window))
  (GraphicsWindow_gc_set (ff-pointer obj) arg0))

(cl:defmethod gc ((obj graphics-window))
  (GraphicsWindow_gc_get (ff-pointer obj)))

(cl:defmethod (cl:setf name) (arg0 (obj graphics-window))
  (GraphicsWindow_name_set (ff-pointer obj) arg0))

(cl:defmethod name ((obj graphics-window))
  (GraphicsWindow_name_get (ff-pointer obj)))

(cl:defmethod (cl:setf id) (arg0 (obj graphics-window))
  (GraphicsWindow_id_set (ff-pointer obj) arg0))

(cl:defmethod id ((obj graphics-window))
  (GraphicsWindow_id_get (ff-pointer obj)))

(cl:defmethod (cl:setf flags) (arg0 (obj graphics-window))
  (GraphicsWindow_flags_set (ff-pointer obj) arg0))

(cl:defmethod flags ((obj graphics-window))
  (GraphicsWindow_flags_get (ff-pointer obj)))


(cl:defclass graphics-context-operation()
  ((ff-pointer :reader ff-pointer)))

(cl:shadow "()")
(cl:defmethod () ((self graphics-context-operation) gc)
  (GraphicsContextOperation___funcall__ (ff-pointer self) gc))

(cl:defmethod run ((self graphics-context-operation) gc)
  (GraphicsContextOperation_run (ff-pointer self) gc))

(cl:defmethod is-finished ((self graphics-context-operation))
  (GraphicsContextOperation_isFinished (ff-pointer self)))


(cl:defclass window-system-adapter()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj window-system-adapter) &key)
  (setf (slot-value obj 'ff-pointer) (new_WindowSystemAdapter)))

(cl:defmethod (cl:setf windows) (arg0 (obj window-system-adapter))
  (WindowSystemAdapter_windows_set (ff-pointer obj) arg0))

(cl:defmethod windows ((obj window-system-adapter))
  (WindowSystemAdapter_windows_get (ff-pointer obj)))

(cl:defmethod register-window ((self window-system-adapter) gc windowName)
  (WindowSystemAdapter_registerWindow (ff-pointer self) gc windowName))

(cl:defmethod pu-initialize ((self window-system-adapter))
  (WindowSystemAdapter_puInitialize (ff-pointer self)))

(cl:defmethod find-window ((self window-system-adapter) name)
  (WindowSystemAdapter_findWindow (ff-pointer self) name))


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

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

(cl:defmethod init ((self fgio))
  (FGIO_init (ff-pointer self)))

(cl:defmethod reinit ((self fgio))
  (FGIO_reinit (ff-pointer self)))

(cl:defmethod bind ((self fgio))
  (FGIO_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgio))
  (FGIO_unbind (ff-pointer self)))

(cl:defmethod update ((self fgio) (dt cl:number))
  (FGIO_update (ff-pointer self) dt))

(cl:defmethod shutdown ((self fgio))
  (FGIO_shutdown (ff-pointer self)))


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

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

(cl:defmethod get-renderer ((self fgglobals))
  (FGGlobals_get_renderer (ff-pointer self)))

(cl:defmethod get-subsystem-mgr ((self fgglobals))
  (FGGlobals_get_subsystem_mgr (ff-pointer self)))

(cl:defmethod get-subsystem ((self fgglobals) (name cl:string))
  (FGGlobals_get_subsystem (ff-pointer self) name))

(cl:defmethod add-subsystem ((self fgglobals) (name cl:string) subsystem type (min_time_sec cl:number))
  (FGGlobals_add_subsystem (ff-pointer self) name subsystem type min_time_sec))

(cl:defmethod add-subsystem ((self fgglobals) (name cl:string) subsystem type)
  (FGGlobals_add_subsystem (ff-pointer self) name subsystem type))

(cl:defmethod add-subsystem ((self fgglobals) (name cl:string) subsystem)
  (FGGlobals_add_subsystem (ff-pointer self) name subsystem))

(cl:defmethod get-event-mgr ((self fgglobals))
  (FGGlobals_get_event_mgr (ff-pointer self)))

(cl:defmethod get-soundmgr ((self fgglobals))
  (FGGlobals_get_soundmgr (ff-pointer self)))

(cl:defmethod get-sim-time-sec ((self fgglobals))
  (FGGlobals_get_sim_time_sec (ff-pointer self)))

(cl:defmethod inc-sim-time-sec ((self fgglobals) (dt cl:number))
  (FGGlobals_inc_sim_time_sec (ff-pointer self) dt))

(cl:defmethod set-sim-time-sec ((self fgglobals) (t-arg1 cl:number))
  (FGGlobals_set_sim_time_sec (ff-pointer self) t-arg1))

(cl:defmethod get-fg-root ((self fgglobals))
  (FGGlobals_get_fg_root (ff-pointer self)))

(cl:defmethod set-fg-root ((self fgglobals) root)
  (FGGlobals_set_fg_root (ff-pointer self) root))

(cl:defmethod get-fg-scenery ((self fgglobals))
  (FGGlobals_get_fg_scenery (ff-pointer self)))

(cl:defmethod set-fg-scenery ((self fgglobals) scenery)
  (FGGlobals_set_fg_scenery (ff-pointer self) scenery))

(cl:defmethod get-aircraft-paths ((self fgglobals))
  (FGGlobals_get_aircraft_paths (ff-pointer self)))

(cl:defmethod append-aircraft-path ((self fgglobals) path)
  (FGGlobals_append_aircraft_path (ff-pointer self) path))

(cl:defmethod append-aircraft-paths ((self fgglobals) path)
  (FGGlobals_append_aircraft_paths (ff-pointer self) path))

(cl:defmethod resolve-aircraft-path ((self fgglobals) branch)
  (FGGlobals_resolve_aircraft_path (ff-pointer self) branch))

(cl:defmethod resolve-maybe-aircraft-path ((self fgglobals) branch)
  (FGGlobals_resolve_maybe_aircraft_path (ff-pointer self) branch))

(cl:defmethod get-browser ((self fgglobals))
  (FGGlobals_get_browser (ff-pointer self)))

(cl:defmethod set-browser ((self fgglobals) b)
  (FGGlobals_set_browser (ff-pointer self) b))

(cl:defmethod get-warp ((self fgglobals))
  (FGGlobals_get_warp (ff-pointer self)))

(cl:defmethod set-warp ((self fgglobals) (w cl:integer))
  (FGGlobals_set_warp (ff-pointer self) w))

(cl:defmethod get-warp-delta ((self fgglobals))
  (FGGlobals_get_warp_delta (ff-pointer self)))

(cl:defmethod set-warp-delta ((self fgglobals) (d cl:integer))
  (FGGlobals_set_warp_delta (ff-pointer self) d))

(cl:defmethod get-time-params ((self fgglobals))
  (FGGlobals_get_time_params (ff-pointer self)))

(cl:defmethod set-time-params ((self fgglobals) t-arg1)
  (FGGlobals_set_time_params (ff-pointer self) t-arg1))

(cl:defmethod get-ephem ((self fgglobals))
  (FGGlobals_get_ephem (ff-pointer self)))

(cl:defmethod set-ephem ((self fgglobals) e)
  (FGGlobals_set_ephem (ff-pointer self) e))

(cl:defmethod get-mag ((self fgglobals))
  (FGGlobals_get_mag (ff-pointer self)))

(cl:defmethod set-mag ((self fgglobals) m)
  (FGGlobals_set_mag (ff-pointer self) m))

(cl:defmethod get-matlib ((self fgglobals))
  (FGGlobals_get_matlib (ff-pointer self)))

(cl:defmethod set-matlib ((self fgglobals) m)
  (FGGlobals_set_matlib (ff-pointer self) m))

(cl:defmethod get-atc-mgr ((self fgglobals))
  (FGGlobals_get_ATC_mgr (ff-pointer self)))

(cl:defmethod set-atc-mgr ((self fgglobals) (a fgatcmgr))
  (FGGlobals_set_ATC_mgr (ff-pointer self) a))

(cl:defmethod get-current-panel ((self fgglobals))
  (FGGlobals_get_current_panel (ff-pointer self)))

(cl:defmethod set-current-panel ((self fgglobals) (cp fgpanel))
  (FGGlobals_set_current_panel (ff-pointer self) cp))

(cl:defmethod get-controls ((self fgglobals))
  (FGGlobals_get_controls (ff-pointer self)))

(cl:defmethod set-controls ((self fgglobals) (c fgcontrols))
  (FGGlobals_set_controls (ff-pointer self) c))

(cl:defmethod get-viewmgr ((self fgglobals))
  (FGGlobals_get_viewmgr (ff-pointer self)))

(cl:defmethod set-viewmgr ((self fgglobals) vm)
  (FGGlobals_set_viewmgr (ff-pointer self) vm))

(cl:defmethod get-current-view ((self fgglobals))
  (FGGlobals_get_current_view (ff-pointer self)))

(cl:defmethod get-props ((self fgglobals))
  (FGGlobals_get_props (ff-pointer self)))

(cl:defmethod set-props ((self fgglobals) n)
  (FGGlobals_set_props (ff-pointer self) n))

(cl:defmethod get-locale ((self fgglobals))
  (FGGlobals_get_locale (ff-pointer self)))

(cl:defmethod set-locale ((self fgglobals) n)
  (FGGlobals_set_locale (ff-pointer self) n))

(cl:defmethod get-commands ((self fgglobals))
  (FGGlobals_get_commands (ff-pointer self)))

(cl:defmethod get-aircraft-model ((self fgglobals))
  (FGGlobals_get_aircraft_model (ff-pointer self)))

(cl:defmethod set-aircraft-model ((self fgglobals) model)
  (FGGlobals_set_aircraft_model (ff-pointer self) model))

(cl:defmethod get-model-mgr ((self fgglobals))
  (FGGlobals_get_model_mgr (ff-pointer self)))

(cl:defmethod set-model-mgr ((self fgglobals) mgr)
  (FGGlobals_set_model_mgr (ff-pointer self) mgr))

(cl:defmethod get-channel-options-list ((self fgglobals))
  (FGGlobals_get_channel_options_list (ff-pointer self)))

(cl:defmethod set-channel-options-list ((self fgglobals) l)
  (FGGlobals_set_channel_options_list (ff-pointer self) l))

(cl:defmethod get-initial-waypoints ((self fgglobals))
  (FGGlobals_get_initial_waypoints (ff-pointer self)))

(cl:defmethod set-initial-waypoints ((self fgglobals) list)
  (FGGlobals_set_initial_waypoints (ff-pointer self) list))

(cl:defmethod get-scenery ((self fgglobals))
  (FGGlobals_get_scenery (ff-pointer self)))

(cl:defmethod set-scenery ((self fgglobals) s)
  (FGGlobals_set_scenery (ff-pointer self) s))

(cl:defmethod get-tile-mgr ((self fgglobals))
  (FGGlobals_get_tile_mgr (ff-pointer self)))

(cl:defmethod set-tile-mgr ((self fgglobals) t-arg1)
  (FGGlobals_set_tile_mgr (ff-pointer self) t-arg1))

(cl:defmethod get-fontcache ((self fgglobals))
  (FGGlobals_get_fontcache (ff-pointer self)))

(cl:defmethod get-navlist ((self fgglobals))
  (FGGlobals_get_navlist (ff-pointer self)))

(cl:defmethod set-navlist ((self fgglobals) n)
  (FGGlobals_set_navlist (ff-pointer self) n))

(cl:defmethod get-loclist ((self fgglobals))
  (FGGlobals_get_loclist (ff-pointer self)))

(cl:defmethod set-loclist ((self fgglobals) n)
  (FGGlobals_set_loclist (ff-pointer self) n))

(cl:defmethod get-gslist ((self fgglobals))
  (FGGlobals_get_gslist (ff-pointer self)))

(cl:defmethod set-gslist ((self fgglobals) n)
  (FGGlobals_set_gslist (ff-pointer self) n))

(cl:defmethod get-dmelist ((self fgglobals))
  (FGGlobals_get_dmelist (ff-pointer self)))

(cl:defmethod set-dmelist ((self fgglobals) n)
  (FGGlobals_set_dmelist (ff-pointer self) n))

(cl:defmethod get-tacanlist ((self fgglobals))
  (FGGlobals_get_tacanlist (ff-pointer self)))

(cl:defmethod set-tacanlist ((self fgglobals) n)
  (FGGlobals_set_tacanlist (ff-pointer self) n))

(cl:defmethod get-carrierlist ((self fgglobals))
  (FGGlobals_get_carrierlist (ff-pointer self)))

(cl:defmethod set-carrierlist ((self fgglobals) n)
  (FGGlobals_set_carrierlist (ff-pointer self) n))

(cl:defmethod get-channellist ((self fgglobals))
  (FGGlobals_get_channellist (ff-pointer self)))

(cl:defmethod set-channellist ((self fgglobals) c)
  (FGGlobals_set_channellist (ff-pointer self) c))

(cl:defmethod save-initial-state ((self fgglobals))
  (FGGlobals_saveInitialState (ff-pointer self)))

(cl:defmethod restore-initial-state ((self fgglobals))
  (FGGlobals_restoreInitialState (ff-pointer self)))


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

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

(cl:defmethod init ((self fglogger))
  (FGLogger_init (ff-pointer self)))

(cl:defmethod reinit ((self fglogger))
  (FGLogger_reinit (ff-pointer self)))

(cl:defmethod bind ((self fglogger))
  (FGLogger_bind (ff-pointer self)))

(cl:defmethod unbind ((self fglogger))
  (FGLogger_unbind (ff-pointer self)))

(cl:defmethod update ((self fglogger) (dt cl:number))
  (FGLogger_update (ff-pointer self) dt))


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

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

(cl:defmethod splashinit ((self fgrenderer))
  (FGRenderer_splashinit (ff-pointer self)))

(cl:defmethod init ((self fgrenderer))
  (FGRenderer_init (ff-pointer self)))

(cl:defmethod get-viewer ((self fgrenderer))
  (FGRenderer_getViewer (ff-pointer self)))

(cl:defmethod get-viewer ((self fgrenderer))
  (FGRenderer_getViewer (ff-pointer self)))

(cl:defmethod set-viewer ((self fgrenderer) viewer)
  (FGRenderer_setViewer (ff-pointer self) viewer))

(cl:defmethod get-event-handler ((self fgrenderer))
  (FGRenderer_getEventHandler (ff-pointer self)))

(cl:defmethod get-event-handler ((self fgrenderer))
  (FGRenderer_getEventHandler (ff-pointer self)))

(cl:defmethod set-event-handler ((self fgrenderer) (manipulator fgevent-handler))
  (FGRenderer_setEventHandler (ff-pointer self) manipulator))

(cl:defmethod add-camera ((self fgrenderer) camera (useSceneData t))
  (FGRenderer_addCamera (ff-pointer self) camera useSceneData))


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

(cl:defmethod initialize-instance :after ((obj fgviewer) &key (Type cl:integer) (from_model t) (from_model_index cl:integer) (at_model t) (at_model_index cl:integer) (damp_roll cl:number) (damp_pitch cl:number) (damp_heading cl:number) (x_offset_m cl:number) (y_offset_m cl:number) (z_offset_m cl:number) (heading_offset_deg cl:number) (pitch_offset_deg cl:number) (roll_offset_deg cl:number) (fov_deg cl:number) (aspect_ratio_multiplier cl:number) (target_x_offset_m cl:number) (target_y_offset_m cl:number) (target_z_offset_m cl:number) (near_m cl:number) (internal t))
  (setf (slot-value obj 'ff-pointer) (new_FGViewer Type from_model from_model_index at_model at_model_index damp_roll damp_pitch damp_heading x_offset_m y_offset_m z_offset_m heading_offset_deg pitch_offset_deg roll_offset_deg fov_deg aspect_ratio_multiplier target_x_offset_m target_y_offset_m target_z_offset_m near_m internal)))

(cl:defmethod init ((self fgviewer))
  (FGViewer_init (ff-pointer self)))

(cl:defmethod bind ((self fgviewer))
  (FGViewer_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgviewer))
  (FGViewer_unbind (ff-pointer self)))

(cl:defmethod update ((self fgviewer) (dt cl:number))
  (FGViewer_update (ff-pointer self) dt))

(cl:defmethod get-type ((self fgviewer))
  (FGViewer_getType (ff-pointer self)))

(cl:defmethod set-type ((self fgviewer) (type cl:integer))
  (FGViewer_setType (ff-pointer self) type))

(cl:defmethod get-internal ((self fgviewer))
  (FGViewer_getInternal (ff-pointer self)))

(cl:defmethod set-internal ((self fgviewer) (internal t))
  (FGViewer_setInternal (ff-pointer self) internal))

(cl:defmethod set-position ((self fgviewer) (lon_deg cl:number) (lat_deg cl:number) (alt_ft cl:number))
  (FGViewer_setPosition (ff-pointer self) lon_deg lat_deg alt_ft))

(cl:defmethod get-position ((self fgviewer))
  (FGViewer_getPosition (ff-pointer self)))

(cl:defmethod set-target-position ((self fgviewer) (lon_deg cl:number) (lat_deg cl:number) (alt_ft cl:number))
  (FGViewer_setTargetPosition (ff-pointer self) lon_deg lat_deg alt_ft))

(cl:defmethod get-target-position ((self fgviewer))
  (FGViewer_getTargetPosition (ff-pointer self)))

(cl:defmethod get-offset-m ((self fgviewer))
  (FGViewer_getOffset_m (ff-pointer self)))

(cl:defmethod get-xoffset-m ((self fgviewer))
  (FGViewer_getXOffset_m (ff-pointer self)))

(cl:defmethod get-yoffset-m ((self fgviewer))
  (FGViewer_getYOffset_m (ff-pointer self)))

(cl:defmethod get-zoffset-m ((self fgviewer))
  (FGViewer_getZOffset_m (ff-pointer self)))

(cl:defmethod get-target-xoffset-m ((self fgviewer))
  (FGViewer_getTargetXOffset_m (ff-pointer self)))

(cl:defmethod get-target-yoffset-m ((self fgviewer))
  (FGViewer_getTargetYOffset_m (ff-pointer self)))

(cl:defmethod get-target-zoffset-m ((self fgviewer))
  (FGViewer_getTargetZOffset_m (ff-pointer self)))

(cl:defmethod set-xoffset-m ((self fgviewer) (x_offset_m cl:number))
  (FGViewer_setXOffset_m (ff-pointer self) x_offset_m))

(cl:defmethod set-yoffset-m ((self fgviewer) (y_offset_m cl:number))
  (FGViewer_setYOffset_m (ff-pointer self) y_offset_m))

(cl:defmethod set-zoffset-m ((self fgviewer) (z_offset_m cl:number))
  (FGViewer_setZOffset_m (ff-pointer self) z_offset_m))

(cl:defmethod set-target-xoffset-m ((self fgviewer) (x_offset_m cl:number))
  (FGViewer_setTargetXOffset_m (ff-pointer self) x_offset_m))

(cl:defmethod set-target-yoffset-m ((self fgviewer) (y_offset_m cl:number))
  (FGViewer_setTargetYOffset_m (ff-pointer self) y_offset_m))

(cl:defmethod set-target-zoffset-m ((self fgviewer) (z_offset_m cl:number))
  (FGViewer_setTargetZOffset_m (ff-pointer self) z_offset_m))

(cl:defmethod set-position-offsets ((self fgviewer) (x_offset_m cl:number) (y_offset_m cl:number) (z_offset_m cl:number))
  (FGViewer_setPositionOffsets (ff-pointer self) x_offset_m y_offset_m z_offset_m))

(cl:defmethod get-roll-deg ((self fgviewer))
  (FGViewer_getRoll_deg (ff-pointer self)))

(cl:defmethod get-pitch-deg ((self fgviewer))
  (FGViewer_getPitch_deg (ff-pointer self)))

(cl:defmethod get-heading-deg ((self fgviewer))
  (FGViewer_getHeading_deg (ff-pointer self)))

(cl:defmethod set-roll-deg ((self fgviewer) (roll_deg cl:number))
  (FGViewer_setRoll_deg (ff-pointer self) roll_deg))

(cl:defmethod set-pitch-deg ((self fgviewer) (pitch_deg cl:number))
  (FGViewer_setPitch_deg (ff-pointer self) pitch_deg))

(cl:defmethod set-heading-deg ((self fgviewer) (heading_deg cl:number))
  (FGViewer_setHeading_deg (ff-pointer self) heading_deg))

(cl:defmethod set-orientation ((self fgviewer) (roll_deg cl:number) (pitch_deg cl:number) (heading_deg cl:number))
  (FGViewer_setOrientation (ff-pointer self) roll_deg pitch_deg heading_deg))

(cl:defmethod get-target-roll-deg ((self fgviewer))
  (FGViewer_getTargetRoll_deg (ff-pointer self)))

(cl:defmethod get-target-pitch-deg ((self fgviewer))
  (FGViewer_getTargetPitch_deg (ff-pointer self)))

(cl:defmethod get-target-heading-deg ((self fgviewer))
  (FGViewer_getTargetHeading_deg (ff-pointer self)))

(cl:defmethod set-target-roll-deg ((self fgviewer) (roll_deg cl:number))
  (FGViewer_setTargetRoll_deg (ff-pointer self) roll_deg))

(cl:defmethod set-target-pitch-deg ((self fgviewer) (pitch_deg cl:number))
  (FGViewer_setTargetPitch_deg (ff-pointer self) pitch_deg))

(cl:defmethod set-target-heading-deg ((self fgviewer) (heading_deg cl:number))
  (FGViewer_setTargetHeading_deg (ff-pointer self) heading_deg))

(cl:defmethod set-target-orientation ((self fgviewer) (roll_deg cl:number) (pitch_deg cl:number) (heading_deg cl:number))
  (FGViewer_setTargetOrientation (ff-pointer self) roll_deg pitch_deg heading_deg))

(cl:defmethod get-roll-offset-deg ((self fgviewer))
  (FGViewer_getRollOffset_deg (ff-pointer self)))

(cl:defmethod get-pitch-offset-deg ((self fgviewer))
  (FGViewer_getPitchOffset_deg (ff-pointer self)))

(cl:defmethod get-heading-offset-deg ((self fgviewer))
  (FGViewer_getHeadingOffset_deg (ff-pointer self)))

(cl:defmethod get-goal-roll-offset-deg ((self fgviewer))
  (FGViewer_getGoalRollOffset_deg (ff-pointer self)))

(cl:defmethod get-goal-pitch-offset-deg ((self fgviewer))
  (FGViewer_getGoalPitchOffset_deg (ff-pointer self)))

(cl:defmethod get-goal-heading-offset-deg ((self fgviewer))
  (FGViewer_getGoalHeadingOffset_deg (ff-pointer self)))

(cl:defmethod set-roll-offset-deg ((self fgviewer) (roll_offset_deg cl:number))
  (FGViewer_setRollOffset_deg (ff-pointer self) roll_offset_deg))

(cl:defmethod set-pitch-offset-deg ((self fgviewer) (pitch_offset_deg cl:number))
  (FGViewer_setPitchOffset_deg (ff-pointer self) pitch_offset_deg))

(cl:defmethod set-heading-offset-deg ((self fgviewer) (heading_offset_deg cl:number))
  (FGViewer_setHeadingOffset_deg (ff-pointer self) heading_offset_deg))

(cl:defmethod set-goal-roll-offset-deg ((self fgviewer) (goal_roll_offset_deg cl:number))
  (FGViewer_setGoalRollOffset_deg (ff-pointer self) goal_roll_offset_deg))

(cl:defmethod set-goal-pitch-offset-deg ((self fgviewer) (goal_pitch_offset_deg cl:number))
  (FGViewer_setGoalPitchOffset_deg (ff-pointer self) goal_pitch_offset_deg))

(cl:defmethod set-goal-heading-offset-deg ((self fgviewer) (goal_heading_offset_deg cl:number))
  (FGViewer_setGoalHeadingOffset_deg (ff-pointer self) goal_heading_offset_deg))

(cl:defmethod set-orientation-offsets ((self fgviewer) (roll_offset_deg cl:number) (heading_offset_deg cl:number) (pitch_offset_deg cl:number))
  (FGViewer_setOrientationOffsets (ff-pointer self) roll_offset_deg heading_offset_deg pitch_offset_deg))

(cl:defmethod get-view-pos ((self fgviewer))
  (FGViewer_get_view_pos (ff-pointer self)))

(cl:defmethod get-view-position ((self fgviewer))
  (FGViewer_getViewPosition (ff-pointer self)))

(cl:defmethod get-view-orientation ((self fgviewer))
  (FGViewer_getViewOrientation (ff-pointer self)))

(cl:defmethod get-view-orientation-offset ((self fgviewer))
  (FGViewer_getViewOrientationOffset (ff-pointer self)))

(cl:defmethod set-fov ((self fgviewer) (fov_deg cl:number))
  (FGViewer_set_fov (ff-pointer self) fov_deg))

(cl:defmethod get-fov ((self fgviewer))
  (FGViewer_get_fov (ff-pointer self)))

(cl:defmethod get-h-fov ((self fgviewer))
  (FGViewer_get_h_fov (ff-pointer self)))

(cl:defmethod get-v-fov ((self fgviewer))
  (FGViewer_get_v_fov (ff-pointer self)))

(cl:defmethod set-aspect-ratio ((self fgviewer) (r cl:number))
  (FGViewer_set_aspect_ratio (ff-pointer self) r))

(cl:defmethod get-aspect-ratio ((self fgviewer))
  (FGViewer_get_aspect_ratio (ff-pointer self)))

(cl:defmethod set-aspect-ratio-multiplier ((self fgviewer) (m cl:number))
  (FGViewer_set_aspect_ratio_multiplier (ff-pointer self) m))

(cl:defmethod get-aspect-ratio-multiplier ((self fgviewer))
  (FGViewer_get_aspect_ratio_multiplier (ff-pointer self)))

(cl:defmethod get-near-m ((self fgviewer))
  (FGViewer_getNear_m (ff-pointer self)))

(cl:defmethod set-near-m ((self fgviewer) (near_m cl:number))
  (FGViewer_setNear_m (ff-pointer self) near_m))

(cl:defmethod set-dirty ((self fgviewer))
  (FGViewer_set_dirty (ff-pointer self)))

(cl:defmethod set-clean ((self fgviewer))
  (FGViewer_set_clean (ff-pointer self)))


(cl:defclass fgview-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgview-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGViewMgr)))

(cl:defmethod init ((self fgview-mgr))
  (FGViewMgr_init (ff-pointer self)))

(cl:defmethod bind ((self fgview-mgr))
  (FGViewMgr_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgview-mgr))
  (FGViewMgr_unbind (ff-pointer self)))

(cl:defmethod update ((self fgview-mgr) (dt cl:number))
  (FGViewMgr_update (ff-pointer self) dt))

(cl:defmethod reinit ((self fgview-mgr))
  (FGViewMgr_reinit (ff-pointer self)))

(cl:defmethod size ((self fgview-mgr))
  (FGViewMgr_size (ff-pointer self)))

(cl:defmethod get-current ((self fgview-mgr))
  (FGViewMgr_get_current (ff-pointer self)))

(cl:defmethod get-current-view ((self fgview-mgr))
  (FGViewMgr_get_current_view (ff-pointer self)))

(cl:defmethod get-current-view ((self fgview-mgr))
  (FGViewMgr_get_current_view (ff-pointer self)))

(cl:defmethod get-view ((self fgview-mgr) (i cl:integer))
  (FGViewMgr_get_view (ff-pointer self) i))

(cl:defmethod get-view ((self fgview-mgr) (i cl:integer))
  (FGViewMgr_get_view (ff-pointer self) i))

(cl:defmethod next-view ((self fgview-mgr))
  (FGViewMgr_next_view (ff-pointer self)))

(cl:defmethod prev-view ((self fgview-mgr))
  (FGViewMgr_prev_view (ff-pointer self)))

(cl:defmethod clear ((self fgview-mgr))
  (FGViewMgr_clear (ff-pointer self)))

(cl:defmethod add-view ((self fgview-mgr) (v fgviewer))
  (FGViewMgr_add_view (ff-pointer self) v))


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

(cl:defmethod initialize-instance :after ((obj fgaircraft-model) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGAircraftModel)))

(cl:defmethod init ((self fgaircraft-model))
  (FGAircraftModel_init (ff-pointer self)))

(cl:defmethod reinit ((self fgaircraft-model))
  (FGAircraftModel_reinit (ff-pointer self)))

(cl:defmethod bind ((self fgaircraft-model))
  (FGAircraftModel_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgaircraft-model))
  (FGAircraftModel_unbind (ff-pointer self)))

(cl:defmethod update ((self fgaircraft-model) (dt cl:number))
  (FGAircraftModel_update (ff-pointer self) dt))

(cl:defmethod get3-dmodel ((self fgaircraft-model))
  (FGAircraftModel_get3DModel (ff-pointer self)))

(cl:defmethod get-velocity ((self fgaircraft-model))
  (FGAircraftModel_getVelocity (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fgpanel-node) &key props)
  (setf (slot-value obj 'ff-pointer) (new_FGPanelNode props)))

(cl:defmethod clone-type ((self fgpanel-node))
  (FGPanelNode_cloneType (ff-pointer self)))

(cl:defmethod clone ((self fgpanel-node) copyop)
  (FGPanelNode_clone (ff-pointer self) copyop))

(cl:defmethod do-mouse-action ((self fgpanel-node) (button cl:integer) (updown cl:integer) (x cl:integer) (y cl:integer))
  (FGPanelNode_doMouseAction (ff-pointer self) button updown x y))

(cl:defmethod get-panel ((self fgpanel-node))
  (FGPanelNode_getPanel (ff-pointer self)))

(cl:defmethod draw-implementation ((self fgpanel-node) renderInfo)
  (FGPanelNode_drawImplementation (ff-pointer self) renderInfo))

(cl:defmethod draw-implementation ((self fgpanel-node) state)
  (FGPanelNode_drawImplementation (ff-pointer self) state))

(cl:defmethod compute-bound ((self fgpanel-node))
  (FGPanelNode_computeBound (ff-pointer self)))


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

(cl:defmethod ident ((self airway))
  (Airway_ident (ff-pointer self)))


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

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

(cl:defmethod initialize-instance :after ((obj fgnode) &key aPos (idx cl:integer) id)
  (setf (slot-value obj 'ff-pointer) (new_FGNode aPos idx id)))

(cl:defmethod set-index ((self fgnode) (idx cl:integer))
  (FGNode_setIndex (ff-pointer self) idx))

(cl:defmethod add-airway ((self fgnode) segment)
  (FGNode_addAirway (ff-pointer self) segment))

(cl:defmethod get-position ((self fgnode))
  (FGNode_getPosition (ff-pointer self)))

(cl:defmethod get-cart ((self fgnode))
  (FGNode_getCart (ff-pointer self)))

(cl:defmethod get-index ((self fgnode))
  (FGNode_getIndex (ff-pointer self)))

(cl:defmethod get-ident ((self fgnode))
  (FGNode_getIdent (ff-pointer self)))

(cl:defmethod get-address ((self fgnode))
  (FGNode_getAddress (ff-pointer self)))

(cl:defmethod get-begin-route ((self fgnode))
  (FGNode_getBeginRoute (ff-pointer self)))

(cl:defmethod get-end-route ((self fgnode))
  (FGNode_getEndRoute (ff-pointer self)))

(cl:defmethod matches ((self fgnode) ident aPos)
  (FGNode_matches (ff-pointer self) ident aPos))


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

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

(cl:defmethod initialize-instance :after ((obj fgairway) &key (arg0 fgnode) (arg1 fgnode) (arg2 cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGAirway arg0 arg1 arg2)))

(cl:defmethod set-index ((self fgairway) (val cl:integer))
  (FGAirway_setIndex (ff-pointer self) val))

(cl:defmethod set-start-node-ref ((self fgairway) val)
  (FGAirway_setStartNodeRef (ff-pointer self) val))

(cl:defmethod set-end-node-ref ((self fgairway) val)
  (FGAirway_setEndNodeRef (ff-pointer self) val))

(cl:defmethod set-start ((self fgairway) nodes)
  (FGAirway_setStart (ff-pointer self) nodes))

(cl:defmethod set-end ((self fgairway) nodes)
  (FGAirway_setEnd (ff-pointer self) nodes))

(cl:defmethod set-type ((self fgairway) (tp cl:integer))
  (FGAirway_setType (ff-pointer self) tp))

(cl:defmethod set-base ((self fgairway) (val cl:integer))
  (FGAirway_setBase (ff-pointer self) val))

(cl:defmethod set-top ((self fgairway) (val cl:integer))
  (FGAirway_setTop (ff-pointer self) val))

(cl:defmethod set-name ((self fgairway) val)
  (FGAirway_setName (ff-pointer self) val))

(cl:defmethod set-track-distance ((self fgairway))
  (FGAirway_setTrackDistance (ff-pointer self)))

(cl:defmethod get-end ((self fgairway))
  (FGAirway_getEnd (ff-pointer self)))

(cl:defmethod get-length ((self fgairway))
  (FGAirway_getLength (ff-pointer self)))

(cl:defmethod get-index ((self fgairway))
  (FGAirway_getIndex (ff-pointer self)))

(cl:defmethod get-name ((self fgairway))
  (FGAirway_getName (ff-pointer self)))


(cl:defclass fgair-route()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgair-route) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGAirRoute)))

(cl:defmethod initialize-instance :after ((obj fgair-route) &key nds (dist cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGAirRoute nds dist)))

(cl:shadow "<")
(cl:defmethod < ((self fgair-route) (other fgair-route))
  (FGAirRoute___lt__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod empty ((self fgair-route))
  (FGAirRoute_empty (ff-pointer self)))

(cl:defmethod next ((self fgair-route) val)
  (FGAirRoute_next (ff-pointer self) val))

(cl:defmethod first ((self fgair-route))
  (FGAirRoute_first (ff-pointer self)))

(cl:defmethod add ((self fgair-route) (other fgair-route))
  (FGAirRoute_add (ff-pointer self) (ff-pointer other)))

(cl:defmethod add ((self fgair-route) (node cl:integer))
  (FGAirRoute_add (ff-pointer self) node))


(cl:defclass fgairway-network()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgairway-network) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGAirwayNetwork)))

(cl:defmethod add-airway ((self fgairway-network) (seg fgairway))
  (FGAirwayNetwork_addAirway (ff-pointer self) seg))

(cl:defmethod init ((self fgairway-network))
  (FGAirwayNetwork_init (ff-pointer self)))

(cl:defmethod exists ((self fgairway-network))
  (FGAirwayNetwork_exists (ff-pointer self)))

(cl:defmethod find-nearest-node ((self fgairway-network) aPos)
  (FGAirwayNetwork_findNearestNode (ff-pointer self) aPos))

(cl:defmethod find-node ((self fgairway-network) (idx cl:integer))
  (FGAirwayNetwork_findNode (ff-pointer self) idx))

(cl:defmethod find-shortest-route ((self fgairway-network) (start cl:integer) (end cl:integer))
  (FGAirwayNetwork_findShortestRoute (ff-pointer self) start end))

(cl:defmethod trace ((self fgairway-network) (arg1 fgnode) (arg2 cl:integer) (arg3 cl:integer) (dist cl:number))
  (FGAirwayNetwork_trace (ff-pointer self) arg1 arg2 arg3 dist))

(cl:defmethod load ((self fgairway-network) path)
  (FGAirwayNetwork_load (ff-pointer self) path))


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

(cl:defmethod initialize-instance :after ((obj fgfix) &key aIdent aPos)
  (setf (slot-value obj 'ff-pointer) (new_FGFix aIdent aPos)))

(cl:defmethod get-ident ((self fgfix))
  (FGFix_get_ident (ff-pointer self)))

(cl:defmethod get-lon ((self fgfix))
  (FGFix_get_lon (ff-pointer self)))

(cl:defmethod get-lat ((self fgfix))
  (FGFix_get_lat (ff-pointer self)))


(cl:defclass fgfix-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgfix-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGFixList)))

(cl:defmethod init ((self fgfix-list) path)
  (FGFixList_init (ff-pointer self) path))


(cl:defclass fgmarker-beacon-record()
  ((ff-pointer :reader ff-pointer)))


(cl:defclass fgnav-list()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnav-list) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNavList)))

(cl:defmethod init ((self fgnav-list))
  (FGNavList_init (ff-pointer self)))

(cl:defmethod add ((self fgnav-list) n)
  (FGNavList_add (ff-pointer self) n))

(cl:defmethod find-by-freq ((self fgnav-list) (freq cl:number) position)
  (FGNavList_findByFreq (ff-pointer self) freq position))

(cl:defmethod find-by-ident-and-freq ((self fgnav-list) ident (freq cl:number))
  (FGNavList_findByIdentAndFreq (ff-pointer self) ident freq))

(cl:defmethod find-by-ident-and-freq ((self fgnav-list) ident)
  (FGNavList_findByIdentAndFreq (ff-pointer self) ident))

(cl:defmethod find-station-by-freq ((self fgnav-list) (frequency cl:number))
  (FGNavList_findStationByFreq (ff-pointer self) frequency))


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

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

(cl:defmethod init ((self fgtacanlist))
  (FGTACANList_init (ff-pointer self)))

(cl:defmethod add ((self fgtacanlist) r)
  (FGTACANList_add (ff-pointer self) r))

(cl:defmethod find-by-channel ((self fgtacanlist) channel)
  (FGTACANList_findByChannel (ff-pointer self) channel))


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

(cl:defmethod type ((self fgpositioned))
  (FGPositioned_type (ff-pointer self)))

(cl:defmethod ident ((self fgpositioned))
  (FGPositioned_ident (ff-pointer self)))

(cl:defmethod name ((self fgpositioned))
  (FGPositioned_name (ff-pointer self)))

(cl:defmethod geod ((self fgpositioned))
  (FGPositioned_geod (ff-pointer self)))

(cl:defmethod cart ((self fgpositioned))
  (FGPositioned_cart (ff-pointer self)))

(cl:defmethod latitude ((self fgpositioned))
  (FGPositioned_latitude (ff-pointer self)))

(cl:defmethod longitude ((self fgpositioned))
  (FGPositioned_longitude (ff-pointer self)))

(cl:defmethod elevation ((self fgpositioned))
  (FGPositioned_elevation (ff-pointer self)))


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

(cl:defmethod owner ((self waypt))
  (Waypt_owner (ff-pointer self)))

(cl:defmethod course-and-distance-from ((self waypt) aPos)
  (Waypt_courseAndDistanceFrom (ff-pointer self) aPos))

(cl:defmethod position ((self waypt))
  (Waypt_position (ff-pointer self)))

(cl:defmethod source ((self waypt))
  (Waypt_source (ff-pointer self)))

(cl:defmethod altitude-ft ((self waypt))
  (Waypt_altitudeFt (ff-pointer self)))

(cl:defmethod speed ((self waypt))
  (Waypt_speed (ff-pointer self)))

(cl:defmethod speed-kts ((self waypt))
  (Waypt_speedKts (ff-pointer self)))

(cl:defmethod speed-mach ((self waypt))
  (Waypt_speedMach (ff-pointer self)))

(cl:defmethod altitude-restriction ((self waypt))
  (Waypt_altitudeRestriction (ff-pointer self)))

(cl:defmethod speed-restriction ((self waypt))
  (Waypt_speedRestriction (ff-pointer self)))

(cl:defmethod set-altitude ((self waypt) (aAlt cl:number) (aRestrict cl:integer))
  (Waypt_setAltitude (ff-pointer self) aAlt aRestrict))

(cl:defmethod set-speed ((self waypt) (aSpeed cl:number) (aRestrict cl:integer))
  (Waypt_setSpeed (ff-pointer self) aSpeed aRestrict))

(cl:defmethod ident ((self waypt))
  (Waypt_ident (ff-pointer self)))

(cl:defmethod flag ((self waypt) (aFlag cl:integer))
  (Waypt_flag (ff-pointer self) aFlag))

(cl:defmethod set-flag ((self waypt) (aFlag cl:integer) (aV t))
  (Waypt_setFlag (ff-pointer self) aFlag aV))

(cl:defmethod set-flag ((self waypt) (aFlag cl:integer))
  (Waypt_setFlag (ff-pointer self) aFlag))

(cl:defmethod save-as-node ((self waypt) node)
  (Waypt_saveAsNode (ff-pointer self) node))

(cl:defmethod matches ((self waypt) (aOther waypt))
  (Waypt_matches (ff-pointer self) (ff-pointer aOther)))

(cl:defmethod matches ((self waypt) aPos)
  (Waypt_matches (ff-pointer self) aPos))

(cl:defmethod type ((self waypt))
  (Waypt_type (ff-pointer self)))

(cl:defmethod magvar-deg ((self waypt))
  (Waypt_magvarDeg (ff-pointer self)))


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

(cl:defmethod ident ((self route))
  (Route_ident (ff-pointer self)))


(cl:defclass route-path()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj route-path) &key wpts)
  (setf (slot-value obj 'ff-pointer) (new_RoutePath wpts)))

(cl:defmethod path-for-index ((self route-path) (index cl:integer))
  (RoutePath_pathForIndex (ff-pointer self) index))

(cl:defmethod position-for-index ((self route-path) (index cl:integer))
  (RoutePath_positionForIndex (ff-pointer self) index))


(cl:defclass basic-waypt(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj basic-waypt) &key aPos aIdent (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_BasicWaypt aPos aIdent aOwner)))

(cl:defmethod initialize-instance :after ((obj basic-waypt) &key aWP (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_BasicWaypt aWP aOwner)))

(cl:defmethod initialize-instance :after ((obj basic-waypt) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_BasicWaypt aOwner)))

(cl:defmethod position ((self basic-waypt))
  (BasicWaypt_position (ff-pointer self)))

(cl:defmethod ident ((self basic-waypt))
  (BasicWaypt_ident (ff-pointer self)))


(cl:defclass navaid-waypoint(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj navaid-waypoint) &key (aPos fgpositioned) (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_NavaidWaypoint aPos aOwner)))

(cl:defmethod initialize-instance :after ((obj navaid-waypoint) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_NavaidWaypoint aOwner)))

(cl:defmethod position ((self navaid-waypoint))
  (NavaidWaypoint_position (ff-pointer self)))

(cl:defmethod source ((self navaid-waypoint))
  (NavaidWaypoint_source (ff-pointer self)))

(cl:defmethod ident ((self navaid-waypoint))
  (NavaidWaypoint_ident (ff-pointer self)))


(cl:defclass offset-navaid-waypoint(flightgear::NavaidWaypoint)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj offset-navaid-waypoint) &key (aPos fgpositioned) (aOwner route) (aRadial cl:number) (aDistNm cl:number))
  (setf (slot-value obj 'ff-pointer) (new_OffsetNavaidWaypoint aPos aOwner aRadial aDistNm)))

(cl:defmethod initialize-instance :after ((obj offset-navaid-waypoint) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_OffsetNavaidWaypoint aOwner)))

(cl:defmethod position ((self offset-navaid-waypoint))
  (OffsetNavaidWaypoint_position (ff-pointer self)))


(cl:defclass runway-waypt(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj runway-waypt) &key (aPos fgrunway) (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_RunwayWaypt aPos aOwner)))

(cl:defmethod initialize-instance :after ((obj runway-waypt) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_RunwayWaypt aOwner)))

(cl:defmethod position ((self runway-waypt))
  (RunwayWaypt_position (ff-pointer self)))

(cl:defmethod source ((self runway-waypt))
  (RunwayWaypt_source (ff-pointer self)))

(cl:defmethod ident ((self runway-waypt))
  (RunwayWaypt_ident (ff-pointer self)))

(cl:defmethod runway ((self runway-waypt))
  (RunwayWaypt_runway (ff-pointer self)))


(cl:defclass hold(flightgear::BasicWaypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj hold) &key aPos aIdent (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_Hold aPos aIdent aOwner)))

(cl:defmethod initialize-instance :after ((obj hold) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_Hold aOwner)))

(cl:defmethod set-hold-radial ((self hold) (aInboundRadial cl:number))
  (Hold_setHoldRadial (ff-pointer self) aInboundRadial))

(cl:defmethod set-hold-distance ((self hold) (aDistanceNm cl:number))
  (Hold_setHoldDistance (ff-pointer self) aDistanceNm))

(cl:defmethod set-hold-time ((self hold) (aTimeSec cl:number))
  (Hold_setHoldTime (ff-pointer self) aTimeSec))

(cl:defmethod set-right-handed ((self hold))
  (Hold_setRightHanded (ff-pointer self)))

(cl:defmethod set-left-handed ((self hold))
  (Hold_setLeftHanded (ff-pointer self)))

(cl:defmethod inbound-radial ((self hold))
  (Hold_inboundRadial (ff-pointer self)))

(cl:defmethod is-left-handed ((self hold))
  (Hold_isLeftHanded (ff-pointer self)))

(cl:defmethod is-distance ((self hold))
  (Hold_isDistance (ff-pointer self)))

(cl:defmethod time-or-distance ((self hold))
  (Hold_timeOrDistance (ff-pointer self)))


(cl:defclass heading-to-altitude(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj heading-to-altitude) &key (aOwner route) aIdent (aMagHdg cl:number))
  (setf (slot-value obj 'ff-pointer) (new_HeadingToAltitude aOwner aIdent aMagHdg)))

(cl:defmethod initialize-instance :after ((obj heading-to-altitude) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_HeadingToAltitude aOwner)))

(cl:defmethod init-from-properties ((self heading-to-altitude) aProp)
  (HeadingToAltitude_initFromProperties (ff-pointer self) aProp))

(cl:defmethod write-to-properties ((self heading-to-altitude) aProp)
  (HeadingToAltitude_writeToProperties (ff-pointer self) aProp))

(cl:defmethod type ((self heading-to-altitude))
  (HeadingToAltitude_type (ff-pointer self)))

(cl:defmethod position ((self heading-to-altitude))
  (HeadingToAltitude_position (ff-pointer self)))

(cl:defmethod ident ((self heading-to-altitude))
  (HeadingToAltitude_ident (ff-pointer self)))

(cl:defmethod heading-deg-magnetic ((self heading-to-altitude))
  (HeadingToAltitude_headingDegMagnetic (ff-pointer self)))

(cl:defmethod magvar-deg ((self heading-to-altitude))
  (HeadingToAltitude_magvarDeg (ff-pointer self)))


(cl:defclass dmeintercept(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj dmeintercept) &key (aOwner route) aIdent aPos (aCourseDeg cl:number) (aDistanceNm cl:number))
  (setf (slot-value obj 'ff-pointer) (new_DMEIntercept aOwner aIdent aPos aCourseDeg aDistanceNm)))

(cl:defmethod initialize-instance :after ((obj dmeintercept) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_DMEIntercept aOwner)))

(cl:defmethod init-from-properties ((self dmeintercept) aProp)
  (DMEIntercept_initFromProperties (ff-pointer self) aProp))

(cl:defmethod write-to-properties ((self dmeintercept) aProp)
  (DMEIntercept_writeToProperties (ff-pointer self) aProp))

(cl:defmethod type ((self dmeintercept))
  (DMEIntercept_type (ff-pointer self)))

(cl:defmethod position ((self dmeintercept))
  (DMEIntercept_position (ff-pointer self)))

(cl:defmethod ident ((self dmeintercept))
  (DMEIntercept_ident (ff-pointer self)))

(cl:defmethod course-deg-magnetic ((self dmeintercept))
  (DMEIntercept_courseDegMagnetic (ff-pointer self)))

(cl:defmethod dme-distance-nm ((self dmeintercept))
  (DMEIntercept_dmeDistanceNm (ff-pointer self)))


(cl:defclass radial-intercept(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj radial-intercept) &key (aOwner route) aIdent aPos (aCourseDeg cl:number) (aRadialDeg cl:number))
  (setf (slot-value obj 'ff-pointer) (new_RadialIntercept aOwner aIdent aPos aCourseDeg aRadialDeg)))

(cl:defmethod initialize-instance :after ((obj radial-intercept) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_RadialIntercept aOwner)))

(cl:defmethod init-from-properties ((self radial-intercept) aProp)
  (RadialIntercept_initFromProperties (ff-pointer self) aProp))

(cl:defmethod write-to-properties ((self radial-intercept) aProp)
  (RadialIntercept_writeToProperties (ff-pointer self) aProp))

(cl:defmethod type ((self radial-intercept))
  (RadialIntercept_type (ff-pointer self)))

(cl:defmethod position ((self radial-intercept))
  (RadialIntercept_position (ff-pointer self)))

(cl:defmethod ident ((self radial-intercept))
  (RadialIntercept_ident (ff-pointer self)))

(cl:defmethod course-deg-magnetic ((self radial-intercept))
  (RadialIntercept_courseDegMagnetic (ff-pointer self)))

(cl:defmethod radial-deg-magnetic ((self radial-intercept))
  (RadialIntercept_radialDegMagnetic (ff-pointer self)))


(cl:defclass atcvectors(flightgear::Waypt)
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj atcvectors) &key (aOwner route) aFacility)
  (setf (slot-value obj 'ff-pointer) (new_ATCVectors aOwner aFacility)))

(cl:defmethod initialize-instance :after ((obj atcvectors) &key (aOwner route))
  (setf (slot-value obj 'ff-pointer) (new_ATCVectors aOwner)))

(cl:defmethod init-from-properties ((self atcvectors) aProp)
  (ATCVectors_initFromProperties (ff-pointer self) aProp))

(cl:defmethod write-to-properties ((self atcvectors) aProp)
  (ATCVectors_writeToProperties (ff-pointer self) aProp))

(cl:defmethod type ((self atcvectors))
  (ATCVectors_type (ff-pointer self)))

(cl:defmethod position ((self atcvectors))
  (ATCVectors_position (ff-pointer self)))

(cl:defmethod ident ((self atcvectors))
  (ATCVectors_ident (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fgatcinput) &key (_board cl:integer) _config_file)
  (setf (slot-value obj 'ff-pointer) (new_FGATCInput _board _config_file)))

(cl:defmethod open ((self fgatcinput))
  (FGATCInput_open (ff-pointer self)))

(cl:defmethod process ((self fgatcinput))
  (FGATCInput_process (ff-pointer self)))

(cl:defmethod close ((self fgatcinput))
  (FGATCInput_close (ff-pointer self)))


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

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

(cl:defmethod open ((self fgatcmain))
  (FGATCMain_open (ff-pointer self)))

(cl:defmethod init-config ((self fgatcmain))
  (FGATCMain_init_config (ff-pointer self)))

(cl:defmethod process ((self fgatcmain))
  (FGATCMain_process (ff-pointer self)))

(cl:defmethod close ((self fgatcmain))
  (FGATCMain_close (ff-pointer self)))

(cl:defmethod set-path-names ((self fgatcmain) in0 in1 out0 out1)
  (FGATCMain_set_path_names (ff-pointer self) in0 in1 out0 out1))


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

(cl:defmethod initialize-instance :after ((obj fgatcoutput) &key (_board cl:integer) _config_file)
  (setf (slot-value obj 'ff-pointer) (new_FGATCOutput _board _config_file)))

(cl:defmethod open ((self fgatcoutput) (lock_fd cl:integer))
  (FGATCOutput_open (ff-pointer self) lock_fd))

(cl:defmethod process ((self fgatcoutput))
  (FGATCOutput_process (ff-pointer self)))

(cl:defmethod close ((self fgatcoutput))
  (FGATCOutput_close (ff-pointer self)))


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

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

(cl:defmethod gen-message ((self fgav400))
  (FGAV400_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgav400))
  (FGAV400_parse_message (ff-pointer self)))

(cl:defmethod open ((self fgav400))
  (FGAV400_open (ff-pointer self)))

(cl:defmethod process ((self fgav400))
  (FGAV400_process (ff-pointer self)))

(cl:defmethod close ((self fgav400))
  (FGAV400_close (ff-pointer self)))

(cl:defmethod (cl:setf fdm) (arg0 (obj fgav400))
  (FGAV400_fdm_set (ff-pointer obj) arg0))

(cl:defmethod fdm ((obj fgav400))
  (FGAV400_fdm_get (ff-pointer obj)))


(cl:defclass fgav400-sim()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgav400-sim) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGAV400Sim)))

(cl:defmethod gen-message ((self fgav400-sim))
  (FGAV400Sim_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgav400-sim))
  (FGAV400Sim_parse_message (ff-pointer self)))

(cl:defmethod open ((self fgav400-sim))
  (FGAV400Sim_open (ff-pointer self)))

(cl:defmethod process ((self fgav400-sim))
  (FGAV400Sim_process (ff-pointer self)))

(cl:defmethod close ((self fgav400-sim))
  (FGAV400Sim_close (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fghla) &key tokens)
  (setf (slot-value obj 'ff-pointer) (new_FGHLA tokens)))

(cl:defmethod open ((self fghla))
  (FGHLA_open (ff-pointer self)))

(cl:defmethod process ((self fghla))
  (FGHLA_process (ff-pointer self)))

(cl:defmethod close ((self fghla))
  (FGHLA_close (ff-pointer self)))


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

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

(cl:defmethod gen-message ((self fgatlas))
  (FGAtlas_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgatlas))
  (FGAtlas_parse_message (ff-pointer self)))

(cl:defmethod open ((self fgatlas))
  (FGAtlas_open (ff-pointer self)))

(cl:defmethod process ((self fgatlas))
  (FGAtlas_process (ff-pointer self)))

(cl:defmethod close ((self fgatlas))
  (FGAtlas_close (ff-pointer self)))


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

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

(cl:defmethod gen-message ((self fggarmin))
  (FGGarmin_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fggarmin))
  (FGGarmin_parse_message (ff-pointer self)))

(cl:defmethod open ((self fggarmin))
  (FGGarmin_open (ff-pointer self)))

(cl:defmethod process ((self fggarmin))
  (FGGarmin_process (ff-pointer self)))

(cl:defmethod close ((self fggarmin))
  (FGGarmin_close (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fggeneric) &key arg0)
  (setf (slot-value obj 'ff-pointer) (new_FGGeneric arg0)))

(cl:defmethod gen-message ((self fggeneric))
  (FGGeneric_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fggeneric) (length cl:integer))
  (FGGeneric_parse_message (ff-pointer self) length))

(cl:defmethod open ((self fggeneric))
  (FGGeneric_open (ff-pointer self)))

(cl:defmethod reinit ((self fggeneric))
  (FGGeneric_reinit (ff-pointer self)))

(cl:defmethod process ((self fggeneric))
  (FGGeneric_process (ff-pointer self)))

(cl:defmethod close ((self fggeneric))
  (FGGeneric_close (ff-pointer self)))

(cl:defmethod set-exit-on-error ((self fggeneric) (val t))
  (FGGeneric_setExitOnError (ff-pointer self) val))

(cl:defmethod get-exit-on-error ((self fggeneric))
  (FGGeneric_getExitOnError (ff-pointer self)))


(cl:defclass httpd-channel()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj httpd-channel) &key)
  (setf (slot-value obj 'ff-pointer) (new_HttpdChannel)))

(cl:defmethod collect-incoming-data ((self httpd-channel) (s cl:string) (n cl:integer))
  (HttpdChannel_collectIncomingData (ff-pointer self) s n))

(cl:defmethod found-terminator ((self httpd-channel))
  (HttpdChannel_foundTerminator (ff-pointer self)))


(cl:defclass httpd-server()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj httpd-server) &key (port cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_HttpdServer port)))


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

(cl:defmethod initialize-instance :after ((obj fghttpd) &key (p cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGHttpd p)))

(cl:defmethod open ((self fghttpd))
  (FGHttpd_open (ff-pointer self)))

(cl:defmethod process ((self fghttpd))
  (FGHttpd_process (ff-pointer self)))

(cl:defmethod close ((self fghttpd))
  (FGHttpd_close (ff-pointer self)))


(cl:defclass fgjoy-client()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgjoy-client) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGJoyClient)))

(cl:defmethod open ((self fgjoy-client))
  (FGJoyClient_open (ff-pointer self)))

(cl:defmethod process ((self fgjoy-client))
  (FGJoyClient_process (ff-pointer self)))

(cl:defmethod close ((self fgjoy-client))
  (FGJoyClient_close (ff-pointer self)))


(cl:defclass tr-jpg-factory()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj tr-jpg-factory) &key)
  (setf (slot-value obj 'ff-pointer) (new_trJpgFactory)))

(cl:defmethod init ((self tr-jpg-factory) (arg1 cl:integer) (arg2 cl:integer))
  (trJpgFactory_init (ff-pointer self) arg1 arg2))

(cl:defmethod destroy ((self tr-jpg-factory))
  (trJpgFactory_destroy (ff-pointer self)))

(cl:defmethod render ((self tr-jpg-factory))
  (trJpgFactory_render (ff-pointer self)))

(cl:defmethod set-frustum ((self tr-jpg-factory) (arg1 cl:number) (arg2 cl:number) (arg3 cl:number) (arg4 cl:number) (arg5 cl:number) (arg6 cl:number))
  (trJpgFactory_setFrustum (ff-pointer self) arg1 arg2 arg3 arg4 arg5 arg6))

(cl:defmethod data ((self tr-jpg-factory))
  (trJpgFactory_data (ff-pointer self)))


(cl:defclass httpd-image-channel()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj httpd-image-channel) &key)
  (setf (slot-value obj 'ff-pointer) (new_HttpdImageChannel)))

(cl:defmethod collect-incoming-data ((self httpd-image-channel) (s cl:string) (n cl:integer))
  (HttpdImageChannel_collectIncomingData (ff-pointer self) s n))

(cl:defmethod found-terminator ((self httpd-image-channel))
  (HttpdImageChannel_foundTerminator (ff-pointer self)))


(cl:defclass httpd-image-server()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj httpd-image-server) &key (port cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_HttpdImageServer port)))


(cl:defclass fgjpeg-httpd()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgjpeg-httpd) &key (p cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGJpegHttpd p)))

(cl:defmethod open ((self fgjpeg-httpd))
  (FGJpegHttpd_open (ff-pointer self)))

(cl:defmethod process ((self fgjpeg-httpd))
  (FGJpegHttpd_process (ff-pointer self)))

(cl:defmethod close ((self fgjpeg-httpd))
  (FGJpegHttpd_close (ff-pointer self)))


(cl:defclass fgjs-client()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgjs-client) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGJsClient)))

(cl:defmethod open ((self fgjs-client))
  (FGJsClient_open (ff-pointer self)))

(cl:defmethod process ((self fgjs-client))
  (FGJsClient_process (ff-pointer self)))

(cl:defmethod close ((self fgjs-client))
  (FGJsClient_close (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fgmultiplay) &key dir (rate cl:integer) host (port cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_FGMultiplay dir rate host port)))

(cl:defmethod open ((self fgmultiplay))
  (FGMultiplay_open (ff-pointer self)))

(cl:defmethod process ((self fgmultiplay))
  (FGMultiplay_process (ff-pointer self)))

(cl:defmethod close ((self fgmultiplay))
  (FGMultiplay_close (ff-pointer self)))

(cl:defmethod set-properties-changed ((self fgmultiplay))
  (FGMultiplay_setPropertiesChanged (ff-pointer self)))


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

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

(cl:defmethod open ((self fgnative))
  (FGNative_open (ff-pointer self)))

(cl:defmethod process ((self fgnative))
  (FGNative_process (ff-pointer self)))

(cl:defmethod close ((self fgnative))
  (FGNative_close (ff-pointer self)))


(cl:defclass fgnative-ctrls()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnative-ctrls) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNativeCtrls)))

(cl:defmethod open ((self fgnative-ctrls))
  (FGNativeCtrls_open (ff-pointer self)))

(cl:defmethod process ((self fgnative-ctrls))
  (FGNativeCtrls_process (ff-pointer self)))

(cl:defmethod close ((self fgnative-ctrls))
  (FGNativeCtrls_close (ff-pointer self)))


(cl:defclass fgnative-fdm()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnative-fdm) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNativeFDM)))

(cl:defmethod open ((self fgnative-fdm))
  (FGNativeFDM_open (ff-pointer self)))

(cl:defmethod process ((self fgnative-fdm))
  (FGNativeFDM_process (ff-pointer self)))

(cl:defmethod close ((self fgnative-fdm))
  (FGNativeFDM_close (ff-pointer self)))


(cl:defclass fgnative-gui()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgnative-gui) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNativeGUI)))

(cl:defmethod open ((self fgnative-gui))
  (FGNativeGUI_open (ff-pointer self)))

(cl:defmethod process ((self fgnative-gui))
  (FGNativeGUI_process (ff-pointer self)))

(cl:defmethod close ((self fgnative-gui))
  (FGNativeGUI_close (ff-pointer self)))


(cl:defclass fgnet-ctrls()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf version) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_version_set (ff-pointer obj) arg0))

(cl:defmethod version ((obj fgnet-ctrls))
  (FGNetCtrls_version_get (ff-pointer obj)))

(cl:defmethod (cl:setf aileron) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_aileron_set (ff-pointer obj) arg0))

(cl:defmethod aileron ((obj fgnet-ctrls))
  (FGNetCtrls_aileron_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevator) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_elevator_set (ff-pointer obj) arg0))

(cl:defmethod elevator ((obj fgnet-ctrls))
  (FGNetCtrls_elevator_get (ff-pointer obj)))

(cl:defmethod (cl:setf rudder) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_rudder_set (ff-pointer obj) arg0))

(cl:defmethod rudder ((obj fgnet-ctrls))
  (FGNetCtrls_rudder_get (ff-pointer obj)))

(cl:defmethod (cl:setf aileron_trim) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_aileron_trim_set (ff-pointer obj) arg0))

(cl:defmethod aileron_trim ((obj fgnet-ctrls))
  (FGNetCtrls_aileron_trim_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevator_trim) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_elevator_trim_set (ff-pointer obj) arg0))

(cl:defmethod elevator_trim ((obj fgnet-ctrls))
  (FGNetCtrls_elevator_trim_get (ff-pointer obj)))

(cl:defmethod (cl:setf rudder_trim) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_rudder_trim_set (ff-pointer obj) arg0))

(cl:defmethod rudder_trim ((obj fgnet-ctrls))
  (FGNetCtrls_rudder_trim_get (ff-pointer obj)))

(cl:defmethod (cl:setf flaps) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_flaps_set (ff-pointer obj) arg0))

(cl:defmethod flaps ((obj fgnet-ctrls))
  (FGNetCtrls_flaps_get (ff-pointer obj)))

(cl:defmethod (cl:setf spoilers) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_spoilers_set (ff-pointer obj) arg0))

(cl:defmethod spoilers ((obj fgnet-ctrls))
  (FGNetCtrls_spoilers_get (ff-pointer obj)))

(cl:defmethod (cl:setf speedbrake) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_speedbrake_set (ff-pointer obj) arg0))

(cl:defmethod speedbrake ((obj fgnet-ctrls))
  (FGNetCtrls_speedbrake_get (ff-pointer obj)))

(cl:defmethod (cl:setf flaps_power) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_flaps_power_set (ff-pointer obj) arg0))

(cl:defmethod flaps_power ((obj fgnet-ctrls))
  (FGNetCtrls_flaps_power_get (ff-pointer obj)))

(cl:defmethod (cl:setf flap_motor_ok) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_flap_motor_ok_set (ff-pointer obj) arg0))

(cl:defmethod flap_motor_ok ((obj fgnet-ctrls))
  (FGNetCtrls_flap_motor_ok_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_engines) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_num_engines_set (ff-pointer obj) arg0))

(cl:defmethod num_engines ((obj fgnet-ctrls))
  (FGNetCtrls_num_engines_get (ff-pointer obj)))

(cl:defmethod (cl:setf master_bat) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_master_bat_set (ff-pointer obj) arg0))

(cl:defmethod master_bat ((obj fgnet-ctrls))
  (FGNetCtrls_master_bat_get (ff-pointer obj)))

(cl:defmethod (cl:setf master_alt) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_master_alt_set (ff-pointer obj) arg0))

(cl:defmethod master_alt ((obj fgnet-ctrls))
  (FGNetCtrls_master_alt_get (ff-pointer obj)))

(cl:defmethod (cl:setf magnetos) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_magnetos_set (ff-pointer obj) arg0))

(cl:defmethod magnetos ((obj fgnet-ctrls))
  (FGNetCtrls_magnetos_get (ff-pointer obj)))

(cl:defmethod (cl:setf starter_power) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_starter_power_set (ff-pointer obj) arg0))

(cl:defmethod starter_power ((obj fgnet-ctrls))
  (FGNetCtrls_starter_power_get (ff-pointer obj)))

(cl:defmethod (cl:setf throttle) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_throttle_set (ff-pointer obj) arg0))

(cl:defmethod throttle ((obj fgnet-ctrls))
  (FGNetCtrls_throttle_get (ff-pointer obj)))

(cl:defmethod (cl:setf mixture) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_mixture_set (ff-pointer obj) arg0))

(cl:defmethod mixture ((obj fgnet-ctrls))
  (FGNetCtrls_mixture_get (ff-pointer obj)))

(cl:defmethod (cl:setf condition) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_condition_set (ff-pointer obj) arg0))

(cl:defmethod condition ((obj fgnet-ctrls))
  (FGNetCtrls_condition_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_pump_power) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_fuel_pump_power_set (ff-pointer obj) arg0))

(cl:defmethod fuel_pump_power ((obj fgnet-ctrls))
  (FGNetCtrls_fuel_pump_power_get (ff-pointer obj)))

(cl:defmethod (cl:setf prop_advance) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_prop_advance_set (ff-pointer obj) arg0))

(cl:defmethod prop_advance ((obj fgnet-ctrls))
  (FGNetCtrls_prop_advance_get (ff-pointer obj)))

(cl:defmethod (cl:setf feed_tank_to) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_feed_tank_to_set (ff-pointer obj) arg0))

(cl:defmethod feed_tank_to ((obj fgnet-ctrls))
  (FGNetCtrls_feed_tank_to_get (ff-pointer obj)))

(cl:defmethod (cl:setf reverse) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_reverse_set (ff-pointer obj) arg0))

(cl:defmethod reverse ((obj fgnet-ctrls))
  (FGNetCtrls_reverse_get (ff-pointer obj)))

(cl:defmethod (cl:setf engine_ok) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_engine_ok_set (ff-pointer obj) arg0))

(cl:defmethod engine_ok ((obj fgnet-ctrls))
  (FGNetCtrls_engine_ok_get (ff-pointer obj)))

(cl:defmethod (cl:setf mag_left_ok) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_mag_left_ok_set (ff-pointer obj) arg0))

(cl:defmethod mag_left_ok ((obj fgnet-ctrls))
  (FGNetCtrls_mag_left_ok_get (ff-pointer obj)))

(cl:defmethod (cl:setf mag_right_ok) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_mag_right_ok_set (ff-pointer obj) arg0))

(cl:defmethod mag_right_ok ((obj fgnet-ctrls))
  (FGNetCtrls_mag_right_ok_get (ff-pointer obj)))

(cl:defmethod (cl:setf spark_plugs_ok) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_spark_plugs_ok_set (ff-pointer obj) arg0))

(cl:defmethod spark_plugs_ok ((obj fgnet-ctrls))
  (FGNetCtrls_spark_plugs_ok_get (ff-pointer obj)))

(cl:defmethod (cl:setf oil_press_status) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_oil_press_status_set (ff-pointer obj) arg0))

(cl:defmethod oil_press_status ((obj fgnet-ctrls))
  (FGNetCtrls_oil_press_status_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_pump_ok) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_fuel_pump_ok_set (ff-pointer obj) arg0))

(cl:defmethod fuel_pump_ok ((obj fgnet-ctrls))
  (FGNetCtrls_fuel_pump_ok_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_tanks) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_num_tanks_set (ff-pointer obj) arg0))

(cl:defmethod num_tanks ((obj fgnet-ctrls))
  (FGNetCtrls_num_tanks_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_selector) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_fuel_selector_set (ff-pointer obj) arg0))

(cl:defmethod fuel_selector ((obj fgnet-ctrls))
  (FGNetCtrls_fuel_selector_get (ff-pointer obj)))

(cl:defmethod (cl:setf xfer_pump) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_xfer_pump_set (ff-pointer obj) arg0))

(cl:defmethod xfer_pump ((obj fgnet-ctrls))
  (FGNetCtrls_xfer_pump_get (ff-pointer obj)))

(cl:defmethod (cl:setf cross_feed) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_cross_feed_set (ff-pointer obj) arg0))

(cl:defmethod cross_feed ((obj fgnet-ctrls))
  (FGNetCtrls_cross_feed_get (ff-pointer obj)))

(cl:defmethod (cl:setf brake_left) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_brake_left_set (ff-pointer obj) arg0))

(cl:defmethod brake_left ((obj fgnet-ctrls))
  (FGNetCtrls_brake_left_get (ff-pointer obj)))

(cl:defmethod (cl:setf brake_right) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_brake_right_set (ff-pointer obj) arg0))

(cl:defmethod brake_right ((obj fgnet-ctrls))
  (FGNetCtrls_brake_right_get (ff-pointer obj)))

(cl:defmethod (cl:setf copilot_brake_left) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_copilot_brake_left_set (ff-pointer obj) arg0))

(cl:defmethod copilot_brake_left ((obj fgnet-ctrls))
  (FGNetCtrls_copilot_brake_left_get (ff-pointer obj)))

(cl:defmethod (cl:setf copilot_brake_right) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_copilot_brake_right_set (ff-pointer obj) arg0))

(cl:defmethod copilot_brake_right ((obj fgnet-ctrls))
  (FGNetCtrls_copilot_brake_right_get (ff-pointer obj)))

(cl:defmethod (cl:setf brake_parking) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_brake_parking_set (ff-pointer obj) arg0))

(cl:defmethod brake_parking ((obj fgnet-ctrls))
  (FGNetCtrls_brake_parking_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_handle) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_gear_handle_set (ff-pointer obj) arg0))

(cl:defmethod gear_handle ((obj fgnet-ctrls))
  (FGNetCtrls_gear_handle_get (ff-pointer obj)))

(cl:defmethod (cl:setf master_avionics) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_master_avionics_set (ff-pointer obj) arg0))

(cl:defmethod master_avionics ((obj fgnet-ctrls))
  (FGNetCtrls_master_avionics_get (ff-pointer obj)))

(cl:defmethod (cl:setf comm_1) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_comm_1_set (ff-pointer obj) arg0))

(cl:defmethod comm_1 ((obj fgnet-ctrls))
  (FGNetCtrls_comm_1_get (ff-pointer obj)))

(cl:defmethod (cl:setf comm_2) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_comm_2_set (ff-pointer obj) arg0))

(cl:defmethod comm_2 ((obj fgnet-ctrls))
  (FGNetCtrls_comm_2_get (ff-pointer obj)))

(cl:defmethod (cl:setf nav_1) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_nav_1_set (ff-pointer obj) arg0))

(cl:defmethod nav_1 ((obj fgnet-ctrls))
  (FGNetCtrls_nav_1_get (ff-pointer obj)))

(cl:defmethod (cl:setf nav_2) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_nav_2_set (ff-pointer obj) arg0))

(cl:defmethod nav_2 ((obj fgnet-ctrls))
  (FGNetCtrls_nav_2_get (ff-pointer obj)))

(cl:defmethod (cl:setf wind_speed_kt) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_wind_speed_kt_set (ff-pointer obj) arg0))

(cl:defmethod wind_speed_kt ((obj fgnet-ctrls))
  (FGNetCtrls_wind_speed_kt_get (ff-pointer obj)))

(cl:defmethod (cl:setf wind_dir_deg) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_wind_dir_deg_set (ff-pointer obj) arg0))

(cl:defmethod wind_dir_deg ((obj fgnet-ctrls))
  (FGNetCtrls_wind_dir_deg_get (ff-pointer obj)))

(cl:defmethod (cl:setf turbulence_norm) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_turbulence_norm_set (ff-pointer obj) arg0))

(cl:defmethod turbulence_norm ((obj fgnet-ctrls))
  (FGNetCtrls_turbulence_norm_get (ff-pointer obj)))

(cl:defmethod (cl:setf temp_c) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_temp_c_set (ff-pointer obj) arg0))

(cl:defmethod temp_c ((obj fgnet-ctrls))
  (FGNetCtrls_temp_c_get (ff-pointer obj)))

(cl:defmethod (cl:setf press_inhg) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_press_inhg_set (ff-pointer obj) arg0))

(cl:defmethod press_inhg ((obj fgnet-ctrls))
  (FGNetCtrls_press_inhg_get (ff-pointer obj)))

(cl:defmethod (cl:setf hground) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_hground_set (ff-pointer obj) arg0))

(cl:defmethod hground ((obj fgnet-ctrls))
  (FGNetCtrls_hground_get (ff-pointer obj)))

(cl:defmethod (cl:setf magvar) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_magvar_set (ff-pointer obj) arg0))

(cl:defmethod magvar ((obj fgnet-ctrls))
  (FGNetCtrls_magvar_get (ff-pointer obj)))

(cl:defmethod (cl:setf icing) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_icing_set (ff-pointer obj) arg0))

(cl:defmethod icing ((obj fgnet-ctrls))
  (FGNetCtrls_icing_get (ff-pointer obj)))

(cl:defmethod (cl:setf speedup) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_speedup_set (ff-pointer obj) arg0))

(cl:defmethod speedup ((obj fgnet-ctrls))
  (FGNetCtrls_speedup_get (ff-pointer obj)))

(cl:defmethod (cl:setf freeze) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_freeze_set (ff-pointer obj) arg0))

(cl:defmethod freeze ((obj fgnet-ctrls))
  (FGNetCtrls_freeze_get (ff-pointer obj)))

(cl:defmethod (cl:setf reserved) (arg0 (obj fgnet-ctrls))
  (FGNetCtrls_reserved_set (ff-pointer obj) arg0))

(cl:defmethod reserved ((obj fgnet-ctrls))
  (FGNetCtrls_reserved_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj fgnet-ctrls) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNetCtrls)))


(cl:defclass fgnet-mini-fdm()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf version) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_version_set (ff-pointer obj) arg0))

(cl:defmethod version ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_version_get (ff-pointer obj)))

(cl:defmethod (cl:setf longitude) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_longitude_set (ff-pointer obj) arg0))

(cl:defmethod longitude ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_longitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf latitude) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_latitude_set (ff-pointer obj) arg0))

(cl:defmethod latitude ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_latitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf altitude) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_altitude_set (ff-pointer obj) arg0))

(cl:defmethod altitude ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_altitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf agl) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_agl_set (ff-pointer obj) arg0))

(cl:defmethod agl ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_agl_get (ff-pointer obj)))

(cl:defmethod (cl:setf phi) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_phi_set (ff-pointer obj) arg0))

(cl:defmethod phi ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_phi_get (ff-pointer obj)))

(cl:defmethod (cl:setf theta) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_theta_set (ff-pointer obj) arg0))

(cl:defmethod theta ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_theta_get (ff-pointer obj)))

(cl:defmethod (cl:setf psi) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_psi_set (ff-pointer obj) arg0))

(cl:defmethod psi ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_psi_get (ff-pointer obj)))

(cl:defmethod (cl:setf vcas) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_vcas_set (ff-pointer obj) arg0))

(cl:defmethod vcas ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_vcas_get (ff-pointer obj)))

(cl:defmethod (cl:setf climb_rate) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_climb_rate_set (ff-pointer obj) arg0))

(cl:defmethod climb_rate ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_climb_rate_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_tanks) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_num_tanks_set (ff-pointer obj) arg0))

(cl:defmethod num_tanks ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_num_tanks_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_quantity) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_fuel_quantity_set (ff-pointer obj) arg0))

(cl:defmethod fuel_quantity ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_fuel_quantity_get (ff-pointer obj)))

(cl:defmethod (cl:setf cur_time) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_cur_time_set (ff-pointer obj) arg0))

(cl:defmethod cur_time ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_cur_time_get (ff-pointer obj)))

(cl:defmethod (cl:setf warp) (arg0 (obj fgnet-mini-fdm))
  (FGNetMiniFDM_warp_set (ff-pointer obj) arg0))

(cl:defmethod warp ((obj fgnet-mini-fdm))
  (FGNetMiniFDM_warp_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj fgnet-mini-fdm) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNetMiniFDM)))


(cl:defclass fgnet-gui()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf version) (arg0 (obj fgnet-gui))
  (FGNetGUI_version_set (ff-pointer obj) arg0))

(cl:defmethod version ((obj fgnet-gui))
  (FGNetGUI_version_get (ff-pointer obj)))

(cl:defmethod (cl:setf longitude) (arg0 (obj fgnet-gui))
  (FGNetGUI_longitude_set (ff-pointer obj) arg0))

(cl:defmethod longitude ((obj fgnet-gui))
  (FGNetGUI_longitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf latitude) (arg0 (obj fgnet-gui))
  (FGNetGUI_latitude_set (ff-pointer obj) arg0))

(cl:defmethod latitude ((obj fgnet-gui))
  (FGNetGUI_latitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf altitude) (arg0 (obj fgnet-gui))
  (FGNetGUI_altitude_set (ff-pointer obj) arg0))

(cl:defmethod altitude ((obj fgnet-gui))
  (FGNetGUI_altitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf agl) (arg0 (obj fgnet-gui))
  (FGNetGUI_agl_set (ff-pointer obj) arg0))

(cl:defmethod agl ((obj fgnet-gui))
  (FGNetGUI_agl_get (ff-pointer obj)))

(cl:defmethod (cl:setf phi) (arg0 (obj fgnet-gui))
  (FGNetGUI_phi_set (ff-pointer obj) arg0))

(cl:defmethod phi ((obj fgnet-gui))
  (FGNetGUI_phi_get (ff-pointer obj)))

(cl:defmethod (cl:setf theta) (arg0 (obj fgnet-gui))
  (FGNetGUI_theta_set (ff-pointer obj) arg0))

(cl:defmethod theta ((obj fgnet-gui))
  (FGNetGUI_theta_get (ff-pointer obj)))

(cl:defmethod (cl:setf psi) (arg0 (obj fgnet-gui))
  (FGNetGUI_psi_set (ff-pointer obj) arg0))

(cl:defmethod psi ((obj fgnet-gui))
  (FGNetGUI_psi_get (ff-pointer obj)))

(cl:defmethod (cl:setf vcas) (arg0 (obj fgnet-gui))
  (FGNetGUI_vcas_set (ff-pointer obj) arg0))

(cl:defmethod vcas ((obj fgnet-gui))
  (FGNetGUI_vcas_get (ff-pointer obj)))

(cl:defmethod (cl:setf climb_rate) (arg0 (obj fgnet-gui))
  (FGNetGUI_climb_rate_set (ff-pointer obj) arg0))

(cl:defmethod climb_rate ((obj fgnet-gui))
  (FGNetGUI_climb_rate_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_tanks) (arg0 (obj fgnet-gui))
  (FGNetGUI_num_tanks_set (ff-pointer obj) arg0))

(cl:defmethod num_tanks ((obj fgnet-gui))
  (FGNetGUI_num_tanks_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_quantity) (arg0 (obj fgnet-gui))
  (FGNetGUI_fuel_quantity_set (ff-pointer obj) arg0))

(cl:defmethod fuel_quantity ((obj fgnet-gui))
  (FGNetGUI_fuel_quantity_get (ff-pointer obj)))

(cl:defmethod (cl:setf cur_time) (arg0 (obj fgnet-gui))
  (FGNetGUI_cur_time_set (ff-pointer obj) arg0))

(cl:defmethod cur_time ((obj fgnet-gui))
  (FGNetGUI_cur_time_get (ff-pointer obj)))

(cl:defmethod (cl:setf warp) (arg0 (obj fgnet-gui))
  (FGNetGUI_warp_set (ff-pointer obj) arg0))

(cl:defmethod warp ((obj fgnet-gui))
  (FGNetGUI_warp_get (ff-pointer obj)))

(cl:defmethod (cl:setf ground_elev) (arg0 (obj fgnet-gui))
  (FGNetGUI_ground_elev_set (ff-pointer obj) arg0))

(cl:defmethod ground_elev ((obj fgnet-gui))
  (FGNetGUI_ground_elev_get (ff-pointer obj)))

(cl:defmethod (cl:setf tuned_freq) (arg0 (obj fgnet-gui))
  (FGNetGUI_tuned_freq_set (ff-pointer obj) arg0))

(cl:defmethod tuned_freq ((obj fgnet-gui))
  (FGNetGUI_tuned_freq_get (ff-pointer obj)))

(cl:defmethod (cl:setf nav_radial) (arg0 (obj fgnet-gui))
  (FGNetGUI_nav_radial_set (ff-pointer obj) arg0))

(cl:defmethod nav_radial ((obj fgnet-gui))
  (FGNetGUI_nav_radial_get (ff-pointer obj)))

(cl:defmethod (cl:setf in_range) (arg0 (obj fgnet-gui))
  (FGNetGUI_in_range_set (ff-pointer obj) arg0))

(cl:defmethod in_range ((obj fgnet-gui))
  (FGNetGUI_in_range_get (ff-pointer obj)))

(cl:defmethod (cl:setf dist_nm) (arg0 (obj fgnet-gui))
  (FGNetGUI_dist_nm_set (ff-pointer obj) arg0))

(cl:defmethod dist_nm ((obj fgnet-gui))
  (FGNetGUI_dist_nm_get (ff-pointer obj)))

(cl:defmethod (cl:setf course_deviation_deg) (arg0 (obj fgnet-gui))
  (FGNetGUI_course_deviation_deg_set (ff-pointer obj) arg0))

(cl:defmethod course_deviation_deg ((obj fgnet-gui))
  (FGNetGUI_course_deviation_deg_get (ff-pointer obj)))

(cl:defmethod (cl:setf gs_deviation_deg) (arg0 (obj fgnet-gui))
  (FGNetGUI_gs_deviation_deg_set (ff-pointer obj) arg0))

(cl:defmethod gs_deviation_deg ((obj fgnet-gui))
  (FGNetGUI_gs_deviation_deg_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj fgnet-gui) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGNetGUI)))


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

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

(cl:defmethod gen-message ((self fgnmea))
  (FGNMEA_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgnmea))
  (FGNMEA_parse_message (ff-pointer self)))

(cl:defmethod open ((self fgnmea))
  (FGNMEA_open (ff-pointer self)))

(cl:defmethod process ((self fgnmea))
  (FGNMEA_process (ff-pointer self)))

(cl:defmethod close ((self fgnmea))
  (FGNMEA_close (ff-pointer self)))


(cl:defclass fgopen-gc()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgopen-gc) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGOpenGC)))

(cl:defmethod open ((self fgopen-gc))
  (FGOpenGC_open (ff-pointer self)))

(cl:defmethod process ((self fgopen-gc))
  (FGOpenGC_process (ff-pointer self)))

(cl:defmethod close ((self fgopen-gc))
  (FGOpenGC_close (ff-pointer self)))

(cl:defmethod collect-data ((self fgopen-gc) data)
  (FGOpenGC_collect_data (ff-pointer self) data))


(cl:defclass ogc-fgdata()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf version_id) (arg0 (obj ogc-fgdata))
  (ogcFGData_version_id_set (ff-pointer obj) arg0))

(cl:defmethod version_id ((obj ogc-fgdata))
  (ogcFGData_version_id_get (ff-pointer obj)))

(cl:defmethod (cl:setf msg_type) (arg0 (obj ogc-fgdata))
  (ogcFGData_msg_type_set (ff-pointer obj) arg0))

(cl:defmethod msg_type ((obj ogc-fgdata))
  (ogcFGData_msg_type_get (ff-pointer obj)))

(cl:defmethod (cl:setf msg_content) (arg0 (obj ogc-fgdata))
  (ogcFGData_msg_content_set (ff-pointer obj) arg0))

(cl:defmethod msg_content ((obj ogc-fgdata))
  (ogcFGData_msg_content_get (ff-pointer obj)))

(cl:defmethod (cl:setf reserved) (arg0 (obj ogc-fgdata))
  (ogcFGData_reserved_set (ff-pointer obj) arg0))

(cl:defmethod reserved ((obj ogc-fgdata))
  (ogcFGData_reserved_get (ff-pointer obj)))

(cl:defmethod (cl:setf latitude) (arg0 (obj ogc-fgdata))
  (ogcFGData_latitude_set (ff-pointer obj) arg0))

(cl:defmethod latitude ((obj ogc-fgdata))
  (ogcFGData_latitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf longitude) (arg0 (obj ogc-fgdata))
  (ogcFGData_longitude_set (ff-pointer obj) arg0))

(cl:defmethod longitude ((obj ogc-fgdata))
  (ogcFGData_longitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevation) (arg0 (obj ogc-fgdata))
  (ogcFGData_elevation_set (ff-pointer obj) arg0))

(cl:defmethod elevation ((obj ogc-fgdata))
  (ogcFGData_elevation_get (ff-pointer obj)))

(cl:defmethod (cl:setf magvar) (arg0 (obj ogc-fgdata))
  (ogcFGData_magvar_set (ff-pointer obj) arg0))

(cl:defmethod magvar ((obj ogc-fgdata))
  (ogcFGData_magvar_get (ff-pointer obj)))

(cl:defmethod (cl:setf pitch) (arg0 (obj ogc-fgdata))
  (ogcFGData_pitch_set (ff-pointer obj) arg0))

(cl:defmethod pitch ((obj ogc-fgdata))
  (ogcFGData_pitch_get (ff-pointer obj)))

(cl:defmethod (cl:setf bank) (arg0 (obj ogc-fgdata))
  (ogcFGData_bank_set (ff-pointer obj) arg0))

(cl:defmethod bank ((obj ogc-fgdata))
  (ogcFGData_bank_get (ff-pointer obj)))

(cl:defmethod (cl:setf heading) (arg0 (obj ogc-fgdata))
  (ogcFGData_heading_set (ff-pointer obj) arg0))

(cl:defmethod heading ((obj ogc-fgdata))
  (ogcFGData_heading_get (ff-pointer obj)))

(cl:defmethod (cl:setf altitude) (arg0 (obj ogc-fgdata))
  (ogcFGData_altitude_set (ff-pointer obj) arg0))

(cl:defmethod altitude ((obj ogc-fgdata))
  (ogcFGData_altitude_get (ff-pointer obj)))

(cl:defmethod (cl:setf altitude_agl) (arg0 (obj ogc-fgdata))
  (ogcFGData_altitude_agl_set (ff-pointer obj) arg0))

(cl:defmethod altitude_agl ((obj ogc-fgdata))
  (ogcFGData_altitude_agl_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_kcas) (arg0 (obj ogc-fgdata))
  (ogcFGData_v_kcas_set (ff-pointer obj) arg0))

(cl:defmethod v_kcas ((obj ogc-fgdata))
  (ogcFGData_v_kcas_get (ff-pointer obj)))

(cl:defmethod (cl:setf groundspeed) (arg0 (obj ogc-fgdata))
  (ogcFGData_groundspeed_set (ff-pointer obj) arg0))

(cl:defmethod groundspeed ((obj ogc-fgdata))
  (ogcFGData_groundspeed_get (ff-pointer obj)))

(cl:defmethod (cl:setf vvi) (arg0 (obj ogc-fgdata))
  (ogcFGData_vvi_set (ff-pointer obj) arg0))

(cl:defmethod vvi ((obj ogc-fgdata))
  (ogcFGData_vvi_get (ff-pointer obj)))

(cl:defmethod (cl:setf mach) (arg0 (obj ogc-fgdata))
  (ogcFGData_mach_set (ff-pointer obj) arg0))

(cl:defmethod mach ((obj ogc-fgdata))
  (ogcFGData_mach_get (ff-pointer obj)))

(cl:defmethod (cl:setf v_keas) (arg0 (obj ogc-fgdata))
  (ogcFGData_v_keas_set (ff-pointer obj) arg0))

(cl:defmethod v_keas ((obj ogc-fgdata))
  (ogcFGData_v_keas_get (ff-pointer obj)))

(cl:defmethod (cl:setf phi_dot) (arg0 (obj ogc-fgdata))
  (ogcFGData_phi_dot_set (ff-pointer obj) arg0))

(cl:defmethod phi_dot ((obj ogc-fgdata))
  (ogcFGData_phi_dot_get (ff-pointer obj)))

(cl:defmethod (cl:setf theta_dot) (arg0 (obj ogc-fgdata))
  (ogcFGData_theta_dot_set (ff-pointer obj) arg0))

(cl:defmethod theta_dot ((obj ogc-fgdata))
  (ogcFGData_theta_dot_get (ff-pointer obj)))

(cl:defmethod (cl:setf psi_dot) (arg0 (obj ogc-fgdata))
  (ogcFGData_psi_dot_set (ff-pointer obj) arg0))

(cl:defmethod psi_dot ((obj ogc-fgdata))
  (ogcFGData_psi_dot_get (ff-pointer obj)))

(cl:defmethod (cl:setf alpha) (arg0 (obj ogc-fgdata))
  (ogcFGData_alpha_set (ff-pointer obj) arg0))

(cl:defmethod alpha ((obj ogc-fgdata))
  (ogcFGData_alpha_get (ff-pointer obj)))

(cl:defmethod (cl:setf alpha_dot) (arg0 (obj ogc-fgdata))
  (ogcFGData_alpha_dot_set (ff-pointer obj) arg0))

(cl:defmethod alpha_dot ((obj ogc-fgdata))
  (ogcFGData_alpha_dot_get (ff-pointer obj)))

(cl:defmethod (cl:setf beta) (arg0 (obj ogc-fgdata))
  (ogcFGData_beta_set (ff-pointer obj) arg0))

(cl:defmethod beta ((obj ogc-fgdata))
  (ogcFGData_beta_get (ff-pointer obj)))

(cl:defmethod (cl:setf beta_dot) (arg0 (obj ogc-fgdata))
  (ogcFGData_beta_dot_set (ff-pointer obj) arg0))

(cl:defmethod beta_dot ((obj ogc-fgdata))
  (ogcFGData_beta_dot_get (ff-pointer obj)))

(cl:defmethod (cl:setf left_aileron) (arg0 (obj ogc-fgdata))
  (ogcFGData_left_aileron_set (ff-pointer obj) arg0))

(cl:defmethod left_aileron ((obj ogc-fgdata))
  (ogcFGData_left_aileron_get (ff-pointer obj)))

(cl:defmethod (cl:setf right_aileron) (arg0 (obj ogc-fgdata))
  (ogcFGData_right_aileron_set (ff-pointer obj) arg0))

(cl:defmethod right_aileron ((obj ogc-fgdata))
  (ogcFGData_right_aileron_get (ff-pointer obj)))

(cl:defmethod (cl:setf aileron_trim) (arg0 (obj ogc-fgdata))
  (ogcFGData_aileron_trim_set (ff-pointer obj) arg0))

(cl:defmethod aileron_trim ((obj ogc-fgdata))
  (ogcFGData_aileron_trim_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevator) (arg0 (obj ogc-fgdata))
  (ogcFGData_elevator_set (ff-pointer obj) arg0))

(cl:defmethod elevator ((obj ogc-fgdata))
  (ogcFGData_elevator_get (ff-pointer obj)))

(cl:defmethod (cl:setf elevator_trim) (arg0 (obj ogc-fgdata))
  (ogcFGData_elevator_trim_set (ff-pointer obj) arg0))

(cl:defmethod elevator_trim ((obj ogc-fgdata))
  (ogcFGData_elevator_trim_get (ff-pointer obj)))

(cl:defmethod (cl:setf rudder) (arg0 (obj ogc-fgdata))
  (ogcFGData_rudder_set (ff-pointer obj) arg0))

(cl:defmethod rudder ((obj ogc-fgdata))
  (ogcFGData_rudder_get (ff-pointer obj)))

(cl:defmethod (cl:setf rudder_trim) (arg0 (obj ogc-fgdata))
  (ogcFGData_rudder_trim_set (ff-pointer obj) arg0))

(cl:defmethod rudder_trim ((obj ogc-fgdata))
  (ogcFGData_rudder_trim_get (ff-pointer obj)))

(cl:defmethod (cl:setf flaps) (arg0 (obj ogc-fgdata))
  (ogcFGData_flaps_set (ff-pointer obj) arg0))

(cl:defmethod flaps ((obj ogc-fgdata))
  (ogcFGData_flaps_get (ff-pointer obj)))

(cl:defmethod (cl:setf flaps_cmd) (arg0 (obj ogc-fgdata))
  (ogcFGData_flaps_cmd_set (ff-pointer obj) arg0))

(cl:defmethod flaps_cmd ((obj ogc-fgdata))
  (ogcFGData_flaps_cmd_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_nose) (arg0 (obj ogc-fgdata))
  (ogcFGData_gear_nose_set (ff-pointer obj) arg0))

(cl:defmethod gear_nose ((obj ogc-fgdata))
  (ogcFGData_gear_nose_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_left) (arg0 (obj ogc-fgdata))
  (ogcFGData_gear_left_set (ff-pointer obj) arg0))

(cl:defmethod gear_left ((obj ogc-fgdata))
  (ogcFGData_gear_left_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_right) (arg0 (obj ogc-fgdata))
  (ogcFGData_gear_right_set (ff-pointer obj) arg0))

(cl:defmethod gear_right ((obj ogc-fgdata))
  (ogcFGData_gear_right_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_left_rear) (arg0 (obj ogc-fgdata))
  (ogcFGData_gear_left_rear_set (ff-pointer obj) arg0))

(cl:defmethod gear_left_rear ((obj ogc-fgdata))
  (ogcFGData_gear_left_rear_get (ff-pointer obj)))

(cl:defmethod (cl:setf gear_right_rear) (arg0 (obj ogc-fgdata))
  (ogcFGData_gear_right_rear_set (ff-pointer obj) arg0))

(cl:defmethod gear_right_rear ((obj ogc-fgdata))
  (ogcFGData_gear_right_rear_get (ff-pointer obj)))

(cl:defmethod (cl:setf parking_brake) (arg0 (obj ogc-fgdata))
  (ogcFGData_parking_brake_set (ff-pointer obj) arg0))

(cl:defmethod parking_brake ((obj ogc-fgdata))
  (ogcFGData_parking_brake_get (ff-pointer obj)))

(cl:defmethod (cl:setf wow_main) (arg0 (obj ogc-fgdata))
  (ogcFGData_wow_main_set (ff-pointer obj) arg0))

(cl:defmethod wow_main ((obj ogc-fgdata))
  (ogcFGData_wow_main_get (ff-pointer obj)))

(cl:defmethod (cl:setf wow_nose) (arg0 (obj ogc-fgdata))
  (ogcFGData_wow_nose_set (ff-pointer obj) arg0))

(cl:defmethod wow_nose ((obj ogc-fgdata))
  (ogcFGData_wow_nose_get (ff-pointer obj)))

(cl:defmethod (cl:setf rpm) (arg0 (obj ogc-fgdata))
  (ogcFGData_rpm_set (ff-pointer obj) arg0))

(cl:defmethod rpm ((obj ogc-fgdata))
  (ogcFGData_rpm_get (ff-pointer obj)))

(cl:defmethod (cl:setf n1_turbine) (arg0 (obj ogc-fgdata))
  (ogcFGData_n1_turbine_set (ff-pointer obj) arg0))

(cl:defmethod n1_turbine ((obj ogc-fgdata))
  (ogcFGData_n1_turbine_get (ff-pointer obj)))

(cl:defmethod (cl:setf epr) (arg0 (obj ogc-fgdata))
  (ogcFGData_epr_set (ff-pointer obj) arg0))

(cl:defmethod epr ((obj ogc-fgdata))
  (ogcFGData_epr_get (ff-pointer obj)))

(cl:defmethod (cl:setf egt) (arg0 (obj ogc-fgdata))
  (ogcFGData_egt_set (ff-pointer obj) arg0))

(cl:defmethod egt ((obj ogc-fgdata))
  (ogcFGData_egt_get (ff-pointer obj)))

(cl:defmethod (cl:setf n2_turbine) (arg0 (obj ogc-fgdata))
  (ogcFGData_n2_turbine_set (ff-pointer obj) arg0))

(cl:defmethod n2_turbine ((obj ogc-fgdata))
  (ogcFGData_n2_turbine_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_flow) (arg0 (obj ogc-fgdata))
  (ogcFGData_fuel_flow_set (ff-pointer obj) arg0))

(cl:defmethod fuel_flow ((obj ogc-fgdata))
  (ogcFGData_fuel_flow_get (ff-pointer obj)))

(cl:defmethod (cl:setf man_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_man_pressure_set (ff-pointer obj) arg0))

(cl:defmethod man_pressure ((obj ogc-fgdata))
  (ogcFGData_man_pressure_get (ff-pointer obj)))

(cl:defmethod (cl:setf oil_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_oil_pressure_set (ff-pointer obj) arg0))

(cl:defmethod oil_pressure ((obj ogc-fgdata))
  (ogcFGData_oil_pressure_get (ff-pointer obj)))

(cl:defmethod (cl:setf oil_temp) (arg0 (obj ogc-fgdata))
  (ogcFGData_oil_temp_set (ff-pointer obj) arg0))

(cl:defmethod oil_temp ((obj ogc-fgdata))
  (ogcFGData_oil_temp_get (ff-pointer obj)))

(cl:defmethod (cl:setf oil_quantity) (arg0 (obj ogc-fgdata))
  (ogcFGData_oil_quantity_set (ff-pointer obj) arg0))

(cl:defmethod oil_quantity ((obj ogc-fgdata))
  (ogcFGData_oil_quantity_get (ff-pointer obj)))

(cl:defmethod (cl:setf hyd_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_hyd_pressure_set (ff-pointer obj) arg0))

(cl:defmethod hyd_pressure ((obj ogc-fgdata))
  (ogcFGData_hyd_pressure_get (ff-pointer obj)))

(cl:defmethod (cl:setf throttle) (arg0 (obj ogc-fgdata))
  (ogcFGData_throttle_set (ff-pointer obj) arg0))

(cl:defmethod throttle ((obj ogc-fgdata))
  (ogcFGData_throttle_get (ff-pointer obj)))

(cl:defmethod (cl:setf mixture) (arg0 (obj ogc-fgdata))
  (ogcFGData_mixture_set (ff-pointer obj) arg0))

(cl:defmethod mixture ((obj ogc-fgdata))
  (ogcFGData_mixture_get (ff-pointer obj)))

(cl:defmethod (cl:setf prop_advance) (arg0 (obj ogc-fgdata))
  (ogcFGData_prop_advance_set (ff-pointer obj) arg0))

(cl:defmethod prop_advance ((obj ogc-fgdata))
  (ogcFGData_prop_advance_get (ff-pointer obj)))

(cl:defmethod (cl:setf num_tanks) (arg0 (obj ogc-fgdata))
  (ogcFGData_num_tanks_set (ff-pointer obj) arg0))

(cl:defmethod num_tanks ((obj ogc-fgdata))
  (ogcFGData_num_tanks_get (ff-pointer obj)))

(cl:defmethod (cl:setf fuel_tank) (arg0 (obj ogc-fgdata))
  (ogcFGData_fuel_tank_set (ff-pointer obj) arg0))

(cl:defmethod fuel_tank ((obj ogc-fgdata))
  (ogcFGData_fuel_tank_get (ff-pointer obj)))

(cl:defmethod (cl:setf static_temperature) (arg0 (obj ogc-fgdata))
  (ogcFGData_static_temperature_set (ff-pointer obj) arg0))

(cl:defmethod static_temperature ((obj ogc-fgdata))
  (ogcFGData_static_temperature_get (ff-pointer obj)))

(cl:defmethod (cl:setf total_temperature) (arg0 (obj ogc-fgdata))
  (ogcFGData_total_temperature_set (ff-pointer obj) arg0))

(cl:defmethod total_temperature ((obj ogc-fgdata))
  (ogcFGData_total_temperature_get (ff-pointer obj)))

(cl:defmethod (cl:setf static_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_static_pressure_set (ff-pointer obj) arg0))

(cl:defmethod static_pressure ((obj ogc-fgdata))
  (ogcFGData_static_pressure_get (ff-pointer obj)))

(cl:defmethod (cl:setf total_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_total_pressure_set (ff-pointer obj) arg0))

(cl:defmethod total_pressure ((obj ogc-fgdata))
  (ogcFGData_total_pressure_get (ff-pointer obj)))

(cl:defmethod (cl:setf dynamic_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_dynamic_pressure_set (ff-pointer obj) arg0))

(cl:defmethod dynamic_pressure ((obj ogc-fgdata))
  (ogcFGData_dynamic_pressure_get (ff-pointer obj)))

(cl:defmethod (cl:setf wind) (arg0 (obj ogc-fgdata))
  (ogcFGData_wind_set (ff-pointer obj) arg0))

(cl:defmethod wind ((obj ogc-fgdata))
  (ogcFGData_wind_get (ff-pointer obj)))

(cl:defmethod (cl:setf wind_dir) (arg0 (obj ogc-fgdata))
  (ogcFGData_wind_dir_set (ff-pointer obj) arg0))

(cl:defmethod wind_dir ((obj ogc-fgdata))
  (ogcFGData_wind_dir_get (ff-pointer obj)))

(cl:defmethod (cl:setf sea_level_pressure) (arg0 (obj ogc-fgdata))
  (ogcFGData_sea_level_pressure_set (ff-pointer obj) arg0))

(cl:defmethod sea_level_pressure ((obj ogc-fgdata))
  (ogcFGData_sea_level_pressure_get (ff-pointer obj)))

(cl:defmethod initialize-instance :after ((obj ogc-fgdata) &key)
  (setf (slot-value obj 'ff-pointer) (new_ogcFGData)))


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

(cl:defmethod initialize-instance :after ((obj fgprops) &key tokens)
  (setf (slot-value obj 'ff-pointer) (new_FGProps tokens)))

(cl:defmethod open ((self fgprops))
  (FGProps_open (ff-pointer self)))

(cl:defmethod process ((self fgprops))
  (FGProps_process (ff-pointer self)))

(cl:defmethod close ((self fgprops))
  (FGProps_close (ff-pointer self)))

(cl:defmethod handle-accept ((self fgprops))
  (FGProps_handleAccept (ff-pointer self)))


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

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

(cl:defmethod open ((self fgprotocol))
  (FGProtocol_open (ff-pointer self)))

(cl:defmethod process ((self fgprotocol))
  (FGProtocol_process (ff-pointer self)))

(cl:defmethod close ((self fgprotocol))
  (FGProtocol_close (ff-pointer self)))

(cl:defmethod get-direction ((self fgprotocol))
  (FGProtocol_get_direction (ff-pointer self)))

(cl:defmethod set-direction ((self fgprotocol) d)
  (FGProtocol_set_direction (ff-pointer self) d))

(cl:defmethod get-hz ((self fgprotocol))
  (FGProtocol_get_hz (ff-pointer self)))

(cl:defmethod set-hz ((self fgprotocol) (t-arg1 cl:number))
  (FGProtocol_set_hz (ff-pointer self) t-arg1))

(cl:defmethod get-count-down ((self fgprotocol))
  (FGProtocol_get_count_down (ff-pointer self)))

(cl:defmethod set-count-down ((self fgprotocol) (c cl:number))
  (FGProtocol_set_count_down (ff-pointer self) c))

(cl:defmethod inc-count-down ((self fgprotocol) (amt cl:number))
  (FGProtocol_inc_count_down (ff-pointer self) amt))

(cl:defmethod dec-count-down ((self fgprotocol) (amt cl:number))
  (FGProtocol_dec_count_down (ff-pointer self) amt))

(cl:defmethod inc-count ((self fgprotocol))
  (FGProtocol_inc_count (ff-pointer self)))

(cl:defmethod get-count ((self fgprotocol))
  (FGProtocol_get_count (ff-pointer self)))

(cl:defmethod gen-message ((self fgprotocol))
  (FGProtocol_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgprotocol))
  (FGProtocol_parse_message (ff-pointer self)))

(cl:defmethod is-enabled ((self fgprotocol))
  (FGProtocol_is_enabled (ff-pointer self)))

(cl:defmethod set-enabled ((self fgprotocol) (b t))
  (FGProtocol_set_enabled (ff-pointer self) b))

(cl:defmethod get-io-channel ((self fgprotocol))
  (FGProtocol_get_io_channel (ff-pointer self)))

(cl:defmethod set-io-channel ((self fgprotocol) c)
  (FGProtocol_set_io_channel (ff-pointer self) c))


(cl:defclass fgprotocol-config-error()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgprotocol-config-error) &key what_string)
  (setf (slot-value obj 'ff-pointer) (new_FGProtocolConfigError what_string)))


(cl:defclass fgpve(FGProtocol)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod gen-message ((self fgpve))
  (FGPVE_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgpve))
  (FGPVE_parse_message (ff-pointer self)))

(cl:defmethod process ((self fgpve))
  (FGPVE_process (ff-pointer self)))


(cl:defclass fgray(FGProtocol)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod gen-message ((self fgray))
  (FGRAY_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgray))
  (FGRAY_parse_message (ff-pointer self)))

(cl:defmethod process ((self fgray))
  (FGRAY_process (ff-pointer self)))


(cl:defclass fgrul(FGProtocol)
  ((ff-pointer :reader ff-pointer)))

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

(cl:defmethod gen-message ((self fgrul))
  (FGRUL_gen_message (ff-pointer self)))

(cl:defmethod parse-message ((self fgrul))
  (FGRUL_parse_message (ff-pointer self)))

(cl:defmethod process ((self fgrul))
  (FGRUL_process (ff-pointer self)))


(cl:defclass scenery-pager()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj scenery-pager) &key)
  (setf (slot-value obj 'ff-pointer) (new_SceneryPager)))

(cl:defmethod initialize-instance :after ((obj scenery-pager) &key (rhs scenery-pager))
  (setf (slot-value obj 'ff-pointer) (new_SceneryPager (ff-pointer rhs))))

(cl:defmethod request-node-file ((self scenery-pager) fileName group (priority cl:number) framestamp databaseRequest options)
  (SceneryPager_requestNodeFile (ff-pointer self) fileName group priority framestamp databaseRequest options))

(cl:defmethod queue-request ((self scenery-pager) fileName node (priority cl:number) frameStamp databaseRequest options)
  (SceneryPager_queueRequest (ff-pointer self) fileName node priority frameStamp databaseRequest options))

(cl:defmethod queue-delete-request ((self scenery-pager) objptr)
  (SceneryPager_queueDeleteRequest (ff-pointer self) objptr))

(cl:defmethod signal-end-frame ((self scenery-pager))
  (SceneryPager_signalEndFrame (ff-pointer self)))


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

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

(cl:defmethod init ((self fgscenery))
  (FGScenery_init (ff-pointer self)))

(cl:defmethod bind ((self fgscenery))
  (FGScenery_bind (ff-pointer self)))

(cl:defmethod unbind ((self fgscenery))
  (FGScenery_unbind (ff-pointer self)))

(cl:defmethod update ((self fgscenery) (dt cl:number))
  (FGScenery_update (ff-pointer self) dt))

(cl:defmethod get-elevation-m ((self fgscenery) geod alt material butNotFrom)
  (FGScenery_get_elevation_m (ff-pointer self) geod alt material butNotFrom))

(cl:defmethod get-elevation-m ((self fgscenery) geod alt material)
  (FGScenery_get_elevation_m (ff-pointer self) geod alt material))

(cl:defmethod get-cart-elevation-m ((self fgscenery) pos (max_altoff cl:number) elevation material butNotFrom)
  (FGScenery_get_cart_elevation_m (ff-pointer self) pos max_altoff elevation material butNotFrom))

(cl:defmethod get-cart-elevation-m ((self fgscenery) pos (max_altoff cl:number) elevation material)
  (FGScenery_get_cart_elevation_m (ff-pointer self) pos max_altoff elevation material))

(cl:defmethod get-cart-ground-intersection ((self fgscenery) start dir nearestHit butNotFrom)
  (FGScenery_get_cart_ground_intersection (ff-pointer self) start dir nearestHit butNotFrom))

(cl:defmethod get-cart-ground-intersection ((self fgscenery) start dir nearestHit)
  (FGScenery_get_cart_ground_intersection (ff-pointer self) start dir nearestHit))

(cl:defmethod get-scene-graph ((self fgscenery))
  (FGScenery_get_scene_graph (ff-pointer self)))

(cl:defmethod get-terrain-branch ((self fgscenery))
  (FGScenery_get_terrain_branch (ff-pointer self)))

(cl:defmethod get-models-branch ((self fgscenery))
  (FGScenery_get_models_branch (ff-pointer self)))

(cl:defmethod get-aircraft-branch ((self fgscenery))
  (FGScenery_get_aircraft_branch (ff-pointer self)))

(cl:defmethod scenery-available ((self fgscenery) position (range_m cl:number))
  (FGScenery_scenery_available (ff-pointer self) position range_m))


(cl:defclass fgtile-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgtile-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTileMgr)))

(cl:defmethod init ((self fgtile-mgr))
  (FGTileMgr_init (ff-pointer self)))

(cl:defmethod reinit ((self fgtile-mgr))
  (FGTileMgr_reinit (ff-pointer self)))

(cl:defmethod update ((self fgtile-mgr) (dt cl:number))
  (FGTileMgr_update (ff-pointer self) dt))

(cl:defmethod config-changed ((self fgtile-mgr))
  (FGTileMgr_configChanged (ff-pointer self)))

(cl:defmethod schedule-tiles-at ((self fgtile-mgr) location (rangeM cl:number))
  (FGTileMgr_schedule_tiles_at (ff-pointer self) location rangeM))

(cl:defmethod get-current-bucket ((self fgtile-mgr))
  (FGTileMgr_get_current_bucket (ff-pointer self)))

(cl:defmethod schedule-scenery ((self fgtile-mgr) position (range_m cl:number) (duration cl:number))
  (FGTileMgr_schedule_scenery (ff-pointer self) position range_m duration))

(cl:defmethod schedule-scenery ((self fgtile-mgr) position (range_m cl:number))
  (FGTileMgr_schedule_scenery (ff-pointer self) position range_m))

(cl:defmethod load-tile-model ((self fgtile-mgr) modelPath (cacheModel t))
  (FGTileMgr_loadTileModel (ff-pointer self) modelPath cacheModel))

(cl:defmethod is-scenery-loaded ((self fgtile-mgr))
  (FGTileMgr_isSceneryLoaded (ff-pointer self)))


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

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

(cl:defmethod init ((self fgbeacon))
  (FGBeacon_init (ff-pointer self)))

(cl:defmethod get-inner ((self fgbeacon))
  (FGBeacon_get_inner (ff-pointer self)))

(cl:defmethod get-middle ((self fgbeacon))
  (FGBeacon_get_middle (ff-pointer self)))

(cl:defmethod get-outer ((self fgbeacon))
  (FGBeacon_get_outer (ff-pointer self)))


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

(cl:defmethod initialize-instance :after ((obj fgfx) &key smgr refname)
  (setf (slot-value obj 'ff-pointer) (new_FGFX smgr refname)))

(cl:defmethod init ((self fgfx))
  (FGFX_init (ff-pointer self)))

(cl:defmethod reinit ((self fgfx))
  (FGFX_reinit (ff-pointer self)))

(cl:defmethod update ((self fgfx) (dt cl:number))
  (FGFX_update (ff-pointer self) dt))


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

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

(cl:defmethod init ((self fgmorse))
  (FGMorse_init (ff-pointer self)))

(cl:defmethod make-ident ((self fgmorse) id (freq cl:integer))
  (FGMorse_make_ident (ff-pointer self) id freq))

(cl:defmethod make-ident ((self fgmorse) id)
  (FGMorse_make_ident (ff-pointer self) id))


(cl:defclass fgsample-queue()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgsample-queue) &key smgr refname)
  (setf (slot-value obj 'ff-pointer) (new_FGSampleQueue smgr refname)))

(cl:defmethod update ((self fgsample-queue) (dt cl:number))
  (FGSampleQueue_update (ff-pointer self) dt))

(cl:defmethod add ((self fgsample-queue) msg)
  (FGSampleQueue_add (ff-pointer self) msg))


(cl:defclass raw-value-methods-data()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod (cl:setf volume) (arg0 (obj raw-value-methods-data))
  (RawValueMethodsData_volume_set (ff-pointer obj) arg0))

(cl:defmethod volume ((obj raw-value-methods-data))
  (RawValueMethodsData_volume_get (ff-pointer obj)))

(cl:defmethod (cl:setf voice) (arg0 (obj raw-value-methods-data))
  (RawValueMethodsData_voice_set (ff-pointer obj) arg0))

(cl:defmethod voice ((obj raw-value-methods-data))
  (RawValueMethodsData_voice_get (ff-pointer obj)))

(cl:defmethod (cl:setf next_voice) (arg0 (obj raw-value-methods-data))
  (RawValueMethodsData_next_voice_set (ff-pointer obj) arg0))

(cl:defmethod next_voice ((obj raw-value-methods-data))
  (RawValueMethodsData_next_voice_get (ff-pointer obj)))

(cl:defmethod (cl:setf paused) (arg0 (obj raw-value-methods-data))
  (RawValueMethodsData_paused_set (ff-pointer obj) arg0))

(cl:defmethod paused ((obj raw-value-methods-data))
  (RawValueMethodsData_paused_get (ff-pointer obj)))

(cl:defmethod (cl:setf dev_name) (arg0 (obj raw-value-methods-data))
  (RawValueMethodsData_dev_name_set (ff-pointer obj) arg0))

(cl:defmethod dev_name ((obj raw-value-methods-data))
  (RawValueMethodsData_dev_name_get (ff-pointer obj)))

(cl:defmethod (cl:setf dir_prefix) (arg0 (obj raw-value-methods-data))
  (RawValueMethodsData_dir_prefix_set (ff-pointer obj) arg0))

(cl:defmethod dir_prefix ((obj raw-value-methods-data))
  (RawValueMethodsData_dir_prefix_get (ff-pointer obj)))

(cl:defmethod init ((self raw-value-methods-data))
  (RawValueMethodsData_init (ff-pointer self)))

(cl:defmethod pause ((self raw-value-methods-data))
  (RawValueMethodsData_pause (ff-pointer self)))

(cl:defmethod resume ((self raw-value-methods-data))
  (RawValueMethodsData_resume (ff-pointer self)))

(cl:defmethod is-playing ((self raw-value-methods-data))
  (RawValueMethodsData_is_playing (ff-pointer self)))

(cl:defmethod play ((self raw-value-methods-data) _voice (flags cl:integer))
  (RawValueMethodsData_play (ff-pointer self) _voice flags))

(cl:defmethod play ((self raw-value-methods-data) _voice)
  (RawValueMethodsData_play (ff-pointer self) _voice))

(cl:defmethod stop ((self raw-value-methods-data) (flags cl:integer))
  (RawValueMethodsData_stop (ff-pointer self) flags))

(cl:defmethod stop ((self raw-value-methods-data))
  (RawValueMethodsData_stop (ff-pointer self)))

(cl:defmethod set-volume ((self raw-value-methods-data) (_volume cl:number))
  (RawValueMethodsData_set_volume (ff-pointer self) _volume))

(cl:defmethod update ((self raw-value-methods-data))
  (RawValueMethodsData_update (ff-pointer self)))

(cl:defmethod bind ((self raw-value-methods-data) node (default_dir_prefix cl:string))
  (RawValueMethodsData_bind (ff-pointer self) node default_dir_prefix))


(cl:defclass pitot-system()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj pitot-system) &key node)
  (setf (slot-value obj 'ff-pointer) (new_PitotSystem node)))

(cl:defmethod init ((self pitot-system))
  (PitotSystem_init (ff-pointer self)))

(cl:defmethod bind ((self pitot-system))
  (PitotSystem_bind (ff-pointer self)))

(cl:defmethod unbind ((self pitot-system))
  (PitotSystem_unbind (ff-pointer self)))

(cl:defmethod update ((self pitot-system) (dt cl:number))
  (PitotSystem_update (ff-pointer self) dt))


(cl:defclass static-system()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj static-system) &key node)
  (setf (slot-value obj 'ff-pointer) (new_StaticSystem node)))

(cl:defmethod initialize-instance :after ((obj static-system) &key (i cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_StaticSystem i)))

(cl:defmethod init ((self static-system))
  (StaticSystem_init (ff-pointer self)))

(cl:defmethod bind ((self static-system))
  (StaticSystem_bind (ff-pointer self)))

(cl:defmethod unbind ((self static-system))
  (StaticSystem_unbind (ff-pointer self)))

(cl:defmethod update ((self static-system) (dt cl:number))
  (StaticSystem_update (ff-pointer self) dt))


(cl:defclass fgsystem-mgr()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgsystem-mgr) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGSystemMgr)))

(cl:defmethod build ((self fgsystem-mgr) config_props)
  (FGSystemMgr_build (ff-pointer self) config_props))


(cl:defclass vacuum-system()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj vacuum-system) &key node)
  (setf (slot-value obj 'ff-pointer) (new_VacuumSystem node)))

(cl:defmethod initialize-instance :after ((obj vacuum-system) &key (i cl:integer))
  (setf (slot-value obj 'ff-pointer) (new_VacuumSystem i)))

(cl:defmethod init ((self vacuum-system))
  (VacuumSystem_init (ff-pointer self)))

(cl:defmethod bind ((self vacuum-system))
  (VacuumSystem_bind (ff-pointer self)))

(cl:defmethod unbind ((self vacuum-system))
  (VacuumSystem_unbind (ff-pointer self)))

(cl:defmethod update ((self vacuum-system) (dt cl:number))
  (VacuumSystem_update (ff-pointer self) dt))


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

(cl:defmethod initialize-instance :after ((obj time-manager) &key)
  (setf (slot-value obj 'ff-pointer) (new_TimeManager)))

(cl:defmethod compute-time-deltas ((self time-manager) simDt realDt)
  (TimeManager_computeTimeDeltas (ff-pointer self) simDt realDt))

(cl:defmethod init ((self time-manager))
  (TimeManager_init (ff-pointer self)))

(cl:defmethod reinit ((self time-manager))
  (TimeManager_reinit (ff-pointer self)))

(cl:defmethod postinit ((self time-manager))
  (TimeManager_postinit (ff-pointer self)))

(cl:defmethod shutdown ((self time-manager))
  (TimeManager_shutdown (ff-pointer self)))

(cl:defmethod update ((self time-manager) (dt cl:number))
  (TimeManager_update (ff-pointer self) dt))

(cl:defmethod value-changed ((self time-manager) arg1)
  (TimeManager_valueChanged (ff-pointer self) arg1))


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

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

(cl:defmethod init ((self fglight))
  (FGLight_init (ff-pointer self)))

(cl:defmethod reinit ((self fglight))
  (FGLight_reinit (ff-pointer self)))

(cl:defmethod bind ((self fglight))
  (FGLight_bind (ff-pointer self)))

(cl:defmethod unbind ((self fglight))
  (FGLight_unbind (ff-pointer self)))

(cl:defmethod update ((self fglight) (dt cl:number))
  (FGLight_update (ff-pointer self) dt))

(cl:defmethod scene-ambient ((self fglight))
  (FGLight_scene_ambient (ff-pointer self)))

(cl:defmethod scene-diffuse ((self fglight))
  (FGLight_scene_diffuse (ff-pointer self)))

(cl:defmethod scene-specular ((self fglight))
  (FGLight_scene_specular (ff-pointer self)))

(cl:defmethod scene-chrome ((self fglight))
  (FGLight_scene_chrome (ff-pointer self)))

(cl:defmethod sky-color ((self fglight))
  (FGLight_sky_color (ff-pointer self)))

(cl:defmethod cloud-color ((self fglight))
  (FGLight_cloud_color (ff-pointer self)))

(cl:defmethod adj-fog-color ((self fglight))
  (FGLight_adj_fog_color (ff-pointer self)))

(cl:defmethod adj-sky-color ((self fglight))
  (FGLight_adj_sky_color (ff-pointer self)))

(cl:defmethod get-sun-angle ((self fglight))
  (FGLight_get_sun_angle (ff-pointer self)))

(cl:defmethod set-sun-angle ((self fglight) (a cl:number))
  (FGLight_set_sun_angle (ff-pointer self) a))

(cl:defmethod get-sun-rotation ((self fglight))
  (FGLight_get_sun_rotation (ff-pointer self)))

(cl:defmethod set-sun-rotation ((self fglight) (r cl:number))
  (FGLight_set_sun_rotation (ff-pointer self) r))

(cl:defmethod get-sun-lon ((self fglight))
  (FGLight_get_sun_lon (ff-pointer self)))

(cl:defmethod set-sun-lon ((self fglight) (l cl:number))
  (FGLight_set_sun_lon (ff-pointer self) l))

(cl:defmethod get-sun-lat ((self fglight))
  (FGLight_get_sun_lat (ff-pointer self)))

(cl:defmethod set-sun-lat ((self fglight) (l cl:number))
  (FGLight_set_sun_lat (ff-pointer self) l))

(cl:defmethod sun-vec ((self fglight))
  (FGLight_sun_vec (ff-pointer self)))

(cl:defmethod sun-vec-inv ((self fglight))
  (FGLight_sun_vec_inv (ff-pointer self)))

(cl:defmethod get-moon-angle ((self fglight))
  (FGLight_get_moon_angle (ff-pointer self)))

(cl:defmethod set-moon-angle ((self fglight) (a cl:number))
  (FGLight_set_moon_angle (ff-pointer self) a))

(cl:defmethod get-moon-rotation ((self fglight))
  (FGLight_get_moon_rotation (ff-pointer self)))

(cl:defmethod set-moon-rotation ((self fglight) (r cl:number))
  (FGLight_set_moon_rotation (ff-pointer self) r))

(cl:defmethod get-moon-lon ((self fglight))
  (FGLight_get_moon_lon (ff-pointer self)))

(cl:defmethod set-moon-lon ((self fglight) (l cl:number))
  (FGLight_set_moon_lon (ff-pointer self) l))

(cl:defmethod get-moon-gc-lat ((self fglight))
  (FGLight_get_moon_gc_lat (ff-pointer self)))

(cl:defmethod set-moon-gc-lat ((self fglight) (l cl:number))
  (FGLight_set_moon_gc_lat (ff-pointer self) l))

(cl:defmethod moon-vec ((self fglight))
  (FGLight_moon_vec (ff-pointer self)))

(cl:defmethod moon-vec-inv ((self fglight))
  (FGLight_moon_vec_inv (ff-pointer self)))


(cl:defclass fgscheduled-flight()
  ((ff-pointer :reader ff-pointer)))

(cl:defmethod initialize-instance :after ((obj fgscheduled-flight) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGScheduledFlight)))

(cl:defmethod initialize-instance :after ((obj fgscheduled-flight) &key (other fgscheduled-flight))
  (setf (slot-value obj 'ff-pointer) (new_FGScheduledFlight (ff-pointer other))))

(cl:defmethod initialize-instance :after ((obj fgscheduled-flight) &key cs fr depPrt arrPrt (cruiseAlt cl:integer) deptime arrtime rep reqAC)
  (setf (slot-value obj 'ff-pointer) (new_FGScheduledFlight cs fr depPrt arrPrt cruiseAlt deptime arrtime rep reqAC)))

(cl:defmethod update ((self fgscheduled-flight))
  (FGScheduledFlight_update (ff-pointer self)))

(cl:defmethod initialize-airports ((self fgscheduled-flight))
  (FGScheduledFlight_initializeAirports (ff-pointer self)))

(cl:defmethod adjust-time ((self fgscheduled-flight) now)
  (FGScheduledFlight_adjustTime (ff-pointer self) now))

(cl:defmethod get-departure-time ((self fgscheduled-flight))
  (FGScheduledFlight_getDepartureTime (ff-pointer self)))

(cl:defmethod get-arrival-time ((self fgscheduled-flight))
  (FGScheduledFlight_getArrivalTime (ff-pointer self)))

(cl:defmethod get-departure-airport ((self fgscheduled-flight))
  (FGScheduledFlight_getDepartureAirport (ff-pointer self)))

(cl:defmethod get-arrival-airport ((self fgscheduled-flight))
  (FGScheduledFlight_getArrivalAirport (ff-pointer self)))

(cl:defmethod get-cruise-alt ((self fgscheduled-flight))
  (FGScheduledFlight_getCruiseAlt (ff-pointer self)))

(cl:shadow "<")
(cl:defmethod < ((self fgscheduled-flight) (other fgscheduled-flight))
  (FGScheduledFlight___lt__ (ff-pointer self) (ff-pointer other)))

(cl:defmethod get-flight-rules ((self fgscheduled-flight))
  (FGScheduledFlight_getFlightRules (ff-pointer self)))

(cl:defmethod process-time-string ((self fgscheduled-flight) time)
  (FGScheduledFlight_processTimeString (ff-pointer self) time))

(cl:defmethod get-call-sign ((self fgscheduled-flight))
  (FGScheduledFlight_getCallSign (ff-pointer self)))

(cl:defmethod get-requirement ((self fgscheduled-flight))
  (FGScheduledFlight_getRequirement (ff-pointer self)))

(cl:defmethod lock ((self fgscheduled-flight))
  (FGScheduledFlight_lock (ff-pointer self)))

(cl:defmethod release ((self fgscheduled-flight))
  (FGScheduledFlight_release (ff-pointer self)))

(cl:defmethod is-available ((self fgscheduled-flight))
  (FGScheduledFlight_isAvailable (ff-pointer self)))


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

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

(cl:defmethod initialize-instance :after ((obj fgaischedule) &key model livery homePort registration flightId (heavy t) acType airline m_class flight_type (radius cl:number) (offset cl:number))
  (setf (slot-value obj 'ff-pointer) (new_FGAISchedule model livery homePort registration flightId heavy acType airline m_class flight_type radius offset)))

(cl:defmethod initialize-instance :after ((obj fgaischedule) &key (other fgaischedule))
  (setf (slot-value obj 'ff-pointer) (new_FGAISchedule (ff-pointer other))))

(cl:defmethod update ((self fgaischedule) now userCart)
  (FGAISchedule_update (ff-pointer self) now userCart))

(cl:defmethod init ((self fgaischedule))
  (FGAISchedule_init (ff-pointer self)))

(cl:defmethod get-speed ((self fgaischedule))
  (FGAISchedule_getSpeed (ff-pointer self)))

(cl:defmethod next ((self fgaischedule))
  (FGAISchedule_next (ff-pointer self)))

(cl:defmethod get-departure-time ((self fgaischedule))
  (FGAISchedule_getDepartureTime (ff-pointer self)))

(cl:defmethod get-departure-airport ((self fgaischedule))
  (FGAISchedule_getDepartureAirport (ff-pointer self)))

(cl:defmethod get-arrival-airport ((self fgaischedule))
  (FGAISchedule_getArrivalAirport (ff-pointer self)))

(cl:defmethod get-cruise-alt ((self fgaischedule))
  (FGAISchedule_getCruiseAlt (ff-pointer self)))

(cl:defmethod get-radius ((self fgaischedule))
  (FGAISchedule_getRadius (ff-pointer self)))

(cl:defmethod get-ground-offset ((self fgaischedule))
  (FGAISchedule_getGroundOffset (ff-pointer self)))

(cl:defmethod get-flight-type ((self fgaischedule))
  (FGAISchedule_getFlightType (ff-pointer self)))

(cl:defmethod get-airline ((self fgaischedule))
  (FGAISchedule_getAirline (ff-pointer self)))

(cl:defmethod get-aircraft ((self fgaischedule))
  (FGAISchedule_getAircraft (ff-pointer self)))

(cl:defmethod get-call-sign ((self fgaischedule))
  (FGAISchedule_getCallSign (ff-pointer self)))

(cl:defmethod get-registration ((self fgaischedule))
  (FGAISchedule_getRegistration (ff-pointer self)))

(cl:defmethod get-flight-rules ((self fgaischedule))
  (FGAISchedule_getFlightRules (ff-pointer self)))

(cl:defmethod get-heavy ((self fgaischedule))
  (FGAISchedule_getHeavy (ff-pointer self)))

(cl:defmethod get-course ((self fgaischedule))
  (FGAISchedule_getCourse (ff-pointer self)))

(cl:defmethod get-run-count ((self fgaischedule))
  (FGAISchedule_getRunCount (ff-pointer self)))

(cl:defmethod get-hits ((self fgaischedule))
  (FGAISchedule_getHits (ff-pointer self)))

(cl:defmethod setrun-count ((self fgaischedule) (count cl:integer))
  (FGAISchedule_setrunCount (ff-pointer self) count))

(cl:defmethod set-hits ((self fgaischedule) (count cl:integer))
  (FGAISchedule_setHits (ff-pointer self) count))

(cl:defmethod set-score ((self fgaischedule))
  (FGAISchedule_setScore (ff-pointer self)))

(cl:defmethod get-score ((self fgaischedule))
  (FGAISchedule_getScore (ff-pointer self)))

(cl:defmethod find-available-flight ((self fgaischedule) currentDestination req)
  (FGAISchedule_findAvailableFlight (ff-pointer self) currentDestination req))

(cl:shadow "<")
(cl:defmethod < ((self fgaischedule) (other fgaischedule))
  (FGAISchedule___lt__ (ff-pointer self) (ff-pointer other)))


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

(cl:defmethod (cl:setf registration) (arg0 (obj heuristic))
  (Heuristic_registration_set (ff-pointer obj) arg0))

(cl:defmethod registration ((obj heuristic))
  (Heuristic_registration_get (ff-pointer obj)))

(cl:defmethod (cl:setf runCount) (arg0 (obj heuristic))
  (Heuristic_runCount_set (ff-pointer obj) arg0))

(cl:defmethod runCount ((obj heuristic))
  (Heuristic_runCount_get (ff-pointer obj)))

(cl:defmethod (cl:setf hits) (arg0 (obj heuristic))
  (Heuristic_hits_set (ff-pointer obj) arg0))

(cl:defmethod hits ((obj heuristic))
  (Heuristic_hits_get (ff-pointer obj)))

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


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

(cl:defmethod initialize-instance :after ((obj fgtraffic-manager) &key)
  (setf (slot-value obj 'ff-pointer) (new_FGTrafficManager)))

(cl:defmethod init ((self fgtraffic-manager))
  (FGTrafficManager_init (ff-pointer self)))

(cl:defmethod update ((self fgtraffic-manager) (time cl:number))
  (FGTrafficManager_update (ff-pointer self) time))

(cl:defmethod release ((self fgtraffic-manager) (ref cl:integer))
  (FGTrafficManager_release (ff-pointer self) ref))

(cl:defmethod is-released ((self fgtraffic-manager) (id cl:integer))
  (FGTrafficManager_isReleased (ff-pointer self) id))

(cl:defmethod get-first-flight ((self fgtraffic-manager) ref)
  (FGTrafficManager_getFirstFlight (ff-pointer self) ref))

(cl:defmethod get-last-flight ((self fgtraffic-manager) ref)
  (FGTrafficManager_getLastFlight (ff-pointer self) ref))

(cl:defmethod start-xml ((self fgtraffic-manager))
  (FGTrafficManager_startXML (ff-pointer self)))

(cl:defmethod end-xml ((self fgtraffic-manager))
  (FGTrafficManager_endXML (ff-pointer self)))

(cl:defmethod start-element ((self fgtraffic-manager) (name cl:string) atts)
  (FGTrafficManager_startElement (ff-pointer self) name atts))

(cl:defmethod end-element ((self fgtraffic-manager) (name cl:string))
  (FGTrafficManager_endElement (ff-pointer self) name))

(cl:defmethod data ((self fgtraffic-manager) (s cl:string) (len cl:integer))
  (FGTrafficManager_data (ff-pointer self) s len))

(cl:defmethod pi ((self fgtraffic-manager) (target cl:string) (data cl:string))
  (FGTrafficManager_pi (ff-pointer self) target data))

(cl:defmethod warning ((self fgtraffic-manager) (message cl:string) (line cl:integer) (column cl:integer))
  (FGTrafficManager_warning (ff-pointer self) message line column))

(cl:defmethod error ((self fgtraffic-manager) (message cl:string) (line cl:integer) (column cl:integer))
  (FGTrafficManager_error (ff-pointer self) message line column))
ViewGit