WebSVN – opensim-development – Blame – Rev 1 – /OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs

1

eva

1

/*

2

* Copyright (c) Contributors, http://opensimulator.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 copyrightD

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 OpenSimulator 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

using System;

28

using System.Collections.Generic;

29

using System.Text;

30

31

using OpenSim.Framework;

32

using OpenSim.Region.Framework;

33

using OpenSim.Region.CoreModules;

34

using OpenSim.Region.Physics.Manager;

using Nini.Config;

using log4net;

using OpenMetaverse;

40

41

namespace OpenSim.Region.Physics.BulletSPlugin

42

{

43

public sealed class BSTerrainMesh : BSTerrainPhys

44

{

45

static string LogHeader = "[BULLETSIM TERRAIN MESH]";

46

47

private float[] m_savedHeightMap;

int m_sizeX;

int m_sizeY;

BulletShape m_terrainShape;

52

BulletBody m_terrainBody;

53

54

public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize)

55

: base(physicsScene, regionBase, id)

{

}

public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id /* parameters for making mesh */)

60

: base(physicsScene, regionBase, id)

{

}

// 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)

{

int indicesCount;

int[] indices;

int verticesCount;

float[] vertices;

m_savedHeightMap = initialMap;

75

76

m_sizeX = (int)(maxCoords.X - minCoords.X);

77

m_sizeY = (int)(maxCoords.Y - minCoords.Y);

78

79

bool meshCreationSuccess = false;

80

if (BSParam.TerrainMeshMagnification == 1)

81

{

82

// If a magnification of one, use the old routine that is tried and true.

83

meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh(m_physicsScene,

84

initialMap, m_sizeX, m_sizeY, // input size

85

Vector3.Zero, // base for mesh

86

out indicesCount, out indices, out verticesCount, out vertices);

}

else

{

// Other magnifications use the newer routine

91

meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh2(m_physicsScene,

92

initialMap, m_sizeX, m_sizeY, // input size

93

BSParam.TerrainMeshMagnification,

94

physicsScene.TerrainManager.DefaultRegionSize,

95

Vector3.Zero, // base for mesh

96

out indicesCount, out indices, out verticesCount, out vertices);

97

}

98

if (!meshCreationSuccess)

99

{

100

// DISASTER!!

101

            m_physicsScene.DetailLog("{0},BSTerrainMesh.create,failedConversionOfHeightmap,id={1}", BSScene.DetailLogZero, ID);

102

            m_physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh! base={1}", LogHeader, TerrainBase);

103

// Something is very messed up and a crash is in our future.

return;

}

m_physicsScene.DetailLog("{0},BSTerrainMesh.create,meshed,id={1},indices={2},indSz={3},vertices={4},vertSz={5}",

108

                                BSScene.DetailLogZero, ID, indicesCount, indices.Length, verticesCount, vertices.Length);

109

110

        m_terrainShape = m_physicsScene.PE.CreateMeshShape(m_physicsScene.World, indicesCount, indices, verticesCount, vertices);

111

if (!m_terrainShape.HasPhysicalShape)

112

{

113

// DISASTER!!

114

            m_physicsScene.DetailLog("{0},BSTerrainMesh.create,failedCreationOfShape,id={1}", BSScene.DetailLogZero, ID);

115

m_physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);

116

// Something is very messed up and a crash is in our future.

return;

}

Vector3 pos = regionBase;

121

Quaternion rot = Quaternion.Identity;

122

123

m_terrainBody = m_physicsScene.PE.CreateBodyWithDefaultMotionState(m_terrainShape, ID, pos, rot);

124

if (!m_terrainBody.HasPhysicalBody)

125

{

126

// DISASTER!!

127

m_physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);

128

// Something is very messed up and a crash is in our future.

129

return;

130

}

131

physicsScene.PE.SetShapeCollisionMargin(m_terrainShape, BSParam.TerrainCollisionMargin);

