fg_scene_commands.cxx

Go to the documentation of this file.

/*
 * SPDX-FileName: fg_scene_commands.cxx
 * SPDX-FileComment: internal FGFS commands
 */
 
#include "config.h"
 
#include <string.h>             // strcmp()
 
#include <simgear/compiler.h>
 
#include <string>
#include <fstream>
 
#include <simgear/sg_inlines.h>
#include <simgear/debug/logstream.hxx>
#include <simgear/math/sg_random.hxx>
#include <simgear/io/iostreams/sgstream.hxx>
#include <simgear/scene/material/mat.hxx>
#include <simgear/scene/material/matlib.hxx>
#include <simgear/structure/exception.hxx>
#include <simgear/structure/commands.hxx>
#include <simgear/props/props.hxx>
#include <simgear/props/props_io.hxx>
#include <simgear/structure/event_mgr.hxx>
#include <simgear/sound/soundmgr.hxx>
#include <simgear/timing/sg_time.hxx>
#include <Network/RemoteXMLRequest.hxx>
 
#include <FDM/flight.hxx>
#include <GUI/gui.h>
#include <GUI/new_gui.hxx>
#include <GUI/dialog.hxx>
#include <Aircraft/replay.hxx>
#include <Scenery/scenery.hxx>
#include <Scripting/NasalSys.hxx>
#include <Sound/sample_queue.hxx>
#include <Airports/xmlloader.hxx>
#include <Network/HTTPClient.hxx>
#include <Viewer/CameraGroup.hxx>
#include <Viewer/viewmgr.hxx>
#include <Viewer/view.hxx>
#include <Environment/presets.hxx>
#include <Navaids/NavDataCache.hxx>
 
#include "fg_init.hxx"
#include "fg_io.hxx"
#include "fg_os.hxx"
#include "fg_commands.hxx"
#include "fg_props.hxx"
#include "globals.hxx"
#include "logger.hxx"
#include "util.hxx"
#include "main.hxx"
#include "positioninit.hxx"
 
#if FG_HAVE_GPERFTOOLS
# include <google/profiler.h>
#endif
 
#if defined(HAVE_QT)
#include <GUI/QtLauncher.hxx>
#endif
 

// Command implementations.

static bool
do_exit (const SGPropertyNode * arg, SGPropertyNode * root)
{
    SG_LOG(SG_INPUT, SG_INFO, "Program exit requested.");
    fgSetBool("/sim/signals/exit", true);
    globals->saveUserSettings();
    fgOSExit(arg->getIntValue("status", 0));
    return true;
}
 

static bool
do_reset (const SGPropertyNode * arg, SGPropertyNode * root)
{
    fgResetIdleState();
    return true;
}
 

static bool
do_switch_aircraft (const SGPropertyNode * arg, SGPropertyNode * root)
{
    fgSetString("/sim/aircraft", arg->getStringValue("aircraft"));
 
    // we could validate the new aircraft is find-able, and if not, bail out
    // of the command at this point? Might give a better user experience?
    // would need something like bool fgIsValidAircraft(name, dir);
    // which could be cooked up by modifying FindAndCacheAircraft
 
    // We assume that we are changing the aircraft, so we remove the aircraft path.
    // this forces aircraft-dir to be recomputed by a full search as the user hopefully
    // expects. 
    // We could allow pasing the dir as an optional argument to this command, if that
    // is ever needed in the future.
    fgGetNode("/sim")->removeChild("aircraft-dir");
 
    // start a reset
    fgResetIdleState();
    return true;
}

static bool
do_reposition (const SGPropertyNode * arg, SGPropertyNode * root)
{
  fgStartReposition();
  return true;
}

static bool
do_panel_load (const SGPropertyNode * arg, SGPropertyNode * root)
{
  std::string panel_path = arg->getStringValue("path");
  if (!panel_path.empty()) {
    // write to the standard property, which will force a load
    fgSetString("/sim/panel/path", panel_path.c_str());
  }
 
  return true;
}

static bool
do_preferences_load (const SGPropertyNode * arg, SGPropertyNode * root)
{
    // disabling this command which was formerly used to reload 'preferences.xml'
    // reloading the defaults doesn't make sense (better to reset the simulator),
    // and loading arbitrary XML docs into the property-tree can be done via
    // the standard load-xml command.
    SG_LOG(SG_GENERAL, SG_ALERT, "preferences-load command is deprecated and non-functional");
    return false;
}

static bool
do_toggle_fullscreen(const SGPropertyNode*, SGPropertyNode*)
{
    fgOSFullScreen();
    return true;
}

static bool
do_screen_capture(const SGPropertyNode*, SGPropertyNode*)
{
  return fgDumpSnapShot();
}
 
static bool
do_reload_shaders (const SGPropertyNode*, SGPropertyNode*)
{
    simgear::reload_shaders();
    return true;
}
 
