aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim
diff options
context:
space:
mode:
Diffstat (limited to '')
-rwxr-xr-xOpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs28
-rwxr-xr-xOpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs26
-rwxr-xr-xOpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs229
-rw-r--r--OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs6
4 files changed, 253 insertions, 36 deletions
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
index 3bb63cd..e9fd0cb 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
@@ -44,10 +44,11 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
44{ 44{
45 static string LogHeader = "[BULLETSIM TERRAIN HEIGHTMAP]"; 45 static string LogHeader = "[BULLETSIM TERRAIN HEIGHTMAP]";
46 46
47 BulletHeightMapInfo m_mapInfo; 47 BulletHeightMapInfo m_mapInfo = null;
48 48
49 public BSTerrainHeightmap(BSScene physicsScene, uint id, Vector3 regionSize) 49 // Constructor to build a default, flat heightmap terrain.
50 : base(physicsScene) 50 public BSTerrainHeightmap(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize)
51 : base(physicsScene, regionBase, id)
51 { 52 {
52 Vector3 minTerrainCoords = new Vector3(0f, 0f, BSTerrainManager.HEIGHT_INITIALIZATION - BSTerrainManager.HEIGHT_EQUAL_FUDGE); 53 Vector3 minTerrainCoords = new Vector3(0f, 0f, BSTerrainManager.HEIGHT_INITIALIZATION - BSTerrainManager.HEIGHT_EQUAL_FUDGE);
53 Vector3 maxTerrainCoords = new Vector3(regionSize.X, regionSize.Y, BSTerrainManager.HEIGHT_INITIALIZATION); 54 Vector3 maxTerrainCoords = new Vector3(regionSize.X, regionSize.Y, BSTerrainManager.HEIGHT_INITIALIZATION);
@@ -60,21 +61,23 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
60 m_mapInfo = new BulletHeightMapInfo(id, initialMap, IntPtr.Zero); 61 m_mapInfo = new BulletHeightMapInfo(id, initialMap, IntPtr.Zero);
61 m_mapInfo.minCoords = minTerrainCoords; 62 m_mapInfo.minCoords = minTerrainCoords;
62 m_mapInfo.maxCoords = maxTerrainCoords; 63 m_mapInfo.maxCoords = maxTerrainCoords;
64 m_mapInfo.terrainRegionBase = TerrainBase;
63 // Don't have to free any previous since we just got here. 65 // Don't have to free any previous since we just got here.
64 BuildHeightmapTerrain(); 66 BuildHeightmapTerrain();
65 } 67 }
66 68
67 // This minCoords and maxCoords passed in give the size of the terrain (min and max Z 69 // This minCoords and maxCoords passed in give the size of the terrain (min and max Z
68 // are the high and low points of the heightmap). 70 // are the high and low points of the heightmap).
69 public BSTerrainHeightmap(BSScene physicsScene, uint id, float[] initialMap, 71 public BSTerrainHeightmap(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap,
70 Vector3 minCoords, Vector3 maxCoords) 72 Vector3 minCoords, Vector3 maxCoords)
71 : base(physicsScene) 73 : base(physicsScene, regionBase, id)
72 { 74 {
73 m_mapInfo = new BulletHeightMapInfo(id, initialMap, IntPtr.Zero); 75 m_mapInfo = new BulletHeightMapInfo(id, initialMap, IntPtr.Zero);
74 m_mapInfo.minCoords = minCoords; 76 m_mapInfo.minCoords = minCoords;
75 m_mapInfo.maxCoords = maxCoords; 77 m_mapInfo.maxCoords = maxCoords;
76 m_mapInfo.minZ = minCoords.Z; 78 m_mapInfo.minZ = minCoords.Z;
77 m_mapInfo.maxZ = maxCoords.Z; 79 m_mapInfo.maxZ = maxCoords.Z;
80 m_mapInfo.terrainRegionBase = TerrainBase;
78 81
79 // Don't have to free any previous since we just got here. 82 // Don't have to free any previous since we just got here.
80 BuildHeightmapTerrain(); 83 BuildHeightmapTerrain();
@@ -135,12 +138,10 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
135 { 138 {
136 if (m_mapInfo.terrainBody.ptr != IntPtr.Zero) 139 if (m_mapInfo.terrainBody.ptr != IntPtr.Zero)
137 { 140 {
138 if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr)) 141 BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr);
139 { 142 // Frees both the body and the shape.
140 // Frees both the body and the shape. 143 BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr);
141 BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr); 144 BulletSimAPI.ReleaseHeightMapInfo2(m_mapInfo.Ptr);
142 BulletSimAPI.ReleaseHeightMapInfo2(m_mapInfo.Ptr);
143 }
144 } 145 }
145 } 146 }
146 m_mapInfo = null; 147 m_mapInfo = null;
@@ -165,10 +166,5 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
165 } 166 }
166 return ret; 167 return ret;
167 } 168 }
168
169 public override Vector3 TerrainBase
170 {
171 get { return m_mapInfo.terrainRegionBase; }
172 }
173} 169}
174} 170}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
index db04299..ed0dfa8 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
@@ -45,14 +45,18 @@ namespace OpenSim.Region.Physics.BulletSPlugin
45public abstract class BSTerrainPhys : IDisposable 45public abstract class BSTerrainPhys : IDisposable
46{ 46{
47 public BSScene PhysicsScene { get; private set; } 47 public BSScene PhysicsScene { get; private set; }
48 // Base of the region in world coordinates. Coordinates inside the region are relative to this.
49 public Vector3 TerrainBase { get; private set; }
50 public uint ID { get; private set; }
48 51
49 public BSTerrainPhys(BSScene physicsScene) 52 public BSTerrainPhys(BSScene physicsScene, Vector3 regionBase, uint id)
50 { 53 {
51 PhysicsScene = physicsScene; 54 PhysicsScene = physicsScene;
55 TerrainBase = regionBase;
56 ID = id;
52 } 57 }
53 public abstract void Dispose(); 58 public abstract void Dispose();
54 public abstract float GetHeightAtXYZ(Vector3 pos); 59 public abstract float GetHeightAtXYZ(Vector3 pos);
55 public abstract Vector3 TerrainBase { get; }
56} 60}
57 61
58// ========================================================================================== 62// ==========================================================================================
@@ -133,7 +137,7 @@ public sealed class BSTerrainManager
133 (uint)CollisionFilterGroups.GroundPlaneFilter, (uint)CollisionFilterGroups.GroundPlaneMask); 137 (uint)CollisionFilterGroups.GroundPlaneFilter, (uint)CollisionFilterGroups.GroundPlaneMask);
134 138
135 // Build an initial terrain and put it in the world. This quickly gets replaced by the real region terrain. 139 // Build an initial terrain and put it in the world. This quickly gets replaced by the real region terrain.
136 BSTerrainPhys initialTerrain = new BSTerrainHeightmap(PhysicsScene, BSScene.TERRAIN_ID, DefaultRegionSize); 140 BSTerrainPhys initialTerrain = new BSTerrainHeightmap(PhysicsScene, Vector3.Zero, BSScene.TERRAIN_ID, DefaultRegionSize);
137 m_terrains.Add(Vector3.Zero, initialTerrain); 141 m_terrains.Add(Vector3.Zero, initialTerrain);
138 } 142 }
139 143
@@ -208,10 +212,9 @@ public sealed class BSTerrainManager
208 BSScene.DetailLogZero, minCoords, maxCoords, inTaintTime); 212 BSScene.DetailLogZero, minCoords, maxCoords, inTaintTime);
209 213
210 // Find high and low points of passed heightmap. 214 // Find high and low points of passed heightmap.
211 // The min and max passed in are usually the region objects can exist in (maximum 215 // The min and max passed in is usually the area objects can be in (maximum
212 // object height, for instance). The terrain wants the bounding box for the 216 // object height, for instance). The terrain wants the bounding box for the
213 // terrain so we replace passed min and max Z with the actual terrain min/max Z. 217 // terrain so we replace passed min and max Z with the actual terrain min/max Z.
214 // limit, for
215 float minZ = float.MaxValue; 218 float minZ = float.MaxValue;
216 float maxZ = float.MinValue; 219 float maxZ = float.MinValue;
217 foreach (float height in heightMap) 220 foreach (float height in heightMap)
@@ -219,6 +222,11 @@ public sealed class BSTerrainManager
219 if (height < minZ) minZ = height; 222 if (height < minZ) minZ = height;
220 if (height > maxZ) maxZ = height; 223 if (height > maxZ) maxZ = height;
221 } 224 }
225 if (minZ == maxZ)
226 {
227 // If min and max are the same, reduce min a little bit so a good bounding box is created.
228 minZ -= BSTerrainManager.HEIGHT_EQUAL_FUDGE;
229 }
222 minCoords.Z = minZ; 230 minCoords.Z = minZ;
223 maxCoords.Z = maxZ; 231 maxCoords.Z = maxZ;
224 232
@@ -240,7 +248,9 @@ public sealed class BSTerrainManager
240 248
241 if (MegaRegionParentPhysicsScene == null) 249 if (MegaRegionParentPhysicsScene == null)
242 { 250 {
243 BSTerrainPhys newTerrainPhys = new BSTerrainHeightmap(PhysicsScene, id, 251 // BSTerrainPhys newTerrainPhys = new BSTerrainHeightmap(PhysicsScene, terrainRegionBase, id,
252 // heightMap, minCoords, maxCoords);
253 BSTerrainPhys newTerrainPhys = new BSTerrainMesh(PhysicsScene, terrainRegionBase, id,
244 heightMap, minCoords, maxCoords); 254 heightMap, minCoords, maxCoords);
245 m_terrains.Add(terrainRegionBase, newTerrainPhys); 255 m_terrains.Add(terrainRegionBase, newTerrainPhys);
246 256
@@ -282,8 +292,8 @@ public sealed class BSTerrainManager
282 { 292 {
283 DetailLog("{0},UpdateTerrain:NewTerrain,taint,baseX={1},baseY={2}", 293 DetailLog("{0},UpdateTerrain:NewTerrain,taint,baseX={1},baseY={2}",
284 BSScene.DetailLogZero, minCoordsX.X, minCoordsX.Y); 294 BSScene.DetailLogZero, minCoordsX.X, minCoordsX.Y);
285 BSTerrainPhys newTerrainPhys = new BSTerrainHeightmap(PhysicsScene, newTerrainID, 295 BSTerrainPhys newTerrainPhys = new BSTerrainHeightmap(PhysicsScene, terrainRegionBase,
286 heightMapX, minCoordsX, maxCoordsX); 296 newTerrainID, heightMapX, minCoordsX, maxCoordsX);
287 m_terrains.Add(terrainRegionBase, newTerrainPhys); 297 m_terrains.Add(terrainRegionBase, newTerrainPhys);
288 298
289 m_terrainModified = true; 299 m_terrainModified = true;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
index 387c78b..bbb014a 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
@@ -44,30 +44,241 @@ public sealed class BSTerrainMesh : BSTerrainPhys
44{ 44{
45 static string LogHeader = "[BULLETSIM TERRAIN MESH]"; 45 static string LogHeader = "[BULLETSIM TERRAIN MESH]";
46 46
47 public BSTerrainMesh(BSScene physicsScene, uint id, Vector3 regionSize) 47 private float[] m_savedHeightMap;
48 : base(physicsScene) 48 int m_sizeX;
49 int m_sizeY;
50
51 BulletShape m_terrainShape;
52 BulletBody m_terrainBody;
53
54 public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize)
55 : base(physicsScene, regionBase, id)
49 { 56 {
50 } 57 }
51 58
52 public BSTerrainMesh(BSScene physicsScene /* parameters for making mesh */) 59 public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id /* parameters for making mesh */)
53 : base(physicsScene) 60 : base(physicsScene, regionBase, id)
54 { 61 {
55 } 62 }
56 63
64 // Create terrain mesh from a heightmap.
65 public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap,
66 Vector3 minCoords, Vector3 maxCoords)
67 : base(physicsScene, regionBase, id)
68 {
69 int indicesCount;
70 int[] indices;
71 int verticesCount;
72 float[] vertices;
73
74 m_savedHeightMap = initialMap;
75
76 m_sizeX = (int)(maxCoords.X - minCoords.X);
77 m_sizeY = (int)(maxCoords.Y - minCoords.Y);
78
79 if (!BSTerrainMesh.ConvertHeightmapToMesh(PhysicsScene, initialMap, m_sizeX, m_sizeY,
80 (float)m_sizeX, (float)m_sizeY,
81 Vector3.Zero, 1.0f,
82 out indicesCount, out indices, out verticesCount, out vertices))
83 {
84 // DISASTER!!
85 PhysicsScene.DetailLog("{0},BSTerrainMesh.create,failedConversionOfHeightmap", ID);
86 PhysicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh! base={1}", LogHeader, TerrainBase);
87 // Something is very messed up and a crash is in our future.
88 return;
89 }
90 PhysicsScene.DetailLog("{0},BSTerrainMesh.create,afterConvertHeightmapToMesh,ver={1},ind={2}",
91 ID, verticesCount, indicesCount);
92
93 m_terrainShape = new BulletShape(BulletSimAPI.CreateMeshShape2(PhysicsScene.World.ptr,
94 indicesCount, indices, verticesCount, vertices),
95 PhysicsShapeType.SHAPE_MESH);
96 if (m_terrainShape.ptr == IntPtr.Zero)
97 {
98 // DISASTER!!
99 PhysicsScene.DetailLog("{0},BSTerrainMesh.create,failedCreationOfShape", ID);
100 physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);
101 // Something is very messed up and a crash is in our future.
102 return;
103 }
104 PhysicsScene.DetailLog("{0},BSTerrainMesh.create,afterCreateShape,shape={1}", ID, m_terrainShape);
105
106 // The terrain object initial position is at the center of the object
107 Vector3 centerPos;
108 centerPos.X = minCoords.X + (m_sizeX / 2f);
109 centerPos.Y = minCoords.Y + (m_sizeY / 2f);
110 centerPos.Z = minCoords.Z + ((maxCoords.Z - minCoords.Z) / 2f);
111 Quaternion rot = Quaternion.Identity;
112
113 PhysicsScene.DetailLog("{0},BSTerrainMesh.create,creatingBody,centerPos={1},rot={2}", ID, centerPos, rot);
114 m_terrainBody = new BulletBody(id, BulletSimAPI.CreateBodyWithDefaultMotionState2(
115 m_terrainShape.ptr, ID, centerPos, rot));
116 if (m_terrainBody.ptr == IntPtr.Zero)
117 {
118 // DISASTER!!
119 physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);
120 // Something is very messed up and a crash is in our future.
121 return;
122 }
123 PhysicsScene.DetailLog("{0},BSTerrainMesh.create,afterCreateBody,body={1}", ID, m_terrainBody);
124
125 // Set current terrain attributes
126 BulletSimAPI.SetFriction2(m_terrainBody.ptr, PhysicsScene.Params.terrainFriction);
127 BulletSimAPI.SetHitFraction2(m_terrainBody.ptr, PhysicsScene.Params.terrainHitFraction);
128 BulletSimAPI.SetRestitution2(m_terrainBody.ptr, PhysicsScene.Params.terrainRestitution);
129 BulletSimAPI.SetCollisionFlags2(m_terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
130
131 // Static objects are not very massive.
132 BulletSimAPI.SetMassProps2(m_terrainBody.ptr, 0f, Vector3.Zero);
133
134 // Return the new terrain to the world of physical objects
135 BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, m_terrainBody.ptr);
136
137 // redo its bounding box now that it is in the world
138 BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, m_terrainBody.ptr);
139
140 BulletSimAPI.SetCollisionFilterMask2(m_terrainBody.ptr,
141 (uint)CollisionFilterGroups.TerrainFilter,
142 (uint)CollisionFilterGroups.TerrainMask);
143
144 // Make it so the terrain will not move or be considered for movement.
145 BulletSimAPI.ForceActivationState2(m_terrainBody.ptr, ActivationState.DISABLE_SIMULATION);
146 }
147
57 public override void Dispose() 148 public override void Dispose()
58 { 149 {
59 return; 150 if (m_terrainBody.ptr != IntPtr.Zero)
151 {
152 BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_terrainBody.ptr);
153 // Frees both the body and the shape.
154 BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, m_terrainBody.ptr);
155 }
60 } 156 }
61 157
62 public override float GetHeightAtXYZ(Vector3 pos) 158 public override float GetHeightAtXYZ(Vector3 pos)
63 { 159 {
64 return 12345f; 160 // For the moment use the saved heightmap to get the terrain height.
161 // TODO: raycast downward to find the true terrain below the position.
162 float ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
163
164 int mapIndex = (int)pos.Y * m_sizeY + (int)pos.X;
165 try
166 {
167 ret = m_savedHeightMap[mapIndex];
168 }
169 catch
170 {
171 // Sometimes they give us wonky values of X and Y. Give a warning and return something.
172 PhysicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
173 LogHeader, TerrainBase, pos);
174 ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
175 }
176 return ret;
65 } 177 }
66 178
67 public override Vector3 TerrainBase 179 // Convert the passed heightmap to mesh information suitable for CreateMeshShape2().
180 // Return 'true' if successfully created.
181 public static bool ConvertHeightmapToMesh(
182 BSScene physicsScene,
183 float[] heightMap, int sizeX, int sizeY, // parameters of incoming heightmap
184 float extentX, float extentY, // zero based range for output vertices
185 Vector3 extentBase, // base to be added to all vertices
186 float magnification, // number of vertices to create between heightMap coords
187 out int indicesCountO, out int[] indicesO,
188 out int verticesCountO, out float[] verticesO)
68 { 189 {
69 get { return Vector3.Zero; } 190 bool ret = false;
70 } 191
192 int indicesCount = 0;
193 int verticesCount = 0;
194 int[] indices = new int[0];
195 float[] vertices = new float[0];
71 196
197 // Simple mesh creation which assumes magnification == 1, sizeX == extentX and sizeY == extentY.
198 // TODO: do a more general solution that scales, adds new vertices and smoothes the result.
199
200 try
201 {
202 // One vertice per heightmap value plus the vertices off the top and bottom edge.
203 int totalVertices = (sizeX + 1) * (sizeY + 1);
204 vertices = new float[totalVertices * 3];
205 int totalIndices = sizeX * sizeY * 6;
206 indices = new int[totalIndices];
207
208 physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,totVert={1},totInd={2}",
209 BSScene.DetailLogZero, totalVertices, totalIndices);
210 float magX = (float)sizeX / extentX;
211 float magY = (float)sizeY / extentY;
212 // Note that sizeX+1 vertices are created since there is land between this and the next region.
213 for (int yy = 0; yy <= sizeY; yy++)
214 {
215 for (int xx = 0; xx <= sizeX; xx++) // Hint: the "<=" means we got through sizeX + 1 times
216 {
217 int offset = yy * sizeX + xx;
218 // Extend the height from the height from the last row or column
219 if (yy == sizeY) offset -= sizeX;
220 if (xx == sizeX) offset -= 1;
221 float height = heightMap[offset];
222 vertices[verticesCount + 0] = (float)xx * magX + extentBase.X;
223 vertices[verticesCount + 1] = (float)yy * magY + extentBase.Y;
224 vertices[verticesCount + 2] = height + extentBase.Z;
225 if (physicsScene.PhysicsLogging.Enabled && verticesCount < 900) // DEBUG DEBUG DEBUG
226 {
227 Vector3 genVertex = new Vector3(
228 vertices[verticesCount + 0],
229 vertices[verticesCount + 1],
230 vertices[verticesCount + 2]);
231 physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,ii={1},vertex={2}",
232 BSScene.DetailLogZero, verticesCount/3, genVertex);
233 }
234 verticesCount += 3;
235 }
236 }
237 verticesCount = verticesCount / 3;
238 physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,completeVerts,verCount={1}",
239 BSScene.DetailLogZero, verticesCount);
240
241 for (int yy = 0; yy < sizeY; yy++)
242 {
243 for (int xx = 0; xx < sizeX; xx++)
244 {
245 int offset = yy * sizeX + xx;
246 // Each vertices is presumed to be the upper left corner of a box of two triangles
247 indices[indicesCount + 0] = offset;
248 indices[indicesCount + 1] = offset + 1;
249 indices[indicesCount + 2] = offset + sizeX + 1; // accounting for the extra column
250 indices[indicesCount + 3] = offset + 1;
251 indices[indicesCount + 4] = offset + sizeX + 2;
252 indices[indicesCount + 5] = offset + sizeX + 1;
253 if (indicesCount < (300 * 6)) // DEBUG DEBUG DEBUG
254 physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,i0={1},i1={2},i2={3},i3={4},i4={5},i5={6}", // DEEBUG DEBUG DEBUG
255 BSScene.DetailLogZero,
256 indices[indicesCount + 0],
257 indices[indicesCount + 1],
258 indices[indicesCount + 2],
259 indices[indicesCount + 3],
260 indices[indicesCount + 4],
261 indices[indicesCount + 5]
262 );
263 indicesCount += 6;
264 }
265 }
266 physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,completeIndices,indCount={1}", // DEEBUG DEBUG DEBUG
267 LogHeader, indicesCount); // DEBUG
268 ret = true;
269 }
270 catch (Exception e)
271 {
272 physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh. Base={1}, e={2}",
273 LogHeader, extentBase, e);
274 }
275
276 indicesCountO = indicesCount;
277 indicesO = indices;
278 verticesCountO = verticesCount;
279 verticesO = vertices;
280
281 return ret;
282 }
72} 283}
73} 284}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
index bab3b3d..a2271a9 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
@@ -391,13 +391,13 @@ public enum CollisionFilterGroups : uint
391 ObjectFilter = BSolidFilter, 391 ObjectFilter = BSolidFilter,
392 ObjectMask = BAllFilter, 392 ObjectMask = BAllFilter,
393 StaticObjectFilter = BStaticFilter, 393 StaticObjectFilter = BStaticFilter,
394 StaticObjectMask = BAllFilter, 394 StaticObjectMask = BAllFilter & ~BStaticFilter, // static objects don't collide with each other
395 LinksetFilter = BLinksetFilter, 395 LinksetFilter = BLinksetFilter,
396 LinksetMask = BAllFilter & ~BLinksetFilter, 396 LinksetMask = BAllFilter & ~BLinksetFilter, // linkset objects don't collide with each other
397 VolumeDetectFilter = BSensorTrigger, 397 VolumeDetectFilter = BSensorTrigger,
398 VolumeDetectMask = ~BSensorTrigger, 398 VolumeDetectMask = ~BSensorTrigger,
399 TerrainFilter = BTerrainFilter, 399 TerrainFilter = BTerrainFilter,
400 TerrainMask = BAllFilter & ~BStaticFilter, 400 TerrainMask = BAllFilter & ~BStaticFilter, // static objects on the ground don't collide
401 GroundPlaneFilter = BGroundPlaneFilter, 401 GroundPlaneFilter = BGroundPlaneFilter,
402 GroundPlaneMask = BAllFilter 402 GroundPlaneMask = BAllFilter
403 403
generated by cgit v1.1 at 2024-12-25 16:45:29 +0000