public void CreateTerrain()
{
float x = 0f;
float[] height = new float[256 * 256];
ImprovedPerlin improvedPerlin = new ImprovedPerlin(0, LibNoise.NoiseQuality.Best);
for (int i = 0; i < 256 * 256; i++)
{
height[i] = improvedPerlin.GetValue(x / 10, x / 10, x * 100) / 3.5f + 1;
//if (height[i] > 1.1f)
//{
// height[i] = height[i] * 0.8f;
//}
//else if (height[i] < 0.9f)
//{
// height[i] = height[i] * 1.2f;
//}
x += 0.001f;
}
SendMessageAndOnResponse(mainCommand.TerrainAdd(new int[] { 256, 256 }, height, "terrain"), "terrain",
(message) =>
{
SendMessageAndOnResponse(mainCommand.renderTerrain("renderTerrain"), "renderTerrain",
(message) =>
{
terrainId = JSONParser.GetTerrainID(message);
string addLayerMsg = mainCommand.AddLayer(terrainId, "addLayer");
SendMessageAndOnResponse(addLayerMsg, "addLayer", (message) => Console.WriteLine(""));
});
});
}
public static T[,] CreateTileDistribution <T>(int width, int height, float scale, float coverage)
{
T[,] output = new T[width, height];
//generate noise
ImprovedPerlin perlin = new ImprovedPerlin();
MultiFractal fractal = new MultiFractal();
fractal.Primitive2D = perlin;
fractal.Primitive3D = perlin;
//scale the noise
ScalePoint scaledNoise = new ScalePoint(fractal, scale, scale, scale);
//create output distribution map from scaled noise + coverage
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
float val = scaledNoise.GetValue(x, y, 0.1f);
if (val < coverage)
{
output[x, y] = (T)Activator.CreateInstance(typeof(T));
}
}
}
return(output);
}
public void StartSimulation()
{
Console.WriteLine("simulating bike...");
//Example BLE Message
//4A-09-4E-05-19-16-00-FF-28-00-00-20-F0
this.running = true;
float x = 0.0f;
//Perlin for Random values
ImprovedPerlin improvedPerlin = new ImprovedPerlin(0, LibNoise.NoiseQuality.Best);
while (this.running)
{
CalculateVariables(improvedPerlin.GetValue(x) + 1);
//Simulate sending data
foreach (IDataReceiver dataReceiver in this.dataReceivers)
{
dataReceiver.Bike(GenerateBike0x19());
dataReceiver.Bike(GenerateBike0x10());
dataReceiver.BPM(GenerateHeart());
}
Thread.Sleep(1000);
x += 0.1f;
eventCounter++;
elapsedTime++;
}
}
public Region(int seed, int size = 4096)
{
Seed = seed;
RegionSize = size;
Chunks = new Dictionary <Tuple <int, int>, Chunk>();
_perlin = new ImprovedPerlin(Seed, NoiseQuality.Best);
}
private void GenWorld()
{
// Create rotation for noise (so they are less likely to be integers)
Quaternion rot = Quaternion.Euler(45, 45, 45);
// Create new grid
grid = new float[width, height];
/*Vector3 initialArgs =
* new Vector3((transform.position.x / transform.lossyScale.x) * (float)width,
* (transform.position.y / transform.lossyScale.y) * (float)height,
* seed);
*
* Vector3 diff = new Vector3(1, 1, 0);*/
Vector3 initialArgs = transform.position;
initialArgs.z = Seed;
Vector3 diff = new Vector3(transform.lossyScale.x / (float)width,
transform.lossyScale.y / (float)height,
0);
for (int y = 0; y < height; ++y)
{
for (int x = 0; x < width; ++x)
{
// Initialise perlin arguments
//Vector3 perlinArgs =
// new Vector3(x / (float)width, y / (float)height, seed);
/*Vector3 perlinArgs =
* new Vector3(x, y, seed);
*
* perlinArgs.x += (transform.position.x / transform.lossyScale.x) * (float)width;
* perlinArgs.y += (transform.position.y / transform.lossyScale.y) * (float)height;*/
Vector3 perlinArgs = initialArgs + new Vector3(diff.x * x, diff.y * y, 0);
perlinArgs.Scale(noiseScale);
// Rotate perlin args so they're unlikely to be integers
perlinArgs = rot * perlinArgs;
// Generate perlin noise
float perlin = ImprovedPerlin.Noise(perlinArgs.x, perlinArgs.y, perlinArgs.z);
// Set grid values to noise
grid[x, y] = perlin;
}
}
}
public float getValue(Vector2 cubeWorldPosition)
{
this.frequency = 0.5f;
this.lacunarity = 2;
this.offset = 1;
this.gain = 2;
this.exponent = 1f;
this.octaveCount = 4f;
ImprovedPerlin perlin = new ImprovedPerlin(seed, NoiseQuality.Standard);
return(this.finalModule.GetValue(cubeWorldPosition.X, cubeWorldPosition.Y));
}
public string RouteCommand(string serialToSend)
{
ImprovedPerlin improvedPerlin = new ImprovedPerlin(4325, LibNoise.NoiseQuality.Best);
Random r = new Random();
dynamic payload = new
{
id = "route/add",
serial = serialToSend,
data = new
{
nodes = new dynamic[]
{
new
{
/*pos = GetPos(0.6f, improvedPerlin)*/
pos = new int[] { 0, 0, 5 },
dir = new int[] { r.Next(20, 100), 0, -r.Next(20, 100) }
},
new
{
//pos = GetPos(1.6f, improvedPerlin),
pos = new int[] { 50, 0, 0 },
dir = new int[] { r.Next(20, 100), 0, r.Next(20, 100) }
},
new
{
//pos = GetPos(2.654f, improvedPerlin),
pos = new int[] { 20, 0, 20 },
dir = new int[] { r.Next(20, 100), 0, r.Next(20, 100) }
},
new
{
//pos = GetPos(3.6543f, improvedPerlin),
pos = new int[] { 10, 0, 50 },
dir = new int[] { -r.Next(3, 7), 0, r.Next(3, 7) }
},
new
{
pos = new int[] { 0, 0, 50 },
dir = new int[] { -r.Next(20, 50), 0, -r.Next(20, 50) }
}
}
}
};
//Console.WriteLine("route command: " + JsonConvert.SerializeObject(Payload(payload)));
return(JsonConvert.SerializeObject(Payload(payload)));
}
// Use this for initialization
void Start()
{
if (targetTerrain == null)
{
targetTerrain = Terrain.activeTerrain;
}
if (targetTerrain == null)
{
Debug.LogError("Please add a terrain object to the scene.");
}
terrainData = targetTerrain.terrainData;
resolution = terrainData.heightmapResolution;
cacheHeights = new float[resolution, resolution];
perlin = new ImprovedPerlin();
}
// Use this for initialization
void Start()
{
// generate the mesh
planeMesh = PlaneHelper.CreatePlane(resolution, resolution);
// add this whenever you'll be updating the mesh frequently
planeMesh.MarkDynamic();
// add these components for our GameObject to be able to display meshes
MeshFilter mf = gameObject.AddComponent <MeshFilter>();
MeshRenderer mr = gameObject.AddComponent <MeshRenderer>();
// assign our new mesh to this gameobject
// sharedMesh means the data will be a pointer instead of copied
mf.sharedMesh = planeMesh;
mr.material = material;
// cache the vertex array so we won't need to allocate each frame
cacheVertices = planeMesh.vertices;
perlin = new ImprovedPerlin();
}
public IModule3D CreateModule(int globalSeed)
{
PrimitiveModule primitiveModule = null;
switch (primative)
{
case NoisePrimitive.Constant:
primitiveModule = new Constant(offset);
break;
case NoisePrimitive.Cylinders:
primitiveModule = new Cylinders(offset);
break;
case NoisePrimitive.Spheres:
primitiveModule = new Spheres(offset);
break;
case NoisePrimitive.BevinsGradient:
primitiveModule = new BevinsGradient();
break;
case NoisePrimitive.BevinsValue:
primitiveModule = new BevinsValue();
break;
case NoisePrimitive.ImprovedPerlin:
primitiveModule = new ImprovedPerlin();
break;
case NoisePrimitive.SimplexPerlin:
primitiveModule = new SimplexPerlin();
break;
}
primitiveModule.Quality = quality;
primitiveModule.Seed = globalSeed + seed;
return((IModule3D)primitiveModule);
}
private void Awake()
{
StartCoroutine(Generate());
perlin = new ImprovedPerlin();
}
private void Awake()
{
StartCoroutine(Generate());
perlin = new ImprovedPerlin ();
}
protected override void CreateNoise(IGH_DataAccess DA, int seed, NoiseQuality noiseQuality)
{
noise = new ImprovedPerlin(seed, noiseQuality);
}
internal static HeightMapModel Create(WorldModel world)
{
var terrainNames = TerrainType.GetTypes()
.OrderBy(x => x.BaseHeight)
.ToArray();
var noiseMap = new LibNoise.Builder.NoiseMap(world.Width, world.Height)
{
BorderValue = 0.0f
};
var noise = new ImprovedPerlin()
{
Quality = LibNoise.NoiseQuality.Best,
Seed = DateTime.Now.Millisecond
};
var noiseBuilder = new LibNoise.Builder.NoiseMapBuilderPlane(0.0f, 3.0f, 0.0f, 3.0f, true)
{
SourceModule = new HybridMultiFractal
{
Primitive3D = noise,
//Lacunarity = 1.8f,
//Frequency =2.0f
},
//SourceModule = new Turbulence
//{
// Power = 0.125f,
// XDistortModule = noise,
// YDistortModule = noise,
// ZDistortModule = noise,
// SourceModule = new ScaleBias()
// {
// Scale = 10.0f,
// //Bias = 8.0f,
// SourceModule = new LibNoise.Modifier.Select(
// controlModule: new Pipe()
// {
// Frequency = 0.5f,
// Lacunarity = 0.25f,
// Primitive3D = noise
// },
// leftModule: new ScaleBias
// {
// Scale = 0.125f,
// Bias = -0.75f,
// SourceModule = new Billow
// {
// Frequency = 2.0f,
// Primitive3D = noise
// }
// },
// rightModule: new RidgedMultiFractal
// {
// Primitive3D = noise,
// Lacunarity = 2.0f,
// },
// edge: 0.125f,
// lower: 0.0f,
// upper: 1000.0f
// )
// }
//},
NoiseMap = noiseMap
};
noiseBuilder.SetSize(world.Width, world.Height);
noiseBuilder.Build();
var heights = noiseMap.Share().Select(x => (double)x).ToList();
//float max = 0.0f, min = 0.0f;
//noiseMap.MinMax(out min, out max);
return(new HeightMapModel
{
Heights = heights.ToArray(),
TerrainTypes = heights.Select(x =>
{
var selected = terrainNames.SkipWhile(terrain => terrain.BaseHeight <= x).FirstOrDefault();
return selected ?? terrainNames.Last();
}).Select(x => x.Id).ToArray(),
Width = world.Width,
Height = world.Height
});
}
private static ushort[] GenerateLandmass(Vector2I chunkCoords)
{
float globalScale = 1.0F;
float baseLandmassScale = 0.005F; // lower => wider. yeah ik.
float detailBias = 0.0F;
float oceanLevel = 63;
float landDeformity = 40;
float oceanDeformity = 20;
float landMaxHeight = oceanLevel + landDeformity;
float oceanMaxDepth = oceanLevel - oceanDeformity;
float mountainsDeformity = 10;
float moutainsScale = 0.01F;
float maxLevel = 63 + 40;
// this is meant to be used as a 2D base for continents apparently unused \/
IModule3D baseLandmass = new ImprovedPerlin(World.Seed.Value, NoiseQuality.Best);
var billow = new Billow
{
Primitive3D = baseLandmass,
OctaveCount = 5.0F,
Frequency = 0.9F,
};
IModule3D detailsLandmass = new ImprovedPerlin(World.Seed.Value * 123456, NoiseQuality.Best);
detailsLandmass = new ScaleBias(detailsLandmass, .2F, detailBias);
baseLandmass = new Add(billow, detailsLandmass);
//LibNoise.Modifier.Exponent baseLandExp = new Exponent(baseLandmass, 1.0F);
//var combiner = new LibNoise.Combiner.Add(baseLandmass1, baseLandmass1);
float oceanCoverage = 0.5F;
ushort airID = ItemCache.GetIndex("winecrash:air");
ushort stoneID = ItemCache.GetIndex("winecrash:stone");
ushort[] indices = new ushort[Chunk.Width * Chunk.Height * Chunk.Depth];
Vector3F shift = Vector3F.Zero;
Vector3F basePos = new Vector3F((chunkCoords.X * Chunk.Width) + shift.X, shift.Y, (chunkCoords.Y * Chunk.Depth) + shift.Z);
for (int i = 0; i < Chunk.Width * Chunk.Height * Chunk.Depth; i++)
{
//Parallel.For(0, Chunk.Width * Chunk.Height * Chunk.Depth, i =>
//{
indices[i] = airID;
// get, from index, the x,y,z coordinates of the block. Then move it from the basePos x scale.
WMath.FlatTo3D(i, Chunk.Width, Chunk.Height, out int x, out int y, out int z);
if (y > maxLevel)
{
continue;
}
Vector3F finalPos = new Vector3F((basePos.X + x) * baseLandmassScale, basePos.Y + y,
(basePos.Z + z) * baseLandmassScale) * globalScale;
float landMassPct = baseLandmass.GetValue(finalPos.X, 0, finalPos.Z);
// retreive the 2D base land value (as seen from top). If under land cap, it's ocean.
bool isLand = landMassPct > oceanCoverage;
float landPct = (float)Math.Pow(WMath.Remap(landMassPct, oceanCoverage, 1.0F, 0.0F, 1.0F), 2F);
float waterPct = WMath.Remap(landMassPct, 0.0F, oceanCoverage, 0.0F, 1.0F);
float landMassHeight = oceanLevel + (landPct * landDeformity);
int finalLandMassHeight = (int)landMassHeight;
float waterHeight = oceanMaxDepth + (waterPct * oceanDeformity);
int finalWaterHeight = (int)waterHeight;
if (isLand)
{
if (y < finalLandMassHeight)
{
indices[i] = stoneID;
}
}
else if (y == oceanLevel - 1)
{
//indices[i] = waterID;
}
else if (y < oceanLevel - 1)
{
if (y > finalWaterHeight)
{
//indices[i] = waterID;
}
else
{
indices[i] = stoneID;
}
}
// debug: display this as grass / sand.
//indices[i] = y == 63 ? (isLand ? grassID : sandID) : (y > 63 ? airID : debugID);//debug.GetValue(finalPos.X, finalPos.Y, finalPos.Z) < cap ? stoneID : airID;
//});
}
return(indices);
}
/// <summary>
///
/// </summary>
protected void GenerateNoise()
{
EnabledInterface(false);
// Parse input ------------------------------------------------------------------------------------
int seed = ParseInt(_tbxSeed.Text, PrimitiveModule.DefaultSeed);
double frequency = ParseDouble(_tbxFrequency.Text, FilterModule.DEFAULT_FREQUENCY);
double lacunarity = ParseDouble(_tbxLacunarity.Text, FilterModule.DEFAULT_LACUNARITY);
double gain = ParseDouble(_tbxGain.Text, FilterModule.DEFAULT_GAIN);
double offset = ParseDouble(_tbxOffset.Text, FilterModule.DEFAULT_OFFSET);
double exponent = ParseDouble(_tbxExponent.Text, FilterModule.DEFAULT_SPECTRAL_EXPONENT);
var octaveCount = (int)_nstpOctave.Value;
bool seamless = _chkbx.Checked;
GradientColor gradient = GradientColors.Grayscale;
NoiseQuality quality = PrimitiveModule.DefaultQuality;
var primitive = NoisePrimitive.ImprovedPerlin;
var filter = NoiseFilter.SumFractal;
try
{
quality = (NoiseQuality)Enum.Parse(typeof(NoiseQuality), _cbxQuality.Text);
}
catch
{
MessageBox.Show(
String.Format("Unknown quality '{0}'", _cbxQuality.Text),
"Libnoise Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
EnabledInterface(true);
return;
}
try
{
primitive = (NoisePrimitive)Enum.Parse(typeof(NoisePrimitive), _cbxPrimitive.Text);
}
catch
{
MessageBox.Show(
String.Format("Unknown primitive '{0}'", _cbxPrimitive.Text),
"Libnoise Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
EnabledInterface(true);
return;
}
try
{
filter = (NoiseFilter)Enum.Parse(typeof(NoiseFilter), _cbxFilter.Text);
}
catch
{
MessageBox.Show(
String.Format("Unknown filter '{0}'", _cbxFilter.Text),
"Libnoise Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
EnabledInterface(true);
return;
}
switch (_cbxGradient.Text)
{
case "Grayscale":
gradient = GradientColors.Grayscale;
break;
case "Terrain":
gradient = GradientColors.Terrain;
break;
}
// Create module tree ------------------------------------------------------------------------------------
PrimitiveModule pModule = null;
switch (primitive)
{
case NoisePrimitive.Constant:
pModule = new Constant(offset);
break;
case NoisePrimitive.Cylinders:
pModule = new Cylinders(offset);
seamless = false;
break;
case NoisePrimitive.Spheres:
pModule = new Spheres(offset);
seamless = false;
break;
case NoisePrimitive.BevinsGradient:
pModule = new BevinsGradient();
break;
case NoisePrimitive.BevinsValue:
pModule = new BevinsValue();
break;
case NoisePrimitive.ImprovedPerlin:
pModule = new ImprovedPerlin();
break;
case NoisePrimitive.SimplexPerlin:
pModule = new SimplexPerlin();
break;
}
pModule.Quality = quality;
pModule.Seed = seed;
FilterModule fModule = null;
ScaleBias scale = null;
switch (filter)
{
case NoiseFilter.Pipe:
fModule = new Pipe();
break;
case NoiseFilter.SumFractal:
fModule = new SumFractal();
break;
case NoiseFilter.SinFractal:
fModule = new SinFractal();
break;
case NoiseFilter.MultiFractal:
fModule = new MultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(fModule, 1, -0.8);
break;
case NoiseFilter.Billow:
fModule = new Billow();
((Billow)fModule).Bias = -0.2;
((Billow)fModule).Scale = 2;
break;
case NoiseFilter.HeterogeneousMultiFractal:
fModule = new HeterogeneousMultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(fModule, -1, 2);
break;
case NoiseFilter.HybridMultiFractal:
fModule = new HybridMultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(fModule, 0.7, -2);
break;
case NoiseFilter.RidgedMultiFractal:
fModule = new RidgedMultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(fModule, 0.9, -1.25);
break;
case NoiseFilter.Voronoi:
fModule = new Voronoi();
break;
}
fModule.Frequency = frequency;
fModule.Lacunarity = lacunarity;
fModule.OctaveCount = octaveCount;
fModule.Offset = offset;
fModule.Offset = offset;
fModule.Gain = gain;
fModule.Primitive3D = (IModule3D)pModule;
IModule3D finalModule;
if (scale == null)
{
finalModule = (IModule3D)fModule;
}
else
{
finalModule = scale;
}
NoiseMapBuilder projection;
switch (_cbxProjection.Text)
{
case "Spherical":
projection = new NoiseMapBuilderSphere();
((NoiseMapBuilderSphere)projection).SetBounds(-90, 90, -180, 180); // degrees
break;
case "Cylindrical":
projection = new NoiseMapBuilderCylinder();
((NoiseMapBuilderCylinder)projection).SetBounds(-180, 180, -10, 10);
break;
case "Planar":
default:
double bound = 2;
projection = new NoiseMapBuilderPlane(bound, bound * 2, bound, bound * 2, seamless);
//projection = new NoiseMapBuilderPlane(-bound, bound, -bound, bound, seamless);
//projection = new NoiseMapBuilderPlane(0, bound, 0, bound, seamless);
break;
}
int width = 0;
int height = 0;
switch (_cbxSize.Text)
{
case "256 x 256":
width = 256;
height = 256;
break;
case "512 x 512":
width = 512;
height = 512;
break;
case "1024 x 1024":
width = 1024;
height = 1024;
break;
case "256 x 128":
width = 256;
height = 128;
break;
case "512 x 256":
width = 512;
height = 256;
break;
case "1024 x 512":
width = 1024;
height = 512;
break;
case "2048 x 1024":
width = 2048;
height = 1024;
break;
default:
case "128 x 128":
width = 128;
height = 128;
break;
}
// ------------------------------------------------------------------------------------------------
// 0 - Initializing
_prbarRenderProgression.Visible = true;
_lblProgressPercent.Visible = true;
_prbarRenderProgression.Value = 0;
;
_lblProgressPercent.Text = "";
_lblLog.Text = String.Format("Create a {0} image with a {1} projection\n", _cbxSize.Text,
_cbxProjection.Text);
var watchDog = new Stopwatch();
TimeSpan ts;
double elaspedTime = 0;
//
// ------------------------------------------------------------------------------------------------
// 1 - Build the noise map
watchDog.Reset();
_prbarRenderProgression.Value = 0;
_lblLog.Text += "Building noise map ... ";
var noiseMap = new NoiseMap();
/*
* // ShapeFilter test
* Bitmap bmpShape = new Bitmap("smileyShape.bmp");
* BitmapAdaptater bmShapeAdaptater = new BitmapAdaptater(bmpShape);
*
* ShapeFilter shapeFilter = new ShapeFilter();
* shapeFilter.Shape = bmShapeAdaptater;
*
* projection.Filter = shapeFilter;
*/
projection.SetSize(width, height);
projection.SourceModule = finalModule;
projection.NoiseMap = noiseMap;
projection.CallBack = delegate(int line)
{
line++;
watchDog.Stop();
//Process message
Application.DoEvents();
_prbarRenderProgression.Value = (line * 100 / height);
_lblProgressPercent.Text = String.Format("{0} % - {1} line(s)", _prbarRenderProgression.Value, line);
watchDog.Start();
};
watchDog.Start();
projection.Build();
watchDog.Stop();
ts = watchDog.Elapsed;
elaspedTime += ts.TotalMilliseconds;
_lblLog.Text += String.Format("{0:00}:{1:00} {2:00},{3:0000}\n",
ts.Hours, ts.Minutes,
ts.Seconds, ts.Milliseconds * 10
);
// ------------------------------------------------------------------------------------------------
// 2 - Render image
// Create a renderer, BitmapAdaptater create a System.Drawing.Bitmap on the fly
watchDog.Reset();
_prbarRenderProgression.Value = 0;
_lblLog.Text += "Rendering image ... ";
var renderer = new ImageRenderer();
renderer.NoiseMap = noiseMap;
renderer.Gradient = gradient;
renderer.LightBrightness = 2;
renderer.LightContrast = 8;
//renderer.LightEnabled = true;
// Libnoise image struct strategy
//Graphics.Tools.Noise.Renderer.Image image = new Graphics.Tools.Noise.Renderer.Image();
//renderer.Image = image;
// Dotnet Bitmap Strategy
var bmpAdaptater = new BitmapAdaptater(width, height);
renderer.Image = bmpAdaptater;
renderer.CallBack = delegate(int line)
{
line++;
watchDog.Stop();
//Process message
Application.DoEvents();
_prbarRenderProgression.Value = (line * 100 / height);
_lblProgressPercent.Text = String.Format("{0} % - {1} line(s)", _prbarRenderProgression.Value, line);
watchDog.Start();
};
// Render the texture.
watchDog.Start();
renderer.Render();
watchDog.Stop();
ts = watchDog.Elapsed;
elaspedTime += ts.TotalMilliseconds;
_lblLog.Text += String.Format("{0:00}:{1:00} {2:00},{3:0000}\n",
ts.Hours, ts.Minutes,
ts.Seconds, ts.Milliseconds * 10
);
//----------------------------------------
// Normalmap rendering test
//
/*
* BitmapAdaptater nmapAdaptater = new BitmapAdaptater(width, height);
* NormalMapRenderer nmap = new NormalMapRenderer();
* nmap.Image = nmapAdaptater;
* nmap.BumpHeight = 30.0;
* nmap.NoiseMap = noiseMap;
* nmap.Render();
* nmapAdaptater.Bitmap.Save("normalMap.png", ImageFormat.Png);
*/
//----------------------------------------
/*
* Heightmap8 heightmap8 = new Heightmap8();
* Heightmap8Renderer heightmapRenderer = new Heightmap8Renderer();
* heightmapRenderer.Heightmap = heightmap8;
*/
/*
* Heightmap16 heightmap16 = new Heightmap16();
* Heightmap16Renderer heightmapRenderer = new Heightmap16Renderer();
* heightmapRenderer.Heightmap = heightmap16;
*/
/*
* Heightmap32 heightmap32 = new Heightmap32();
* Heightmap32Renderer heightmapRenderer = new Heightmap32Renderer();
* heightmapRenderer.Heightmap = heightmap32;
*/
/*
* heightmapRenderer.NoiseMap = noiseMap;
* heightmapRenderer.ExactFit();
* heightmapRenderer.Render();
*/
/*
* Heightmap16RawWriter rawWriter = new Heightmap16RawWriter();
* rawWriter.Heightmap = heightmap16;
* rawWriter.Filename = "heightmap16.raw";
* rawWriter.WriteFile();
*/
// ------------------------------------------------------------------------------------------------
// 3 - Painting
// Save the file
//bmpAdaptater.Bitmap.Save("rendered.png",ImageFormat.Png);
_imageRendered.Width = width;
_imageRendered.Height = height;
//_imageRendered.Image = _bitmap;
_imageRendered.Image = bmpAdaptater.Bitmap;
if (_imageRendered.Width > _panImageViewport.Width)
{
_imageRendered.Left = 0;
}
else
{
_imageRendered.Left = (_panImageViewport.Width - _imageRendered.Width) / 2;
}
if (_imageRendered.Height > _panImageViewport.Height)
{
_imageRendered.Top = 0;
}
else
{
_imageRendered.Top = (_panImageViewport.Height - _imageRendered.Height) / 2;
}
if (_imageRendered.Width > _panImageViewport.Width || _imageRendered.Height > _panImageViewport.Height)
{
_imageRendered.Anchor = (AnchorStyles.Left | AnchorStyles.Top);
_panImageViewport.AutoScroll = true;
}
else
{
_panImageViewport.AutoScroll = false;
}
// ----------------------------------------------------------------
ts = TimeSpan.FromMilliseconds(elaspedTime);
// Format and display the TimeSpan value.
_lblLog.Text += String.Format("Duration : {0:00}:{1:00} {2:00},{3:0000}\n",
ts.Hours, ts.Minutes,
ts.Seconds, ts.Milliseconds * 10
);
EnabledInterface(true);
_prbarRenderProgression.Value = 0;
_lblProgressPercent.Text = "";
_prbarRenderProgression.Visible = false;
_lblProgressPercent.Visible = false;
}
private float[] GetPos(float n, ImprovedPerlin improvedPerlin)
{
float[] res = new float[] { improvedPerlin.GetValue(n) * 50, 0, improvedPerlin.GetValue(n) * 50 };
return(res);
}
public Perlin2DPrimitive(double frequency, double scale, int seed, NoiseQuality quality)
{
this.frequency = frequency;
this.scale = scale;
perlin = new ImprovedPerlin(seed, quality);
}
public NoiseMap Render()
{
PrimitiveModule primitive = null;
switch (this.Primitive)
{
case NoisePrimitive.Constant:
primitive = new Constant(this.Offset);
break;
case NoisePrimitive.Cylinders:
primitive = new Cylinders(this.Offset);
this.Seamless = false;
break;
case NoisePrimitive.Spheres:
primitive = new Spheres(this.Offset);
this.Seamless = false;
break;
case NoisePrimitive.BevinsGradient: primitive = new BevinsGradient(); break;
case NoisePrimitive.BevinsValue: primitive = new BevinsValue(); break;
case NoisePrimitive.ImprovedPerlin: primitive = new ImprovedPerlin(); break;
case NoisePrimitive.SimplexPerlin: primitive = new SimplexPerlin(); break;
}
primitive.Seed = this.Seed;
primitive.Quality = this.NoiseQuality;
FilterModule filter = null;
ScaleBias scale = null;
switch (this.Filter)
{
case NoiseFilter.Pipe: filter = new Pipe(); break;
case NoiseFilter.SumFractal: filter = new SumFractal(); break;
case NoiseFilter.SinFractal: filter = new SinFractal(); break;
case NoiseFilter.MultiFractal:
filter = new MultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(filter, 1f, -0.8f);
break;
case NoiseFilter.Billow:
filter = new Billow();
((Billow)filter).Bias = -0.2f;
((Billow)filter).Scale = 2f;
break;
case NoiseFilter.HeterogeneousMultiFractal:
filter = new HeterogeneousMultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(filter, -1f, 2f);
break;
case NoiseFilter.HybridMultiFractal:
filter = new HybridMultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(filter, 0.7f, -2f);
break;
case NoiseFilter.RidgedMultiFractal:
filter = new RidgedMultiFractal();
// Used to show the difference with our gradient color (-1 + 1)
scale = new ScaleBias(filter, 0.9f, -1.25f);
break;
case NoiseFilter.Voronoi: filter = new Voronoi(); break;
}
filter.Frequency = this.Frequency;
filter.Lacunarity = this.Lacunarity;
filter.OctaveCount = this.OctaveCount;
filter.Offset = this.Offset;
filter.Gain = this.Gain;
filter.Primitive3D = (IModule3D)primitive;
IModule3D final = scale ?? (IModule3D)filter;
NoiseMapBuilder projection;
switch (this.Projection)
{
case NoiseMapProjection.Spherical:
projection = new NoiseMapBuilderSphere();
((NoiseMapBuilderSphere)projection).SetBounds(-90f, 90f, -180f, 180f); // degrees
break;
case NoiseMapProjection.Cylindrical:
projection = new NoiseMapBuilderCylinder();
((NoiseMapBuilderCylinder)projection).SetBounds(-180f, 180f, -10f, 10f);
break;
case NoiseMapProjection.Planar:
default:
float bound = 2f;
projection = new NoiseMapBuilderPlane(bound, bound * 2, bound, bound * 2, this.Seamless);
break;
}
NoiseMap noise = new NoiseMap();
projection.SetSize(this.Width, this.Height);
projection.SourceModule = final;
projection.NoiseMap = noise;
projection.Build();
float min, max;
noise.MinMax(out min, out max);
this.Map = noise;
return(noise);
}