static bool
do_dump_scene_graph (const SGPropertyNode*, SGPropertyNode*)
{
    fgDumpSceneGraph();
    return true;
}
 
static bool
do_dump_terrain_branch (const SGPropertyNode*, SGPropertyNode*)
{
    fgDumpTerrainBranch();
 
    double lon_deg = fgGetDouble("/position/longitude-deg");
    double lat_deg = fgGetDouble("/position/latitude-deg");
    SGGeod geodPos = SGGeod::fromDegFt(lon_deg, lat_deg, 0.0);
    SGVec3d zero = SGVec3d::fromGeod(geodPos);
 
    SG_LOG(SG_INPUT, SG_INFO, "Model parameters:");
    SG_LOG(SG_INPUT, SG_INFO, "Center: " << zero.x() << ", " << zero.y() << ", " << zero.z() );
    SG_LOG(SG_INPUT, SG_INFO, "Rotation: " << lat_deg << ", " << lon_deg );
 
    return true;
}
 
static bool
do_print_visible_scene_info(const SGPropertyNode*, SGPropertyNode*)
{
    fgPrintVisibleSceneInfoCommand();
    return true;
}

static bool
do_reload_compositor(const SGPropertyNode*, SGPropertyNode*)
{
    flightgear::reloadCompositors(flightgear::CameraGroup::getDefault());
    return true;
}

static bool
do_tile_cache_reload (const SGPropertyNode * arg, SGPropertyNode * root)
{
    SGPropertyNode *master_freeze = fgGetNode("/sim/freeze/master");
    bool freeze = master_freeze->getBoolValue();
    SG_LOG(SG_INPUT, SG_INFO, "ReIniting TileCache");
    if ( !freeze ) {
        master_freeze->setBoolValue(true);
    }
 
    globals->get_subsystem<FGScenery>()->reinit();
 
    if ( !freeze ) {
        master_freeze->setBoolValue(false);
    }
    return true;
}

static bool
do_materials_reload (const SGPropertyNode * arg, SGPropertyNode * root)
{
    SG_LOG(SG_INPUT, SG_INFO, "Reloading Materials");
    SGMaterialLib* new_matlib =  new SGMaterialLib;
    SGPath mpath( globals->get_fg_root() );
    mpath.append( fgGetString("/sim/rendering/materials-file") );
    bool loaded = new_matlib->load(globals->get_fg_root(),
                                  mpath,
                                  globals->get_props());
 
    if ( ! loaded ) {
       SG_LOG( SG_GENERAL, SG_ALERT,
               "Error loading materials file " << mpath );
       return false;
    }
 
    globals->set_matlib(new_matlib);
    FGScenery* scenery = static_cast<FGScenery*>(globals->get_scenery());
    scenery->materialLibChanged();
 
    return true;
}

static bool
do_dialog_new (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    if (!gui) {
      return false;
    }
 
    // Note the casting away of const: this is *real*.  Doing a
    // "dialog-apply" command later on will mutate this property node.
    // I'm not convinced that this isn't the Right Thing though; it
    // allows client to create a node, pass it to dialog-new, and get
    // the values back from the dialog by reading the same node.
    // Perhaps command arguments are not as "const" as they would
    // seem?
    gui->newDialog((SGPropertyNode*)arg);
    return true;
}

static bool
do_dialog_show (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    gui->showDialog(arg->getStringValue("dialog-name"));
    return true;
}

static bool
do_dialog_toggle (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    gui->toggleDialog(arg->getStringValue("dialog-name"));
    return true;
}
 

static bool
do_dialog_close (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    if(arg->hasValue("dialog-name"))
        return gui->closeDialog(arg->getStringValue("dialog-name"));
    return gui->closeActiveDialog();
}
 

static bool
do_dialog_update (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    FGDialog * dialog;
    if (arg->hasValue("dialog-name"))
        dialog = gui->getDialog(arg->getStringValue("dialog-name"));
    else
        dialog = gui->getActiveDialog();
 
    if (dialog != 0) {
        dialog->updateValues(arg->getStringValue("object-name"));
        return true;
    } else {
        return false;
    }
}
 
static bool
do_open_browser (const SGPropertyNode * arg, SGPropertyNode * root)
{
    std::string path;
    if (arg->hasValue("path"))
        path = arg->getStringValue("path");
    else
    if (arg->hasValue("url"))
        path = arg->getStringValue("url");
    else
        return false;
 
    return openBrowser(path);
}
 
static bool
do_open_launcher(const SGPropertyNode*, SGPropertyNode*)
{
#if defined(HAVE_QT)
    bool ok = flightgear::runInAppLauncherDialog();
    if (ok) {
        // start a full reset
        fgResetIdleState();
    }
    return true; // don't report failure
#else
    return false;
#endif
}

