/// <summary>Create a random translation matrix.</summary>
/// <param name="self"></param>
/// <param name="min"></param>
/// <param name="max"></param>
/// <param name="result"></param>
public static void NextTranslationMatrix4d(this Random self, ref Vector3d min, ref Vector3d max, out Matrix4d result)
{
Vector3d amount;
self.NextVector3dInRange(ref min, ref max, out amount);
Matrix4d.Translate(ref amount, out result);
}
/// <summary>
/// Add fractal brownian motion to the height texture.
/// </summary>
/// <param name="strength"></param>
/// <param name="scale"></param>
/// <param name="offset"></param>
/// <param name="octaves"></param>
/// <param name="lacunarity"></param>
/// <param name="gain"></param>
public void FractalBrownianMotion(float strength, float scale, float offset, int octaves, float lacunarity, float gain)
{
Program.Uniforms["FractalBrownianMotionLacunarity"].Set(lacunarity);
Program.Uniforms["FractalBrownianMotionGain"].Set(gain);
Program.Uniforms["FractalBrownianMotionOctaves"].Set(octaves);
Program.Uniforms["FractalBrownianMotionOffset"].Set(offset);
Program.Uniforms["FractalBrownianMotionScale"].Set(scale);
Program.Uniforms["FractalBrownianMotionStrength"].Set(strength);
Matrix4d perlinTransform = PerlinTransform;
PerlinTransform = Matrix4d.Translate(new Vector3d(TerrainBlock.BlockIndex.X * scale, TerrainBlock.BlockIndex.Y * scale, 0)) * PerlinTransform;
//LoadRandomPerlinTransform();
ProcessHeightAll("FractalBrownianMotionTechnique");
PerlinTransform = perlinTransform;
}
internal void Draw(ref Vector3 viewPoint, ref Matrix4d world, ref Matrix4d view, ref Matrix4d projection)
{
Vector3d worldOffset = WorldOffset;
Matrix4d blockWorld;
Matrix4d.Translate(ref worldOffset, out blockWorld);
blockWorld.Multiply(ref world, out blockWorld);
foreach (TerrainComponent component in Terrain.Components)
{
component.OnDrawing(this, ref blockWorld);
}
DrawSetParameters("draw", ref blockWorld, ref view, ref projection);
Draw(terrain.Program, viewPoint, ref blockWorld);
}
public ProceduralParameters Build()
{
Vector2i detailLevel = new Vector2i(
Math.Max(DetailLevel.X + 1, 3),
Math.Max(DetailLevel.Y + 1, 3));
Vector2d inputSpan = MaxInput - MinInput;
Matrix4d transform = Transform * Matrix4d.Scale(Size) * Matrix4d.Translate(Centre);
// Write the vertices.
int vo = Builder.VertexCount;
for (int y = 0, i = 0; y < detailLevel.Y; y++)
{
for (int x = 0; x < detailLevel.X; x++, i++)
{
Vector2d input = (new Vector2d(x, y) * inputSpan + MinInput) / (Vector2d)(detailLevel - 1);
Vector3d normal;
Vector3d position = transform * SurfaceGenerator(ref input, out normal);
Vector2d texel = TexelGenerator(ref input, ref position, ref normal);
Builder.AddVertex(position);
Builder.SetNormal(normal);
Builder.SetTexel(texel);
}
}
// Write the indices.
for (int y = 0, i = 0; y < detailLevel.Y - 1; y++)
{
int s = vo + y * detailLevel.X, t = s + detailLevel.X;
for (int x = 0; x < detailLevel.X - 1; x++, i += 6, s++, t++)
{
Builder.AddIndices(
s, s + 1, t + 1,
s, t + 1, t);
}
}
Builder.FinishPart(Primitive.Triangles, Material ?? new ModelMaterial());
return(this);
}
public void ColorByElevationAndTilt(Texture2D texture, Length minimumElevation, Length maximumElevation, Angle maximumTilt)
{
Matrix4d transform = Matrix4d.Translate(0, -minimumElevation.InUniversal, 0) * Matrix4d.Scale(1.0 / maximumTilt.InRadians, 1.0 / (maximumElevation - minimumElevation).InUniversal, 1);
ColorByElevationAndTilt(texture, transform);
}
