public void Initialize(IGenericData GenericData, Nini.Config.IConfigSource source, IRegistryCore simBase, string DefaultConnectionString)
{
DataManager.DataManager.RegisterPlugin(this);
string path = Util.BasePathCombine(System.IO.Path.Combine("data", "OpenRegionSettingsPage.html"));
if(System.IO.File.Exists(path))
HTMLPage = System.IO.File.ReadAllText(path);
}
public void Save(Nini.Config.IConfigSource source)
{
Nini.Config.IConfig config = source.AddConfig("Druhy");
string s = "";
foreach (string ss in druhy) if (s == "") s = ss;
else s = s + "," + ss;
config.Set("Všechny druhy", s);
}
public void Initialise(Scene scene, Nini.Config.IConfigSource source)
{
m_scene = scene;
if (source.Configs["realXtend"] != null)
{
m_maxHeight = source.Configs["realXtend"].GetFloat("FlightCeilingHeight", 0);
}
m_scene.AddCommand(this, "flightceiling", "flightceiling <float>", "Set maximum movement height. Zero is disabled", SetFlightCeilingHeight);
}
public void WindConfig(OpenSim.Region.Framework.Scenes.Scene scene, Nini.Config.IConfig windConfig)
{
if (windConfig != null)
{
if (windConfig.Contains("strength"))
{
m_strength = windConfig.GetFloat("strength", 1.0F);
}
}
}
public void Load(Nini.Config.IConfigSource source)
{
if (source.Configs.Contains("Druhy"))
{
Nini.Config.IConfig config = source.Configs["Druhy"];
string s = config.GetString("Všechny druhy");
string[] ss = s.Split(',');
foreach (string sss in ss) druhy.Add(sss);
}
}
public void WindConfig (IScene scene, Nini.Config.IConfig windConfig)
{
if (windConfig != null)
{
if (windConfig.Contains("strength"))
{
m_strength = windConfig.GetFloat("strength", 1.0F);
}
}
}
public override EReturn Load(Nini.Config.IConfig config)
{
base.Load(config);
//Nini.Config.IConfig config = GetConfig(source, "Udalost");
if (config != null)
{
Cena = config.GetInt("Cena");
return EReturn.NoError;
}
else return EReturn.Error;
}
public override EReturn Save(Nini.Config.IConfig config)
{
base.Save(config);
//Nini.Config.IConfig config = source.AddConfig("Udalost");
if (config != null)
{
config.Set("Cena", Cena);
return EReturn.NoError;
}
else return EReturn.Error;
}
public void Initialise(Nini.Config.IConfigSource source)
{
if (source.Configs["VersionControl"] == null)
return;
IConfig config = source.Configs["VersionControl"];
m_Enabled = config.GetBoolean("Enabled", false);
//Auto OAR config
m_autoOAREnabled = config.GetBoolean("AutoVersionEnabled", false);
m_autoOARTime = config.GetFloat("AutoVersionTime", 1);
}
public void Initialise(Scene scene, Nini.Config.IConfigSource source)
{
m_scene = scene;
if (source.Configs["realXtend"] != null)
{
m_bypassPermissions = !(source.Configs["realXtend"].GetBoolean("UploadPermissionsEnabled", false));
m_disableFromAll = source.Configs["realXtend"].GetBoolean("DisableUploads", false);
}
m_scene.AddCommand(this, "uploadpermissions", "uploadpermissions true|false", "this enables or disables upload permissions", SetUploadPermissionsCommand);
m_scene.AddCommand(this, "disableupload", "disableupload true|false", "this enables or disables upload", DisableUploadCommand);
}
public override void Initialize(Nini.Config.IConfigSource config, IRegistryCore registry)
{
m_registry = registry;
IConfig hgConfig = config.Configs["HyperGrid"];
if (hgConfig == null || !hgConfig.GetBoolean ("Enabled", false))
return;
IConfig handlerConfig = config.Configs["Handlers"];
if (handlerConfig.GetString ("AgentInfoHandler", "") != Name)
return;
registry.RegisterModuleInterface<IAgentInfoService> (this);
}
public CommunicationHelpers(Nini.Config.IConfigSource config, String moduleName, String moduleVersion)
{
try {
Nini.Config.IConfig startupConfig = config.Configs["OpenMetaverseEconomy"];
m_gatewayEnvironment = startupConfig.GetString("OMBaseEnvironment", "TEST");
m_initURL = startupConfig.GetString("OMEconomyInitialize", String.Empty);
m_gridShortName = startupConfig.GetString("GridShortName", String.Empty);
m_gridURL = config.Configs["GridService"].GetString("GridServerURI", String.Empty);
if(m_gridShortName == String.Empty || m_initURL == String.Empty) {
m_log.Error("[" + moduleName + "]: GridShortName or OMEconomyInitialize not set");
return;
}
#if DEBUG
m_log.Debug(String.Format("[OMECONOMY] getGatewayURL({0}, {1}, {2}, {3})", m_initURL, moduleName, moduleVersion, m_gatewayEnvironment));
#endif
Dictionary<string, string> d = new Dictionary<string, string>();
d.Add("moduleName", moduleName);
d.Add("moduleVersion", moduleVersion);
//d.Add("gridShortName", m_gridShortName);
d.Add("gatewayEnvironment", m_gatewayEnvironment);
m_gatewayURL = m_initURL; //use to obtain the real gatewayURL;
Dictionary<string, string> response = DoRequestDictionary(d);
if (response != null)
{
m_gatewayURL = (string)response["gatewayURL"];
if(m_gatewayURL != m_initURL && m_gatewayURL != null)
{
m_log.Info("[" + moduleName + "]: GatewayURL: " + m_gatewayURL);
}
else
{
m_log.Error("[" + moduleName + "]: Could not set the GatewayURL - Please restart or contact the module vendor");
}
}
else
{
m_gatewayURL = null;
m_log.Error("[" + moduleName + "]: Could not retrieve GatewayURL");
}
} catch(Exception e) {
m_log.Error("[OMBASE]: " + e);
}
}
public override EReturn Save(Nini.Config.IConfig config)
{
base.Save(config);
//Nini.Config.IConfig config = source.AddConfig("Zrada");
if (config != null)
{
string s = "";
foreach (MyString ss in Stin)
if (s == "") s = ss.String;
else s = s + "," + ss.String;
config.Set("Stin", s);
return EReturn.NoError;
}
else return EReturn.Error;
}
public override EReturn Load(Nini.Config.IConfig config)
{
base.Load(config);
//Nini.Config.IConfig config = GetConfig(source, "Hrdina");
if (config != null)
{
Hrozba = config.GetInt("Hrozba");
Vule = config.GetInt("Vule");
Utok = config.GetInt("Utok");
Obrana = config.GetInt("Obrana");
Zivoty = config.GetInt("Zivoty");
return EReturn.NoError;
}
else return EReturn.Error;
}
public void WindConfig(OpenSim.Region.Framework.Scenes.Scene scene, Nini.Config.IConfig windConfig)
{
if (windConfig != null)
{
// Uses strength value if avg_strength not specified
m_avgStrength = windConfig.GetFloat("strength", 5.0F);
m_avgStrength = windConfig.GetFloat("avg_strength", 5.0F);
m_avgDirection = windConfig.GetFloat("avg_direction", 0.0F);
m_varStrength = windConfig.GetFloat("var_strength", 5.0F);
m_varDirection = windConfig.GetFloat("var_direction", 30.0F);
m_rateChange = windConfig.GetFloat("rate_change", 1.0F);
LogSettings();
}
}
public void Initialise(Nini.Config.IConfigSource source)
{
var cfg = source.Configs["InWorldz.Thoosa"];
if (cfg == null || cfg.GetBoolean("enable_serialization_engine", true))
{
_engine = new Engines.SerializationEngine();
ProviderRegistry.Instance.RegisterInterface<ISerializationEngine>(_engine);
Preload();
m_log.InfoFormat("[InWorldz.Thoosa]: Serialization engine enabled");
}
else
{
m_log.InfoFormat("[InWorldz.Thoosa]: Serialization engine disabled");
}
}
public void Initialize(Nini.Config.IConfigSource source)
{
//read our connection string
IConfig userConfig = source.Configs["UserService"];
string connString = String.Empty;
if (userConfig != null)
{
connString = userConfig.GetString("ConnectionString", String.Empty);
}
if (String.Empty == connString)
{
userConfig = source.Configs["StandAlone"];
connString = userConfig.GetString("user_source", String.Empty);
}
_connFactory = new ConnectionFactory("MySQL", connString);
}
public override EReturn Load(Nini.Config.IConfig config)
{
base.Load(config);
//Nini.Config.IConfig config = GetConfig(source, "Zrada");
if (config != null)
{
string s = config.GetString("Stin");
string[] stin = s.Split(',');
List<MyString> mujList = new List<MyString>();
foreach (string ss in stin)
{
MyString ms = new MyString();
ms.String = ss;
mujList.Add(ms);
}
Stin = mujList;
return EReturn.NoError;
}
else return EReturn.Error;
}
private bool ReadAndPopulateConfig(Nini.Config.IConfigSource source)
{
bool rex_conf = CheckRexConfig(source);
if (CheckStartupConfig(source))
{
//Default event queue enabled or line missing
if (rex_conf)
{
m_log.Warn("[REXEVENTQUEUE]: Both default and Rex Event Queue enabled. Using default.");
}
return false;
}
else
{
//Default event queue disabled
if (rex_conf)
{
m_log.Info("[REXEVENTQUEUE]: Using Rex Event Queue");
return rex_conf;
}
}
return false;
}
private bool CheckStartupConfig(Nini.Config.IConfigSource source)
{
if (source.Configs["Startup"] != null)
{
return source.Configs["Startup"].GetBoolean("EventQueue", true);
}
else
{
return true;
}
}
private bool CheckRexConfig(Nini.Config.IConfigSource source)
{
if (source.Configs["realXtend"] != null)
{
if (source.Configs["realXtend"].GetBoolean("RexEventQueue", true))
{
return true;
}
}
return false;
}
public void Initialise(Nini.Config.IConfigSource source)
{
MainConsole.Instance.Commands.AddCommand(
"generate fractal terrain",
"generate fractal terrain",
"Generates a fractal terrain",
GenerateTerrain, true, false);
}
public void Initialise(Nini.Config.IConfigSource source)
{
}
public void Initialise(Scene scene, Nini.Config.IConfigSource source)
{
m_scene = scene;
}
public void Initialize(IGenericData GenericData, Nini.Config.IConfigSource source, IRegistryCore simBase, string DefaultConnectionString)
{
Aurora.DataManager.DataManager.RegisterPlugin(Name, this);
}
public void WindConfig(OpenSim.Region.Framework.Scenes.Scene scene, Nini.Config.IConfig windConfig)
{
_scene = scene;
// Default to ground turbulence
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 16; x++)
{
m_options[y * 16 + x] = WindConstants.WindSpeedTurbulence;
}
}
if (windConfig != null)
{
// Uses strength value if avg_strength not specified
m_avgWindStrength = windConfig.GetFloat("strength", 5.0F);
m_avgWindStrength = windConfig.GetFloat("avg_strength", 5.0F);
m_avgWindDirection = windConfig.GetFloat("avg_direction", 0.0F);
m_varWindStrength = windConfig.GetFloat("var_strength", 5.0F);
m_varWindDirection = windConfig.GetFloat("var_direction", 30.0F);
m_rateChangeAloft = windConfig.GetFloat("rate_change_aloft", 1.0f);
m_rateChangeFlutter = windConfig.GetFloat("rate_change_flutter", 64.0f);
LogSettings();
}
}
public void Initialise(Nini.Config.IConfigSource source)
{
m_enabled = source.Configs["Handlers"].GetBoolean("RobustCompatibility", m_enabled);
}
public override void Initialise(Scene scene, Nini.Config.IConfigSource source)
{
m_scene = scene;
bool enable_now = ReadAndPopulateConfig(source);
if (enable_now)
{
scene.RegisterModuleInterface<IEventQueue>(this);
scene.EventManager.OnClientClosed += ClientClosed;
scene.EventManager.OnRegisterCaps += OnRegisterCaps;
scene.EventManager.OnNewClient += OnNewClient;
}
else
{
;
}
}
public override void Initialize(IMesher meshmerizer, Nini.Config.IConfigSource config, OpenMetaverse.UUID regionId)
{
_regionId = regionId;
_mesher = meshmerizer;
m_log.Info("[InWorldz.PhysxPhysics] Creating PhysX scene");
if (config.Configs["InWorldz.PhysxPhysics"] != null)
{
Settings.Instance.UseVisualDebugger = config.Configs["InWorldz.PhysxPhysics"].GetBoolean("use_visual_debugger", false);
Settings.Instance.UseCCD = config.Configs["InWorldz.PhysxPhysics"].GetBoolean("use_ccd", true);
Settings.Instance.Gravity = config.Configs["InWorldz.PhysxPhysics"].GetFloat("gravity", -9.8f);
Settings.Instance.ThrowOnSdkError = config.Configs["InWorldz.PhysxPhysics"].GetBoolean("throw_on_sdk_error", false);
Settings.Instance.InstrumentMeshing = config.Configs["InWorldz.PhysxPhysics"].GetBoolean("instrument_meshing", false);
}
else
{
Settings.Instance.UseVisualDebugger = false;
Settings.Instance.UseCCD = true;
Settings.Instance.Gravity = -9.8f;
Settings.Instance.ThrowOnSdkError = false;
Settings.Instance.InstrumentMeshing = false;
}
Nini.Config.IConfig startupcfg = config.Configs["Startup"];
if (startupcfg != null)
_gridmode = startupcfg.GetBoolean("gridmode", false);
if (_foundation == null)
{
_foundation = new PhysX.Foundation(s_ErrorCallback);
_physics = new PhysX.Physics(_foundation);
Material.BuiltinMaterialInit(_physics);
}
_sceneDesc = new PhysX.SceneDesc(null, Settings.Instance.UseCCD);
_sceneDesc.Gravity = new PhysX.Math.Vector3(0f, 0f, Settings.Instance.Gravity);
_simEventDelegator = new SimulationEventCallbackDelegator();
_simEventDelegator.OnContactCallback += this.OnContact;
_simEventDelegator.OnTriggerCallback += this.OnTrigger;
_sceneDesc.SimulationEventCallback = _simEventDelegator;
_scene = _physics.CreateScene(_sceneDesc);
Preload();
if (Settings.Instance.UseCCD)
{
_scene.SetFlag(PhysX.SceneFlag.SweptIntegration, true);
}
if (Settings.Instance.UseVisualDebugger && _physics.RemoteDebugger != null)
{
_physics.RemoteDebugger.Connect("localhost", null, null, PhysX.VisualDebugger.VisualDebuggerConnectionFlag.Debug, null);
}
_controllerManager = _scene.CreateControllerManager();
CreateDefaults();
_terrainMesher = new Meshing.TerrainMesher(_scene);
_terrainMgr = new TerrainManager(_scene, _terrainMesher, regionId);
_meshingStage = new Meshing.MeshingStage(_scene, meshmerizer, _terrainMesher);
_meshingStage.OnShapeNeedsFreeing += new Meshing.MeshingStage.ShapeNeedsFreeingDelegate(_meshingStage_OnShapeNeedsFreeing);
_kinematicManager = new KinematicManager();
//fire up our work loop
HeartbeatThread = Watchdog.StartThread(new ThreadStart(Heartbeat), "Physics Heartbeat",
ThreadPriority.Normal, false);
TimingThread = Watchdog.StartThread(new ThreadStart(DoTiming), string.Format("Physics Timing"),
ThreadPriority.Highest, false);
}
public void Initialize(Nini.Config.IConfigSource source)
{
_configSource = source;
Preload();
}
