* Bringing Sugilite in to trunk

author: Adam Frisby 2007-07-11 08:10:25 +0000
committer: Adam Frisby 2007-07-11 08:10:25 +0000
commit: e2ff441e31328e60c8bb1d4bb32fa4ac64f91978 (patch)
tree: 8405b6cef57b66a58f31a24c859846085d0b81f7 /OpenSim/Region/Physics/OdePlugin
parent: * Wiping trunk in prep for Sugilite (diff)
parent: * Applying dalien's patches from bug#177 and #179 (diff)
download: opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.zip
opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.tar.gz
opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.tar.bz2
opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.tar.xz
2 files changed, 513 insertions, 0 deletions
diff --git a/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs
new file mode 100644
index 0000000..ee10430
--- /dev/null
+++ b/OpenSim/Region/Physics/OdePlugin/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("RealPhysXplugin")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("RealPhysXplugin")]
+[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.*")]
diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
new file mode 100644
index 0000000..2780188
--- /dev/null
+++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -0,0 +1,457 @@
+/*
+* 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;
+using System.Collections.Generic;
+using Axiom.Math;
+using Ode.NET;
+using OpenSim.Physics.Manager;
+namespace OpenSim.Region.Physics.OdePlugin
+{
+    /// <summary>
+    /// ODE plugin 
+    /// </summary>
+    public class OdePlugin : IPhysicsPlugin
+    {
+        private OdeScene _mScene;
+        public OdePlugin()
+        {
+        }
+        public bool Init()
+        {
+            return true;
+        }
+        public PhysicsScene GetScene()
+        {
+            if (_mScene == null)
+            {
+                _mScene = new OdeScene();
+            }
+            return (_mScene);
+        }
+        public string GetName()
+        {
+            return ("OpenDynamicsEngine");
+        }
+        public void Dispose()
+        {
+        }
+    }
+    public class OdeScene : PhysicsScene
+    {
+        static public IntPtr world;
+        static public IntPtr space;
+        static private IntPtr contactgroup;
+        static private IntPtr LandGeom;
+        //static private IntPtr Land;
+        private double[] _heightmap;
+        static private d.NearCallback nearCallback = near;
+        private List<OdeCharacter> _characters = new List<OdeCharacter>();
+        private static d.ContactGeom[] contacts = new d.ContactGeom[30];
+        private static d.Contact contact;
+        public OdeScene()
+        {
+            contact.surface.mode = d.ContactFlags.Bounce | d.ContactFlags.SoftCFM;
+            contact.surface.mu = d.Infinity;
+            contact.surface.mu2 = 0.0f;
+            contact.surface.bounce = 0.1f;
+            contact.surface.bounce_vel = 0.1f;
+            contact.surface.soft_cfm = 0.01f;
+            world = d.WorldCreate();
+            space = d.HashSpaceCreate(IntPtr.Zero);
+            contactgroup = d.JointGroupCreate(0);
+            d.WorldSetGravity(world, 0.0f, 0.0f, -0.5f);
+            //d.WorldSetCFM(world, 1e-5f);
+            d.WorldSetAutoDisableFlag(world, false);
+            d.WorldSetContactSurfaceLayer(world, 0.001f);
+           // d.CreatePlane(space, 0, 0, 1, 0);
+            this._heightmap = new double[65536];
+        }
+        // This function blatantly ripped off from BoxStack.cs
+        static private void near(IntPtr space, IntPtr g1, IntPtr g2)
+        {
+            IntPtr b1 = d.GeomGetBody(g1);
+            IntPtr b2 = d.GeomGetBody(g2);
+            if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
+                return;
+            int count = d.Collide(g1, g2, 500, contacts, d.ContactGeom.SizeOf);
+            for (int i = 0; i < count; ++i)
+            {
+                contact.geom = contacts[i];
+                IntPtr joint = d.JointCreateContact(world, contactgroup, ref contact);
+                d.JointAttach(joint, b1, b2);
+            }
+        }
+        public override PhysicsActor AddAvatar(PhysicsVector position)
+        {
+            PhysicsVector pos = new PhysicsVector();
+            pos.X = position.X;
+            pos.Y = position.Y;
+            pos.Z = position.Z + 20;
+            OdeCharacter newAv = new OdeCharacter(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 OdePrim();
+        }
+        public override void Simulate(float timeStep)
+        {
+            foreach (OdeCharacter actor in _characters)
+            {
+                actor.Move(timeStep * 5f);
+            }
+            d.SpaceCollide(space, IntPtr.Zero, nearCallback);
+            d.WorldQuickStep(world, timeStep * 5f);
+            d.JointGroupEmpty(contactgroup);
+            foreach (OdeCharacter 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)
+        {
+            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] = (double)heightMap[x * 256 + y];
+            }
+            IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
+            d.GeomHeightfieldDataBuildDouble(HeightmapData, _heightmap, 0, 256, 256, 256, 256, 1.0f, 0.0f, 2.0f, 0);
+            d.GeomHeightfieldDataSetBounds(HeightmapData, 256, 256);
+            LandGeom = d.CreateHeightfield(space, HeightmapData, 1);
+            d.Matrix3 R = new d.Matrix3();
+            
+            Quaternion q1 =Quaternion.FromAngleAxis(1.5707f, new Vector3(1,0,0));
+            Quaternion q2 =Quaternion.FromAngleAxis(1.5707f, new Vector3(0,1,0));
+           //Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
+            
+            q1 = q1 * q2;
+            //q1 = q1 * q3;
+            Vector3 v3 = new Vector3();
+            float angle = 0;
+            q1.ToAngleAxis(ref angle, ref v3);
+            d.RFromAxisAndAngle(out R, v3.x, v3.y, v3.z, angle);
+            d.GeomSetRotation(LandGeom, ref R); 
+            d.GeomSetPosition(LandGeom, 128, 128, 0); 
+        }
+        public override void DeleteTerrain()
+        {
+        }
+    }
+    public class OdeCharacter : PhysicsActor
+    {
+        private PhysicsVector _position;
+        private PhysicsVector _velocity;
+        private PhysicsVector _acceleration;
+        private bool flying;
+        //private float gravityAccel;
+        private IntPtr BoundingCapsule;
+        IntPtr capsule_geom;
+        d.Mass capsule_mass;
+        public OdeCharacter(OdeScene parent_scene, PhysicsVector pos)
+        {
+            _velocity = new PhysicsVector();
+            _position = pos;
+            _acceleration = new PhysicsVector();
+            d.MassSetCapsule(out capsule_mass, 5.0f, 3, 0.5f, 2f);
+            capsule_geom = d.CreateCapsule(OdeScene.space, 0.5f, 2f);
+            this.BoundingCapsule = d.BodyCreate(OdeScene.world);
+            d.BodySetMass(BoundingCapsule, ref capsule_mass);
+            d.BodySetPosition(BoundingCapsule, pos.X, pos.Y, pos.Z);
+            d.GeomSetBody(capsule_geom, BoundingCapsule);
+        }
+        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 Quaternion Orientation
+        {
+            get
+            {
+                return 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)
+        {
+            PhysicsVector vec = new PhysicsVector();
+            vec.X = this._velocity.X * timeStep;
+            vec.Y = this._velocity.Y * timeStep;
+            if (flying)
+            {
+                vec.Z = (this._velocity.Z + 0.5f) * timeStep;
+            }
+            d.BodySetLinearVel(this.BoundingCapsule, vec.X, vec.Y, vec.Z);
+        }
+        public void UpdatePosition()
+        {
+            d.Vector3 vec = d.BodyGetPosition(BoundingCapsule);
+            this._position.X = vec.X;
+            this._position.Y = vec.Y;
+            this._position.Z = vec.Z+1.0f;
+        }
+    }
+    public class OdePrim : PhysicsActor
+    {
+        private PhysicsVector _position;
+        private PhysicsVector _velocity;
+        private PhysicsVector _acceleration;
+        public OdePrim()
+        {
+            _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 Quaternion Orientation
+        {
+            get
+            {
+                Quaternion res = new 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	Adam Frisby	2007-07-11 08:10:25 +0000
committer	Adam Frisby	2007-07-11 08:10:25 +0000
commit	e2ff441e31328e60c8bb1d4bb32fa4ac64f91978 (patch)
tree	8405b6cef57b66a58f31a24c859846085d0b81f7 /OpenSim/Region/Physics/OdePlugin
parent	* Wiping trunk in prep for Sugilite (diff)
parent	* Applying dalien's patches from bug#177 and #179 (diff)
download	opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.zip opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.tar.gz opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.tar.bz2 opensim-SC-e2ff441e31328e60c8bb1d4bb32fa4ac64f91978.tar.xz

diff --git a/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs new file mode 100644 index 0000000..ee10430 --- /dev/null +++ b/OpenSim/Region/Physics/OdePlugin/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("RealPhysXplugin")]
	37	[assembly: AssemblyDescription("")]
	38	[assembly: AssemblyConfiguration("")]
	39	[assembly: AssemblyCompany("")]
	40	[assembly: AssemblyProduct("RealPhysXplugin")]
	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.*")]


diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs new file mode 100644 index 0000000..2780188 --- /dev/null +++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -0,0 +1,457 @@
	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;
	29	using System.Collections.Generic;
	30	using Axiom.Math;
	31	using Ode.NET;
	32	using OpenSim.Physics.Manager;
	33
	34	namespace OpenSim.Region.Physics.OdePlugin
	35	{
	36	/// <summary>
	37	/// ODE plugin
	38	/// </summary>
	39	public class OdePlugin : IPhysicsPlugin
	40	{
	41	private OdeScene _mScene;
	42
	43	public OdePlugin()
	44	{
	45
	46	}
	47
	48	public bool Init()
	49	{
	50	return true;
	51	}
	52
	53	public PhysicsScene GetScene()
	54	{
	55	if (_mScene == null)
	56	{
	57	_mScene = new OdeScene();
	58	}
	59	return (_mScene);
	60	}
	61
	62	public string GetName()
	63	{
	64	return ("OpenDynamicsEngine");
	65	}
	66
	67	public void Dispose()
	68	{
	69
	70	}
	71	}
	72
	73	public class OdeScene : PhysicsScene
	74	{
	75	static public IntPtr world;
	76	static public IntPtr space;
	77	static private IntPtr contactgroup;
	78	static private IntPtr LandGeom;
	79	//static private IntPtr Land;
	80	private double[] _heightmap;
	81	static private d.NearCallback nearCallback = near;
	82	private List<OdeCharacter> _characters = new List<OdeCharacter>();
	83	private static d.ContactGeom[] contacts = new d.ContactGeom[30];
	84	private static d.Contact contact;
	85
	86	public OdeScene()
	87	{
	88	contact.surface.mode = d.ContactFlags.Bounce \| d.ContactFlags.SoftCFM;
	89	contact.surface.mu = d.Infinity;
	90	contact.surface.mu2 = 0.0f;
	91	contact.surface.bounce = 0.1f;
	92	contact.surface.bounce_vel = 0.1f;
	93	contact.surface.soft_cfm = 0.01f;
	94
	95	world = d.WorldCreate();
	96	space = d.HashSpaceCreate(IntPtr.Zero);
	97	contactgroup = d.JointGroupCreate(0);
	98	d.WorldSetGravity(world, 0.0f, 0.0f, -0.5f);
	99	//d.WorldSetCFM(world, 1e-5f);
	100	d.WorldSetAutoDisableFlag(world, false);
	101	d.WorldSetContactSurfaceLayer(world, 0.001f);
	102	// d.CreatePlane(space, 0, 0, 1, 0);
	103	this._heightmap = new double[65536];
	104	}
	105
	106	// This function blatantly ripped off from BoxStack.cs
	107	static private void near(IntPtr space, IntPtr g1, IntPtr g2)
	108	{
	109	IntPtr b1 = d.GeomGetBody(g1);
	110	IntPtr b2 = d.GeomGetBody(g2);
	111	if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
	112	return;
	113
	114	int count = d.Collide(g1, g2, 500, contacts, d.ContactGeom.SizeOf);
	115	for (int i = 0; i < count; ++i)
	116	{
	117	contact.geom = contacts[i];
	118	IntPtr joint = d.JointCreateContact(world, contactgroup, ref contact);
	119	d.JointAttach(joint, b1, b2);
	120	}
	121
	122	}
	123
	124	public override PhysicsActor AddAvatar(PhysicsVector position)
	125	{
	126	PhysicsVector pos = new PhysicsVector();
	127	pos.X = position.X;
	128	pos.Y = position.Y;
	129	pos.Z = position.Z + 20;
	130	OdeCharacter newAv = new OdeCharacter(this, pos);
	131	this._characters.Add(newAv);
	132	return newAv;
	133	}
	134
	135	public override void RemoveAvatar(PhysicsActor actor)
	136	{
	137
	138	}
	139
	140	public override PhysicsActor AddPrim(PhysicsVector position, PhysicsVector size)
	141	{
	142	PhysicsVector pos = new PhysicsVector();
	143	pos.X = position.X;
	144	pos.Y = position.Y;
	145	pos.Z = position.Z;
	146	PhysicsVector siz = new PhysicsVector();
	147	siz.X = size.X;
	148	siz.Y = size.Y;
	149	siz.Z = size.Z;
	150	return new OdePrim();
	151	}
	152
	153	public override void Simulate(float timeStep)
	154	{
	155	foreach (OdeCharacter actor in _characters)
	156	{
	157	actor.Move(timeStep * 5f);
	158	}
	159	d.SpaceCollide(space, IntPtr.Zero, nearCallback);
	160	d.WorldQuickStep(world, timeStep * 5f);
	161	d.JointGroupEmpty(contactgroup);
	162	foreach (OdeCharacter actor in _characters)
	163	{
	164	actor.UpdatePosition();
	165	}
	166
	167	}
	168
	169	public override void GetResults()
	170	{
	171
	172	}
	173
	174	public override bool IsThreaded
	175	{
	176	get
	177	{
	178	return (false); // for now we won't be multithreaded
	179	}
	180	}
	181
	182	public override void SetTerrain(float[] heightMap)
	183	{
	184	for (int i = 0; i < 65536; i++)
	185	{
	186	// this._heightmap[i] = (double)heightMap[i];
	187	// dbm (danx0r) -- heightmap x,y must be swapped for Ode (should fix ODE, but for now...)
	188	int x = i & 0xff;
	189	int y = i >> 8;
	190	this._heightmap[i] = (double)heightMap[x * 256 + y];
	191	}
	192	IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
	193	d.GeomHeightfieldDataBuildDouble(HeightmapData, _heightmap, 0, 256, 256, 256, 256, 1.0f, 0.0f, 2.0f, 0);
	194	d.GeomHeightfieldDataSetBounds(HeightmapData, 256, 256);
	195	LandGeom = d.CreateHeightfield(space, HeightmapData, 1);
	196	d.Matrix3 R = new d.Matrix3();
	197
	198	Quaternion q1 =Quaternion.FromAngleAxis(1.5707f, new Vector3(1,0,0));
	199	Quaternion q2 =Quaternion.FromAngleAxis(1.5707f, new Vector3(0,1,0));
	200	//Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
	201
	202	q1 = q1 * q2;
	203	//q1 = q1 * q3;
	204	Vector3 v3 = new Vector3();
	205	float angle = 0;
	206	q1.ToAngleAxis(ref angle, ref v3);
	207
	208	d.RFromAxisAndAngle(out R, v3.x, v3.y, v3.z, angle);
	209	d.GeomSetRotation(LandGeom, ref R);
	210	d.GeomSetPosition(LandGeom, 128, 128, 0);
	211	}
	212
	213	public override void DeleteTerrain()
	214	{
	215
	216	}
	217	}
	218
	219	public class OdeCharacter : PhysicsActor
	220	{
	221	private PhysicsVector _position;
	222	private PhysicsVector _velocity;
	223	private PhysicsVector _acceleration;
	224	private bool flying;
	225	//private float gravityAccel;
	226	private IntPtr BoundingCapsule;
	227	IntPtr capsule_geom;
	228	d.Mass capsule_mass;
	229
	230	public OdeCharacter(OdeScene parent_scene, PhysicsVector pos)
	231	{
	232	_velocity = new PhysicsVector();
	233	_position = pos;
	234	_acceleration = new PhysicsVector();
	235	d.MassSetCapsule(out capsule_mass, 5.0f, 3, 0.5f, 2f);
	236	capsule_geom = d.CreateCapsule(OdeScene.space, 0.5f, 2f);
	237	this.BoundingCapsule = d.BodyCreate(OdeScene.world);
	238	d.BodySetMass(BoundingCapsule, ref capsule_mass);
	239	d.BodySetPosition(BoundingCapsule, pos.X, pos.Y, pos.Z);
	240	d.GeomSetBody(capsule_geom, BoundingCapsule);
	241	}
	242
	243	public override bool Flying
	244	{
	245	get
	246	{
	247	return flying;
	248	}
	249	set
	250	{
	251	flying = value;
	252	}
	253	}
	254
	255	public override PhysicsVector Position
	256	{
	257	get
	258	{
	259	return _position;
	260	}
	261	set
	262	{
	263	_position = value;
	264	}
	265	}
	266
	267	public override PhysicsVector Velocity
	268	{
	269	get
	270	{
	271	return _velocity;
	272	}
	273	set
	274	{
	275	_velocity = value;
	276	}
	277	}
	278
	279	public override bool Kinematic
	280	{
	281	get
	282	{
	283	return false;
	284	}
	285	set
	286	{
	287
	288	}
	289	}
	290
	291	public override Quaternion Orientation
	292	{
	293	get
	294	{
	295	return Quaternion.Identity;
	296	}
	297	set
	298	{
	299
	300	}
	301	}
	302
	303	public override PhysicsVector Acceleration
	304	{
	305	get
	306	{
	307	return _acceleration;
	308	}
	309
	310	}
	311	public void SetAcceleration(PhysicsVector accel)
	312	{
	313	this._acceleration = accel;
	314	}
	315
	316	public override void AddForce(PhysicsVector force)
	317	{
	318
	319	}
	320
	321	public override void SetMomentum(PhysicsVector momentum)
	322	{
	323
	324	}
	325
	326	public void Move(float timeStep)
	327	{
	328	PhysicsVector vec = new PhysicsVector();
	329	vec.X = this._velocity.X * timeStep;
	330	vec.Y = this._velocity.Y * timeStep;
	331	if (flying)
	332	{
	333	vec.Z = (this._velocity.Z + 0.5f) * timeStep;
	334	}
	335	d.BodySetLinearVel(this.BoundingCapsule, vec.X, vec.Y, vec.Z);
	336	}
	337
	338	public void UpdatePosition()
	339	{
	340	d.Vector3 vec = d.BodyGetPosition(BoundingCapsule);
	341	this._position.X = vec.X;
	342	this._position.Y = vec.Y;
	343	this._position.Z = vec.Z+1.0f;
	344	}
	345	}
	346
	347	public class OdePrim : PhysicsActor
	348	{
	349	private PhysicsVector _position;
	350	private PhysicsVector _velocity;
	351	private PhysicsVector _acceleration;
	352
	353	public OdePrim()
	354	{
	355	_velocity = new PhysicsVector();
	356	_position = new PhysicsVector();
	357	_acceleration = new PhysicsVector();
	358	}
	359	public override bool Flying
	360	{
	361	get
	362	{
	363	return false; //no flying prims for you
	364	}
	365	set
	366	{
	367
	368	}
	369	}
	370	public override PhysicsVector Position
	371	{
	372	get
	373	{
	374	PhysicsVector pos = new PhysicsVector();
	375	// PhysicsVector vec = this._prim.Position;
	376	//pos.X = vec.X;
	377	//pos.Y = vec.Y;
	378	//pos.Z = vec.Z;
	379	return pos;
	380
	381	}
	382	set
	383	{
	384	/*PhysicsVector vec = value;
	385	PhysicsVector pos = new PhysicsVector();
	386	pos.X = vec.X;
	387	pos.Y = vec.Y;
	388	pos.Z = vec.Z;
	389	this._prim.Position = pos;*/
	390	}
	391	}
	392
	393	public override PhysicsVector Velocity
	394	{
	395	get
	396	{
	397	return _velocity;
	398	}
	399	set
	400	{
	401	_velocity = value;
	402	}
	403	}
	404
	405	public override bool Kinematic
	406	{
	407	get
	408	{
	409	return false;
	410	//return this._prim.Kinematic;
	411	}
	412	set
	413	{
	414	//this._prim.Kinematic = value;
	415	}
	416	}
	417
	418	public override Quaternion Orientation
	419	{
	420	get
	421	{
	422	Quaternion res = new Quaternion();
	423	return res;
	424	}
	425	set
	426	{
	427
	428	}
	429	}
	430
	431	public override PhysicsVector Acceleration
	432	{
	433	get
	434	{
	435	return _acceleration;
	436	}
	437
	438	}
	439	public void SetAcceleration(PhysicsVector accel)
	440	{
	441	this._acceleration = accel;
	442	}
	443
	444	public override void AddForce(PhysicsVector force)
	445	{
	446
	447	}
	448
	449	public override void SetMomentum(PhysicsVector momentum)
	450	{
	451
	452	}
	453
	454
	455	}
	456
	457	}