980 lines
38 KiB
C#
980 lines
38 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 copyrightD
|
|
* 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.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Framework;
|
|
using OpenSim.Region.CoreModules;
|
|
using Logging = OpenSim.Region.CoreModules.Framework.Statistics.Logging;
|
|
using OpenSim.Region.Physics.Manager;
|
|
using Nini.Config;
|
|
using log4net;
|
|
using OpenMetaverse;
|
|
|
|
namespace OpenSim.Region.Physics.BulletSPlugin
|
|
{
|
|
public sealed class BSScene : PhysicsScene, IPhysicsParameters
|
|
{
|
|
internal static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
internal static readonly string LogHeader = "[BULLETS SCENE]";
|
|
|
|
// The name of the region we're working for.
|
|
public string RegionName { get; private set; }
|
|
|
|
public string BulletSimVersion = "?";
|
|
|
|
// The handle to the underlying managed or unmanaged version of Bullet being used.
|
|
public string BulletEngineName { get; private set; }
|
|
public BSAPITemplate PE;
|
|
|
|
public Dictionary<uint, BSPhysObject> PhysObjects;
|
|
public BSShapeCollection Shapes;
|
|
|
|
// Keeping track of the objects with collisions so we can report begin and end of a collision
|
|
public HashSet<BSPhysObject> ObjectsWithCollisions = new HashSet<BSPhysObject>();
|
|
public HashSet<BSPhysObject> ObjectsWithNoMoreCollisions = new HashSet<BSPhysObject>();
|
|
// Keep track of all the avatars so we can send them a collision event
|
|
// every tick so OpenSim will update its animation.
|
|
private HashSet<BSPhysObject> m_avatars = new HashSet<BSPhysObject>();
|
|
|
|
// let my minuions use my logger
|
|
public ILog Logger { get { return m_log; } }
|
|
|
|
public IMesher mesher;
|
|
public uint WorldID { get; private set; }
|
|
public BulletWorld World { get; private set; }
|
|
|
|
// All the constraints that have been allocated in this instance.
|
|
public BSConstraintCollection Constraints { get; private set; }
|
|
|
|
// Simulation parameters
|
|
internal int m_maxSubSteps;
|
|
internal float m_fixedTimeStep;
|
|
internal long m_simulationStep = 0;
|
|
internal float NominalFrameRate { get; set; }
|
|
public long SimulationStep { get { return m_simulationStep; } }
|
|
internal float LastTimeStep { get; private set; }
|
|
|
|
// Physical objects can register for prestep or poststep events
|
|
public delegate void PreStepAction(float timeStep);
|
|
public delegate void PostStepAction(float timeStep);
|
|
public event PreStepAction BeforeStep;
|
|
public event PostStepAction AfterStep;
|
|
|
|
// A value of the time now so all the collision and update routines do not have to get their own
|
|
// Set to 'now' just before all the prims and actors are called for collisions and updates
|
|
public int SimulationNowTime { get; private set; }
|
|
|
|
// True if initialized and ready to do simulation steps
|
|
private bool m_initialized = false;
|
|
|
|
// Flag which is true when processing taints.
|
|
// Not guaranteed to be correct all the time (don't depend on this) but good for debugging.
|
|
public bool InTaintTime { get; private set; }
|
|
|
|
// Pinned memory used to pass step information between managed and unmanaged
|
|
internal int m_maxCollisionsPerFrame;
|
|
internal CollisionDesc[] m_collisionArray;
|
|
|
|
internal int m_maxUpdatesPerFrame;
|
|
internal EntityProperties[] m_updateArray;
|
|
|
|
public const uint TERRAIN_ID = 0; // OpenSim senses terrain with a localID of zero
|
|
public const uint GROUNDPLANE_ID = 1;
|
|
public const uint CHILDTERRAIN_ID = 2; // Terrain allocated based on our mega-prim childre start here
|
|
|
|
public float SimpleWaterLevel { get; set; }
|
|
public BSTerrainManager TerrainManager { get; private set; }
|
|
|
|
public ConfigurationParameters Params
|
|
{
|
|
get { return UnmanagedParams[0]; }
|
|
}
|
|
public Vector3 DefaultGravity
|
|
{
|
|
get { return new Vector3(0f, 0f, Params.gravity); }
|
|
}
|
|
// Just the Z value of the gravity
|
|
public float DefaultGravityZ
|
|
{
|
|
get { return Params.gravity; }
|
|
}
|
|
|
|
// When functions in the unmanaged code must be called, it is only
|
|
// done at a known time just before the simulation step. The taint
|
|
// system saves all these function calls and executes them in
|
|
// order before the simulation.
|
|
public delegate void TaintCallback();
|
|
private struct TaintCallbackEntry
|
|
{
|
|
public String ident;
|
|
public TaintCallback callback;
|
|
public TaintCallbackEntry(string i, TaintCallback c)
|
|
{
|
|
ident = i;
|
|
callback = c;
|
|
}
|
|
}
|
|
private Object _taintLock = new Object(); // lock for using the next object
|
|
private List<TaintCallbackEntry> _taintOperations;
|
|
private Dictionary<string, TaintCallbackEntry> _postTaintOperations;
|
|
private List<TaintCallbackEntry> _postStepOperations;
|
|
|
|
// A pointer to an instance if this structure is passed to the C++ code
|
|
// Used to pass basic configuration values to the unmanaged code.
|
|
internal ConfigurationParameters[] UnmanagedParams;
|
|
|
|
// Sometimes you just have to log everything.
|
|
public Logging.LogWriter PhysicsLogging;
|
|
private bool m_physicsLoggingEnabled;
|
|
private string m_physicsLoggingDir;
|
|
private string m_physicsLoggingPrefix;
|
|
private int m_physicsLoggingFileMinutes;
|
|
private bool m_physicsLoggingDoFlush;
|
|
private bool m_physicsPhysicalDumpEnabled;
|
|
public int PhysicsMetricDumpFrames { get; set; }
|
|
// 'true' of the vehicle code is to log lots of details
|
|
public bool VehicleLoggingEnabled { get; private set; }
|
|
public bool VehiclePhysicalLoggingEnabled { get; private set; }
|
|
|
|
#region Construction and Initialization
|
|
public BSScene(string engineType, string identifier)
|
|
{
|
|
m_initialized = false;
|
|
|
|
// The name of the region we're working for is passed to us. Keep for identification.
|
|
RegionName = identifier;
|
|
|
|
// Set identifying variables in the PhysicsScene interface.
|
|
EngineType = engineType;
|
|
Name = EngineType + "/" + RegionName;
|
|
}
|
|
|
|
public override void Initialise(IMesher meshmerizer, IConfigSource config)
|
|
{
|
|
mesher = meshmerizer;
|
|
_taintOperations = new List<TaintCallbackEntry>();
|
|
_postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
|
|
_postStepOperations = new List<TaintCallbackEntry>();
|
|
PhysObjects = new Dictionary<uint, BSPhysObject>();
|
|
Shapes = new BSShapeCollection(this);
|
|
|
|
// Allocate pinned memory to pass parameters.
|
|
UnmanagedParams = new ConfigurationParameters[1];
|
|
|
|
// Set default values for physics parameters plus any overrides from the ini file
|
|
GetInitialParameterValues(config);
|
|
|
|
// Get the connection to the physics engine (could be native or one of many DLLs)
|
|
PE = SelectUnderlyingBulletEngine(BulletEngineName);
|
|
|
|
// Enable very detailed logging.
|
|
// By creating an empty logger when not logging, the log message invocation code
|
|
// can be left in and every call doesn't have to check for null.
|
|
if (m_physicsLoggingEnabled)
|
|
{
|
|
PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes);
|
|
PhysicsLogging.ErrorLogger = m_log; // for DEBUG. Let's the logger output error messages.
|
|
}
|
|
else
|
|
{
|
|
PhysicsLogging = new Logging.LogWriter();
|
|
}
|
|
|
|
// Allocate memory for returning of the updates and collisions from the physics engine
|
|
m_collisionArray = new CollisionDesc[m_maxCollisionsPerFrame];
|
|
m_updateArray = new EntityProperties[m_maxUpdatesPerFrame];
|
|
|
|
// The bounding box for the simulated world. The origin is 0,0,0 unless we're
|
|
// a child in a mega-region.
|
|
// Bullet actually doesn't care about the extents of the simulated
|
|
// area. It tracks active objects no matter where they are.
|
|
Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
|
|
|
|
World = PE.Initialize(worldExtent, Params, m_maxCollisionsPerFrame, ref m_collisionArray, m_maxUpdatesPerFrame, ref m_updateArray);
|
|
|
|
Constraints = new BSConstraintCollection(World);
|
|
|
|
TerrainManager = new BSTerrainManager(this);
|
|
TerrainManager.CreateInitialGroundPlaneAndTerrain();
|
|
|
|
m_log.WarnFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation);
|
|
|
|
InTaintTime = false;
|
|
m_initialized = true;
|
|
}
|
|
|
|
// All default parameter values are set here. There should be no values set in the
|
|
// variable definitions.
|
|
private void GetInitialParameterValues(IConfigSource config)
|
|
{
|
|
ConfigurationParameters parms = new ConfigurationParameters();
|
|
UnmanagedParams[0] = parms;
|
|
|
|
BSParam.SetParameterDefaultValues(this);
|
|
|
|
if (config != null)
|
|
{
|
|
// If there are specifications in the ini file, use those values
|
|
IConfig pConfig = config.Configs["BulletSim"];
|
|
if (pConfig != null)
|
|
{
|
|
BSParam.SetParameterConfigurationValues(this, pConfig);
|
|
|
|
// There are two Bullet implementations to choose from
|
|
BulletEngineName = pConfig.GetString("BulletEngine", "BulletUnmanaged");
|
|
|
|
// Very detailed logging for physics debugging
|
|
// TODO: the boolean values can be moved to the normal parameter processing.
|
|
m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false);
|
|
m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", ".");
|
|
m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-%REGIONNAME%-");
|
|
m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5);
|
|
m_physicsLoggingDoFlush = pConfig.GetBoolean("PhysicsLoggingDoFlush", false);
|
|
m_physicsPhysicalDumpEnabled = pConfig.GetBoolean("PhysicsPhysicalDumpEnabled", false);
|
|
// Very detailed logging for vehicle debugging
|
|
VehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false);
|
|
VehiclePhysicalLoggingEnabled = pConfig.GetBoolean("VehiclePhysicalLoggingEnabled", false);
|
|
|
|
// Do any replacements in the parameters
|
|
m_physicsLoggingPrefix = m_physicsLoggingPrefix.Replace("%REGIONNAME%", RegionName);
|
|
}
|
|
|
|
// The material characteristics.
|
|
BSMaterials.InitializeFromDefaults(Params);
|
|
if (pConfig != null)
|
|
{
|
|
// Let the user add new and interesting material property values.
|
|
BSMaterials.InitializefromParameters(pConfig);
|
|
}
|
|
}
|
|
}
|
|
|
|
// A helper function that handles a true/false parameter and returns the proper float number encoding
|
|
float ParamBoolean(IConfig config, string parmName, float deflt)
|
|
{
|
|
float ret = deflt;
|
|
if (config.Contains(parmName))
|
|
{
|
|
ret = ConfigurationParameters.numericFalse;
|
|
if (config.GetBoolean(parmName, false))
|
|
{
|
|
ret = ConfigurationParameters.numericTrue;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Select the connection to the actual Bullet implementation.
|
|
// The main engine selection is the engineName up to the first hypen.
|
|
// So "Bullet-2.80-OpenCL-Intel" specifies the 'bullet' class here and the whole name
|
|
// is passed to the engine to do its special selection, etc.
|
|
private BSAPITemplate SelectUnderlyingBulletEngine(string engineName)
|
|
{
|
|
// For the moment, do a simple switch statement.
|
|
// Someday do fancyness with looking up the interfaces in the assembly.
|
|
BSAPITemplate ret = null;
|
|
|
|
string selectionName = engineName.ToLower();
|
|
int hyphenIndex = engineName.IndexOf("-");
|
|
if (hyphenIndex > 0)
|
|
selectionName = engineName.ToLower().Substring(0, hyphenIndex - 1);
|
|
|
|
switch (selectionName)
|
|
{
|
|
case "bulletunmanaged":
|
|
ret = new BSAPIUnman(engineName, this);
|
|
break;
|
|
/*
|
|
case "bulletxna":
|
|
ret = new BSAPIXNA(engineName, this);
|
|
// Disable some features that are not implemented in BulletXNA
|
|
m_log.InfoFormat("{0} Disabling some physics features not implemented by BulletXNA", LogHeader);
|
|
BSParam.ShouldUseBulletHACD = false;
|
|
BSParam.ShouldUseSingleConvexHullForPrims = false;
|
|
break;
|
|
*/
|
|
}
|
|
|
|
if (ret == null)
|
|
{
|
|
m_log.ErrorFormat("{0) COULD NOT SELECT BULLET ENGINE: '[BulletSim]PhysicsEngine' must be either 'BulletUnmanaged-*' or 'BulletXNA-*'", LogHeader);
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat("{0} Selected bullet engine {1} -> {2}/{3}", LogHeader, engineName, ret.BulletEngineName, ret.BulletEngineVersion);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
public override void Dispose()
|
|
{
|
|
// m_log.DebugFormat("{0}: Dispose()", LogHeader);
|
|
|
|
// make sure no stepping happens while we're deleting stuff
|
|
m_initialized = false;
|
|
|
|
foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
|
|
{
|
|
kvp.Value.Destroy();
|
|
}
|
|
PhysObjects.Clear();
|
|
|
|
// Now that the prims are all cleaned up, there should be no constraints left
|
|
if (Constraints != null)
|
|
{
|
|
Constraints.Dispose();
|
|
Constraints = null;
|
|
}
|
|
|
|
if (Shapes != null)
|
|
{
|
|
Shapes.Dispose();
|
|
Shapes = null;
|
|
}
|
|
|
|
if (TerrainManager != null)
|
|
{
|
|
TerrainManager.ReleaseGroundPlaneAndTerrain();
|
|
TerrainManager.Dispose();
|
|
TerrainManager = null;
|
|
}
|
|
|
|
// Anything left in the unmanaged code should be cleaned out
|
|
PE.Shutdown(World);
|
|
|
|
// Not logging any more
|
|
PhysicsLogging.Close();
|
|
}
|
|
#endregion // Construction and Initialization
|
|
|
|
#region Prim and Avatar addition and removal
|
|
|
|
public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
|
|
{
|
|
m_log.ErrorFormat("{0}: CALL TO AddAvatar in BSScene. NOT IMPLEMENTED", LogHeader);
|
|
return null;
|
|
}
|
|
|
|
public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, bool isFlying)
|
|
{
|
|
// m_log.DebugFormat("{0}: AddAvatar: {1}", LogHeader, avName);
|
|
|
|
if (!m_initialized) return null;
|
|
|
|
BSCharacter actor = new BSCharacter(localID, avName, this, position, size, isFlying);
|
|
lock (PhysObjects)
|
|
PhysObjects.Add(localID, actor);
|
|
|
|
// TODO: Remove kludge someday.
|
|
// We must generate a collision for avatars whether they collide or not.
|
|
// This is required by OpenSim to update avatar animations, etc.
|
|
lock (m_avatars)
|
|
m_avatars.Add(actor);
|
|
|
|
return actor;
|
|
}
|
|
|
|
public override void RemoveAvatar(PhysicsActor actor)
|
|
{
|
|
// m_log.DebugFormat("{0}: RemoveAvatar", LogHeader);
|
|
|
|
if (!m_initialized) return;
|
|
|
|
BSCharacter bsactor = actor as BSCharacter;
|
|
if (bsactor != null)
|
|
{
|
|
try
|
|
{
|
|
lock (PhysObjects)
|
|
PhysObjects.Remove(bsactor.LocalID);
|
|
// Remove kludge someday
|
|
lock (m_avatars)
|
|
m_avatars.Remove(bsactor);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.WarnFormat("{0}: Attempt to remove avatar that is not in physics scene: {1}", LogHeader, e);
|
|
}
|
|
bsactor.Destroy();
|
|
// bsactor.dispose();
|
|
}
|
|
else
|
|
{
|
|
m_log.ErrorFormat("{0}: Requested to remove avatar that is not a BSCharacter. ID={1}, type={2}",
|
|
LogHeader, actor.LocalID, actor.GetType().Name);
|
|
}
|
|
}
|
|
|
|
public override void RemovePrim(PhysicsActor prim)
|
|
{
|
|
if (!m_initialized) return;
|
|
|
|
BSPhysObject bsprim = prim as BSPhysObject;
|
|
if (bsprim != null)
|
|
{
|
|
DetailLog("{0},RemovePrim,call", bsprim.LocalID);
|
|
// m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID);
|
|
try
|
|
{
|
|
lock (PhysObjects) PhysObjects.Remove(bsprim.LocalID);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.ErrorFormat("{0}: Attempt to remove prim that is not in physics scene: {1}", LogHeader, e);
|
|
}
|
|
bsprim.Destroy();
|
|
// bsprim.dispose();
|
|
}
|
|
else
|
|
{
|
|
m_log.ErrorFormat("{0}: Attempt to remove prim that is not a BSPrim type.", LogHeader);
|
|
}
|
|
}
|
|
|
|
public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
|
|
Vector3 size, Quaternion rotation, bool isPhysical, uint localID)
|
|
{
|
|
// m_log.DebugFormat("{0}: AddPrimShape2: {1}", LogHeader, primName);
|
|
|
|
if (!m_initialized) return null;
|
|
|
|
// DetailLog("{0},BSScene.AddPrimShape,call", localID);
|
|
|
|
BSPhysObject prim = new BSPrimLinkable(localID, primName, this, position, size, rotation, pbs, isPhysical);
|
|
lock (PhysObjects) PhysObjects.Add(localID, prim);
|
|
return prim;
|
|
}
|
|
|
|
// This is a call from the simulator saying that some physical property has been updated.
|
|
// The BulletSim driver senses the changing of relevant properties so this taint
|
|
// information call is not needed.
|
|
public override void AddPhysicsActorTaint(PhysicsActor prim) { }
|
|
|
|
#endregion // Prim and Avatar addition and removal
|
|
|
|
#region Simulation
|
|
// Simulate one timestep
|
|
public override float Simulate(float timeStep)
|
|
{
|
|
// prevent simulation until we've been initialized
|
|
if (!m_initialized) return 5.0f;
|
|
|
|
LastTimeStep = timeStep;
|
|
|
|
int updatedEntityCount = 0;
|
|
int collidersCount = 0;
|
|
|
|
int beforeTime = 0;
|
|
int simTime = 0;
|
|
|
|
// update the prim states while we know the physics engine is not busy
|
|
int numTaints = _taintOperations.Count;
|
|
|
|
InTaintTime = true; // Only used for debugging so locking is not necessary.
|
|
|
|
ProcessTaints();
|
|
|
|
// Some of the physical objects requre individual, pre-step calls
|
|
// (vehicles and avatar movement, in particular)
|
|
TriggerPreStepEvent(timeStep);
|
|
|
|
// the prestep actions might have added taints
|
|
numTaints += _taintOperations.Count;
|
|
ProcessTaints();
|
|
|
|
InTaintTime = false; // Only used for debugging so locking is not necessary.
|
|
|
|
// The following causes the unmanaged code to output ALL the values found in ALL the objects in the world.
|
|
// Only enable this in a limited test world with few objects.
|
|
if (m_physicsPhysicalDumpEnabled)
|
|
PE.DumpAllInfo(World);
|
|
|
|
// step the physical world one interval
|
|
m_simulationStep++;
|
|
int numSubSteps = 0;
|
|
try
|
|
{
|
|
if (PhysicsLogging.Enabled)
|
|
beforeTime = Util.EnvironmentTickCount();
|
|
|
|
numSubSteps = PE.PhysicsStep(World, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount, out collidersCount);
|
|
|
|
if (PhysicsLogging.Enabled)
|
|
{
|
|
simTime = Util.EnvironmentTickCountSubtract(beforeTime);
|
|
DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}, objWColl={7}",
|
|
DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps,
|
|
updatedEntityCount, collidersCount, ObjectsWithCollisions.Count);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.WarnFormat("{0},PhysicsStep Exception: nTaints={1}, substeps={2}, updates={3}, colliders={4}, e={5}",
|
|
LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e);
|
|
DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}",
|
|
DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount);
|
|
updatedEntityCount = 0;
|
|
collidersCount = 0;
|
|
}
|
|
|
|
if (PhysicsMetricDumpFrames != 0 && ((m_simulationStep % PhysicsMetricDumpFrames) == 0))
|
|
PE.DumpPhysicsStatistics(World);
|
|
|
|
// Get a value for 'now' so all the collision and update routines don't have to get their own.
|
|
SimulationNowTime = Util.EnvironmentTickCount();
|
|
|
|
// If there were collisions, process them by sending the event to the prim.
|
|
// Collisions must be processed before updates.
|
|
if (collidersCount > 0)
|
|
{
|
|
for (int ii = 0; ii < collidersCount; ii++)
|
|
{
|
|
uint cA = m_collisionArray[ii].aID;
|
|
uint cB = m_collisionArray[ii].bID;
|
|
Vector3 point = m_collisionArray[ii].point;
|
|
Vector3 normal = m_collisionArray[ii].normal;
|
|
float penetration = m_collisionArray[ii].penetration;
|
|
SendCollision(cA, cB, point, normal, penetration);
|
|
SendCollision(cB, cA, point, -normal, penetration);
|
|
}
|
|
}
|
|
|
|
// The above SendCollision's batch up the collisions on the objects.
|
|
// Now push the collisions into the simulator.
|
|
if (ObjectsWithCollisions.Count > 0)
|
|
{
|
|
foreach (BSPhysObject bsp in ObjectsWithCollisions)
|
|
if (!bsp.SendCollisions())
|
|
{
|
|
// If the object is done colliding, see that it's removed from the colliding list
|
|
ObjectsWithNoMoreCollisions.Add(bsp);
|
|
}
|
|
}
|
|
|
|
// This is a kludge to get avatar movement updates.
|
|
// The simulator expects collisions for avatars even if there are have been no collisions.
|
|
// The event updates avatar animations and stuff.
|
|
// If you fix avatar animation updates, remove this overhead and let normal collision processing happen.
|
|
foreach (BSPhysObject bsp in m_avatars)
|
|
if (!ObjectsWithCollisions.Contains(bsp)) // don't call avatars twice
|
|
bsp.SendCollisions();
|
|
|
|
// Objects that are done colliding are removed from the ObjectsWithCollisions list.
|
|
// Not done above because it is inside an iteration of ObjectWithCollisions.
|
|
// This complex collision processing is required to create an empty collision
|
|
// event call after all real collisions have happened on an object. This enables
|
|
// the simulator to generate the 'collision end' event.
|
|
if (ObjectsWithNoMoreCollisions.Count > 0)
|
|
{
|
|
foreach (BSPhysObject po in ObjectsWithNoMoreCollisions)
|
|
ObjectsWithCollisions.Remove(po);
|
|
ObjectsWithNoMoreCollisions.Clear();
|
|
}
|
|
// Done with collisions.
|
|
|
|
// If any of the objects had updated properties, tell the object it has been changed by the physics engine
|
|
if (updatedEntityCount > 0)
|
|
{
|
|
for (int ii = 0; ii < updatedEntityCount; ii++)
|
|
{
|
|
EntityProperties entprop = m_updateArray[ii];
|
|
BSPhysObject pobj;
|
|
if (PhysObjects.TryGetValue(entprop.ID, out pobj))
|
|
{
|
|
pobj.UpdateProperties(entprop);
|
|
}
|
|
}
|
|
}
|
|
|
|
TriggerPostStepEvent(timeStep);
|
|
|
|
// The following causes the unmanaged code to output ALL the values found in ALL the objects in the world.
|
|
// Only enable this in a limited test world with few objects.
|
|
if (m_physicsPhysicalDumpEnabled)
|
|
PE.DumpAllInfo(World);
|
|
|
|
// The physics engine returns the number of milliseconds it simulated this call.
|
|
// These are summed and normalized to one second and divided by 1000 to give the reported physics FPS.
|
|
// Multiply by a fixed nominal frame rate to give a rate similar to the simulator (usually 55).
|
|
return (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
|
|
}
|
|
|
|
// Something has collided
|
|
private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penetration)
|
|
{
|
|
if (localID <= TerrainManager.HighestTerrainID)
|
|
{
|
|
return; // don't send collisions to the terrain
|
|
}
|
|
|
|
BSPhysObject collider;
|
|
if (!PhysObjects.TryGetValue(localID, out collider))
|
|
{
|
|
// If the object that is colliding cannot be found, just ignore the collision.
|
|
DetailLog("{0},BSScene.SendCollision,colliderNotInObjectList,id={1},with={2}", DetailLogZero, localID, collidingWith);
|
|
return;
|
|
}
|
|
|
|
// The terrain is not in the physical object list so 'collidee' can be null when Collide() is called.
|
|
BSPhysObject collidee = null;
|
|
PhysObjects.TryGetValue(collidingWith, out collidee);
|
|
|
|
// DetailLog("{0},BSScene.SendCollision,collide,id={1},with={2}", DetailLogZero, localID, collidingWith);
|
|
|
|
if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
|
|
{
|
|
// If a collision was posted, remember to send it to the simulator
|
|
ObjectsWithCollisions.Add(collider);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#endregion // Simulation
|
|
|
|
public override void GetResults() { }
|
|
|
|
#region Terrain
|
|
|
|
public override void SetTerrain(float[] heightMap) {
|
|
TerrainManager.SetTerrain(heightMap);
|
|
}
|
|
|
|
public override void SetWaterLevel(float baseheight)
|
|
{
|
|
SimpleWaterLevel = baseheight;
|
|
}
|
|
|
|
public override void DeleteTerrain()
|
|
{
|
|
// m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader);
|
|
}
|
|
|
|
// Although no one seems to check this, I do support combining.
|
|
public override bool SupportsCombining()
|
|
{
|
|
return TerrainManager.SupportsCombining();
|
|
}
|
|
// This call says I am a child to region zero in a mega-region. 'pScene' is that
|
|
// of region zero, 'offset' is my offset from regions zero's origin, and
|
|
// 'extents' is the largest XY that is handled in my region.
|
|
public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
|
|
{
|
|
TerrainManager.Combine(pScene, offset, extents);
|
|
}
|
|
|
|
// Unhook all the combining that I know about.
|
|
public override void UnCombine(PhysicsScene pScene)
|
|
{
|
|
TerrainManager.UnCombine(pScene);
|
|
}
|
|
|
|
#endregion // Terrain
|
|
|
|
public override Dictionary<uint, float> GetTopColliders()
|
|
{
|
|
Dictionary<uint, float> topColliders;
|
|
|
|
lock (PhysObjects)
|
|
{
|
|
foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
|
|
{
|
|
kvp.Value.ComputeCollisionScore();
|
|
}
|
|
|
|
List<BSPhysObject> orderedPrims = new List<BSPhysObject>(PhysObjects.Values);
|
|
orderedPrims.OrderByDescending(p => p.CollisionScore);
|
|
topColliders = orderedPrims.Take(25).ToDictionary(p => p.LocalID, p => p.CollisionScore);
|
|
}
|
|
|
|
return topColliders;
|
|
}
|
|
|
|
public override bool IsThreaded { get { return false; } }
|
|
|
|
#region Taints
|
|
// The simulation execution order is:
|
|
// Simulate()
|
|
// DoOneTimeTaints
|
|
// TriggerPreStepEvent
|
|
// DoOneTimeTaints
|
|
// Step()
|
|
// ProcessAndSendToSimulatorCollisions
|
|
// ProcessAndSendToSimulatorPropertyUpdates
|
|
// TriggerPostStepEvent
|
|
|
|
// Calls to the PhysicsActors can't directly call into the physics engine
|
|
// because it might be busy. We delay changes to a known time.
|
|
// We rely on C#'s closure to save and restore the context for the delegate.
|
|
public void TaintedObject(String ident, TaintCallback callback)
|
|
{
|
|
if (!m_initialized) return;
|
|
|
|
lock (_taintLock)
|
|
{
|
|
_taintOperations.Add(new TaintCallbackEntry(ident, callback));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Sometimes a potentially tainted operation can be used in and out of taint time.
|
|
// This routine executes the command immediately if in taint-time otherwise it is queued.
|
|
public void TaintedObject(bool inTaintTime, string ident, TaintCallback callback)
|
|
{
|
|
if (inTaintTime)
|
|
callback();
|
|
else
|
|
TaintedObject(ident, callback);
|
|
}
|
|
|
|
private void TriggerPreStepEvent(float timeStep)
|
|
{
|
|
PreStepAction actions = BeforeStep;
|
|
if (actions != null)
|
|
actions(timeStep);
|
|
|
|
}
|
|
|
|
private void TriggerPostStepEvent(float timeStep)
|
|
{
|
|
PostStepAction actions = AfterStep;
|
|
if (actions != null)
|
|
actions(timeStep);
|
|
|
|
}
|
|
|
|
// When someone tries to change a property on a BSPrim or BSCharacter, the object queues
|
|
// a callback into itself to do the actual property change. That callback is called
|
|
// here just before the physics engine is called to step the simulation.
|
|
public void ProcessTaints()
|
|
{
|
|
ProcessRegularTaints();
|
|
ProcessPostTaintTaints();
|
|
}
|
|
|
|
private void ProcessRegularTaints()
|
|
{
|
|
if (_taintOperations.Count > 0) // save allocating new list if there is nothing to process
|
|
{
|
|
// swizzle a new list into the list location so we can process what's there
|
|
List<TaintCallbackEntry> oldList;
|
|
lock (_taintLock)
|
|
{
|
|
oldList = _taintOperations;
|
|
_taintOperations = new List<TaintCallbackEntry>();
|
|
}
|
|
|
|
foreach (TaintCallbackEntry tcbe in oldList)
|
|
{
|
|
try
|
|
{
|
|
DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG
|
|
tcbe.callback();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e);
|
|
}
|
|
}
|
|
oldList.Clear();
|
|
}
|
|
}
|
|
|
|
// Schedule an update to happen after all the regular taints are processed.
|
|
// Note that new requests for the same operation ("ident") for the same object ("ID")
|
|
// will replace any previous operation by the same object.
|
|
public void PostTaintObject(String ident, uint ID, TaintCallback callback)
|
|
{
|
|
string uniqueIdent = ident + "-" + ID.ToString();
|
|
lock (_taintLock)
|
|
{
|
|
_postTaintOperations[uniqueIdent] = new TaintCallbackEntry(uniqueIdent, callback);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Taints that happen after the normal taint processing but before the simulation step.
|
|
private void ProcessPostTaintTaints()
|
|
{
|
|
if (_postTaintOperations.Count > 0)
|
|
{
|
|
Dictionary<string, TaintCallbackEntry> oldList;
|
|
lock (_taintLock)
|
|
{
|
|
oldList = _postTaintOperations;
|
|
_postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
|
|
}
|
|
|
|
foreach (KeyValuePair<string,TaintCallbackEntry> kvp in oldList)
|
|
{
|
|
try
|
|
{
|
|
DetailLog("{0},BSScene.ProcessPostTaintTaints,doTaint,id={1}", DetailLogZero, kvp.Key); // DEBUG DEBUG DEBUG
|
|
kvp.Value.callback();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
m_log.ErrorFormat("{0}: ProcessPostTaintTaints: {1}: Exception: {2}", LogHeader, kvp.Key, e);
|
|
}
|
|
}
|
|
oldList.Clear();
|
|
}
|
|
}
|
|
|
|
// Only used for debugging. Does not change state of anything so locking is not necessary.
|
|
public bool AssertInTaintTime(string whereFrom)
|
|
{
|
|
if (!InTaintTime)
|
|
{
|
|
DetailLog("{0},BSScene.AssertInTaintTime,NOT IN TAINT TIME,Region={1},Where={2}", DetailLogZero, RegionName, whereFrom);
|
|
m_log.ErrorFormat("{0} NOT IN TAINT TIME!! Region={1}, Where={2}", LogHeader, RegionName, whereFrom);
|
|
// Util.PrintCallStack(DetailLog);
|
|
}
|
|
return InTaintTime;
|
|
}
|
|
|
|
#endregion // Taints
|
|
|
|
#region IPhysicsParameters
|
|
// Get the list of parameters this physics engine supports
|
|
public PhysParameterEntry[] GetParameterList()
|
|
{
|
|
BSParam.BuildParameterTable();
|
|
return BSParam.SettableParameters;
|
|
}
|
|
|
|
// Set parameter on a specific or all instances.
|
|
// Return 'false' if not able to set the parameter.
|
|
// Setting the value in the m_params block will change the value the physics engine
|
|
// will use the next time since it's pinned and shared memory.
|
|
// Some of the values require calling into the physics engine to get the new
|
|
// value activated ('terrainFriction' for instance).
|
|
public bool SetPhysicsParameter(string parm, string val, uint localID)
|
|
{
|
|
bool ret = false;
|
|
|
|
BSParam.ParameterDefnBase theParam;
|
|
if (BSParam.TryGetParameter(parm, out theParam))
|
|
{
|
|
// Set the value in the C# code
|
|
theParam.SetValue(this, val);
|
|
|
|
// Optionally set the parameter in the unmanaged code
|
|
if (theParam.HasSetOnObject)
|
|
{
|
|
// update all the localIDs specified
|
|
// If the local ID is APPLY_TO_NONE, just change the default value
|
|
// If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs
|
|
// If the localID is a specific object, apply the parameter change to only that object
|
|
List<uint> objectIDs = new List<uint>();
|
|
switch (localID)
|
|
{
|
|
case PhysParameterEntry.APPLY_TO_NONE:
|
|
// This will cause a call into the physical world if some operation is specified (SetOnObject).
|
|
objectIDs.Add(TERRAIN_ID);
|
|
TaintedUpdateParameter(parm, objectIDs, val);
|
|
break;
|
|
case PhysParameterEntry.APPLY_TO_ALL:
|
|
lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys);
|
|
TaintedUpdateParameter(parm, objectIDs, val);
|
|
break;
|
|
default:
|
|
// setting only one localID
|
|
objectIDs.Add(localID);
|
|
TaintedUpdateParameter(parm, objectIDs, val);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ret = true;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// schedule the actual updating of the paramter to when the phys engine is not busy
|
|
private void TaintedUpdateParameter(string parm, List<uint> lIDs, string val)
|
|
{
|
|
string xval = val;
|
|
List<uint> xlIDs = lIDs;
|
|
string xparm = parm;
|
|
TaintedObject("BSScene.UpdateParameterSet", delegate() {
|
|
BSParam.ParameterDefnBase thisParam;
|
|
if (BSParam.TryGetParameter(xparm, out thisParam))
|
|
{
|
|
if (thisParam.HasSetOnObject)
|
|
{
|
|
foreach (uint lID in xlIDs)
|
|
{
|
|
BSPhysObject theObject = null;
|
|
if (PhysObjects.TryGetValue(lID, out theObject))
|
|
thisParam.SetOnObject(this, theObject);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Get parameter.
|
|
// Return 'false' if not able to get the parameter.
|
|
public bool GetPhysicsParameter(string parm, out string value)
|
|
{
|
|
string val = String.Empty;
|
|
bool ret = false;
|
|
BSParam.ParameterDefnBase theParam;
|
|
if (BSParam.TryGetParameter(parm, out theParam))
|
|
{
|
|
val = theParam.GetValue(this);
|
|
ret = true;
|
|
}
|
|
value = val;
|
|
return ret;
|
|
}
|
|
|
|
#endregion IPhysicsParameters
|
|
|
|
// Invoke the detailed logger and output something if it's enabled.
|
|
public void DetailLog(string msg, params Object[] args)
|
|
{
|
|
PhysicsLogging.Write(msg, args);
|
|
// Add the Flush() if debugging crashes. Gets all the messages written out.
|
|
if (m_physicsLoggingDoFlush) PhysicsLogging.Flush();
|
|
}
|
|
// Used to fill in the LocalID when there isn't one. It's the correct number of characters.
|
|
public const string DetailLogZero = "0000000000";
|
|
|
|
}
|
|
}
|