132

133

// Set current terrain attributes

134

m_physicsScene.PE.SetFriction(m_terrainBody, BSParam.TerrainFriction);

135

m_physicsScene.PE.SetHitFraction(m_terrainBody, BSParam.TerrainHitFraction);

136

m_physicsScene.PE.SetRestitution(m_terrainBody, BSParam.TerrainRestitution);

137

m_physicsScene.PE.SetContactProcessingThreshold(m_terrainBody, BSParam.TerrainContactProcessingThreshold);

138

m_physicsScene.PE.SetCollisionFlags(m_terrainBody, CollisionFlags.CF_STATIC_OBJECT);

139

140

// Static objects are not very massive.

141

m_physicsScene.PE.SetMassProps(m_terrainBody, 0f, Vector3.Zero);

142

143

// Put the new terrain to the world of physical objects

144

m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_terrainBody);

145

146

// Redo its bounding box now that it is in the world

147

m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_terrainBody);

148

149

m_terrainBody.collisionType = CollisionType.Terrain;

150

m_terrainBody.ApplyCollisionMask(m_physicsScene);

151

152

if (BSParam.UseSingleSidedMeshes)

153

{

154

m_physicsScene.DetailLog("{0},BSTerrainMesh.settingCustomMaterial,id={1}", BSScene.DetailLogZero, id);

155

m_physicsScene.PE.AddToCollisionFlags(m_terrainBody, CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);

156

}

157

158

// Make it so the terrain will not move or be considered for movement.

159

m_physicsScene.PE.ForceActivationState(m_terrainBody, ActivationState.DISABLE_SIMULATION);

160

}

161

162

public override void Dispose()

163

{

164

if (m_terrainBody.HasPhysicalBody)

165

{

166

m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_terrainBody);

167

// Frees both the body and the shape.

168

m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_terrainBody);

169

m_terrainBody.Clear();

170

m_terrainShape.Clear();

}

}

public override float GetTerrainHeightAtXYZ(Vector3 pos)

175

{

176

// For the moment use the saved heightmap to get the terrain height.

177

// TODO: raycast downward to find the true terrain below the position.

178

float ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;

179

180

int mapIndex = (int)pos.Y * m_sizeY + (int)pos.X;

181

try

182

{

183

ret = m_savedHeightMap[mapIndex];

}

catch

{

// Sometimes they give us wonky values of X and Y. Give a warning and return something.

188

m_physicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",

189

LogHeader, TerrainBase, pos);

190

ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;

}

return ret;

}

// The passed position is relative to the base of the region.

196

public override float GetWaterLevelAtXYZ(Vector3 pos)

197

{

198

return m_physicsScene.SimpleWaterLevel;

199

}

200

201

// Convert the passed heightmap to mesh information suitable for CreateMeshShape2().

202

// Return 'true' if successfully created.

203

public static bool ConvertHeightmapToMesh( BSScene physicsScene,

204

float[] heightMap, int sizeX, int sizeY, // parameters of incoming heightmap

205

Vector3 extentBase, // base to be added to all vertices

206

out int indicesCountO, out int[] indicesO,

207

out int verticesCountO, out float[] verticesO)

