OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

BulletSim: correct line endings in new BulletSimData.cs file.

0.7.5-pf-bulletsim
Robert Adams 2012-12-13 16:15:21 -08:00
parent 3b2b785a46
commit 60950bfab5
1 changed files with 282 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

564
OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
View File

@ -1,282 +1,282 @@
/* /*
* Copyright (c) Contributors, http://opensimulator.org/ * Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders. * See CONTRIBUTORS.TXT for a full list of copyright holders.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright * * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyrightD * * Redistributions in binary form must reproduce the above copyrightD
* notice, this list of conditions and the following disclaimer in the * notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution. * documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSimulator Project nor the * * Neither the name of the OpenSimulator Project nor the
* names of its contributors may be used to endorse or promote products * names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission. * derived from this software without specific prior written permission.
* *
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * 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 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
using OMV = OpenMetaverse; using OMV = OpenMetaverse;
namespace OpenSim.Region.Physics.BulletSPlugin namespace OpenSim.Region.Physics.BulletSPlugin
{ {
// Classes to allow some type checking for the API // Classes to allow some type checking for the API
// These hold pointers to allocated objects in the unmanaged space. // These hold pointers to allocated objects in the unmanaged space.
// The physics engine controller class created at initialization // The physics engine controller class created at initialization
public struct BulletSim public struct BulletSim
{ {
public BulletSim(uint worldId, BSScene bss, IntPtr xx) public BulletSim(uint worldId, BSScene bss, IntPtr xx)
{ {
ptr = xx; ptr = xx;
worldID = worldId; worldID = worldId;
physicsScene = bss; physicsScene = bss;
} }
public IntPtr ptr; public IntPtr ptr;
public uint worldID; public uint worldID;
// The scene is only in here so very low level routines have a handle to print debug/error messages // The scene is only in here so very low level routines have a handle to print debug/error messages
public BSScene physicsScene; public BSScene physicsScene;
} }
// An allocated Bullet btRigidBody // An allocated Bullet btRigidBody
public struct BulletBody public struct BulletBody
{ {
public BulletBody(uint id) : this(id, IntPtr.Zero) public BulletBody(uint id) : this(id, IntPtr.Zero)
{ {
} }
public BulletBody(uint id, IntPtr xx) public BulletBody(uint id, IntPtr xx)
{ {
ID = id; ID = id;
ptr = xx; ptr = xx;
collisionType = CollisionType.Static; collisionType = CollisionType.Static;
} }
public IntPtr ptr; public IntPtr ptr;
public uint ID; public uint ID;
public CollisionType collisionType; public CollisionType collisionType;
public void Clear() public void Clear()
{ {
ptr = IntPtr.Zero; ptr = IntPtr.Zero;
} }
public bool HasPhysicalBody { get { return ptr != IntPtr.Zero; } } public bool HasPhysicalBody { get { return ptr != IntPtr.Zero; } }
// Apply the specificed collision mask into the physical world // Apply the specificed collision mask into the physical world
public void ApplyCollisionMask() public void ApplyCollisionMask()
{ {
// Should assert the body has been added to the physical world. // Should assert the body has been added to the physical world.
// (The collision masks are stored in the collision proxy cache which only exists for // (The collision masks are stored in the collision proxy cache which only exists for
// a collision body that is in the world.) // a collision body that is in the world.)
BulletSimAPI.SetCollisionGroupMask2(ptr, BulletSimAPI.SetCollisionGroupMask2(ptr,
BulletSimData.CollisionTypeMasks[collisionType].group, BulletSimData.CollisionTypeMasks[collisionType].group,
BulletSimData.CollisionTypeMasks[collisionType].mask); BulletSimData.CollisionTypeMasks[collisionType].mask);
} }
public override string ToString() public override string ToString()
{ {
StringBuilder buff = new StringBuilder(); StringBuilder buff = new StringBuilder();
buff.Append("<id="); buff.Append("<id=");
buff.Append(ID.ToString()); buff.Append(ID.ToString());
buff.Append(",p="); buff.Append(",p=");
buff.Append(ptr.ToString("X")); buff.Append(ptr.ToString("X"));
buff.Append(",c="); buff.Append(",c=");
buff.Append(collisionType); buff.Append(collisionType);
buff.Append(">"); buff.Append(">");
return buff.ToString(); return buff.ToString();
} }
} }
public struct BulletShape public struct BulletShape
{ {
public BulletShape(IntPtr xx) public BulletShape(IntPtr xx)
{ {
ptr = xx; ptr = xx;
type=BSPhysicsShapeType.SHAPE_UNKNOWN; type=BSPhysicsShapeType.SHAPE_UNKNOWN;
shapeKey = (System.UInt64)FixedShapeKey.KEY_NONE; shapeKey = (System.UInt64)FixedShapeKey.KEY_NONE;
isNativeShape = false; isNativeShape = false;
} }
public BulletShape(IntPtr xx, BSPhysicsShapeType typ) public BulletShape(IntPtr xx, BSPhysicsShapeType typ)
{ {
ptr = xx; ptr = xx;
type = typ; type = typ;
shapeKey = 0; shapeKey = 0;
isNativeShape = false; isNativeShape = false;
} }
public IntPtr ptr; public IntPtr ptr;
public BSPhysicsShapeType type; public BSPhysicsShapeType type;
public System.UInt64 shapeKey; public System.UInt64 shapeKey;
public bool isNativeShape; public bool isNativeShape;
public void Clear() public void Clear()
{ {
ptr = IntPtr.Zero; ptr = IntPtr.Zero;
} }
public bool HasPhysicalShape { get { return ptr != IntPtr.Zero; } } public bool HasPhysicalShape { get { return ptr != IntPtr.Zero; } }
public override string ToString() public override string ToString()
{ {
StringBuilder buff = new StringBuilder(); StringBuilder buff = new StringBuilder();
buff.Append("<p="); buff.Append("<p=");
buff.Append(ptr.ToString("X")); buff.Append(ptr.ToString("X"));
buff.Append(",s="); buff.Append(",s=");
buff.Append(type.ToString()); buff.Append(type.ToString());
buff.Append(",k="); buff.Append(",k=");
buff.Append(shapeKey.ToString("X")); buff.Append(shapeKey.ToString("X"));
buff.Append(",n="); buff.Append(",n=");
buff.Append(isNativeShape.ToString()); buff.Append(isNativeShape.ToString());
buff.Append(">"); buff.Append(">");
return buff.ToString(); return buff.ToString();
} }
} }
// An allocated Bullet btConstraint // An allocated Bullet btConstraint
public struct BulletConstraint public struct BulletConstraint
{ {
public BulletConstraint(IntPtr xx) public BulletConstraint(IntPtr xx)
{ {
ptr = xx; ptr = xx;
} }
public IntPtr ptr; public IntPtr ptr;
public void Clear() public void Clear()
{ {
ptr = IntPtr.Zero; ptr = IntPtr.Zero;
} }
public bool HasPhysicalConstraint { get { return ptr != IntPtr.Zero; } } public bool HasPhysicalConstraint { get { return ptr != IntPtr.Zero; } }
} }
// An allocated HeightMapThing which holds various heightmap info. // An allocated HeightMapThing which holds various heightmap info.
// Made a class rather than a struct so there would be only one // Made a class rather than a struct so there would be only one
// instance of this and C# will pass around pointers rather // instance of this and C# will pass around pointers rather
// than making copies. // than making copies.
public class BulletHeightMapInfo public class BulletHeightMapInfo
{ {
public BulletHeightMapInfo(uint id, float[] hm, IntPtr xx) { public BulletHeightMapInfo(uint id, float[] hm, IntPtr xx) {
ID = id; ID = id;
Ptr = xx; Ptr = xx;
heightMap = hm; heightMap = hm;
terrainRegionBase = OMV.Vector3.Zero; terrainRegionBase = OMV.Vector3.Zero;
minCoords = new OMV.Vector3(100f, 100f, 25f); minCoords = new OMV.Vector3(100f, 100f, 25f);
maxCoords = new OMV.Vector3(101f, 101f, 26f); maxCoords = new OMV.Vector3(101f, 101f, 26f);
minZ = maxZ = 0f; minZ = maxZ = 0f;
sizeX = sizeY = 256f; sizeX = sizeY = 256f;
} }
public uint ID; public uint ID;
public IntPtr Ptr; public IntPtr Ptr;
public float[] heightMap; public float[] heightMap;
public OMV.Vector3 terrainRegionBase; public OMV.Vector3 terrainRegionBase;
public OMV.Vector3 minCoords; public OMV.Vector3 minCoords;
public OMV.Vector3 maxCoords; public OMV.Vector3 maxCoords;
public float sizeX, sizeY; public float sizeX, sizeY;
public float minZ, maxZ; public float minZ, maxZ;
public BulletShape terrainShape; public BulletShape terrainShape;
public BulletBody terrainBody; public BulletBody terrainBody;
} }
// The general class of collsion object. // The general class of collsion object.
public enum CollisionType public enum CollisionType
{ {
Avatar, Avatar,
Groundplane, Groundplane,
Terrain, Terrain,
Static, Static,
Dynamic, Dynamic,
VolumeDetect, VolumeDetect,
// Linkset, // A linkset proper should be either Static or Dynamic // Linkset, // A linkset proper should be either Static or Dynamic
LinksetChild, LinksetChild,
Unknown Unknown
}; };
// Hold specification of group and mask collision flags for a CollisionType // Hold specification of group and mask collision flags for a CollisionType
public struct CollisionTypeFilterGroup public struct CollisionTypeFilterGroup
{ {
public CollisionTypeFilterGroup(CollisionType t, uint g, uint m) public CollisionTypeFilterGroup(CollisionType t, uint g, uint m)
{ {
type = t; type = t;
group = g; group = g;
mask = m; mask = m;
} }
public CollisionType type; public CollisionType type;
public uint group; public uint group;
public uint mask; public uint mask;
}; };
/* /*
// The collsion filters and masked are defined in one place -- don't want them scattered // The collsion filters and masked are defined in one place -- don't want them scattered
AvatarGroup = BCharacterGroup, AvatarGroup = BCharacterGroup,
AvatarMask = BAllGroup, AvatarMask = BAllGroup,
ObjectGroup = BSolidGroup, ObjectGroup = BSolidGroup,
ObjectMask = BAllGroup, ObjectMask = BAllGroup,
StaticObjectGroup = BStaticGroup, StaticObjectGroup = BStaticGroup,
StaticObjectMask = AvatarGroup | ObjectGroup, // static things don't interact with much StaticObjectMask = AvatarGroup | ObjectGroup, // static things don't interact with much
LinksetGroup = BLinksetGroup, LinksetGroup = BLinksetGroup,
LinksetMask = BAllGroup, LinksetMask = BAllGroup,
LinksetChildGroup = BLinksetChildGroup, LinksetChildGroup = BLinksetChildGroup,
LinksetChildMask = BNoneGroup, // Linkset children disappear from the world LinksetChildMask = BNoneGroup, // Linkset children disappear from the world
VolumeDetectGroup = BSensorTrigger, VolumeDetectGroup = BSensorTrigger,
VolumeDetectMask = ~BSensorTrigger, VolumeDetectMask = ~BSensorTrigger,
TerrainGroup = BTerrainGroup, TerrainGroup = BTerrainGroup,
TerrainMask = BAllGroup & ~BStaticGroup, // static objects on the ground don't collide TerrainMask = BAllGroup & ~BStaticGroup, // static objects on the ground don't collide
GroundPlaneGroup = BGroundPlaneGroup, GroundPlaneGroup = BGroundPlaneGroup,
GroundPlaneMask = BAllGroup GroundPlaneMask = BAllGroup
*/ */
public static class BulletSimData public static class BulletSimData
{ {
// Map of collisionTypes to flags for collision groups and masks. // Map of collisionTypes to flags for collision groups and masks.
// As mentioned above, don't use the CollisionFilterGroups definitions directly in the code // As mentioned above, don't use the CollisionFilterGroups definitions directly in the code
// but, instead, user references to this dictionary. This makes finding and debugging // but, instead, use references to this dictionary. Finding and debugging
// collision flag usage easier. // collision flag problems will be made easier.
public static Dictionary<CollisionType, CollisionTypeFilterGroup> CollisionTypeMasks public static Dictionary<CollisionType, CollisionTypeFilterGroup> CollisionTypeMasks
= new Dictionary<CollisionType, CollisionTypeFilterGroup>() = new Dictionary<CollisionType, CollisionTypeFilterGroup>()
{ {
{ CollisionType.Avatar, { CollisionType.Avatar,
new CollisionTypeFilterGroup(CollisionType.Avatar, new CollisionTypeFilterGroup(CollisionType.Avatar,
(uint)CollisionFilterGroups.BCharacterGroup, (uint)CollisionFilterGroups.BCharacterGroup,
(uint)CollisionFilterGroups.BAllGroup) (uint)CollisionFilterGroups.BAllGroup)
}, },
{ CollisionType.Groundplane, { CollisionType.Groundplane,
new CollisionTypeFilterGroup(CollisionType.Groundplane, new CollisionTypeFilterGroup(CollisionType.Groundplane,
(uint)CollisionFilterGroups.BGroundPlaneGroup, (uint)CollisionFilterGroups.BGroundPlaneGroup,
(uint)CollisionFilterGroups.BAllGroup) (uint)CollisionFilterGroups.BAllGroup)
}, },
{ CollisionType.Terrain, { CollisionType.Terrain,
new CollisionTypeFilterGroup(CollisionType.Terrain, new CollisionTypeFilterGroup(CollisionType.Terrain,
(uint)CollisionFilterGroups.BTerrainGroup, (uint)CollisionFilterGroups.BTerrainGroup,
(uint)(CollisionFilterGroups.BAllGroup & ~CollisionFilterGroups.BStaticGroup)) (uint)(CollisionFilterGroups.BAllGroup & ~CollisionFilterGroups.BStaticGroup))
}, },
{ CollisionType.Static, { CollisionType.Static,
new CollisionTypeFilterGroup(CollisionType.Static, new CollisionTypeFilterGroup(CollisionType.Static,
(uint)CollisionFilterGroups.BStaticGroup, (uint)CollisionFilterGroups.BStaticGroup,
(uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup)) (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
}, },
{ CollisionType.Dynamic, { CollisionType.Dynamic,
new CollisionTypeFilterGroup(CollisionType.Dynamic, new CollisionTypeFilterGroup(CollisionType.Dynamic,
(uint)CollisionFilterGroups.BSolidGroup, (uint)CollisionFilterGroups.BSolidGroup,
(uint)(CollisionFilterGroups.BAllGroup)) (uint)(CollisionFilterGroups.BAllGroup))
}, },
{ CollisionType.VolumeDetect, { CollisionType.VolumeDetect,
new CollisionTypeFilterGroup(CollisionType.VolumeDetect, new CollisionTypeFilterGroup(CollisionType.VolumeDetect,
(uint)CollisionFilterGroups.BSensorTrigger, (uint)CollisionFilterGroups.BSensorTrigger,
(uint)(~CollisionFilterGroups.BSensorTrigger)) (uint)(~CollisionFilterGroups.BSensorTrigger))
}, },
{ CollisionType.LinksetChild, { CollisionType.LinksetChild,
new CollisionTypeFilterGroup(CollisionType.LinksetChild, new CollisionTypeFilterGroup(CollisionType.LinksetChild,
(uint)CollisionFilterGroups.BTerrainGroup, (uint)CollisionFilterGroups.BTerrainGroup,
(uint)(CollisionFilterGroups.BNoneGroup)) (uint)(CollisionFilterGroups.BNoneGroup))
}, },
}; };
} }
} }