From 1d6b33bc2da3b312cff1d1802a73aacdf72b0385 Mon Sep 17 00:00:00 2001 From: Diva Canto Date: Sun, 30 Aug 2015 20:06:53 -0700 Subject: Major renaming of Physics dlls / folders. No functional changes, just renames. --- .../SharedBase/PhysicsPluginManager.cs | 242 +++++++++++++++++++++ 1 file changed, 242 insertions(+) create mode 100644 OpenSim/Region/PhysicsModules/SharedBase/PhysicsPluginManager.cs (limited to 'OpenSim/Region/PhysicsModules/SharedBase/PhysicsPluginManager.cs') diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsPluginManager.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsPluginManager.cs new file mode 100644 index 0000000..d8279b7 --- /dev/null +++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsPluginManager.cs @@ -0,0 +1,242 @@ +/* + * 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; +using OpenMetaverse; + +namespace OpenSim.Region.Physics.Manager +{ + /// + /// Description of MyClass. + /// + public class PhysicsPluginManager + { + private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); + + private Dictionary _PhysPlugins = new Dictionary(); + private Dictionary _MeshPlugins = new Dictionary(); + + /// + /// Constructor. + /// + 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()); + } + + /// + /// Get a physics scene for the given physics engine and mesher. + /// + /// + /// + /// + /// + public PhysicsScene GetPhysicsScene(string physEngineName, string meshEngineName, + IConfigSource config, string regionName, Vector3 regionExtent) + { + 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, regionExtent); + return result; + } + else + { + m_log.WarnFormat("[PHYSICS]: couldn't find physicsEngine: {0}", physEngineName); + throw new ArgumentException(String.Format("couldn't find physicsEngine: {0}", physEngineName)); + } + } + + /// + /// Load all plugins in assemblies at the given path + /// + /// + 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]); + } + } + + /// + /// Load plugins from an assembly at the given path + /// + /// + 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"); + + 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"); + + 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); + } +} -- cgit v1.1