241 lines
9.6 KiB
C#
241 lines
9.6 KiB
C#
/*
|
|
* Copyright (c) Contributors, http://opensimulator.org/
|
|
* See CONTRIBUTORS.TXT for a full list of copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of the OpenSimulator Project nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using Nini.Config;
|
|
using log4net;
|
|
using OpenSim.Framework;
|
|
|
|
namespace OpenSim.Region.Physics.Manager
|
|
{
|
|
/// <summary>
|
|
/// Description of MyClass.
|
|
/// </summary>
|
|
public class PhysicsPluginManager
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private Dictionary<string, IPhysicsPlugin> _PhysPlugins = new Dictionary<string, IPhysicsPlugin>();
|
|
private Dictionary<string, IMeshingPlugin> _MeshPlugins = new Dictionary<string, IMeshingPlugin>();
|
|
|
|
/// <summary>
|
|
/// Constructor.
|
|
/// </summary>
|
|
public PhysicsPluginManager()
|
|
{
|
|
// Load "plugins", that are hard coded and not existing in form of an external lib, and hence always
|
|
// available
|
|
IMeshingPlugin plugHard;
|
|
plugHard = new ZeroMesherPlugin();
|
|
_MeshPlugins.Add(plugHard.GetName(), plugHard);
|
|
|
|
m_log.Info("[PHYSICS]: Added meshing engine: " + plugHard.GetName());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a physics scene for the given physics engine and mesher.
|
|
/// </summary>
|
|
/// <param name="physEngineName"></param>
|
|
/// <param name="meshEngineName"></param>
|
|
/// <param name="config"></param>
|
|
/// <returns></returns>
|
|
public PhysicsScene GetPhysicsScene(string physEngineName, string meshEngineName, IConfigSource config, string regionName)
|
|
{
|
|
if (String.IsNullOrEmpty(physEngineName))
|
|
{
|
|
return PhysicsScene.Null;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty(meshEngineName))
|
|
{
|
|
return PhysicsScene.Null;
|
|
}
|
|
|
|
IMesher meshEngine = null;
|
|
if (_MeshPlugins.ContainsKey(meshEngineName))
|
|
{
|
|
m_log.Info("[PHYSICS]: creating meshing engine " + meshEngineName);
|
|
meshEngine = _MeshPlugins[meshEngineName].GetMesher(config);
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat("[PHYSICS]: couldn't find meshingEngine: {0}", meshEngineName);
|
|
throw new ArgumentException(String.Format("couldn't find meshingEngine: {0}", meshEngineName));
|
|
}
|
|
|
|
if (_PhysPlugins.ContainsKey(physEngineName))
|
|
{
|
|
m_log.Info("[PHYSICS]: creating " + physEngineName);
|
|
PhysicsScene result = _PhysPlugins[physEngineName].GetScene(regionName);
|
|
result.Initialise(meshEngine, config);
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat("[PHYSICS]: couldn't find physicsEngine: {0}", physEngineName);
|
|
throw new ArgumentException(String.Format("couldn't find physicsEngine: {0}", physEngineName));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load all plugins in assemblies at the given path
|
|
/// </summary>
|
|
/// <param name="pluginsPath"></param>
|
|
public void LoadPluginsFromAssemblies(string assembliesPath)
|
|
{
|
|
// Walk all assemblies (DLLs effectively) and see if they are home
|
|
// of a plugin that is of interest for us
|
|
string[] pluginFiles = Directory.GetFiles(assembliesPath, "*.dll");
|
|
|
|
for (int i = 0; i < pluginFiles.Length; i++)
|
|
{
|
|
LoadPluginsFromAssembly(pluginFiles[i]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load plugins from an assembly at the given path
|
|
/// </summary>
|
|
/// <param name="assemblyPath"></param>
|
|
public void LoadPluginsFromAssembly(string assemblyPath)
|
|
{
|
|
// TODO / NOTE
|
|
// The assembly named 'OpenSim.Region.Physics.BasicPhysicsPlugin' was loaded from
|
|
// 'file:///C:/OpenSim/trunk2/bin/Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll'
|
|
// using the LoadFrom context. The use of this context can result in unexpected behavior
|
|
// for serialization, casting and dependency resolution. In almost all cases, it is recommended
|
|
// that the LoadFrom context be avoided. This can be done by installing assemblies in the
|
|
// Global Assembly Cache or in the ApplicationBase directory and using Assembly.
|
|
// Load when explicitly loading assemblies.
|
|
Assembly pluginAssembly = null;
|
|
Type[] types = null;
|
|
|
|
try
|
|
{
|
|
pluginAssembly = Assembly.LoadFrom(assemblyPath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.Error("[PHYSICS]: Failed to load plugin from " + assemblyPath, ex);
|
|
}
|
|
|
|
if (pluginAssembly != null)
|
|
{
|
|
try
|
|
{
|
|
types = pluginAssembly.GetTypes();
|
|
}
|
|
catch (ReflectionTypeLoadException ex)
|
|
{
|
|
m_log.Error("[PHYSICS]: Failed to enumerate types in plugin from " + assemblyPath + ": " +
|
|
ex.LoaderExceptions[0].Message, ex);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
m_log.Error("[PHYSICS]: Failed to enumerate types in plugin from " + assemblyPath, ex);
|
|
}
|
|
|
|
if (types != null)
|
|
{
|
|
foreach (Type pluginType in types)
|
|
{
|
|
if (pluginType.IsPublic)
|
|
{
|
|
if (!pluginType.IsAbstract)
|
|
{
|
|
Type physTypeInterface = pluginType.GetInterface("IPhysicsPlugin", true);
|
|
|
|
if (physTypeInterface != null)
|
|
{
|
|
IPhysicsPlugin plug =
|
|
(IPhysicsPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));
|
|
plug.Init();
|
|
if (!_PhysPlugins.ContainsKey(plug.GetName()))
|
|
{
|
|
_PhysPlugins.Add(plug.GetName(), plug);
|
|
m_log.Info("[PHYSICS]: Added physics engine: " + plug.GetName());
|
|
}
|
|
}
|
|
|
|
Type meshTypeInterface = pluginType.GetInterface("IMeshingPlugin", true);
|
|
|
|
if (meshTypeInterface != null)
|
|
{
|
|
IMeshingPlugin plug =
|
|
(IMeshingPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));
|
|
if (!_MeshPlugins.ContainsKey(plug.GetName()))
|
|
{
|
|
_MeshPlugins.Add(plug.GetName(), plug);
|
|
m_log.Info("[PHYSICS]: Added meshing engine: " + plug.GetName());
|
|
}
|
|
}
|
|
|
|
physTypeInterface = null;
|
|
meshTypeInterface = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pluginAssembly = null;
|
|
}
|
|
|
|
//---
|
|
public static void PhysicsPluginMessage(string message, bool isWarning)
|
|
{
|
|
if (isWarning)
|
|
{
|
|
m_log.Warn("[PHYSICS]: " + message);
|
|
}
|
|
else
|
|
{
|
|
m_log.Info("[PHYSICS]: " + message);
|
|
}
|
|
}
|
|
|
|
//---
|
|
}
|
|
|
|
public interface IPhysicsPlugin
|
|
{
|
|
bool Init();
|
|
PhysicsScene GetScene(String sceneIdentifier);
|
|
string GetName();
|
|
void Dispose();
|
|
}
|
|
|
|
public interface IMeshingPlugin
|
|
{
|
|
string GetName();
|
|
IMesher GetMesher(IConfigSource config);
|
|
}
|
|
}
|