 I have been working on a heightmap. I can’t get the code to work so that the cube stays on the terrain. When the height is set to a constant number t he cube seems to stay on the terrain. I don’t know who to ask, I’m pulling my hair out!

Here is the code:

``````////////////////////Move in Z direction
//height map is 80 * 80 vertices, 180 size
//move in negative z direction
if (window.isKeyPressed(GLFW_KEY_W)) {

//change in z
gZ += .05f;

// size of height map * scale of display is size of terrain to draw :  180 * .04  = 7.2
// terrain size is 7.2 so 3.6 is in center and height map terrain is 25 times bigger
// because scale of display is .04
float zTerrain = (3.6f + gZ) * 25f;

//height map cell is size of height map divided by (vectors - 1)   :   2.278
//first parameter is x, centered so, half of 79 cells times 2.278
float answer = terrain.getTheHeight(79f * .5f * 2.278f, zTerrain 	,0f,0f,theHeight);
gameItems.setScale(.125f);
//scale of displayed terrain Y is .04 times height map's Y and image is centered on
//displayed terrain
gameItems.setPosition(0.f,  .04f * answer  + 0.0625f,  -3.6f-gZ );
camera.setPosition(0, 1,-gZ);

////////////////////

//////////Make terrain
VERTEX_COUNT = 80;
SIZE = 180;
int count = VERTEX_COUNT * VERTEX_COUNT;
float[] vertices = new float[count * 3];
float[] normals = new float[count * 3];
float[] textureCoords = new float[count*2];
int[] indices2 = new int[6*(VERTEX_COUNT-1)*(VERTEX_COUNT-1)];
int vertexPointer = 0;

for(int i=-40;i<(VERTEX_COUNT/2);i++){
for(int j=-40;j<(VERTEX_COUNT/2);j++){
vertices[vertexPointer*3] = (float)j/((float)VERTEX_COUNT - 1) * SIZE;

tempHeight = terrain.getHeight(j+40, i+40, image);
vertices[vertexPointer*3+1] =  tempHeight;
theHeight[j + 40][i + 40] = tempHeight;
vertices[vertexPointer*3+2] = (float)i/((float)VERTEX_COUNT - 1) * SIZE;
//normals[vertexPointer*3] = 0;
//normals[vertexPointer*3+1] = 1;
//normals[vertexPointer*3+2] = 0;
textureCoords[vertexPointer*2] = (float)j/((float)VERTEX_COUNT - 1);
textureCoords[vertexPointer*2+1] = (float)i/((float)VERTEX_COUNT - 1);
vertexPointer++;
}
}
int pointer = 0;
for(int gz=-0;gz<(VERTEX_COUNT-1);gz++){
for(int gx =-0;gx<(VERTEX_COUNT-1);gx++){
int topLeft = (gz*VERTEX_COUNT)+gx;
int topRight = topLeft + 1;
int bottomLeft = ((gz+1)*VERTEX_COUNT)+gx;
int bottomRight = bottomLeft + 1;
indices2[pointer++] = topLeft;
indices2[pointer++] = bottomLeft;
indices2[pointer++] = topRight;
indices2[pointer++] = topRight;
indices2[pointer++] = bottomLeft;
indices2[pointer++] = bottomRight;

}
}

//////////

/////////////Part of terrain class
public float getHeight(int x, int z, BufferedImage image)
{
//image is 256 x 256, 32 bit png
float height = image.getRGB(x, z);

//MAX_PIXEL_COLOUR = 256 * 256 * 256
//MAX_HEIGHT = 40
height  += MAX_PIXEL_COLOUR/2f;
height /= MAX_PIXEL_COLOUR/2f;
height *= MAX_HEIGHT;

return height;
}

public static float barryCentric(Vector3f p1, Vector3f p2, Vector3f p3, Vector2f pos) {
float det = (p2.z - p3.z) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.z - p3.z);
float l1 = ((p2.z - p3.z) * (pos.x - p3.x) + (p3.x - p2.x) * (pos.y - p3.z)) / det;
float l2 = ((p3.z - p1.z) * (pos.x - p3.x) + (p1.x - p3.x) * (pos.y - p3.z)) / det;
float l3 = 1.0f - l1 - l2;
return l1 * p1.y + l2 * p2.y + l3 * p3.y;
}

public float getTheHeight(float worldX, float worldZ, float xOfGrid, float zOfGrid , float [][]theHeights)
{
//world coordinates not used yet
float terrainX = worldX - xOfGrid;
float terrainZ = worldZ - zOfGrid;
//gridsquaresize = grid size / vertex - 1
//180 / 79 = 2.278f
float gridSquareSize = 2.278f;
int gridX = (int) Math.floor(terrainX/gridSquareSize);
int gridZ = (int) Math.floor(terrainZ/gridSquareSize);

float xCoord = (terrainX % gridSquareSize)/gridSquareSize;
float zCoord = (terrainZ % gridSquareSize)/gridSquareSize;

if (xCoord <= (1-zCoord))
{
answer = barryCentric(new Vector3f(0, theHeights[gridX][gridZ], 0), new Vector3f(1,
theHeights[gridX + 1][gridZ], 0), new Vector3f(0,
theHeights[gridX][gridZ + 1], 1), new Vector2f(xCoord, zCoord));
}else
{
answer = barryCentric(new Vector3f(1, theHeights[gridX + 1][gridZ], 0), new Vector3f(1,
theHeights[gridX + 1][gridZ + 1], 1), new Vector3f(0,
theHeights[gridX][gridZ + 1], 1), new Vector2f(xCoord, zCoord));
}