1
0

PhysicsPluginManager.cs 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  1. /*
  2. * Copyright (c) Contributors, http://opensimulator.org/
  3. * See CONTRIBUTORS.TXT for a full list of copyright holders.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. * * Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * * Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. * * Neither the name of the OpenSimulator Project nor the
  13. * names of its contributors may be used to endorse or promote products
  14. * derived from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
  17. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
  20. * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21. * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. using System;
  28. using System.Collections.Generic;
  29. using System.IO;
  30. using System.Reflection;
  31. using Nini.Config;
  32. using log4net;
  33. namespace OpenSim.Region.Physics.Manager
  34. {
  35. /// <summary>
  36. /// Description of MyClass.
  37. /// </summary>
  38. public class PhysicsPluginManager
  39. {
  40. private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
  41. private Dictionary<string, IPhysicsPlugin> _PhysPlugins = new Dictionary<string, IPhysicsPlugin>();
  42. private Dictionary<string, IMeshingPlugin> _MeshPlugins = new Dictionary<string, IMeshingPlugin>();
  43. /// <summary>
  44. /// Constructor.
  45. /// </summary>
  46. public PhysicsPluginManager()
  47. {
  48. // Load "plugins", that are hard coded and not existing in form of an external lib, and hence always
  49. // available
  50. IMeshingPlugin plugHard;
  51. plugHard = new ZeroMesherPlugin();
  52. _MeshPlugins.Add(plugHard.GetName(), plugHard);
  53. m_log.Info("[PHYSICS]: Added meshing engine: " + plugHard.GetName());
  54. }
  55. /// <summary>
  56. /// Get a physics scene for the given physics engine and mesher.
  57. /// </summary>
  58. /// <param name="physEngineName"></param>
  59. /// <param name="meshEngineName"></param>
  60. /// <param name="config"></param>
  61. /// <returns></returns>
  62. public PhysicsScene GetPhysicsScene(string physEngineName, string meshEngineName, IConfigSource config, string regionName)
  63. {
  64. if (String.IsNullOrEmpty(physEngineName))
  65. {
  66. return PhysicsScene.Null;
  67. }
  68. if (String.IsNullOrEmpty(meshEngineName))
  69. {
  70. return PhysicsScene.Null;
  71. }
  72. IMesher meshEngine = null;
  73. if (_MeshPlugins.ContainsKey(meshEngineName))
  74. {
  75. m_log.Info("[PHYSICS]: creating meshing engine " + meshEngineName);
  76. meshEngine = _MeshPlugins[meshEngineName].GetMesher(config);
  77. }
  78. else
  79. {
  80. m_log.WarnFormat("[PHYSICS]: couldn't find meshingEngine: {0}", meshEngineName);
  81. throw new ArgumentException(String.Format("couldn't find meshingEngine: {0}", meshEngineName));
  82. }
  83. if (_PhysPlugins.ContainsKey(physEngineName))
  84. {
  85. m_log.Info("[PHYSICS]: creating " + physEngineName);
  86. PhysicsScene result = _PhysPlugins[physEngineName].GetScene(regionName);
  87. result.Initialise(meshEngine, config);
  88. return result;
  89. }
  90. else
  91. {
  92. m_log.WarnFormat("[PHYSICS]: couldn't find physicsEngine: {0}", physEngineName);
  93. throw new ArgumentException(String.Format("couldn't find physicsEngine: {0}", physEngineName));
  94. }
  95. }
  96. /// <summary>
  97. /// Load all plugins in assemblies at the given path
  98. /// </summary>
  99. /// <param name="pluginsPath"></param>
  100. public void LoadPluginsFromAssemblies(string assembliesPath)
  101. {
  102. // Walk all assemblies (DLLs effectively) and see if they are home
  103. // of a plugin that is of interest for us
  104. string[] pluginFiles = Directory.GetFiles(assembliesPath, "*.dll");
  105. for (int i = 0; i < pluginFiles.Length; i++)
  106. {
  107. LoadPluginsFromAssembly(pluginFiles[i]);
  108. }
  109. }
  110. /// <summary>
  111. /// Load plugins from an assembly at the given path
  112. /// </summary>
  113. /// <param name="assemblyPath"></param>
  114. public void LoadPluginsFromAssembly(string assemblyPath)
  115. {
  116. // TODO / NOTE
  117. // The assembly named 'OpenSim.Region.Physics.BasicPhysicsPlugin' was loaded from
  118. // 'file:///C:/OpenSim/trunk2/bin/Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll'
  119. // using the LoadFrom context. The use of this context can result in unexpected behavior
  120. // for serialization, casting and dependency resolution. In almost all cases, it is recommended
  121. // that the LoadFrom context be avoided. This can be done by installing assemblies in the
  122. // Global Assembly Cache or in the ApplicationBase directory and using Assembly.
  123. // Load when explicitly loading assemblies.
  124. Assembly pluginAssembly = null;
  125. Type[] types = null;
  126. try
  127. {
  128. pluginAssembly = Assembly.LoadFrom(assemblyPath);
  129. }
  130. catch (Exception ex)
  131. {
  132. m_log.Error("[PHYSICS]: Failed to load plugin from " + assemblyPath, ex);
  133. }
  134. if (pluginAssembly != null)
  135. {
  136. try
  137. {
  138. types = pluginAssembly.GetTypes();
  139. }
  140. catch (ReflectionTypeLoadException ex)
  141. {
  142. m_log.Error("[PHYSICS]: Failed to enumerate types in plugin from " + assemblyPath + ": " +
  143. ex.LoaderExceptions[0].Message, ex);
  144. }
  145. catch (Exception ex)
  146. {
  147. m_log.Error("[PHYSICS]: Failed to enumerate types in plugin from " + assemblyPath, ex);
  148. }
  149. if (types != null)
  150. {
  151. foreach (Type pluginType in types)
  152. {
  153. if (pluginType.IsPublic)
  154. {
  155. if (!pluginType.IsAbstract)
  156. {
  157. Type physTypeInterface = pluginType.GetInterface("IPhysicsPlugin", true);
  158. if (physTypeInterface != null)
  159. {
  160. IPhysicsPlugin plug =
  161. (IPhysicsPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));
  162. plug.Init();
  163. if (!_PhysPlugins.ContainsKey(plug.GetName()))
  164. {
  165. _PhysPlugins.Add(plug.GetName(), plug);
  166. m_log.Info("[PHYSICS]: Added physics engine: " + plug.GetName());
  167. }
  168. }
  169. Type meshTypeInterface = pluginType.GetInterface("IMeshingPlugin", true);
  170. if (meshTypeInterface != null)
  171. {
  172. IMeshingPlugin plug =
  173. (IMeshingPlugin)Activator.CreateInstance(pluginAssembly.GetType(pluginType.ToString()));
  174. if (!_MeshPlugins.ContainsKey(plug.GetName()))
  175. {
  176. _MeshPlugins.Add(plug.GetName(), plug);
  177. m_log.Info("[PHYSICS]: Added meshing engine: " + plug.GetName());
  178. }
  179. }
  180. physTypeInterface = null;
  181. meshTypeInterface = null;
  182. }
  183. }
  184. }
  185. }
  186. }
  187. pluginAssembly = null;
  188. }
  189. //---
  190. public static void PhysicsPluginMessage(string message, bool isWarning)
  191. {
  192. if (isWarning)
  193. {
  194. m_log.Warn("[PHYSICS]: " + message);
  195. }
  196. else
  197. {
  198. m_log.Info("[PHYSICS]: " + message);
  199. }
  200. }
  201. //---
  202. }
  203. public interface IPhysicsPlugin
  204. {
  205. bool Init();
  206. PhysicsScene GetScene(String sceneIdentifier);
  207. string GetName();
  208. void Dispose();
  209. }
  210. public interface IMeshingPlugin
  211. {
  212. string GetName();
  213. IMesher GetMesher(IConfigSource config);
  214. }
  215. }