BulletSim: code to generate a higher resolution terrain mesh. Parameter
TerrainMeshMagnification controls number of vertices generated per heightmap point. Default is 3.user_profiles
Robert Adams
parent
8510f57ad4
commit
8360223fed
|
|
@ -286,7 +286,7 @@ public override void SetShapeCollisionMargin(BulletShape shape, float margin)
|
|||
{
|
||||
BulletShapeUnman shapeu = shape as BulletShapeUnman;
|
||||
if (shapeu != null && shapeu.HasPhysicalShape)
|
||||
BSAPICPP.SetShapeCollisionMargin2(shapeu.ptr, margin);
|
||||
BSAPICPP.SetShapeCollisionMargin(shapeu.ptr, margin);
|
||||
}
|
||||
|
||||
public override BulletShape BuildCapsuleShape(BulletWorld world, float radius, float height, Vector3 scale)
|
||||
|
|
@ -1420,7 +1420,7 @@ public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData)
|
|||
public static extern bool IsNativeShape2(IntPtr shape);
|
||||
|
||||
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
|
||||
public static extern void SetShapeCollisionMargin2(IntPtr shape, float margin);
|
||||
public static extern void SetShapeCollisionMargin(IntPtr shape, float margin);
|
||||
|
||||
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
|
||||
public static extern IntPtr BuildCapsuleShape2(IntPtr world, float radius, float height, Vector3 scale);
|
||||
|
|
|
|||
|
|
@ -1201,8 +1201,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
|
|||
|
||||
VehicleAddForce(appliedGravity);
|
||||
|
||||
VDetailLog("{0}, MoveLinear,applyGravity,vehGrav={1},collid={2},appliedForce={3}",
|
||||
Prim.LocalID, m_VehicleGravity, Prim.IsColliding, appliedGravity);
|
||||
VDetailLog("{0}, MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={3}",
|
||||
Prim.LocalID, m_VehicleGravity,
|
||||
Prim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
|
||||
}
|
||||
|
||||
// =======================================================================
|
||||
|
|
|
|||
|
|
@ -88,6 +88,7 @@ public static class BSParam
|
|||
public static bool ShouldRemoveZeroWidthTriangles { get; private set; }
|
||||
|
||||
public static float TerrainImplementation { get; private set; }
|
||||
public static int TerrainMeshMagnification { get; private set; }
|
||||
public static float TerrainFriction { get; private set; }
|
||||
public static float TerrainHitFraction { get; private set; }
|
||||
public static float TerrainRestitution { get; private set; }
|
||||
|
|
@ -461,6 +462,10 @@ public static class BSParam
|
|||
(float)BSTerrainPhys.TerrainImplementation.Mesh,
|
||||
(s) => { return TerrainImplementation; },
|
||||
(s,v) => { TerrainImplementation = v; } ),
|
||||
new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
|
||||
3,
|
||||
(s) => { return TerrainMeshMagnification; },
|
||||
(s,v) => { TerrainMeshMagnification = v; } ),
|
||||
new ParameterDefn<float>("TerrainFriction", "Factor to reduce movement against terrain surface" ,
|
||||
0.3f,
|
||||
(s) => { return TerrainFriction; },
|
||||
|
|
|
|||
|
|
@ -76,11 +76,26 @@ public sealed class BSTerrainMesh : BSTerrainPhys
|
|||
m_sizeX = (int)(maxCoords.X - minCoords.X);
|
||||
m_sizeY = (int)(maxCoords.Y - minCoords.Y);
|
||||
|
||||
if (!BSTerrainMesh.ConvertHeightmapToMesh(PhysicsScene, initialMap,
|
||||
m_sizeX, m_sizeY,
|
||||
(float)m_sizeX, (float)m_sizeY,
|
||||
Vector3.Zero, 1.0f,
|
||||
out indicesCount, out indices, out verticesCount, out vertices))
|
||||
bool meshCreationSuccess = false;
|
||||
if (BSParam.TerrainMeshMagnification == 1)
|
||||
{
|
||||
// If a magnification of one, use the old routine that is tried and true.
|
||||
meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh(PhysicsScene,
|
||||
initialMap, m_sizeX, m_sizeY, // input size
|
||||
Vector3.Zero, // base for mesh
|
||||
out indicesCount, out indices, out verticesCount, out vertices);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Other magnifications use the newer routine
|
||||
meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh2(PhysicsScene,
|
||||
initialMap, m_sizeX, m_sizeY, // input size
|
||||
BSParam.TerrainMeshMagnification,
|
||||
physicsScene.TerrainManager.DefaultRegionSize,
|
||||
Vector3.Zero, // base for mesh
|
||||
out indicesCount, out indices, out verticesCount, out vertices);
|
||||
}
|
||||
if (!meshCreationSuccess)
|
||||
{
|
||||
// DISASTER!!
|
||||
PhysicsScene.DetailLog("{0},BSTerrainMesh.create,failedConversionOfHeightmap", ID);
|
||||
|
|
@ -88,6 +103,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
|
|||
// Something is very messed up and a crash is in our future.
|
||||
return;
|
||||
}
|
||||
|
||||
PhysicsScene.DetailLog("{0},BSTerrainMesh.create,meshed,indices={1},indSz={2},vertices={3},vertSz={4}",
|
||||
ID, indicesCount, indices.Length, verticesCount, vertices.Length);
|
||||
|
||||
|
|
@ -186,9 +202,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
|
|||
// Return 'true' if successfully created.
|
||||
public static bool ConvertHeightmapToMesh( BSScene physicsScene,
|
||||
float[] heightMap, int sizeX, int sizeY, // parameters of incoming heightmap
|
||||
float extentX, float extentY, // zero based range for output vertices
|
||||
Vector3 extentBase, // base to be added to all vertices
|
||||
float magnification, // number of vertices to create between heightMap coords
|
||||
out int indicesCountO, out int[] indicesO,
|
||||
out int verticesCountO, out float[] verticesO)
|
||||
{
|
||||
|
|
@ -209,17 +223,15 @@ public sealed class BSTerrainMesh : BSTerrainPhys
|
|||
// of the heightmap.
|
||||
try
|
||||
{
|
||||
// One vertice per heightmap value plus the vertices off the top and bottom edge.
|
||||
// One vertice per heightmap value plus the vertices off the side and bottom edge.
|
||||
int totalVertices = (sizeX + 1) * (sizeY + 1);
|
||||
vertices = new float[totalVertices * 3];
|
||||
int totalIndices = sizeX * sizeY * 6;
|
||||
indices = new int[totalIndices];
|
||||
|
||||
float magX = (float)sizeX / extentX;
|
||||
float magY = (float)sizeY / extentY;
|
||||
if (physicsScene != null)
|
||||
physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,totVert={1},totInd={2},extentBase={3},magX={4},magY={5}",
|
||||
BSScene.DetailLogZero, totalVertices, totalIndices, extentBase, magX, magY);
|
||||
physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,totVert={1},totInd={2},extentBase={3}",
|
||||
BSScene.DetailLogZero, totalVertices, totalIndices, extentBase);
|
||||
float minHeight = float.MaxValue;
|
||||
// Note that sizeX+1 vertices are created since there is land between this and the next region.
|
||||
for (int yy = 0; yy <= sizeY; yy++)
|
||||
|
|
@ -232,8 +244,8 @@ public sealed class BSTerrainMesh : BSTerrainPhys
|
|||
if (xx == sizeX) offset -= 1;
|
||||
float height = heightMap[offset];
|
||||
minHeight = Math.Min(minHeight, height);
|
||||
vertices[verticesCount + 0] = (float)xx * magX + extentBase.X;
|
||||
vertices[verticesCount + 1] = (float)yy * magY + extentBase.Y;
|
||||
vertices[verticesCount + 0] = (float)xx + extentBase.X;
|
||||
vertices[verticesCount + 1] = (float)yy + extentBase.Y;
|
||||
vertices[verticesCount + 2] = height + extentBase.Z;
|
||||
verticesCount += 3;
|
||||
}
|
||||
|
|
@ -272,5 +284,158 @@ public sealed class BSTerrainMesh : BSTerrainPhys
|
|||
|
||||
return ret;
|
||||
}
|
||||
|
||||
private class HeightMapGetter
|
||||
{
|
||||
private float[] m_heightMap;
|
||||
private int m_sizeX;
|
||||
private int m_sizeY;
|
||||
public HeightMapGetter(float[] pHeightMap, int pSizeX, int pSizeY)
|
||||
{
|
||||
m_heightMap = pHeightMap;
|
||||
m_sizeX = pSizeX;
|
||||
m_sizeY = pSizeY;
|
||||
}
|
||||
// The heightmap is extended as an infinite plane at the last height
|
||||
public float GetHeight(int xx, int yy)
|
||||
{
|
||||
int offset = 0;
|
||||
// Extend the height with the height from the last row or column
|
||||
if (yy >= m_sizeY)
|
||||
if (xx >= m_sizeX)
|
||||
offset = (m_sizeY - 1) * m_sizeX + (m_sizeX - 1);
|
||||
else
|
||||
offset = (m_sizeY - 1) * m_sizeX + xx;
|
||||
else
|
||||
if (xx >= m_sizeX)
|
||||
offset = yy * m_sizeX + (m_sizeX - 1);
|
||||
else
|
||||
offset = yy * m_sizeX + xx;
|
||||
|
||||
return m_heightMap[offset];
|
||||
}
|
||||
}
|
||||
|
||||
// Convert the passed heightmap to mesh information suitable for CreateMeshShape2().
|
||||
// Version that handles magnification.
|
||||
// Return 'true' if successfully created.
|
||||
public static bool ConvertHeightmapToMesh2( BSScene physicsScene,
|
||||
float[] heightMap, int sizeX, int sizeY, // parameters of incoming heightmap
|
||||
int magnification, // number of vertices per heighmap step
|
||||
Vector3 extent, // dimensions of the output mesh
|
||||
Vector3 extentBase, // base to be added to all vertices
|
||||
out int indicesCountO, out int[] indicesO,
|
||||
out int verticesCountO, out float[] verticesO)
|
||||
{
|
||||
bool ret = false;
|
||||
|
||||
int indicesCount = 0;
|
||||
int verticesCount = 0;
|
||||
int[] indices = new int[0];
|
||||
float[] vertices = new float[0];
|
||||
|
||||
HeightMapGetter hmap = new HeightMapGetter(heightMap, sizeX, sizeY);
|
||||
|
||||
// The vertices dimension of the output mesh
|
||||
int meshX = sizeX * magnification;
|
||||
int meshY = sizeY * magnification;
|
||||
// The output size of one mesh step
|
||||
float meshXStep = extent.X / meshX;
|
||||
float meshYStep = extent.Y / meshY;
|
||||
|
||||
// Create an array of vertices that is meshX+1 by meshY+1 (note the loop
|
||||
// from zero to <= meshX). The triangle indices are then generated as two triangles
|
||||
// per heightmap point. There are meshX by meshY of these squares. The extra row and
|
||||
// column of vertices are used to complete the triangles of the last row and column
|
||||
// of the heightmap.
|
||||
try
|
||||
{
|
||||
// Vertices for the output heightmap plus one on the side and bottom to complete triangles
|
||||
int totalVertices = (meshX + 1) * (meshY + 1);
|
||||
vertices = new float[totalVertices * 3];
|
||||
int totalIndices = meshX * meshY * 6;
|
||||
indices = new int[totalIndices];
|
||||
|
||||
if (physicsScene != null)
|
||||
physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,inSize={1},outSize={2},totVert={3},totInd={4},extentBase={5}",
|
||||
BSScene.DetailLogZero, new Vector2(sizeX, sizeY), new Vector2(meshX, meshY),
|
||||
totalVertices, totalIndices, extentBase);
|
||||
|
||||
float minHeight = float.MaxValue;
|
||||
// Note that sizeX+1 vertices are created since there is land between this and the next region.
|
||||
// Loop through the output vertices and compute the mediun height in between the input vertices
|
||||
for (int yy = 0; yy <= meshY; yy++)
|
||||
{
|
||||
for (int xx = 0; xx <= meshX; xx++) // Hint: the "<=" means we go around sizeX + 1 times
|
||||
{
|
||||
float offsetY = (float)yy * (float)sizeY / (float)meshY; // The Y that is closest to the mesh point
|
||||
int stepY = (int)offsetY;
|
||||
float fractionalY = offsetY - (float)stepY;
|
||||
float offsetX = (float)xx * (float)sizeX / (float)meshX; // The X that is closest to the mesh point
|
||||
int stepX = (int)offsetX;
|
||||
float fractionalX = offsetX - (float)stepX;
|
||||
|
||||
// physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,xx={1},yy={2},offX={3},stepX={4},fractX={5},offY={6},stepY={7},fractY={8}",
|
||||
// BSScene.DetailLogZero, xx, yy, offsetX, stepX, fractionalX, offsetY, stepY, fractionalY);
|
||||
|
||||
// get the four corners of the heightmap square the mesh point is in
|
||||
float heightUL = hmap.GetHeight(stepX , stepY );
|
||||
float heightUR = hmap.GetHeight(stepX + 1, stepY );
|
||||
float heightLL = hmap.GetHeight(stepX , stepY + 1);
|
||||
float heightLR = hmap.GetHeight(stepX + 1, stepY + 1);
|
||||
|
||||
// bilinear interplolation
|
||||
float height = heightUL * (1 - fractionalX) * (1 - fractionalY)
|
||||
+ heightUR * fractionalX * (1 - fractionalY)
|
||||
+ heightLL * (1 - fractionalX) * fractionalY
|
||||
+ heightLR * fractionalX * fractionalY;
|
||||
|
||||
// physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,heightUL={1},heightUR={2},heightLL={3},heightLR={4},heightMap={5}",
|
||||
// BSScene.DetailLogZero, heightUL, heightUR, heightLL, heightLR, height);
|
||||
|
||||
minHeight = Math.Min(minHeight, height);
|
||||
|
||||
vertices[verticesCount + 0] = (float)xx * meshXStep + extentBase.X;
|
||||
vertices[verticesCount + 1] = (float)yy * meshYStep + extentBase.Y;
|
||||
vertices[verticesCount + 2] = height + extentBase.Z;
|
||||
verticesCount += 3;
|
||||
}
|
||||
}
|
||||
// The number of vertices generated
|
||||
verticesCount /= 3;
|
||||
|
||||
// Loop through all the heightmap squares and create indices for the two triangles for that square
|
||||
for (int yy = 0; yy < meshY; yy++)
|
||||
{
|
||||
for (int xx = 0; xx < meshX; xx++)
|
||||
{
|
||||
int offset = yy * (meshX + 1) + xx;
|
||||
// Each vertices is presumed to be the upper left corner of a box of two triangles
|
||||
indices[indicesCount + 0] = offset;
|
||||
indices[indicesCount + 1] = offset + 1;
|
||||
indices[indicesCount + 2] = offset + meshX + 1; // accounting for the extra column
|
||||
indices[indicesCount + 3] = offset + 1;
|
||||
indices[indicesCount + 4] = offset + meshX + 2;
|
||||
indices[indicesCount + 5] = offset + meshX + 1;
|
||||
indicesCount += 6;
|
||||
}
|
||||
}
|
||||
|
||||
ret = true;
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
if (physicsScene != null)
|
||||
physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh. For={1}/{2}, e={3}",
|
||||
LogHeader, physicsScene.RegionName, extentBase, e);
|
||||
}
|
||||
|
||||
indicesCountO = indicesCount;
|
||||
indicesO = indices;
|
||||
verticesCountO = verticesCount;
|
||||
verticesO = vertices;
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue