Part two of Darok's Bullet physics plugin: added the actual plugin, although haven't added the project to prebuild.xml yet.

Also might have messed up some of the SVN properties on some of the folders, so if the cleaning lady has to come in again, I just hope she doesn't moan.
author: MW 2007-07-13 17:52:11 +0000
committer: MW 2007-07-13 17:52:11 +0000
commit: 07b0e2df6fadf6b2ce720a13d555028f03f73fe8 (patch)
tree: 8c49605b06948dc35707a5b817518714aeed53e5 /OpenSim
parent: * Moved LSL-style functions to ScriptInterpretedAPI.cs and put a XML remark c... (diff)
download: opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.zip
opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.tar.gz
opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.tar.bz2
opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.tar.xz
6 files changed, 602 insertions, 2 deletions
diff --git a/OpenSim/Region/Application/Application.cs b/OpenSim/Region/Application/Application.cs
index 0428f5a..10beaff 100644
--- a/OpenSim/Region/Application/Application.cs
+++ b/OpenSim/Region/Application/Application.cs
@@ -71,6 +71,11 @@ namespace OpenSim
                    physicsEngine = "RealPhysX";
                    allowFlying = true;
                }
+                if (args[i] == "-bulletX")
+                {
+                    physicsEngine = "BulletXEngine";
+                    allowFlying = true;
+                }
                if (args[i] == "-ode")
                {
                    physicsEngine = "OpenDynamicsEngine";
diff --git a/OpenSim/Region/Application/OpenSimMain.cs b/OpenSim/Region/Application/OpenSimMain.cs
index bc9537b..48997e2 100644
--- a/OpenSim/Region/Application/OpenSimMain.cs
+++ b/OpenSim/Region/Application/OpenSimMain.cs
@@ -373,6 +373,11 @@ namespace OpenSim
                    this.m_physicsEngine = "OpenDynamicsEngine";
                    ScenePresence.PhysicsEngineFlying = true;
                    break;
+                case "BulletXEngine":
+                    this.m_physicsEngine = "BulletXEngine";
+                    ScenePresence.PhysicsEngineFlying = true;
+                    break;
            }
            configData.Commit();
diff --git a/OpenSim/Region/Environment/Scenes/Primitive.cs b/OpenSim/Region/Environment/Scenes/Primitive.cs
index 53314e3..ab50373 100644
--- a/OpenSim/Region/Environment/Scenes/Primitive.cs
+++ b/OpenSim/Region/Environment/Scenes/Primitive.cs
@@ -174,7 +174,7 @@ namespace OpenSim.Region.Environment.Scenes
            dupe.Rotation = new Quaternion(this.Rotation.w, this.Rotation.x, this.Rotation.y, this.Rotation.z);
            dupe.Pos = new LLVector3(this.Pos.X, this.Pos.Y, this.Pos.Z);
            rootParent.AddChildToList(dupe);
+            
            foreach (Primitive prim in this.children)
            {
                Primitive primClone = prim.Copy(this, rootParent);
diff --git a/OpenSim/Region/Environment/Scenes/Scene.cs b/OpenSim/Region/Environment/Scenes/Scene.cs
index c8714ae..0305b50 100644
--- a/OpenSim/Region/Environment/Scenes/Scene.cs
+++ b/OpenSim/Region/Environment/Scenes/Scene.cs
@@ -453,7 +453,7 @@ namespace OpenSim.Region.Environment.Scenes
            
        }
