PerlinNoise | 1D/2D/3D Perlin noise function for Unity | Game Engine library

I have no parent set to these objects and no parent set to the other object as well.

Actually, you do set parent:

I'm not quite sure exactly what you are doing so I'll just tell you how I generally do it. My voxels use some variation of marching cubes so I'll change it a bit to suit what you're doing.

First you can loop though all your voxels and take the center point. Then normalize it. I'm assuming your asteroid has (0.0,0.0,0) in the middle, if not just offset everything. In any case that gives you points around a unit sphere. You can then multiply those points by some constant to get a bigger sphere of points, like say 5 or 10. The bigger the number the higher the frequency of your noise. Play with it until it looks good to you. Next plug those points in 3D nose, Perlin or simplex. Simplex is generally better. This will give you a value from around -1 to 1 for every voxel.

Then you just need to have a base radius for your asteroid. For instance if your voxels go from -10 to +10 in all dimensions you can use a base radius of say 8. If you add that to your noise you get values of roughly 7 to 9 for every voxel all the way around the sphere. If the distance of the center of a voxel to the origin is less than it's calculated number it's solid. If it's greater, it's non-solid. Bingo you're done.

You can also scale your noise up and down to give you higher peaks and lower valleys. And then there are various ways to combine noise to get a lot of different kinds of terrain. The Ridged Multi-Fractal is one of my favorites. With low resolution it's not so important however since you won't see the details anyway.

In the article you linked, the grad() function returns a dot product of two vectors, but I don't see what leads you to say these vectors are expected to have unit magnitude. The sampling position may be continuously anywhere in the cube. Supposing a cube of unit size, the distance vector to the sampling position could have magnitude between 0 and sqrt(3). So, it looks like ||gradient vector|| = sqrt(2) and ||distance vector|| ≤ sqrt(3), bounding the output of grad() between −sqrt(6) and +sqrt(6) (≈ 2.45).

Yes.

See Mathf.PerlinNoise

Any point in the plane can be sampled by passing the appropriate X and Y coordinates. The same coordinates will always return the same sample value [...]

The key word you are looking for is tileable.

But I have a great news for you, noise function such as perlin are periodic in nature. So instead of calling ChunckSize * ChunkSize a noise function you should only call it once and then divide the results.

I will advice you to read this excellent tutorial:

https://www.scratchapixel.com/lessons/procedural-generation-virtual-worlds/procedural-patterns-noise-part-1/creating-simple-1D-noise

It's the gradient set being used. Directions (1, 1) point directly at diagonal neighbors. If those diagonal neighbors have (-1, -1), then they constructively interfere. Same for other corner pairs, and for when they point negative instead of positive at each other. EDIT: You can try +x + ROOT2*y, +ROOT2*x + y, and all sign permutations thereof, to produce 8 gradients.

Also, even if you improve the gradients, you may have heard that Perlin is an older method for noise, which produces a lot of 45 and 90 degree bias. There aren't a lot of cases where I recommend it. If you want to implement noise as a programming exercise, that's great. But if you want to use noise in a project, I would either code or import a good 2D simplex implementation.

EDIT: See comments. I looked at the wrong image. Solution you need, is only sample = sample * 0.5 + 0.5 to rescale the output so that the negative values don't all get cut off in the image.

Also if you want to convert your noise into a rudimentary simplex, you can do this:

1. Define constants double F2 = 0.366025403784439 and double G2 = -0.211324865405187. These will be used below, to work with the triangular grid.
2. At the beginning of GetPixel(double x, double y) add double s = (x + y) * F2; x += s; y += s;. This will convert the coordinates which produce integers on a square grid, to coordinates which produce integers on a diagonally-compressed square grid which represents equilateral triangles.
3. After you define xdec and ydec, add double t = (xdec + ydec) * G2; xdec += t; ydec += t;. This will unskew these coordinates relative to the base of the compressed square, so that they can now be used for distance and gradients again.
4. Define doubles xdec2 = xdec - 1 - G2; ydec2 = ydec - G2;. Define xdec3 = xdec - G2; ydec3 = ydec - 1 - G2;. Define xdec4 = xdec - 1 - 2*G2; ydec4 = ydec - 1 - 2*G2;. You need this, because simply subtracting 1 doesn't work anymore to get the relative coordinates to the other four corners, because the corners aren't aligned with a square anymore. Now, any time you subtract 1 from either of the coordinates, you also need to subtract G2 from both. Thus, for #2 and #3 you subtract G2 once from each, and for #4 you subtract it twice (2*G2). You can re-derive this yourself by seeing what happens if you had already subtracted 1 from one or both of the coordinates, before calculating the previous step where you define double t.
5. Change d2, d3, d4 to use these values instead, like d2 = grad(g2, xdec2, ydec2);
6. Remove everything starting with double u and ending with return yInter;. Add double value = 0;. You will add stuff to this value.
7. Define double a1 = 0.5 - xdec*xdec - ydec*ydec; double a2 = 0.5 - xdec2*xdec2 - ydec2*ydec2; and the same pattern for a3 and a4. These functions represent circles around each triangle vertex, which stop at the triangle edges.
8. Add if (a1 > 0) value += (a1 * a1) * (a1 * a1) * d1; and the same for a2, a3, a4. These add a value to the noise inside each of those circles, based on the gradient and distance.
9. If you use the improved gradients I suggested for Perlin, add return value * 38.283687591552734375;. If you use the original ones, I think the right value to multiply by is 75.3929901123046875 but I'm not sure. It will be something close to that, though. Really, you probably want more gradients for simplex, but the 8 should make it look better than Perlin at least.

The noise will not look very good without the improved gradients. You will still see a lot of 45 degree bias. If you want to really improve the noise, here is my suggestion, with 24 gradients. You can find these gradients here. Use 99.83685446303647 as the value you multiply by at the end.

The two are not related!

The only thing that Random.InitState changes is the way how e.g. Random.Range or Random.value work.

Without using it it would simply use values based on the system time instead.

Mathf.PerlinNoise is not connected to that. You can actually try different seeds and always see the same perlin result. This is actually stated in the API

The same coordinates will always return the same sample value but the plane is essentially infinite so it is easy to avoid repetition by choosing a random area to sample from.

They already give you a hint how to solve your problem: Use a different offset!

Now here comes your seed into play: Simply choose a random offset based on the seed -> random but always equal for the same seed!

So your question consists of 2 problems:

1. Create a seed from the 2 float values that always maps the same input to the same seed.

2. Using a seed to generate a random float.

For the first problem this can be solved by creating a hashcode, there are different ways to do it but I'll refer to this answer by John Skeet for more information on that. For you the hashing would look like this:

Based on Frank's comment, I reverted my Perlin Noise filter to its original, functional state and instead applied the color map as a following step using this improved version of the CIColorMap filter which can generate its own gradient image based on a [CGFloat: CIColor] dictionary.