{

bool ret = false;

int indicesCount = 0;

212

int verticesCount = 0;

213

int[] indices = new int[0];

214

float[] vertices = new float[0];

215

216

// Simple mesh creation which assumes magnification == 1.

217

// TODO: do a more general solution that scales, adds new vertices and smoothes the result.

218

219

// Create an array of vertices that is sizeX+1 by sizeY+1 (note the loop

220

// from zero to <= sizeX). The triangle indices are then generated as two triangles

221

// per heightmap point. There are sizeX by sizeY of these squares. The extra row and

222

// column of vertices are used to complete the triangles of the last row and column

223

// of the heightmap.

224

try

225

{

226

// One vertice per heightmap value plus the vertices off the side and bottom edge.

227

int totalVertices = (sizeX + 1) * (sizeY + 1);

228

vertices = new float[totalVertices * 3];

229

int totalIndices = sizeX * sizeY * 6;

230

indices = new int[totalIndices];

231

232

if (physicsScene != null)

233

physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,totVert={1},totInd={2},extentBase={3}",

234

BSScene.DetailLogZero, totalVertices, totalIndices, extentBase);

235

float minHeight = float.MaxValue;

236

// Note that sizeX+1 vertices are created since there is land between this and the next region.

237

for (int yy = 0; yy <= sizeY; yy++)

238

{

239

for (int xx = 0; xx <= sizeX; xx++) // Hint: the "<=" means we go around sizeX + 1 times

240

{

241

int offset = yy * sizeX + xx;

242

// Extend the height with the height from the last row or column

243

if (yy == sizeY) offset -= sizeX;

244

if (xx == sizeX) offset -= 1;

245

float height = heightMap[offset];

246

minHeight = Math.Min(minHeight, height);

247

vertices[verticesCount + 0] = (float)xx + extentBase.X;

248

vertices[verticesCount + 1] = (float)yy + extentBase.Y;

249

vertices[verticesCount + 2] = height + extentBase.Z;

250

verticesCount += 3;

251

}

252

}

253

verticesCount = verticesCount / 3;

254

255

for (int yy = 0; yy < sizeY; yy++)

256

{

257

for (int xx = 0; xx < sizeX; xx++)

258

{

259

int offset = yy * (sizeX + 1) + xx;

260

// Each vertices is presumed to be the upper left corner of a box of two triangles

261

indices[indicesCount + 0] = offset;

262

indices[indicesCount + 1] = offset + 1;

263

indices[indicesCount + 2] = offset + sizeX + 1; // accounting for the extra column

264

indices[indicesCount + 3] = offset + 1;

265

indices[indicesCount + 4] = offset + sizeX + 2;

266

indices[indicesCount + 5] = offset + sizeX + 1;

indicesCount += 6;

}

}

ret = true;

}

catch (Exception e)

274

{

275

if (physicsScene != null)

276

physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh. For={1}/{2}, e={3}",

277

LogHeader, physicsScene.RegionName, extentBase, e);

278

}

279

280

indicesCountO = indicesCount;

281

indicesO = indices;

282

verticesCountO = verticesCount;

283

verticesO = vertices;

return ret;

}

private class HeightMapGetter

289

{

290

private float[] m_heightMap;

291

private int m_sizeX;

292

private int m_sizeY;

293

public HeightMapGetter(float[] pHeightMap, int pSizeX, int pSizeY)

294

{

295

m_heightMap = pHeightMap;

m_sizeX = pSizeX;

m_sizeY = pSizeY;

}

// The heightmap is extended as an infinite plane at the last height

300

public float GetHeight(int xx, int yy)

301

{

302

int offset = 0;

303

// Extend the height with the height from the last row or column

304

if (yy >= m_sizeY)

305

if (xx >= m_sizeX)

306

offset = (m_sizeY - 1) * m_sizeX + (m_sizeX - 1);

307

else

308

offset = (m_sizeY - 1) * m_sizeX + xx;

309

else

310

if (xx >= m_sizeX)

311

offset = yy * m_sizeX + (m_sizeX - 1);

312

else

313

offset = yy * m_sizeX + xx;

314

315

return m_heightMap[offset];

}

}

// Convert the passed heightmap to mesh information suitable for CreateMeshShape2().

320

// Version that handles magnification.

321

// Return 'true' if successfully created.

322

public static bool ConvertHeightmapToMesh2( BSScene physicsScene,

323

float[] heightMap, int sizeX, int sizeY, // parameters of incoming heightmap

324

int magnification, // number of vertices per heighmap step

325

Vector3 extent, // dimensions of the output mesh

326

Vector3 extentBase, // base to be added to all vertices

327

out int indicesCountO, out int[] indicesO,

328

out int verticesCountO, out float[] verticesO)