-        protected override void SubscribeToClientEvents(IClientAPI client)
+        protected virtual void SubscribeToClientEvents(IClientAPI client)
        {
            client.OnRegionHandShakeReply += this.SendLayerData;
            //remoteClient.OnRequestWearables += new GenericCall(this.GetInitialPrims);
diff --git a/OpenSim/Region/Physics/BulletXPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/BulletXPlugin/AssemblyInfo.cs
new file mode 100644
index 0000000..bda35f7
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletXPlugin/AssemblyInfo.cs
@@ -0,0 +1,56 @@
+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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 OpenSim 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.Reflection;
+using System.Runtime.InteropServices;
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+[assembly: AssemblyTitle("BulletXPlugin")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("BulletXPlugin")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+[assembly: ComVisible(false)]
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+[assembly: AssemblyVersion("1.0.0.0")]
diff --git a/OpenSim/Region/Physics/BulletXPlugin/BulletXPlugin.cs b/OpenSim/Region/Physics/BulletXPlugin/BulletXPlugin.cs
new file mode 100644
index 0000000..1ca5efe
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletXPlugin/BulletXPlugin.cs
@@ -0,0 +1,534 @@
+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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 OpenSim 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.
+* 
+*/
+#region References
+using System;
+using System.Collections.Generic;
+using OpenSim.Physics.Manager;
+using Axiom.Math;
+//Specific References for BulletXPlugin
+using MonoXnaCompactMaths;
+using XnaDevRu.BulletX;
+using XnaDevRu.BulletX.Dynamics;
+#endregion
+namespace OpenSim.Region.Physics.BulletXPlugin
+{
+    /// <summary>
+    /// This Class converts objects and types for BulletX
+    /// </summary>
+    public class BulletXConversions
+    {
+        public static MonoXnaCompactMaths.Vector3 PhysicsVectorToXnaVector3(PhysicsVector physicsVector)
+        {
+            return new MonoXnaCompactMaths.Vector3(physicsVector.X, physicsVector.Y, physicsVector.Z);
+        }
+        public static void PhysicsVectorToXnaVector3(PhysicsVector physicsVector, out MonoXnaCompactMaths.Vector3 XnaVector3)
+        {
+            XnaVector3.X = physicsVector.X;
+            XnaVector3.Y = physicsVector.Y;
+            XnaVector3.Z = physicsVector.Z;
+        }
+        public static PhysicsVector XnaVector3ToPhysicsVector(MonoXnaCompactMaths.Vector3 xnaVector3)
+        {
+            return new PhysicsVector(xnaVector3.X, xnaVector3.Y, xnaVector3.Z);
+        }
+        /*public static void XnaVector3ToPhysicsVector(MonoXnaCompactMaths.Vector3 xnaVector3, out PhysicsVector physicsVector)
+        {
+            xnaVector3.X = physicsVector.X;
+            xnaVector3.Y = physicsVector.Y;
+            xnaVector3.Z = physicsVector.Z;
+        }*/
+        #region Axiom and Xna
+        ///// <summary>
+        ///// BTW maybe some conversions will be a simply converion that it doesn't require this class, but i don't know
+        ///// </summary>
+        ///// <param name="AxiomVector3"></param>
+        ///// <returns></returns>
+        //public static MonoXnaCompactMaths.Vector3 Vector3AxiomToXna(Axiom.Math.Vector3 AxiomVector3)
+        //{
+        //    return new MonoXnaCompactMaths.Vector3(AxiomVector3.x, AxiomVector3.y, AxiomVector3.z);
+        //}
+        #endregion
+    }
+    /// <summary>
+    /// PhysicsPlugin Class for BulletX
+    /// </summary>
+    public class BulletXPlugin : IPhysicsPlugin
+    {
+        private BulletXScene _mScene;
+        public BulletXPlugin()
+        {
+        }
+        public bool Init()
+        {
+            return true;
+        }
+        public PhysicsScene GetScene()
+        {
+            if (_mScene == null)
+            {
+                _mScene = new BulletXScene();
+            }
+            return (_mScene);
+        }
+        public string GetName()
+        {
+            return ("BulletXEngine");
+        }
+        public void Dispose()
+        {
+        }
+    }
+    /// <summary>
+    /// PhysicsScene Class for BulletX
+    /// </summary>
+    public class BulletXScene : PhysicsScene
+    {
+        public DiscreteDynamicsWorld ddWorld;
+                private CollisionDispatcher cDispatcher;
+                private OverlappingPairCache opCache;
+                private SequentialImpulseConstraintSolver sicSolver;
+        private const int minXY = 0;
+        private const int minZ = 0;
+        private const int maxXY = 256;
+        private const int maxZ = 4096;
+        private const int maxHandles = 32766; //Why? I don't know
+        private static float gravity = 9.8f;
+        private static float heightLevel0 = 77.0f;
+        private static float heightLevel1 = 200.0f;
+        private static float lowGravityFactor = 0.2f;
+        private float[] _heightmap;
+        private List<BulletXCharacter> _characters = new List<BulletXCharacter>();
+        public static float Gravity { get { return gravity; } }
+        public static float HeightLevel0 { get { return heightLevel0; } }
+        public static float HeightLevel1 { get { return heightLevel1; } }
+        public static float LowGravityFactor { get { return lowGravityFactor; } }
+        public BulletXScene()
+        {
+            cDispatcher = new CollisionDispatcher();
+            MonoXnaCompactMaths.Vector3 worldMinDim = new MonoXnaCompactMaths.Vector3((float)minXY, (float)minXY, (float)minZ);
+            MonoXnaCompactMaths.Vector3 worldMaxDim = new MonoXnaCompactMaths.Vector3((float)maxXY, (float)maxXY, (float)maxZ);
+            opCache = new AxisSweep3(worldMinDim, worldMaxDim, maxHandles);
+            sicSolver = new SequentialImpulseConstraintSolver();
+            ddWorld = new DiscreteDynamicsWorld(cDispatcher, opCache, sicSolver);
+            ddWorld.Gravity = new MonoXnaCompactMaths.Vector3(0, 0, -gravity);
+            this._heightmap = new float[65536];
+        }
+        public override PhysicsActor AddAvatar(PhysicsVector position)
+        {
+            PhysicsVector pos = new PhysicsVector();
+            pos.X = position.X;
+            pos.Y = position.Y;
+            pos.Z = position.Z + 20;
+            BulletXCharacter newAv = new BulletXCharacter(this, pos);
+            this._characters.Add(newAv);
+            return newAv;
+        }
+        public override void RemoveAvatar(PhysicsActor actor)
+        {
+        }
+        public override PhysicsActor AddPrim(PhysicsVector position, PhysicsVector size)
+        {
+            PhysicsVector pos = new PhysicsVector();
+            pos.X = position.X;
+            pos.Y = position.Y;
+            pos.Z = position.Z;
+            PhysicsVector siz = new PhysicsVector();
+            siz.X = size.X;
+            siz.Y = size.Y;
+            siz.Z = size.Z;
+            return new BulletXPrim();
+        }
+        public override void Simulate(float timeStep)
+        {
+            foreach (BulletXCharacter actor in _characters)
+            {
+                actor.Move(timeStep);
+            }
+            ddWorld.StepSimulation(timeStep, 0, timeStep);
+            foreach (BulletXCharacter actor in _characters)
+            {
+                actor.ValidateHeight(this._heightmap[
+                    (int)Math.Round(actor.RigidBodyHorizontalPosition.x) * 256 
+                    + (int)Math.Round(actor.RigidBodyHorizontalPosition.y)]);
+            }
+            foreach (BulletXCharacter actor in _characters)
+            {
+                actor.UpdatePosition();
+            }
+        }
+        public override void GetResults()
+        {
+        }
+        public override bool IsThreaded
+        {
+            get
+            {
+                return (false); // for now we won't be multithreaded
+            }
+        }
+        public override void SetTerrain(float[] heightMap)
+        {
+            //As the same as ODE, heightmap (x,y) must be swapped for BulletX
+            for (int i = 0; i < 65536; i++)
+            {
+                // this._heightmap[i] = (double)heightMap[i];
+                // dbm (danx0r) -- heightmap x,y must be swapped for Ode (should fix ODE, but for now...)
+                int x = i & 0xff;
+                int y = i >> 8;
+                this._heightmap[i] = heightMap[x * 256 + y];
+            }
+        }
+        public override void DeleteTerrain()
+        {
+        }
+    }
+    /// <summary>
+    /// PhysicsActor Character Class for BulletX
+    /// </summary>
+    public class BulletXCharacter : PhysicsActor
+    {
+        private PhysicsVector _position;
+        private PhysicsVector _velocity;
+        private PhysicsVector _acceleration;
+        private bool flying;
+        private RigidBody rigidBody;
+        public Axiom.Math.Vector2 RigidBodyHorizontalPosition
+        {
+            get
+            {
+                return new Axiom.Math.Vector2(this.rigidBody.CenterOfMassPosition.X, this.rigidBody.CenterOfMassPosition.Y);
+            }
+        }
+        public BulletXCharacter(BulletXScene parent_scene, PhysicsVector pos)
+        {
+            _velocity = new PhysicsVector();
+            _position = pos;
+            _acceleration = new PhysicsVector();
+            float _mass = 50.0f; //This depends of avatar's dimensions
+            Matrix _startTransform = Matrix.Identity;
+            _startTransform.Translation = BulletXConversions.PhysicsVectorToXnaVector3(pos);
+            Matrix _centerOfMassOffset = Matrix.Identity;
+            CollisionShape _collisionShape = new BoxShape(new MonoXnaCompactMaths.Vector3(0.5f, 0.5f, 1.60f));
+            DefaultMotionState _motionState = new DefaultMotionState(_startTransform, _centerOfMassOffset);
+            MonoXnaCompactMaths.Vector3 _localInertia = new MonoXnaCompactMaths.Vector3();
+            _collisionShape.CalculateLocalInertia(_mass, out _localInertia); //Always when mass > 0
+            //The next values might change
+            float _linearDamping = 0.0f;
+            float _angularDamping = 0.0f;
+            float _friction = 0.5f;
+            float _restitution = 0.0f;
+            rigidBody = new RigidBody(_mass, _motionState, _collisionShape, _localInertia, _linearDamping, _angularDamping, _friction, _restitution);
+            rigidBody.ActivationState = ActivationState.DisableDeactivation;
+            parent_scene.ddWorld.AddRigidBody(rigidBody);
+        }
+        public override bool Flying
+        {
+            get
+            {
+                return flying;
+            }
+            set
+            {
+                flying = value;
+            }
+        }
+        public override PhysicsVector Position
+        {
+            get
+            {
+                return _position;
+            }
+            set
+            {
+                _position = value;
+            }
+        }
+        public override PhysicsVector Velocity
+        {
+            get
+            {
+                return _velocity;
+            }
+            set
+            {
+                _velocity = value;
+            }
+        }
+        public override bool Kinematic
+        {
+            get
+            {
+                return false;
+            }
+            set
+            {
+            }
+        }
+        public override Axiom.Math.Quaternion Orientation
+        {
+            get
+            {
+                return Axiom.Math.Quaternion.Identity;
+            }
+            set
+            {
+            }
+        }
+        public override PhysicsVector Acceleration
+        {
+            get
+            {
+                return _acceleration;
+            }
+        }
+        public void SetAcceleration(PhysicsVector accel)
+        {
+            this._acceleration = accel;
+        }
+        public override void AddForce(PhysicsVector force)
+        {
+        }
+        public override void SetMomentum(PhysicsVector momentum)
+        {
+        }
+        public void Move(float timeStep)
+        {
+            MonoXnaCompactMaths.Vector3 vec = new MonoXnaCompactMaths.Vector3();
+            //if (this._velocity.X == 0.0f)
+            //    vec.X = this.rigidBody.LinearVelocity.X; //current velocity
+            //else 
+                vec.X = this._velocity.X; //overrides current velocity
+            //if (this._velocity.Y == 0.0f)
+            //    vec.Y = this.rigidBody.LinearVelocity.Y; //current velocity
+            //else
+                vec.Y = this._velocity.Y; //overrides current velocity
+            float nextZVelocity;
+            //if (this._velocity.Z == 0.0f)
+            //    nextZVelocity = this.rigidBody.LinearVelocity.Z; //current velocity
+            //else
+                nextZVelocity = this._velocity.Z; //overrides current velocity
+            if (flying)
+            {
+                //Antigravity with movement
+                if (this._position.Z <= BulletXScene.HeightLevel0) 
+                {
+                    vec.Z = nextZVelocity + BulletXScene.Gravity * timeStep;
+                }
+                //Lowgravity with movement
+                else if((this._position.Z > BulletXScene.HeightLevel0) 
+                    && (this._position.Z <= BulletXScene.HeightLevel1)) 
+                {
+                    vec.Z = nextZVelocity + BulletXScene.Gravity * timeStep * (1.0f - BulletXScene.LowGravityFactor);
+                }
+                //Lowgravity with...
+                else if (this._position.Z > BulletXScene.HeightLevel1) 
+                {
+                    if(nextZVelocity > 0) //no movement
+                        vec.Z = BulletXScene.Gravity * timeStep * (1.0f - BulletXScene.LowGravityFactor);
+                    else
+                        vec.Z = nextZVelocity + BulletXScene.Gravity * timeStep * (1.0f - BulletXScene.LowGravityFactor);
+                }
+            }
+            else
+            {
+                vec.Z = nextZVelocity;
+            }
+            rigidBody.LinearVelocity = vec;
+        }
+        public void UpdatePosition()
+        {
+            this._position = BulletXConversions.XnaVector3ToPhysicsVector(rigidBody.CenterOfMassPosition);
+        }
+        //This validation is very basic
+        internal void ValidateHeight(float heighmapPositionValue)
+        {
+            if (rigidBody.CenterOfMassPosition.Z < heighmapPositionValue)
+            {
+                Matrix m = rigidBody.WorldTransform;
+                MonoXnaCompactMaths.Vector3 v3 = m.Translation;
+                v3.Z = heighmapPositionValue;
+                m.Translation = v3;
+                rigidBody.WorldTransform = m;
+            }
+        }
+    }
+    /// <summary>
+    /// PhysicsActor Prim Class for BulletX
+    /// </summary>
+    public class BulletXPrim : PhysicsActor
+    {
+        private PhysicsVector _position;
+        private PhysicsVector _velocity;
+        private PhysicsVector _acceleration;
+        public BulletXPrim()
+        {
+            _velocity = new PhysicsVector();
+            _position = new PhysicsVector();
+            _acceleration = new PhysicsVector();
+        }
+        public override bool Flying
+        {
+            get
+            {
+                return false; //no flying prims for you
+            }
+            set
+            {
+            }
+        }
+        public override PhysicsVector Position
+        {
+            get
+            {
+                PhysicsVector pos = new PhysicsVector();
+                //      PhysicsVector vec = this._prim.Position;
+                //pos.X = vec.X;
+                //pos.Y = vec.Y;
+                //pos.Z = vec.Z;
+                return pos;
+            }
+            set
+            {
+                /*PhysicsVector vec = value;
+                PhysicsVector pos = new PhysicsVector();
+                pos.X = vec.X;
+                pos.Y = vec.Y;
+                pos.Z = vec.Z;
+                this._prim.Position = pos;*/
+            }
+        }
+        public override PhysicsVector Velocity
+        {
+            get
+            {
+                return _velocity;
+            }
+            set
+            {
+                _velocity = value;
+            }
+        }
+        public override bool Kinematic
+        {
+            get
+            {
+                return false;
+                //return this._prim.Kinematic;
+            }
+            set
+            {
+                //this._prim.Kinematic = value;
+            }
+        }
+        public override Axiom.Math.Quaternion Orientation
+        {
+            get
+            {
+                Axiom.Math.Quaternion res = new Axiom.Math.Quaternion();
+                return res;
+            }
+            set
+            {
+            }
+        }
+        public override PhysicsVector Acceleration
+        {
+            get
+            {
+                return _acceleration;
+            }
+        }
+        public void SetAcceleration(PhysicsVector accel)
+        {
+            this._acceleration = accel;
+        }
+        public override void AddForce(PhysicsVector force)
+        {
+        }
+        public override void SetMomentum(PhysicsVector momentum)
+        {
+        }
+    }
+}
author	MW	2007-07-13 17:52:11 +0000
committer	MW	2007-07-13 17:52:11 +0000
commit	07b0e2df6fadf6b2ce720a13d555028f03f73fe8 (patch)
tree	8c49605b06948dc35707a5b817518714aeed53e5 /OpenSim
parent	* Moved LSL-style functions to ScriptInterpretedAPI.cs and put a XML remark c... (diff)
download	opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.zip opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.tar.gz opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.tar.bz2 opensim-SC-07b0e2df6fadf6b2ce720a13d555028f03f73fe8.tar.xz

diff --git a/OpenSim/Region/Application/Application.cs b/OpenSim/Region/Application/Application.cs index 0428f5a..10beaff 100644 --- a/OpenSim/Region/Application/Application.cs +++ b/OpenSim/Region/Application/Application.cs
@@ -71,6 +71,11 @@ namespace OpenSim
71	physicsEngine = "RealPhysX";	71	physicsEngine = "RealPhysX";
72	allowFlying = true;	72	allowFlying = true;
73	}	73	}
		74	if (args[i] == "-bulletX")
		75	{
		76	physicsEngine = "BulletXEngine";
		77	allowFlying = true;
		78	}
74	if (args[i] == "-ode")	79	if (args[i] == "-ode")
75	{	80	{
76	physicsEngine = "OpenDynamicsEngine";	81	physicsEngine = "OpenDynamicsEngine";


diff --git a/OpenSim/Region/Application/OpenSimMain.cs b/OpenSim/Region/Application/OpenSimMain.cs index bc9537b..48997e2 100644 --- a/OpenSim/Region/Application/OpenSimMain.cs +++ b/OpenSim/Region/Application/OpenSimMain.cs
@@ -373,6 +373,11 @@ namespace OpenSim
373	this.m_physicsEngine = "OpenDynamicsEngine";	373	this.m_physicsEngine = "OpenDynamicsEngine";
374	ScenePresence.PhysicsEngineFlying = true;	374	ScenePresence.PhysicsEngineFlying = true;
375	break;	375	break;
		376
		377	case "BulletXEngine":
		378	this.m_physicsEngine = "BulletXEngine";
		379	ScenePresence.PhysicsEngineFlying = true;
		380	break;
376	}	381	}
377		382
378	configData.Commit();	383	configData.Commit();


diff --git a/OpenSim/Region/Environment/Scenes/Primitive.cs b/OpenSim/Region/Environment/Scenes/Primitive.cs index 53314e3..ab50373 100644 --- a/OpenSim/Region/Environment/Scenes/Primitive.cs +++ b/OpenSim/Region/Environment/Scenes/Primitive.cs
@@ -174,7 +174,7 @@ namespace OpenSim.Region.Environment.Scenes
174	dupe.Rotation = new Quaternion(this.Rotation.w, this.Rotation.x, this.Rotation.y, this.Rotation.z);	174	dupe.Rotation = new Quaternion(this.Rotation.w, this.Rotation.x, this.Rotation.y, this.Rotation.z);
175	dupe.Pos = new LLVector3(this.Pos.X, this.Pos.Y, this.Pos.Z);	175	dupe.Pos = new LLVector3(this.Pos.X, this.Pos.Y, this.Pos.Z);
176	rootParent.AddChildToList(dupe);	176	rootParent.AddChildToList(dupe);
177		177
178	foreach (Primitive prim in this.children)	178	foreach (Primitive prim in this.children)
179	{	179	{
180	Primitive primClone = prim.Copy(this, rootParent);	180	Primitive primClone = prim.Copy(this, rootParent);


diff --git a/OpenSim/Region/Environment/Scenes/Scene.cs b/OpenSim/Region/Environment/Scenes/Scene.cs index c8714ae..0305b50 100644 --- a/OpenSim/Region/Environment/Scenes/Scene.cs +++ b/OpenSim/Region/Environment/Scenes/Scene.cs
@@ -453,7 +453,7 @@ namespace OpenSim.Region.Environment.Scenes
453		453
454	}	454	}
455		455
456	protected override void SubscribeToClientEvents(IClientAPI client)	456	protected virtual void SubscribeToClientEvents(IClientAPI client)
457	{	457	{
458	client.OnRegionHandShakeReply += this.SendLayerData;	458	client.OnRegionHandShakeReply += this.SendLayerData;
459	//remoteClient.OnRequestWearables += new GenericCall(this.GetInitialPrims);	459	//remoteClient.OnRequestWearables += new GenericCall(this.GetInitialPrims);


diff --git a/OpenSim/Region/Physics/BulletXPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/BulletXPlugin/AssemblyInfo.cs new file mode 100644 index 0000000..bda35f7 --- /dev/null +++ b/OpenSim/Region/Physics/BulletXPlugin/AssemblyInfo.cs
@@ -0,0 +1,56 @@
		1	/*
		2	* Copyright (c) Contributors, http://www.openmetaverse.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 OpenSim 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	*/
		28	using System.Reflection;
		29	using System.Runtime.InteropServices;
		30	// Information about this assembly is defined by the following
		31	// attributes.
		32	//
		33	// change them to the information which is associated with the assembly
		34	// you compile.
		35
		36	[assembly: AssemblyTitle("BulletXPlugin")]
		37	[assembly: AssemblyDescription("")]
		38	[assembly: AssemblyConfiguration("")]
		39	[assembly: AssemblyCompany("")]
		40	[assembly: AssemblyProduct("BulletXPlugin")]
		41	[assembly: AssemblyCopyright("")]
		42	[assembly: AssemblyTrademark("")]
		43	[assembly: AssemblyCulture("")]
		44
		45	// This sets the default COM visibility of types in the assembly to invisible.
		46	// If you need to expose a type to COM, use [ComVisible(true)] on that type.
		47	[assembly: ComVisible(false)]
		48
		49	// The assembly version has following format :
		50	//
		51	// Major.Minor.Build.Revision
		52	//
		53	// You can specify all values by your own or you can build default build and revision
		54	// numbers with the '*' character (the default):
		55
		56	[assembly: AssemblyVersion("1.0.0.0")]


diff --git a/OpenSim/Region/Physics/BulletXPlugin/BulletXPlugin.cs b/OpenSim/Region/Physics/BulletXPlugin/BulletXPlugin.cs new file mode 100644 index 0000000..1ca5efe --- /dev/null +++ b/OpenSim/Region/Physics/BulletXPlugin/BulletXPlugin.cs
@@ -0,0 +1,534 @@
		1	/*
		2	* Copyright (c) Contributors, http://www.openmetaverse.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 OpenSim 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	*/
		28	#region References
		29	using System;
		30	using System.Collections.Generic;
		31	using OpenSim.Physics.Manager;
		32	using Axiom.Math;
		33	//Specific References for BulletXPlugin
		34	using MonoXnaCompactMaths;
		35	using XnaDevRu.BulletX;
		36	using XnaDevRu.BulletX.Dynamics;
		37	#endregion
		38
		39	namespace OpenSim.Region.Physics.BulletXPlugin
		40	{
		41	/// <summary>
		42	/// This Class converts objects and types for BulletX
		43	/// </summary>
		44	public class BulletXConversions
		45	{
		46	public static MonoXnaCompactMaths.Vector3 PhysicsVectorToXnaVector3(PhysicsVector physicsVector)
		47	{
		48	return new MonoXnaCompactMaths.Vector3(physicsVector.X, physicsVector.Y, physicsVector.Z);
		49	}
		50	public static void PhysicsVectorToXnaVector3(PhysicsVector physicsVector, out MonoXnaCompactMaths.Vector3 XnaVector3)
		51	{
		52	XnaVector3.X = physicsVector.X;
		53	XnaVector3.Y = physicsVector.Y;
		54	XnaVector3.Z = physicsVector.Z;
		55	}
		56	public static PhysicsVector XnaVector3ToPhysicsVector(MonoXnaCompactMaths.Vector3 xnaVector3)
		57	{
		58	return new PhysicsVector(xnaVector3.X, xnaVector3.Y, xnaVector3.Z);
		59	}
		60	/*public static void XnaVector3ToPhysicsVector(MonoXnaCompactMaths.Vector3 xnaVector3, out PhysicsVector physicsVector)
		61	{
		62	xnaVector3.X = physicsVector.X;
		63	xnaVector3.Y = physicsVector.Y;
		64	xnaVector3.Z = physicsVector.Z;
		65	}*/
		66	#region Axiom and Xna
		67	///// <summary>
		68	///// BTW maybe some conversions will be a simply converion that it doesn't require this class, but i don't know
		69	///// </summary>
		70	///// <param name="AxiomVector3"></param>
		71	///// <returns></returns>
		72	//public static MonoXnaCompactMaths.Vector3 Vector3AxiomToXna(Axiom.Math.Vector3 AxiomVector3)
		73	//{
		74	// return new MonoXnaCompactMaths.Vector3(AxiomVector3.x, AxiomVector3.y, AxiomVector3.z);
		75	//}
		76	#endregion
		77	}
		78	/// <summary>
		79	/// PhysicsPlugin Class for BulletX
		80	/// </summary>
		81	public class BulletXPlugin : IPhysicsPlugin
		82	{
		83	private BulletXScene _mScene;
		84
		85	public BulletXPlugin()
		86	{
		87	}
		88	public bool Init()
		89	{
		90	return true;
		91	}
		92	public PhysicsScene GetScene()
		93	{
		94	if (_mScene == null)
		95	{
		96	_mScene = new BulletXScene();
		97	}
		98	return (_mScene);
		99	}
		100	public string GetName()
		101	{
		102	return ("BulletXEngine");
		103	}
		104	public void Dispose()
		105	{
		106	}
		107	}
		108	/// <summary>
		109	/// PhysicsScene Class for BulletX
		110	/// </summary>
		111	public class BulletXScene : PhysicsScene
		112	{
		113	public DiscreteDynamicsWorld ddWorld;
		114	private CollisionDispatcher cDispatcher;
		115	private OverlappingPairCache opCache;
		116	private SequentialImpulseConstraintSolver sicSolver;
		117
		118	private const int minXY = 0;
		119	private const int minZ = 0;
		120	private const int maxXY = 256;
		121	private const int maxZ = 4096;
		122	private const int maxHandles = 32766; //Why? I don't know
		123	private static float gravity = 9.8f;
		124	private static float heightLevel0 = 77.0f;
		125	private static float heightLevel1 = 200.0f;
		126	private static float lowGravityFactor = 0.2f;
		127
		128	private float[] _heightmap;
		129	private List<BulletXCharacter> _characters = new List<BulletXCharacter>();
		130
		131	public static float Gravity { get { return gravity; } }
		132	public static float HeightLevel0 { get { return heightLevel0; } }
		133	public static float HeightLevel1 { get { return heightLevel1; } }
		134	public static float LowGravityFactor { get { return lowGravityFactor; } }
		135
		136	public BulletXScene()
		137	{
		138	cDispatcher = new CollisionDispatcher();
		139	MonoXnaCompactMaths.Vector3 worldMinDim = new MonoXnaCompactMaths.Vector3((float)minXY, (float)minXY, (float)minZ);
		140	MonoXnaCompactMaths.Vector3 worldMaxDim = new MonoXnaCompactMaths.Vector3((float)maxXY, (float)maxXY, (float)maxZ);
		141	opCache = new AxisSweep3(worldMinDim, worldMaxDim, maxHandles);
		142	sicSolver = new SequentialImpulseConstraintSolver();
		143
		144	ddWorld = new DiscreteDynamicsWorld(cDispatcher, opCache, sicSolver);
		145	ddWorld.Gravity = new MonoXnaCompactMaths.Vector3(0, 0, -gravity);
		146
		147	this._heightmap = new float[65536];
		148	}
		149
		150	public override PhysicsActor AddAvatar(PhysicsVector position)
		151	{
		152	PhysicsVector pos = new PhysicsVector();
		153	pos.X = position.X;
		154	pos.Y = position.Y;
		155	pos.Z = position.Z + 20;
		156	BulletXCharacter newAv = new BulletXCharacter(this, pos);
		157	this._characters.Add(newAv);
		158	return newAv;
		159	}
		160
		161	public override void RemoveAvatar(PhysicsActor actor)
		162	{
		163
		164	}
		165
		166	public override PhysicsActor AddPrim(PhysicsVector position, PhysicsVector size)
		167	{
		168	PhysicsVector pos = new PhysicsVector();
		169	pos.X = position.X;
		170	pos.Y = position.Y;
		171	pos.Z = position.Z;
		172	PhysicsVector siz = new PhysicsVector();
		173	siz.X = size.X;
		174	siz.Y = size.Y;
		175	siz.Z = size.Z;
		176	return new BulletXPrim();
		177	}
		178
		179	public override void Simulate(float timeStep)
		180	{
		181	foreach (BulletXCharacter actor in _characters)
		182	{
		183	actor.Move(timeStep);
		184
		185	}
		186	ddWorld.StepSimulation(timeStep, 0, timeStep);
		187	foreach (BulletXCharacter actor in _characters)
		188	{
		189	actor.ValidateHeight(this._heightmap[
		190	(int)Math.Round(actor.RigidBodyHorizontalPosition.x) * 256
		191	+ (int)Math.Round(actor.RigidBodyHorizontalPosition.y)]);
		192	}
		193	foreach (BulletXCharacter actor in _characters)
		194	{
		195	actor.UpdatePosition();
		196	}
		197
		198	}
		199
		200	public override void GetResults()
		201	{
		202
		203	}
		204
		205	public override bool IsThreaded
		206	{
		207	get
		208	{
		209	return (false); // for now we won't be multithreaded
		210	}
		211	}
		212
		213	public override void SetTerrain(float[] heightMap)
		214	{
		215	//As the same as ODE, heightmap (x,y) must be swapped for BulletX
		216	for (int i = 0; i < 65536; i++)
		217	{
		218	// this._heightmap[i] = (double)heightMap[i];
		219	// dbm (danx0r) -- heightmap x,y must be swapped for Ode (should fix ODE, but for now...)
		220	int x = i & 0xff;
		221	int y = i >> 8;
		222	this._heightmap[i] = heightMap[x * 256 + y];
		223	}
		224	}
		225
		226	public override void DeleteTerrain()
		227	{
		228
		229	}
		230	}
		231	/// <summary>
		232	/// PhysicsActor Character Class for BulletX
		233	/// </summary>
		234	public class BulletXCharacter : PhysicsActor
		235	{
		236	private PhysicsVector _position;
		237	private PhysicsVector _velocity;
		238	private PhysicsVector _acceleration;
		239	private bool flying;
		240	private RigidBody rigidBody;
		241	public Axiom.Math.Vector2 RigidBodyHorizontalPosition
		242	{
		243	get
		244	{
		245	return new Axiom.Math.Vector2(this.rigidBody.CenterOfMassPosition.X, this.rigidBody.CenterOfMassPosition.Y);
		246	}
		247	}
		248	public BulletXCharacter(BulletXScene parent_scene, PhysicsVector pos)
		249	{
		250	_velocity = new PhysicsVector();
		251	_position = pos;
		252	_acceleration = new PhysicsVector();
		253	float _mass = 50.0f; //This depends of avatar's dimensions
		254	Matrix _startTransform = Matrix.Identity;
		255	_startTransform.Translation = BulletXConversions.PhysicsVectorToXnaVector3(pos);
		256	Matrix _centerOfMassOffset = Matrix.Identity;
		257	CollisionShape _collisionShape = new BoxShape(new MonoXnaCompactMaths.Vector3(0.5f, 0.5f, 1.60f));
		258	DefaultMotionState _motionState = new DefaultMotionState(_startTransform, _centerOfMassOffset);
		259	MonoXnaCompactMaths.Vector3 _localInertia = new MonoXnaCompactMaths.Vector3();
		260	_collisionShape.CalculateLocalInertia(_mass, out _localInertia); //Always when mass > 0
		261
		262	//The next values might change
		263	float _linearDamping = 0.0f;
		264	float _angularDamping = 0.0f;
		265	float _friction = 0.5f;
		266	float _restitution = 0.0f;
		267
		268	rigidBody = new RigidBody(_mass, _motionState, _collisionShape, _localInertia, _linearDamping, _angularDamping, _friction, _restitution);
		269	rigidBody.ActivationState = ActivationState.DisableDeactivation;
		270
		271	parent_scene.ddWorld.AddRigidBody(rigidBody);
		272	}
		273
		274	public override bool Flying
		275	{
		276	get
		277	{
		278	return flying;
		279	}
		280	set
		281	{
		282	flying = value;
		283	}
		284	}
		285
		286	public override PhysicsVector Position
		287	{
		288	get
		289	{
		290	return _position;
		291	}
		292	set
		293	{
		294	_position = value;
		295	}
		296	}
		297
		298	public override PhysicsVector Velocity
		299	{
		300	get
		301	{
		302	return _velocity;
		303	}
		304	set
		305	{
		306	_velocity = value;
		307	}
		308	}
		309
		310	public override bool Kinematic
		311	{
		312	get
		313	{
		314	return false;
		315	}
		316	set
		317	{
		318
		319	}
		320	}
		321
		322	public override Axiom.Math.Quaternion Orientation
		323	{
		324	get
		325	{
		326	return Axiom.Math.Quaternion.Identity;
		327	}
		328	set
		329	{
		330
		331	}
		332	}
		333
		334	public override PhysicsVector Acceleration
		335	{
		336	get
		337	{
		338	return _acceleration;
		339	}
		340
		341	}
		342	public void SetAcceleration(PhysicsVector accel)
		343	{
		344	this._acceleration = accel;
		345	}
		346
		347	public override void AddForce(PhysicsVector force)
		348	{
		349
		350	}
		351
		352	public override void SetMomentum(PhysicsVector momentum)
		353	{
		354
		355	}
		356
		357	public void Move(float timeStep)
		358	{
		359	MonoXnaCompactMaths.Vector3 vec = new MonoXnaCompactMaths.Vector3();
		360	//if (this._velocity.X == 0.0f)
		361	// vec.X = this.rigidBody.LinearVelocity.X; //current velocity
		362	//else
		363	vec.X = this._velocity.X; //overrides current velocity
		364
		365	//if (this._velocity.Y == 0.0f)
		366	// vec.Y = this.rigidBody.LinearVelocity.Y; //current velocity
		367	//else
		368	vec.Y = this._velocity.Y; //overrides current velocity
		369
		370	float nextZVelocity;
		371	//if (this._velocity.Z == 0.0f)
		372	// nextZVelocity = this.rigidBody.LinearVelocity.Z; //current velocity
		373	//else
		374	nextZVelocity = this._velocity.Z; //overrides current velocity
		375
		376	if (flying)
		377	{
		378	//Antigravity with movement
		379	if (this._position.Z <= BulletXScene.HeightLevel0)
		380	{
		381	vec.Z = nextZVelocity + BulletXScene.Gravity * timeStep;
		382	}
		383	//Lowgravity with movement
		384	else if((this._position.Z > BulletXScene.HeightLevel0)
		385	&& (this._position.Z <= BulletXScene.HeightLevel1))
		386	{
		387	vec.Z = nextZVelocity + BulletXScene.Gravity * timeStep * (1.0f - BulletXScene.LowGravityFactor);
		388	}
		389	//Lowgravity with...
		390	else if (this._position.Z > BulletXScene.HeightLevel1)
		391	{
		392	if(nextZVelocity > 0) //no movement
		393	vec.Z = BulletXScene.Gravity * timeStep * (1.0f - BulletXScene.LowGravityFactor);
		394	else
		395	vec.Z = nextZVelocity + BulletXScene.Gravity * timeStep * (1.0f - BulletXScene.LowGravityFactor);
		396
		397	}
		398	}
		399	else
		400	{
		401	vec.Z = nextZVelocity;
		402	}
		403	rigidBody.LinearVelocity = vec;
		404	}
		405
		406	public void UpdatePosition()
		407	{
		408	this._position = BulletXConversions.XnaVector3ToPhysicsVector(rigidBody.CenterOfMassPosition);
		409	}
		410
		411	//This validation is very basic
		412	internal void ValidateHeight(float heighmapPositionValue)
		413	{
		414	if (rigidBody.CenterOfMassPosition.Z < heighmapPositionValue)
		415	{
		416	Matrix m = rigidBody.WorldTransform;
		417	MonoXnaCompactMaths.Vector3 v3 = m.Translation;
		418	v3.Z = heighmapPositionValue;
		419	m.Translation = v3;
		420	rigidBody.WorldTransform = m;
		421	}
		422	}
		423	}
		424	/// <summary>
		425	/// PhysicsActor Prim Class for BulletX
		426	/// </summary>
		427	public class BulletXPrim : PhysicsActor
		428	{
		429	private PhysicsVector _position;
		430	private PhysicsVector _velocity;
		431	private PhysicsVector _acceleration;
		432
		433	public BulletXPrim()
		434	{
		435	_velocity = new PhysicsVector();
		436	_position = new PhysicsVector();
		437	_acceleration = new PhysicsVector();
		438	}
		439	public override bool Flying
		440	{
		441	get
		442	{
		443	return false; //no flying prims for you
		444	}
		445	set
		446	{
		447
		448	}
		449	}
		450	public override PhysicsVector Position
		451	{
		452	get
		453	{
		454	PhysicsVector pos = new PhysicsVector();
		455	// PhysicsVector vec = this._prim.Position;
		456	//pos.X = vec.X;
		457	//pos.Y = vec.Y;
		458	//pos.Z = vec.Z;
		459	return pos;
		460
		461	}
		462	set
		463	{
		464	/*PhysicsVector vec = value;
		465	PhysicsVector pos = new PhysicsVector();
		466	pos.X = vec.X;
		467	pos.Y = vec.Y;
		468	pos.Z = vec.Z;
		469	this._prim.Position = pos;*/
		470	}
		471	}
		472
		473	public override PhysicsVector Velocity
		474	{
		475	get
		476	{
		477	return _velocity;
		478	}
		479	set
		480	{
		481	_velocity = value;
		482	}
		483	}
		484
		485	public override bool Kinematic
		486	{
		487	get
		488	{
		489	return false;
		490	//return this._prim.Kinematic;
		491	}
		492	set
		493	{
		494	//this._prim.Kinematic = value;
		495	}
		496	}
		497
		498	public override Axiom.Math.Quaternion Orientation
		499	{
		500	get
		501	{
		502	Axiom.Math.Quaternion res = new Axiom.Math.Quaternion();
		503	return res;
		504	}
		505	set
		506	{
		507
		508	}
		509	}
		510
		511	public override PhysicsVector Acceleration
		512	{
		513	get
		514	{
		515	return _acceleration;
		516	}
		517
		518	}
		519	public void SetAcceleration(PhysicsVector accel)
		520	{
		521	this._acceleration = accel;
		522	}
		523
		524	public override void AddForce(PhysicsVector force)
		525	{
		526
		527	}
		528
		529	public override void SetMomentum(PhysicsVector momentum)
		530	{
		531
		532	}
		533	}
		534	}