public void LoadViewMatrix(JCamera camera)
{
Matrix4 viewMatrix = JMathUtils.createViewMatrix(camera);
base.loadMatrix(location_viewMatrix, viewMatrix);
base.LoadVector(location_cameraPosition, camera.Position);
}
private Vector3 CalculateNormal(int x, int z, float[,] noiseMap)
{
if (x == 0)
{
x = 1;
}
if (z == 0)
{
z = 1;
}
if (z == (VERTEX_COUNT - 1))
{
z = (VERTEX_COUNT - 2);
}
if (x == (VERTEX_COUNT - 1))
{
x = (VERTEX_COUNT - 2);
}
float heightL = JMathUtils.HeightCurve2(noiseMap[x - 1, z]) * MAX_HEIGHT;
float heightR = JMathUtils.HeightCurve2(noiseMap[x + 1, z]) * MAX_HEIGHT;
float heightD = JMathUtils.HeightCurve2(noiseMap[x, z - 1]) * MAX_HEIGHT;
float heightU = JMathUtils.HeightCurve2(noiseMap[x, z + 1]) * MAX_HEIGHT;
Vector3 normal = new Vector3(heightL - heightR, 2f, heightD - heightU);
normal.Normalize();
return(normal);
}
public float GetHeightOfTerrain(float worldX, float worldZ)
{
float terrainX = worldX - this.X;
float terrainZ = worldZ - this.Z;
float gridSquareSize = SIZE / ((float)heights.GetLength(0) - 1);
int gridX = (int)Math.Floor(terrainX / gridSquareSize);
int gridZ = (int)Math.Floor(terrainZ / gridSquareSize);
if (gridX >= heights.GetLength(0) - 1 || gridZ >= heights.GetLength(1) - 1 || gridX < 0 || gridZ < 0)
{
return(0);
}
float xCoord = (terrainX % gridSquareSize) / gridSquareSize;
float zCoord = (terrainZ % gridSquareSize) / gridSquareSize;
float answer;
if (xCoord <= (1 - zCoord))
{
answer = JMathUtils.BarryCentric(new Vector3(0, heights[gridX, gridZ], 0), new Vector3(1,
heights[gridX + 1, gridZ], 0), new Vector3(0,
heights[gridX, gridZ + 1], 1), new Vector2(xCoord, zCoord));
}
else
{
answer = JMathUtils.BarryCentric(new Vector3(1, heights[gridX + 1, gridZ], 0), new Vector3(1,
heights[gridX + 1, gridZ + 1], 1), new Vector3(0,
heights[gridX, gridZ + 1], 1), new Vector2(xCoord, zCoord));
}
return(answer);
}
/// <summary>
/// Generate a float[mapWidth,mapHeight] containing values in the range [0,1] based on PerlinNoise algorithm.
/// </summary>
/// <param name="mapWidth"></param>
/// <param name="mapHeight"></param>
/// <param name="scale"></param>
/// <param name="octaves">The number of octives. Must be greater than 0.</param>
/// <param name="persistance">A value, in the range 0 to 1, commonly 0.5.</param>
/// <param name="lacunarity">A value, greater than 1, commonly 2.</param>
/// <returns>A float array of "randomly" distributed values.</returns>
public static float[,] GenerateNoiseMap(int mapWidth, int mapHeight, float scale, int octaves, float persistance, float lacunarity)
{
float[,] noiseMap = new float[mapWidth, mapHeight];
float maxNoiseHeight = float.MinValue;
float minNoiseHeight = float.MaxValue;
if (scale <= 0)
{
scale = 0.0001f;
}
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
float amplitude = 1;
float frequency = 1;
float noiseHeight = 0;
for (int i = 0; i < octaves; i++)
{
float sampleX = (x / scale) * frequency;
float sampleY = (y / scale) * frequency;
float perlinValue = (float)JPerlinNoise.GetNoise((double)sampleX, (double)sampleY, (double)1.0f) * 2 - 1;
noiseHeight += perlinValue * amplitude;
// Amplitude decreases each octive.
amplitude *= persistance;
// Frequency increases each octive.
frequency *= lacunarity;
}
// Track the minimum and maximum values within noiseMap.
if (noiseHeight > maxNoiseHeight)
{
maxNoiseHeight = noiseHeight;
}
else if (noiseHeight < minNoiseHeight)
{
minNoiseHeight = noiseHeight;
}
noiseMap[x, y] = noiseHeight;
}
}
// Map the noiseMap values to the range [0,1].
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
noiseMap[x, y] = JMathUtils.InvLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x, y]);
}
}
return(noiseMap);
}
private void prepareInstance(JEntity entity)
{
//Matrix4 transformationMatrix = JMathUtils.createTransformationMatrix(entity.Position, entity.RotX, entity.RotY, entity.RotZ, entity.Scale);
//JMathUtils.testTransformationMatrix(entity.Position, entity.Orientation, entity.Scale);
Matrix4 transformationMatrix = JMathUtils.testTransformationMatrix(entity.Position, entity.Orientation, entity.Scale);
Shader.LoadTransformationMatrix(transformationMatrix);
}
private JRawModel generateTerrain(JLoader loader)
{
Console.WriteLine("Generating terrain...");
float[,] test = JNoise.GenerateNoiseMap(100, 100, 20.0f, 4, 0.5f, 2.0f);
int count = VERTEX_COUNT * VERTEX_COUNT;
heights = new float[VERTEX_COUNT, VERTEX_COUNT];
float[] vertices = new float[count * 3];
float[] normals = new float[count * 3];
float[] textureCoords = new float[count * 2];
uint[] indices = new uint[6 * (VERTEX_COUNT - 1) * (VERTEX_COUNT - 1)];
int vertexPointer = 0;
for (int i = 0; i < VERTEX_COUNT; i++)
{
for (int j = 0; j < VERTEX_COUNT; j++)
{
vertices[vertexPointer * 3] = (float)j / ((float)VERTEX_COUNT - 1) * SIZE;
float height = JMathUtils.HeightCurve2(test[j, i]) * MAX_HEIGHT;
vertices[vertexPointer * 3 + 1] = height;
heights[j, i] = height;
vertices[vertexPointer * 3 + 2] = (float)i / ((float)VERTEX_COUNT - 1) * SIZE;
Vector3 normal = CalculateNormal(j, i, test);
normals[vertexPointer * 3] = normal.X;
normals[vertexPointer * 3 + 1] = normal.Y;
normals[vertexPointer * 3 + 2] = normal.Z;
textureCoords[vertexPointer * 2] = (float)j / ((float)VERTEX_COUNT - 1);
textureCoords[vertexPointer * 2 + 1] = (float)i / ((float)VERTEX_COUNT - 1);
vertexPointer++;
}
}
int pointer = 0;
for (uint gz = 0; gz < VERTEX_COUNT - 1; gz++)
{
for (uint gx = 0; gx < VERTEX_COUNT - 1; gx++)
{
uint topLeft = (uint)(gz * VERTEX_COUNT) + gx;
uint topRight = topLeft + 1;
uint bottomLeft = (uint)((gz + 1) * VERTEX_COUNT) + gx;
uint bottomRight = bottomLeft + 1;
indices[pointer++] = topLeft;
indices[pointer++] = bottomLeft;
indices[pointer++] = topRight;
indices[pointer++] = topRight;
indices[pointer++] = bottomLeft;
indices[pointer++] = bottomRight;
}
}
Console.WriteLine("Terrain generation complete...");
return(loader.LoadToVAO(vertices, textureCoords, normals, indices));
}
public void Render(List <JWaterTile> waterTiles, JCamera camera, JLight light)
{
PrepareRender(camera, light);
foreach (JWaterTile tile in waterTiles)
{
Matrix4 modelMatrix = JMathUtils.createTransformationMatrix(new Vector3(tile.X, tile.Height, tile.Z), 0, 0, 0, JWaterTile.TILE_SIZE);
WaterShader.LoadModelMatrix(modelMatrix);
GL.DrawArrays(PrimitiveType.Triangles, 0, WaterQuad.vertexCount);
}
Unbind();
}
public JMasterRenderer(JTerrainTexturePack texturePack)
{
terrains = new List <JPerlinTerrain>();
skyRed = 0.5f;
skyGreen = 0.5f;
skyBlue = 0.5f;
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Back);
this.projectionMatrix = JMathUtils.createProjectionMatrix(JConfig.FOV, JConfig.NEAR_PLANE, JConfig.FAR_PLANE);
this.Shader = new JStaticShader();
this.TerrainShader = new JTerrainShader();
this.Renderer = new JEntityRenderer(Shader, projectionMatrix);
this.TerrainRenderer = new JTerrainRenderer(TerrainShader, projectionMatrix, texturePack);
this.Entities = new Dictionary <JTexturedModel, List <JEntity> >();
}
private void LoadModelMatrix(JPerlinTerrain terrain)
{
Matrix4 transformationMatrix = JMathUtils.createTransformationMatrix(new Vector3(terrain.X, 0, terrain.Z), 0, 0, 0, 1);
TerrainShader.LoadTransformationMatrix(transformationMatrix);
}
/// <summary>
/// Use an offset to sample JPerlinNoise at a random location rather than a consistent location. Not working quite right yet.
/// </summary>
/// <param name="mapWidth"></param>
/// <param name="mapHeight"></param>
/// <param name="seed"></param>
/// <param name="scale"></param>
/// <param name="octaves">The number of octives. Must be greater than 0.</param>
/// <param name="persistance">A value, in the range 0 to 1, commonly 0.5.</param>
/// <param name="lacunarity">A value, greater than 1, commonly 2.</param>
/// <returns></returns>
public static float[,] GenerateNoiseMap(int mapWidth, int mapHeight, int seed, float scale, int octaves, float persistance, float lacunarity)
{
float[,] noiseMap = new float[mapWidth, mapHeight];
float maxNoiseHeight = float.MinValue;
float minNoiseHeight = float.MaxValue;
Random rand = new Random(seed);
Vector2[] octaveOffsets = new Vector2[octaves];
for (int i = 0; i < octaves; i++)
{
float offsetX = rand.Next(-5, 5) / scale;
float offsetY = rand.Next(-5, 5) / scale;
octaveOffsets[i] = new Vector2(offsetX, offsetY);
}
if (scale <= 0)
{
scale = 0.0001f;
}
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
float amplitude = 1;
float frequency = 1;
float noiseHeight = 0;
for (int i = 0; i < octaves; i++)
{
float sampleX = (x / scale) * frequency + octaveOffsets[i].X;
float sampleY = (y / scale) * frequency + octaveOffsets[i].Y;
float perlinValue = (float)JPerlinNoise.GetNoise((double)sampleX, (double)sampleY, (double)1.0f) * 2 - 1;
noiseHeight += perlinValue * amplitude;
// Amplitude decreases each octive.
amplitude *= persistance;
// Frequency increases each octive.
frequency *= lacunarity;
}
// Track the minimum and maximum values with noiseMap.
if (noiseHeight > maxNoiseHeight)
{
maxNoiseHeight = noiseHeight;
}
else if (noiseHeight < minNoiseHeight)
{
minNoiseHeight = noiseHeight;
}
noiseMap[x, y] = noiseHeight;
}
}
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
noiseMap[x, y] = JMathUtils.InvLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x, y]);
}
}
return(noiseMap);
}
public void LoadViewMatrix(JCamera camera)
{
Matrix4 viewMatrix = JMathUtils.createViewMatrix(camera);
base.loadMatrix(location_viewMatrix, viewMatrix);
}