{

bool ret = false;

int indicesCount = 0;

333

int verticesCount = 0;

334

int[] indices = new int[0];

335

float[] vertices = new float[0];

336

337

HeightMapGetter hmap = new HeightMapGetter(heightMap, sizeX, sizeY);

338

339

// The vertices dimension of the output mesh

340

int meshX = sizeX * magnification;

341

int meshY = sizeY * magnification;

342

// The output size of one mesh step

343

float meshXStep = extent.X / meshX;

344

float meshYStep = extent.Y / meshY;

345

346

// Create an array of vertices that is meshX+1 by meshY+1 (note the loop

347

// from zero to <= meshX). The triangle indices are then generated as two triangles

348

// per heightmap point. There are meshX by meshY of these squares. The extra row and

349

// column of vertices are used to complete the triangles of the last row and column

350

// of the heightmap.

351

try

352

{

353

// Vertices for the output heightmap plus one on the side and bottom to complete triangles

354

int totalVertices = (meshX + 1) * (meshY + 1);

355

vertices = new float[totalVertices * 3];

356

int totalIndices = meshX * meshY * 6;

357

indices = new int[totalIndices];

358

359

if (physicsScene != null)

360

                physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,inSize={1},outSize={2},totVert={3},totInd={4},extentBase={5}",

361

BSScene.DetailLogZero, new Vector2(sizeX, sizeY), new Vector2(meshX, meshY),

362

totalVertices, totalIndices, extentBase);

363

364

float minHeight = float.MaxValue;

365

// Note that sizeX+1 vertices are created since there is land between this and the next region.

366

// Loop through the output vertices and compute the mediun height in between the input vertices

367

for (int yy = 0; yy <= meshY; yy++)

368

{

369

for (int xx = 0; xx <= meshX; xx++) // Hint: the "<=" means we go around sizeX + 1 times

370

{

371

                    float offsetY = (float)yy * (float)sizeY / (float)meshY;     // The Y that is closest to the mesh point

372

int stepY = (int)offsetY;

373

float fractionalY = offsetY - (float)stepY;

374

                    float offsetX = (float)xx * (float)sizeX / (float)meshX;     // The X that is closest to the mesh point

375

int stepX = (int)offsetX;

376

float fractionalX = offsetX - (float)stepX;

377

378

                    // physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,xx={1},yy={2},offX={3},stepX={4},fractX={5},offY={6},stepY={7},fractY={8}",

379

                    //                 BSScene.DetailLogZero, xx, yy, offsetX, stepX, fractionalX, offsetY, stepY, fractionalY);

380

381

// get the four corners of the heightmap square the mesh point is in

382

float heightUL = hmap.GetHeight(stepX , stepY );

383

float heightUR = hmap.GetHeight(stepX + 1, stepY );

384

float heightLL = hmap.GetHeight(stepX , stepY + 1);

385

float heightLR = hmap.GetHeight(stepX + 1, stepY + 1);

386

387

// bilinear interplolation

388

float height = heightUL * (1 - fractionalX) * (1 - fractionalY)

389

+ heightUR * fractionalX * (1 - fractionalY)

390

+ heightLL * (1 - fractionalX) * fractionalY

391

+ heightLR * fractionalX * fractionalY;

392

393

                    // physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,heightUL={1},heightUR={2},heightLL={3},heightLR={4},heightMap={5}",

394

// BSScene.DetailLogZero, heightUL, heightUR, heightLL, heightLR, height);

395

396

minHeight = Math.Min(minHeight, height);

397

398

vertices[verticesCount + 0] = (float)xx * meshXStep + extentBase.X;

399

vertices[verticesCount + 1] = (float)yy * meshYStep + extentBase.Y;

400

vertices[verticesCount + 2] = height + extentBase.Z;