427 lines
14 KiB
C#
427 lines
14 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.Reflection;
|
|
using log4net;
|
|
using OpenMetaverse;
|
|
using OpenSim.Framework;
|
|
using OpenSim.Region.Physics.Manager;
|
|
|
|
namespace OpenSim.Region.Physics.BulletSPlugin
|
|
{
|
|
public class BSCharacter : PhysicsActor
|
|
{
|
|
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
private static readonly string LogHeader = "[BULLETS CHAR]";
|
|
|
|
private BSScene _scene;
|
|
private String _avName;
|
|
private bool _stopped;
|
|
private Vector3 _size;
|
|
private Vector3 _scale;
|
|
private PrimitiveBaseShape _pbs;
|
|
private uint _localID = 0;
|
|
private bool _grabbed;
|
|
private bool _selected;
|
|
private Vector3 _position;
|
|
private float _mass = 80f;
|
|
public float _density = 60f;
|
|
public float CAPSULE_RADIUS = 0.37f;
|
|
public float CAPSULE_LENGTH = 2.140599f;
|
|
private Vector3 _force;
|
|
private Vector3 _velocity;
|
|
private Vector3 _torque;
|
|
private float _collisionScore;
|
|
private Vector3 _acceleration;
|
|
private Quaternion _orientation;
|
|
private int _physicsActorType;
|
|
private bool _isPhysical;
|
|
private bool _flying;
|
|
private bool _setAlwaysRun;
|
|
private bool _throttleUpdates;
|
|
private bool _isColliding;
|
|
private long _collidingStep;
|
|
private bool _collidingGround;
|
|
private long _collidingGroundStep;
|
|
private bool _collidingObj;
|
|
private bool _floatOnWater;
|
|
private Vector3 _rotationalVelocity;
|
|
private bool _kinematic;
|
|
private float _buoyancy;
|
|
|
|
private int _subscribedEventsMs = 0;
|
|
private int _lastCollisionTime = 0;
|
|
|
|
private Vector3 _PIDTarget;
|
|
private bool _usePID;
|
|
private float _PIDTau;
|
|
private bool _useHoverPID;
|
|
private float _PIDHoverHeight;
|
|
private PIDHoverType _PIDHoverType;
|
|
private float _PIDHoverTao;
|
|
|
|
public BSCharacter(uint localID, String avName, BSScene parent_scene, Vector3 pos, Vector3 size, bool isFlying)
|
|
{
|
|
_localID = localID;
|
|
_avName = avName;
|
|
_scene = parent_scene;
|
|
_position = pos;
|
|
_size = size;
|
|
_orientation = Quaternion.Identity;
|
|
_velocity = Vector3.Zero;
|
|
_buoyancy = 0f; // characters return a buoyancy of zero
|
|
_scale = new Vector3(1f, 1f, 1f);
|
|
float AVvolume = (float) (Math.PI*Math.Pow(CAPSULE_RADIUS, 2)*CAPSULE_LENGTH);
|
|
_mass = _density*AVvolume;
|
|
|
|
ShapeData shapeData = new ShapeData();
|
|
shapeData.ID = _localID;
|
|
shapeData.Type = ShapeData.PhysicsShapeType.SHAPE_AVATAR;
|
|
shapeData.Position = _position;
|
|
shapeData.Rotation = _orientation;
|
|
shapeData.Velocity = _velocity;
|
|
shapeData.Scale = _scale;
|
|
shapeData.Mass = _mass;
|
|
shapeData.Buoyancy = isFlying ? 0f : 1f;
|
|
shapeData.Static = ShapeData.numericFalse;
|
|
|
|
// do actual create at taint time
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
BulletSimAPI.CreateObject(parent_scene.WorldID, shapeData);
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
// called when this character is being destroyed and the resources should be released
|
|
public void Destroy()
|
|
{
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
BulletSimAPI.DestroyObject(_scene.WorldID, _localID);
|
|
});
|
|
}
|
|
|
|
public override void RequestPhysicsterseUpdate()
|
|
{
|
|
base.RequestPhysicsterseUpdate();
|
|
}
|
|
|
|
public override bool Stopped {
|
|
get { return _stopped; }
|
|
}
|
|
public override Vector3 Size {
|
|
get { return _size; }
|
|
set { _size = value;
|
|
}
|
|
}
|
|
public override PrimitiveBaseShape Shape {
|
|
set { _pbs = value;
|
|
}
|
|
}
|
|
public override uint LocalID {
|
|
set { _localID = value;
|
|
}
|
|
get { return _localID; }
|
|
}
|
|
public override bool Grabbed {
|
|
set { _grabbed = value;
|
|
}
|
|
}
|
|
public override bool Selected {
|
|
set { _selected = value;
|
|
}
|
|
}
|
|
public override void CrossingFailure() { return; }
|
|
public override void link(PhysicsActor obj) { return; }
|
|
public override void delink() { return; }
|
|
public override void LockAngularMotion(Vector3 axis) { return; }
|
|
|
|
public override Vector3 Position {
|
|
get {
|
|
// _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
|
|
return _position;
|
|
}
|
|
set {
|
|
_position = value;
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation);
|
|
});
|
|
}
|
|
}
|
|
public override float Mass {
|
|
get {
|
|
return _mass;
|
|
}
|
|
}
|
|
public override Vector3 Force {
|
|
get { return _force; }
|
|
set {
|
|
_force = value;
|
|
m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force);
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
BulletSimAPI.SetObjectForce(_scene.WorldID, _localID, _force);
|
|
});
|
|
}
|
|
}
|
|
|
|
public override int VehicleType {
|
|
get { return 0; }
|
|
set { return; }
|
|
}
|
|
public override void VehicleFloatParam(int param, float value) { }
|
|
public override void VehicleVectorParam(int param, Vector3 value) {}
|
|
public override void VehicleRotationParam(int param, Quaternion rotation) { }
|
|
public override void VehicleFlags(int param, bool remove) { }
|
|
|
|
// Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
|
|
public override void SetVolumeDetect(int param) { return; }
|
|
|
|
public override Vector3 GeometricCenter { get { return Vector3.Zero; } }
|
|
public override Vector3 CenterOfMass { get { return Vector3.Zero; } }
|
|
public override Vector3 Velocity {
|
|
get { return _velocity; }
|
|
set {
|
|
_velocity = value;
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
BulletSimAPI.SetObjectVelocity(_scene.WorldID, _localID, _velocity);
|
|
});
|
|
}
|
|
}
|
|
public override Vector3 Torque {
|
|
get { return _torque; }
|
|
set { _torque = value;
|
|
}
|
|
}
|
|
public override float CollisionScore {
|
|
get { return _collisionScore; }
|
|
set { _collisionScore = value;
|
|
}
|
|
}
|
|
public override Vector3 Acceleration {
|
|
get { return _acceleration; }
|
|
}
|
|
public override Quaternion Orientation {
|
|
get { return _orientation; }
|
|
set {
|
|
_orientation = value;
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
// _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
|
|
BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation);
|
|
});
|
|
}
|
|
}
|
|
public override int PhysicsActorType {
|
|
get { return _physicsActorType; }
|
|
set { _physicsActorType = value;
|
|
}
|
|
}
|
|
public override bool IsPhysical {
|
|
get { return _isPhysical; }
|
|
set { _isPhysical = value;
|
|
}
|
|
}
|
|
public override bool Flying {
|
|
get { return _flying; }
|
|
set {
|
|
_flying = value;
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
// simulate flying by changing the effect of gravity
|
|
BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, LocalID, _flying ? 0f : 1f);
|
|
});
|
|
}
|
|
}
|
|
public override bool
|
|
SetAlwaysRun {
|
|
get { return _setAlwaysRun; }
|
|
set { _setAlwaysRun = value; }
|
|
}
|
|
public override bool ThrottleUpdates {
|
|
get { return _throttleUpdates; }
|
|
set { _throttleUpdates = value; }
|
|
}
|
|
public override bool IsColliding {
|
|
get { return (_collidingStep == _scene.SimulationStep); }
|
|
set { _isColliding = value; }
|
|
}
|
|
public override bool CollidingGround {
|
|
get { return (_collidingGroundStep == _scene.SimulationStep); }
|
|
set { _collidingGround = value; }
|
|
}
|
|
public override bool CollidingObj {
|
|
get { return _collidingObj; }
|
|
set { _collidingObj = value; }
|
|
}
|
|
public override bool FloatOnWater {
|
|
set { _floatOnWater = value; }
|
|
}
|
|
public override Vector3 RotationalVelocity {
|
|
get { return _rotationalVelocity; }
|
|
set { _rotationalVelocity = value; }
|
|
}
|
|
public override bool Kinematic {
|
|
get { return _kinematic; }
|
|
set { _kinematic = value; }
|
|
}
|
|
public override float Buoyancy {
|
|
get { return _buoyancy; }
|
|
set { _buoyancy = value; }
|
|
}
|
|
|
|
// Used for MoveTo
|
|
public override Vector3 PIDTarget {
|
|
set { _PIDTarget = value; }
|
|
}
|
|
public override bool PIDActive {
|
|
set { _usePID = value; }
|
|
}
|
|
public override float PIDTau {
|
|
set { _PIDTau = value; }
|
|
}
|
|
|
|
// Used for llSetHoverHeight and maybe vehicle height
|
|
// Hover Height will override MoveTo target's Z
|
|
public override bool PIDHoverActive {
|
|
set { _useHoverPID = value; }
|
|
}
|
|
public override float PIDHoverHeight {
|
|
set { _PIDHoverHeight = value; }
|
|
}
|
|
public override PIDHoverType PIDHoverType {
|
|
set { _PIDHoverType = value; }
|
|
}
|
|
public override float PIDHoverTau {
|
|
set { _PIDHoverTao = value; }
|
|
}
|
|
|
|
// For RotLookAt
|
|
public override Quaternion APIDTarget { set { return; } }
|
|
public override bool APIDActive { set { return; } }
|
|
public override float APIDStrength { set { return; } }
|
|
public override float APIDDamping { set { return; } }
|
|
|
|
public override void AddForce(Vector3 force, bool pushforce) {
|
|
if (force.IsFinite())
|
|
{
|
|
_force.X += force.X;
|
|
_force.Y += force.Y;
|
|
_force.Z += force.Z;
|
|
_scene.TaintedObject(delegate()
|
|
{
|
|
BulletSimAPI.SetObjectForce(_scene.WorldID, _localID, _force);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
m_log.WarnFormat("{0}: Got a NaN force applied to a Character", LogHeader);
|
|
}
|
|
//m_lastUpdateSent = false;
|
|
}
|
|
public override void AddAngularForce(Vector3 force, bool pushforce) {
|
|
}
|
|
public override void SetMomentum(Vector3 momentum) {
|
|
}
|
|
public override void SubscribeEvents(int ms) {
|
|
_subscribedEventsMs = ms;
|
|
_lastCollisionTime = Util.EnvironmentTickCount() - _subscribedEventsMs; // make first collision happen
|
|
}
|
|
public override void UnSubscribeEvents() {
|
|
_subscribedEventsMs = 0;
|
|
}
|
|
public override bool SubscribedEvents() {
|
|
return (_subscribedEventsMs > 0);
|
|
}
|
|
|
|
// The physics engine says that properties have updated. Update same and inform
|
|
// the world that things have changed.
|
|
public void UpdateProperties(EntityProperties entprop)
|
|
{
|
|
bool changed = false;
|
|
// we assign to the local variables so the normal set action does not happen
|
|
if (_position != entprop.Position)
|
|
{
|
|
_position = entprop.Position;
|
|
changed = true;
|
|
}
|
|
if (_orientation != entprop.Rotation)
|
|
{
|
|
_orientation = entprop.Rotation;
|
|
changed = true;
|
|
}
|
|
if (_velocity != entprop.Velocity)
|
|
{
|
|
_velocity = entprop.Velocity;
|
|
changed = true;
|
|
}
|
|
if (_acceleration != entprop.Acceleration)
|
|
{
|
|
_acceleration = entprop.Acceleration;
|
|
changed = true;
|
|
}
|
|
if (_rotationalVelocity != entprop.AngularVelocity)
|
|
{
|
|
_rotationalVelocity = entprop.AngularVelocity;
|
|
changed = true;
|
|
}
|
|
if (changed)
|
|
{
|
|
// base.RequestPhysicsterseUpdate();
|
|
}
|
|
}
|
|
|
|
public void Collide(uint collidingWith, ActorTypes type, Vector3 contactPoint, Vector3 contactNormal, float pentrationDepth)
|
|
{
|
|
// m_log.DebugFormat("{0}: Collide: ms={1}, id={2}, with={3}", LogHeader, _subscribedEventsMs, LocalID, collidingWith);
|
|
|
|
// The following makes IsColliding() and IsCollidingGround() work
|
|
_collidingStep = _scene.SimulationStep;
|
|
if (collidingWith == BSScene.TERRAIN_ID || collidingWith == BSScene.GROUNDPLANE_ID)
|
|
{
|
|
_collidingGroundStep = _scene.SimulationStep;
|
|
}
|
|
|
|
if (_subscribedEventsMs == 0) return; // don't want collisions
|
|
int nowTime = Util.EnvironmentTickCount();
|
|
if (nowTime < (_lastCollisionTime + _subscribedEventsMs)) return;
|
|
_lastCollisionTime = nowTime;
|
|
|
|
Dictionary<uint, ContactPoint> contactPoints = new Dictionary<uint, ContactPoint>();
|
|
contactPoints.Add(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
|
|
CollisionEventUpdate args = new CollisionEventUpdate(LocalID, (int)type, 1, contactPoints);
|
|
base.SendCollisionUpdate(args);
|
|
}
|
|
|
|
}
|
|
}
|