mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix issue in HeightField and user Perlin noise to generate terrain

Browse Source
This commit is contained in:
Daniel Chappuis 2016-02-11 23:09:01 +01:00
parent 7dae30718b
commit eeb1052833
7 changed files with 213 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/collision/shapes/HeightFieldShape.cpp
View File

@ -57,7 +57,7 @@ HeightFieldShape::HeightFieldShape(int nbWidthGridPoints, int nbLengthGridPoints
mHeightFieldData = heightFieldData;
decimal halfHeight = (mMaxHeight - mMinHeight) * decimal(0.5);
assert(halfHeight > 0);
assert(halfHeight >= 0);
// Compute the local AABB of the height field
if (mUpAxis == 0) {

13
src/collision/shapes/HeightFieldShape.h
View File

@ -198,22 +198,23 @@ inline Vector3 HeightFieldShape::getVertexAt(int x, int y) const {
// Get the height value
const decimal height = getHeightAt(x, y);
// Get the difference between the center of AABB and zero level of the height field
const decimal originToZeroHeight = (mMaxHeight - mMinHeight) * decimal(0.5);
// Height values origin
const decimal heightOrigin = -(mMaxHeight - mMinHeight) * decimal(0.5) - mMinHeight;
Vector3 vertex;
switch (mUpAxis) {
case 0: vertex = Vector3(height - originToZeroHeight, -mWidth * decimal(0.5) + x, -mLength * decimal(0.5) + y) * mScaling;
case 0: vertex = Vector3(heightOrigin + height, -mWidth * decimal(0.5) + x, -mLength * decimal(0.5) + y);
break;
case 1: vertex = Vector3(-mWidth * decimal(0.5) + x, height - originToZeroHeight, -mLength * decimal(0.5) + y) * mScaling;
case 1: vertex = Vector3(-mWidth * decimal(0.5) + x, heightOrigin + height, -mLength * decimal(0.5) + y);
break;
case 2: vertex = Vector3(-mWidth * decimal(0.5) + x, -mLength * decimal(0.5) + y, height - originToZeroHeight) * mScaling;
case 2: vertex = Vector3(-mWidth * decimal(0.5) + x, -mLength * decimal(0.5) + y, heightOrigin + height);
break;
default: assert(false);
}
assert(mAABB.contains(vertex));
return vertex;
return vertex * mScaling;
}
// Return the height of a given (x,y) point in the height field

57
testbed/common/HeightField.cpp
View File

@ -25,6 +25,7 @@
// Libraries
#include "HeightField.h"
#include "PerlinNoise.h"
// Constructor
HeightField::HeightField(const openglframework::Vector3 &position,
@ -47,7 +48,7 @@ HeightField::HeightField(const openglframework::Vector3 &position,
// Create the collision shape for the rigid body (convex mesh shape) and
// do not forget to delete it at the end
mHeightFieldShape = new rp3d::HeightFieldShape(HEIGHTFIELD_WIDTH, HEIGHTFIELD_LENGTH, 0, 5,
mHeightFieldShape = new rp3d::HeightFieldShape(NB_POINTS_WIDTH, NB_POINTS_LENGTH, mMinHeight, mMaxHeight,
mHeightData, rp3d::HeightFieldShape::HEIGHT_FLOAT_TYPE);
// Initial position and orientation of the rigid body
@ -90,7 +91,7 @@ HeightField::HeightField(const openglframework::Vector3 &position, float mass,
// Create the collision shape for the rigid body (convex mesh shape) and
// do not forget to delete it at the end
mHeightFieldShape = new rp3d::HeightFieldShape(HEIGHTFIELD_WIDTH, HEIGHTFIELD_LENGTH, 0, 5,
mHeightFieldShape = new rp3d::HeightFieldShape(NB_POINTS_WIDTH, NB_POINTS_LENGTH, mMinHeight, mMaxHeight,
mHeightData, rp3d::HeightFieldShape::HEIGHT_FLOAT_TYPE);
// Initial position and orientation of the rigid body
@ -188,12 +189,33 @@ void HeightField::render(openglframework::Shader& shader,
// Compute the heights of the height field
void HeightField::generateHeightField() {
mMinHeight = 0.0;
mMaxHeight = 5.0;
double persistence = 6;
double frequency = 0.13;
double amplitude = 18;
int octaves = 1;
int randomseed = 779;
PerlinNoise perlinNoise(persistence, frequency, amplitude, octaves, randomseed);
for (int i=0; i<HEIGHTFIELD_WIDTH; i++) {
for (int j=0; j<HEIGHTFIELD_LENGTH; j++) {
mHeightData[i][j] = 5.0f;
mMinHeight = 0;
mMaxHeight = 5;
float width = (NB_POINTS_WIDTH - 1);
float length = (NB_POINTS_LENGTH - 1);
for (int i=0; i<NB_POINTS_WIDTH; i++) {
for (int j=0; j<NB_POINTS_LENGTH; j++) {
int arrayIndex = j * NB_POINTS_WIDTH + i;
mHeightData[arrayIndex] = (float)(perlinNoise.GetHeight(-width * 0.5 + i, -length * 0.5 + j));
if (i==0 && j==0) {
mMinHeight = mHeightData[arrayIndex] ;
mMaxHeight = mHeightData[arrayIndex] ;
}
if (mHeightData[arrayIndex] > mMaxHeight) mMaxHeight = mHeightData[arrayIndex] ;
if (mHeightData[arrayIndex] < mMinHeight) mMinHeight = mHeightData[arrayIndex] ;
}
}
}
@ -204,21 +226,27 @@ void HeightField::generateGraphicsMesh() {
std::vector<uint> indices;
int vertexId = 0;
for (int i=0; i<HEIGHTFIELD_WIDTH; i++) {
for (int j=0; j<HEIGHTFIELD_LENGTH; j++) {
float horizontalScale = 1.0f;
float height = mHeightData[i][j] - (mMaxHeight - mMinHeight) * 0.5f;
openglframework::Vector3 vertex(-(HEIGHTFIELD_WIDTH - 1) * 0.5f + i, height, -(HEIGHTFIELD_LENGTH - 1) * 0.5 + j);
for (int i=0; i<NB_POINTS_WIDTH; i++) {
for (int j=0; j<NB_POINTS_LENGTH; j++) {
float originHeight = -(mMaxHeight - mMinHeight) * 0.5f - mMinHeight;
float height = originHeight + mHeightData[j * NB_POINTS_WIDTH + i];
openglframework::Vector3 vertex(-(NB_POINTS_WIDTH - 1) * 0.5f + i, height, -(NB_POINTS_LENGTH - 1) * 0.5f + j);
vertex.x *= horizontalScale;
vertex.z *= horizontalScale;
mVertices.push_back(vertex);
// Triangle indices
if ((i < HEIGHTFIELD_WIDTH - 1) && (j < HEIGHTFIELD_LENGTH - 1)) {
if ((i < NB_POINTS_WIDTH - 1) && (j < NB_POINTS_LENGTH - 1)) {
int v1 = vertexId;
int v2 = vertexId + 1;
int v3 = vertexId + HEIGHTFIELD_LENGTH;
int v4 = vertexId + HEIGHTFIELD_LENGTH + 1;
int v3 = vertexId + NB_POINTS_LENGTH;
int v4 = vertexId + NB_POINTS_LENGTH + 1;
// First triangle
indices.push_back(v1);
@ -326,4 +354,3 @@ void HeightField::setScaling(const openglframework::Vector3& scaling) {
0, 0, scaling.z, 0,
0, 0, 0, 1.0f);
}

13
testbed/common/HeightField.h
View File

@ -31,18 +31,19 @@
#include "reactphysics3d.h"
#include "PhysicsObject.h"
// Class HeightField
class HeightField : public openglframework::Mesh, public PhysicsObject {
private :
static const int HEIGHTFIELD_WIDTH = 10;
static const int HEIGHTFIELD_LENGTH = 5;
static const int NB_POINTS_WIDTH = 100;
static const int NB_POINTS_LENGTH = 100;
// -------------------- Attributes -------------------- //
/// Height field data
float mHeightData[HEIGHTFIELD_WIDTH][HEIGHTFIELD_LENGTH];
float mHeightData[NB_POINTS_WIDTH * NB_POINTS_LENGTH];
/// Previous transform (for interpolation)
rp3d::Transform mPreviousTransform;
@ -74,13 +75,13 @@ class HeightField : public openglframework::Mesh, public PhysicsObject {
// -------------------- Methods -------------------- //
// Create the Vertex Buffer Objects used to render with OpenGL.
/// Create the Vertex Buffer Objects used to render with OpenGL.
void createVBOAndVAO();
// Compute the heights of the height field
/// Compute the heights of the height field
void generateHeightField();
// Generate the graphics mesh to render the height field
/// Generate the graphics mesh to render the height field
void generateGraphicsMesh();
public :

111
testbed/common/PerlinNoise.cpp Normal file
View File

@ -0,0 +1,111 @@
#include "PerlinNoise.h"
PerlinNoise::PerlinNoise()
{
persistence = 0;
frequency = 0;
amplitude = 0;
octaves = 0;
randomseed = 0;
}
PerlinNoise::PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
persistence = _persistence;
frequency = _frequency;
amplitude = _amplitude;
octaves = _octaves;
randomseed = 2 + _randomseed * _randomseed;
}
void PerlinNoise::Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed)
{
persistence = _persistence;
frequency = _frequency;
amplitude = _amplitude;
octaves = _octaves;
randomseed = 2 + _randomseed * _randomseed;
}
double PerlinNoise::GetHeight(double x, double y) const
{
return amplitude * Total(x, y);
}
double PerlinNoise::Total(double i, double j) const
{
//properties of one octave (changing each loop)
double t = 0.0f;
double _amplitude = 1;
double freq = frequency;
for(int k = 0; k < octaves; k++)
{
t += GetValue(j * freq + randomseed, i * freq + randomseed) * _amplitude;
_amplitude *= persistence;
freq *= 2;
}
return t;
}
double PerlinNoise::GetValue(double x, double y) const
{
int Xint = (int)x;
int Yint = (int)y;
double Xfrac = x - Xint;
double Yfrac = y - Yint;
//noise values
double n01 = Noise(Xint-1, Yint-1);
double n02 = Noise(Xint+1, Yint-1);
double n03 = Noise(Xint-1, Yint+1);
double n04 = Noise(Xint+1, Yint+1);
double n05 = Noise(Xint-1, Yint);
double n06 = Noise(Xint+1, Yint);
double n07 = Noise(Xint, Yint-1);
double n08 = Noise(Xint, Yint+1);
double n09 = Noise(Xint, Yint);
double n12 = Noise(Xint+2, Yint-1);
double n14 = Noise(Xint+2, Yint+1);
double n16 = Noise(Xint+2, Yint);
double n23 = Noise(Xint-1, Yint+2);
double n24 = Noise(Xint+1, Yint+2);
double n28 = Noise(Xint, Yint+2);
double n34 = Noise(Xint+2, Yint+2);
//find the noise values of the four corners
double x0y0 = 0.0625*(n01+n02+n03+n04) + 0.125*(n05+n06+n07+n08) + 0.25*(n09);
double x1y0 = 0.0625*(n07+n12+n08+n14) + 0.125*(n09+n16+n02+n04) + 0.25*(n06);
double x0y1 = 0.0625*(n05+n06+n23+n24) + 0.125*(n03+n04+n09+n28) + 0.25*(n08);
double x1y1 = 0.0625*(n09+n16+n28+n34) + 0.125*(n08+n14+n06+n24) + 0.25*(n04);
//interpolate between those values according to the x and y fractions
double v1 = Interpolate(x0y0, x1y0, Xfrac); //interpolate in x direction (y)
double v2 = Interpolate(x0y1, x1y1, Xfrac); //interpolate in x direction (y+1)
double fin = Interpolate(v1, v2, Yfrac); //interpolate in y direction
return fin;
}
double PerlinNoise::Interpolate(double x, double y, double a) const
{
double negA = 1.0 - a;
double negASqr = negA * negA;
double fac1 = 3.0 * (negASqr) - 2.0 * (negASqr * negA);
double aSqr = a * a;
double fac2 = 3.0 * aSqr - 2.0 * (aSqr * a);
return x * fac1 + y * fac2; //add the weighted factors
}
double PerlinNoise::Noise(int x, int y) const
{
int n = x + y * 57;
n = (n << 13) ^ n;
int t = (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff;
return 1.0 - double(t) * 0.931322574615478515625e-9;/// 1073741824.0);
}

44
testbed/common/PerlinNoise.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef PERLIN_NOISE_H
#define PERLIN_NOISE_H
/// Class PerlinNoise
/// Code from http://stackoverflow.com/questions/4753055/perlin-noise-generation-for-terrain
class PerlinNoise {
public:
// Constructor
PerlinNoise();
PerlinNoise(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);
// Get Height
double GetHeight(double x, double y) const;
// Get
double Persistence() const { return persistence; }
double Frequency() const { return frequency; }
double Amplitude() const { return amplitude; }
int Octaves() const { return octaves; }
int RandomSeed() const { return randomseed; }
// Set
void Set(double _persistence, double _frequency, double _amplitude, int _octaves, int _randomseed);
void SetPersistence(double _persistence) { persistence = _persistence; }
void SetFrequency( double _frequency) { frequency = _frequency; }
void SetAmplitude( double _amplitude) { amplitude = _amplitude; }
void SetOctaves( int _octaves) { octaves = _octaves; }
void SetRandomSeed( int _randomseed) { randomseed = _randomseed; }
private:
double Total(double i, double j) const;
double GetValue(double x, double y) const;
double Interpolate(double x, double y, double a) const;
double Noise(int x, int y) const;
double persistence, frequency, amplitude;
int octaves, randomseed;
};
#endif

2
testbed/scenes/heightfield/HeightFieldScene.cpp
View File

@ -164,7 +164,7 @@ void HeightFieldScene::reset() {
rp3d::Transform transform(rp3d::Vector3(0, 0, 0), initOrientation);
mHeightField->resetTransform(transform);
rp3d::Vector3 spherePos(-3.6, 15, 1.7);
rp3d::Vector3 spherePos(0, 13, 0);
rp3d::Transform sphereTransform(spherePos, initOrientation);
mBox->resetTransform(sphereTransform);
}