static bool
do_dialog_apply (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    FGDialog* dialog = nullptr;
    if (arg->hasValue("dialog-name"))
        dialog = gui->getDialog(arg->getStringValue("dialog-name"));
    else
        dialog = gui->getActiveDialog();
 
    if (dialog) {
        dialog->applyValues(arg->getStringValue("object-name"));
        return true;
    } else {
        return false;
    }
}
 

static bool
do_gui_redraw (const SGPropertyNode * arg, SGPropertyNode * root)
{
    auto gui = globals->get_subsystem<NewGUI>();
    gui->redraw();
    return true;
}
 

static bool
do_add_model (const SGPropertyNode * arg, SGPropertyNode * root)
{
    SGPropertyNode * model = fgGetNode("models", true);
    int i;
    for (i = 0; model->hasChild("model",i); i++);
    model = model->getChild("model", i, true);
    copyProperties(arg, model);
    if (model->hasValue("elevation-m"))
        model->setDoubleValue("elevation-ft", model->getDoubleValue("elevation-m")
                * SG_METER_TO_FEET);
    model->getNode("load", true);
    model->removeChildren("load");
    const_cast<SGPropertyNode *>(arg)->setStringValue("property", model->getPath());
    return true;
}

static bool
do_presets_commit (const SGPropertyNode * arg, SGPropertyNode * root)
{
    if (fgGetBool("/sim/initialized", false)) {
      fgResetIdleState();
    } else {
      // Nasal can trigger this during initial init, which confuses
      // the logic in ReInitSubsystems, since initial state has not been
      // saved at that time. Short-circuit everything here.
      flightgear::initPosition();
    }
 
    return true;
}
 
static bool
do_press_cockpit_button (const SGPropertyNode * arg, SGPropertyNode * root)
{
  const std::string prefix = arg->getStringValue("prefix");
 
  if (arg->getBoolValue("guarded") && fgGetDouble((prefix + "-guard").c_str()) < 1)
    return true;
 
  std::string prop = prefix + "-button";
  double value;
 
  if (arg->getBoolValue("latching"))
    value = fgGetDouble(prop.c_str()) > 0 ? 0 : 1;
  else
    value = 1;
 
  fgSetDouble(prop.c_str(), value);
  fgSetBool(arg->getStringValue("discrete"), value > 0);
 
  return true;
}
 
static bool
do_release_cockpit_button (const SGPropertyNode * arg, SGPropertyNode * root)
{
  const std::string prefix = arg->getStringValue("prefix");
 
  if (arg->getBoolValue("guarded")) {
    std::string prop = prefix + "-guard";
    if (fgGetDouble(prop.c_str()) < 1) {
      fgSetDouble(prop.c_str(), 1);
      return true;
    }
  }
 
  if (! arg->getBoolValue("latching")) {
    fgSetDouble((prefix + "-button").c_str(), 0);
    fgSetBool(arg->getStringValue("discrete"), false);
  }
 
  return true;
}

// Command setup.
 

static struct {
  const char * name;
  SGCommandMgr::command_t command;
} built_ins [] = {
    { "exit", do_exit },
    { "reset", do_reset },
    { "reposition", do_reposition },
    { "switch-aircraft", do_switch_aircraft },
    { "panel-load", do_panel_load },
    { "preferences-load", do_preferences_load },
    { "toggle-fullscreen", do_toggle_fullscreen },
    { "screen-capture", do_screen_capture },
    { "tile-cache-reload", do_tile_cache_reload },
    { "dialog-new", do_dialog_new },
    { "dialog-show", do_dialog_show },
    { "dialog-toggle", do_dialog_toggle },
    { "dialog-close", do_dialog_close },
    { "dialog-update", do_dialog_update },
    { "dialog-apply", do_dialog_apply },
    { "open-browser", do_open_browser },
    { "gui-redraw", do_gui_redraw },
    { "add-model", do_add_model },
    { "presets-commit", do_presets_commit },
    { "press-cockpit-button", do_press_cockpit_button },
    { "release-cockpit-button", do_release_cockpit_button },
    { "dump-scenegraph", do_dump_scene_graph },
    { "dump-terrainbranch", do_dump_terrain_branch },
    { "print-visible-scene", do_print_visible_scene_info },
    { "reload-shaders", do_reload_shaders },
    { "reload-materials", do_materials_reload },
    { "reload-compositor", do_reload_compositor },
    { "open-launcher", do_open_launcher },
    { 0, 0 }                    // zero-terminated
};
 

void
fgInitSceneCommands ()
{
  SG_LOG(SG_GENERAL, SG_BULK, "Initializing scene built-in commands:");
  for (int i = 0; built_ins[i].name != 0; i++) {
    SG_LOG(SG_GENERAL, SG_BULK, "  " << built_ins[i].name);
    globals->get_commands()->addCommand(built_ins[i].name,
                                        built_ins[i].command);
  }
 
}