I placed a SimpleVector at the x and z position of my player, and the y will always be 0,
I did this to get the actual height of the terrain at x,z.
So that when the SimpleVector is above the terrain, it should return 25 and below the terrain a -25 or whatever
then negativating (as far as thats a word) would return the actual terrain height.
The calcMinDistance does not work when 'looking at' the bottom of a vertex (eg, not dualsided)
terrHeightUp = ground.calcMinDistance(heightCalcPos, new SimpleVector(0,-1,0), 100); // always 2147483647
terrHeightDown = ground.calcMinDistance(heightCalcPos, new SimpleVector(0,1,0), 100);
The terrHeightUp should be when the SimpleVector (heightCalcPos) is below the terrain and return the terrein height in negative value.
but as the terrain is not dual sided it looks straight through it and always returning 2147483647.
Is there a (simple) solution for this?
Or should I make the terrain dualsided (cpu and memory eating process), if so, how?
Current terrain generating script:
public class Terrain {
//private static float[][] terrain = new float[128][128];
//private static Object3D ground = null;
public static Object3D Generate(int X_SIZE, int Z_SIZE, TextureManager tm, String TextureID){
/** Generate ground **/
//int X_SIZE = 128;
//int Z_SIZE = 128;
float[][] terrain = new float[X_SIZE][Z_SIZE];
for (int x = 0; x < X_SIZE; x++) {
for (int z = 0; z < Z_SIZE; z++) {
terrain[x][z] = -20 + (float) Math.random() * 40f; // Very simple....
}
}
for (int x = 0; x < X_SIZE - 1; x++) {
for (int z = 0; z < Z_SIZE - 1; z++) {
terrain[x][z] = (terrain[x][z] + terrain[x + 1][z] + terrain[x][z + 1] + terrain[x + 1][z + 1]) / 4;
}
}
Object3D ground = new Object3D(X_SIZE * Z_SIZE * 2);
float xSizeF = (float) X_SIZE;
float zSizeF = (float) Z_SIZE;
int id = tm.getTextureID(TextureID);
for (int x = 0; x < X_SIZE - 1; x++) {
for (int z = 0; z < Z_SIZE - 1; z++) {
/**
* We are now taking the heights calculated above and build the
* actual triangles using this data. The terrain's grid is fixed
* in x and z direction and so are the texture coordinates. The
* only part that varies is the height, represented by the data
* in terrain[][]. jPCT automatically takes care of vertex
* sharing and mesh optimizations (this is why building objects
* this way isn't blazing fast...but it pays out in the
* end...:-)) The Mesh is build with triangle strips in mind
* here. The format for these strips is equal to that of
* OpenGL's triangle strips.
*/
TextureInfo ti = new TextureInfo(id, (x / xSizeF), (z / zSizeF), ((x + 1) / xSizeF), (z / zSizeF), (x / xSizeF), ((z + 1) / zSizeF));
ground.addTriangle(new SimpleVector(x * 10, terrain[x][z], z * 10), new SimpleVector((x + 1) * 10, terrain[x + 1][z], z * 10),
new SimpleVector(x * 10, terrain[x][z + 1], (z + 1) * 10), ti);
ti = new TextureInfo(id, (x / xSizeF), ((z + 1) / zSizeF), ((x + 1) / xSizeF), (z / zSizeF), ((x + 1) / xSizeF), ((z + 1) / zSizeF));
ground.addTriangle(new SimpleVector(x * 10, terrain[x][z + 1], (z + 1) * 10), new SimpleVector((x + 1) * 10, terrain[x + 1][z], z * 10), new SimpleVector((x + 1) * 10,
terrain[x + 1][z + 1], (z + 1) * 10), ti);
}
}
return ground;
}
}
Optional:
I would like to use height-maps instead of randomly generated terrain.
How would I go on about that?
Kind regards,
Kaiidyn.