/// <summary>
/// Nacte hodnoty ze souboru
/// </summary>
public static void Load()
{
if (Hodnoty == null)
{
return;
}
//nacte hodnoty
Nini.Config.IConfigSource source = Ini.InitSoubor();
foreach (Hodnota h in Hodnoty)
{
Nini.Config.IConfig config = source.Configs[h.Sekce];
if (config == null)
{
config = source.AddConfig(h.Sekce);
}
if (config != null)
{
if (config.Contains(h.Jmeno))
{
h.Refresh(config);
}
else
{
config.Set(h.Jmeno, h.Value);
}
}
}
}
/// <summary>
/// Uloží Hodnoty
/// </summary>
public static void Save()
{
if (Hodnoty == null)
{
return;
}
Nini.Config.IConfigSource source = Ini.InitSoubor();
source.Configs.Clear();
foreach (Hodnota h in Hodnoty)
{
if (h != null)
{
Nini.Config.IConfig config = source.Configs[h.Sekce];
if (config == null)
{
config = source.AddConfig(h.Sekce);
}
if (config != null)
{
config.Set(h.Jmeno, h.Value);
}
}
}
source.Save();
}
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 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 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 void InitialiseX(Scene scene, Nini.Config.IConfigSource source)
{
m_scene = scene;
m_log.Error("[SCENEIMPORT]: Add Initialise ");
m_log.Error(scene.Modules.ToString());
foreach (System.Collections.Generic.KeyValuePair <string, OpenSim.Region.Framework.Interfaces.IRegionModuleBase> entry in scene.RegionModules)
{
m_log.ErrorFormat("region modules[{0}]={1}", entry.Key, entry.Value);
}
foreach (System.Collections.Generic.KeyValuePair <string, OpenSim.Region.Framework.Interfaces.IRegionModule> entry in scene.Modules)
{
m_log.ErrorFormat("modules[{0}]={1}", entry.Key, entry.Value);
}
//m_log.Error(scene.RegionModules["rex uploader module"].ToString());
// this.OnNewAvatarUrl += new AppearanceAddedDelegate(AvatarUrlReciver_OnNewAvatarUrl);
}
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 Initialize(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 string VratInit(string jmeno, Nini.Config.IConfigSource defaultConfigSource)
{
if (defaultConfigSource == null)
{
return(VratInit(jmeno));
}
string IniPath = AppDomain.CurrentDomain.BaseDirectory;
if (!Directory.Exists(IniPath))
{
return(null);
}
string s = Path.Combine(IniPath, jmeno + pripona);
if (!File.Exists(s))
{
File.Create(s).Close();
Nini.Config.IConfigSource source = new Nini.Config.IniConfigSource(s);
source.Merge(defaultConfigSource);
source.Save();
}
return(s);
}
public RadegastViewer(RadegastInstance inst, IConfigSource iconfig, IdealistUserControl control):base(iconfig)
{
RInstance = inst;
m_configSource = new IdealistViewerConfigSource();
m_configSource.Source = new IniConfigSource();
ViewerControl = control;
string iniconfig = Path.Combine(Util.configDir(), "IdealistViewer.ini");
if (File.Exists(iniconfig))
{
m_configSource.Source.Merge(new IniConfigSource(iniconfig));
}
m_configSource.Source.Merge(iconfig);
StartupTime = DateTime.UtcNow;
}
public void Initialise(Nini.Config.IConfigSource source)
{
m_enabled = source.Configs["Handlers"].GetBoolean("RobustCompatibility", m_enabled);
}
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 Initialise(Nini.Config.IConfigSource source)
{
}
public void Initialise(Nini.Config.IConfigSource source)
{
MainConsole.Instance.Commands.AddCommand("generate fractal terrain", "generate fractal terrain",
"Generates a fractal terrain", Generate, true, false);
}
