Miscellaneous Procedural Generation Code

[impixiParticipant]

Perlin noise

(See attachment for runnable example)

Monkey

[crayon-5cb9d7a859902782035018 inline="true" ] 'http://devmag.org.za/2009/04/25/perlin-noise/ Function GeneratePerlinMap(array:Double[,], octaveCount:Int) If Not array Then Return Local Interpolate := Lambda:Double(val0:Double, val1:Double, alpha:Double) Return val0 * (1.0 - alpha) + alpha * val1 End Local width := array.GetSize(0) Local height := array.GetSize(1) Local baseNoise := New Double[width, height] For Local x := 0 Until width For Local y := 0 Until height baseNoise[x, y] = Rnd(0.0, 1.0) Next Next Local persistance:Double = 0.7 Local smoothNoise := New Double[octaveCount, width, height] For Local i:= 0 Until octaveCount For Local x := 0 Until width For Local y := 0 Until height smoothNoise[i, x, y] = 0.0 Next Next Next For Local octave:=0 Until octaveCount Local samplePeriod:Int = 1 Shl octave Local sampleFrequency:Double = 1.0 / samplePeriod For Local x:= 0 Until width Local sampleX0:Int = (x / samplePeriod) * samplePeriod Local sampleX1:Int = (sampleX0 + samplePeriod) Mod Double(width) Local horizontalBlend:Double = (Double(x) - sampleX0) * sampleFrequency For Local y:= 0 Until height Local sampleY0:Int = (y / samplePeriod) * samplePeriod Local sampleY1:Int = (sampleY0 + samplePeriod) Mod Double(height) Local verticalBlend:Double = (Double(y) - sampleY0) * sampleFrequency Local top:Double = Interpolate(baseNoise[sampleX0, sampleY0], baseNoise[sampleX1, sampleY0], horizontalBlend) Local bottom:Double = Interpolate(baseNoise[sampleX0, sampleY1], baseNoise[sampleX1, sampleY1], horizontalBlend) smoothNoise[octave, x, y] = Interpolate(top, bottom, verticalBlend) Next Next Next For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next Local amplitude:Double = 1.0 Local totalAmplitude:Double = 0.0 For Local octave := (octaveCount - 1) To 0 Step -1 amplitude *= persistance totalAmplitude += amplitude For Local x := 0 Until width For Local y := 0 Until height array[x, y] += smoothNoise[octave, x, y] * amplitude Next Next Next For Local x := 0 Until width For Local y := 0 Until height array[x, y] /= totalAmplitude Next Next End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

[crayon-5cb9d7a859902782035018 inline="true" ] 'http://devmag.org.za/2009/04/25/perlin-noise/ Function GeneratePerlinMap(array:Double[,], octaveCount:Int) If Not array Then Return Local Interpolate := Lambda:Double(val0:Double, val1:Double, alpha:Double) Return val0 * (1.0 - alpha) + alpha * val1 End Local width := array.GetSize(0) Local height := array.GetSize(1) Local baseNoise := New Double[width, height] For Local x := 0 Until width For Local y := 0 Until height baseNoise[x, y] = Rnd(0.0, 1.0) Next Next Local persistance:Double = 0.7 Local smoothNoise := New Double[octaveCount, width, height] For Local i:= 0 Until octaveCount For Local x := 0 Until width For Local y := 0 Until height smoothNoise[i, x, y] = 0.0 Next Next Next   For Local octave:=0 Until octaveCount Local samplePeriod:Int = 1 Shl octave Local sampleFrequency:Double = 1.0 / samplePeriod For Local x:= 0 Until width Local sampleX0:Int = (x / samplePeriod) * samplePeriod Local sampleX1:Int = (sampleX0 + samplePeriod) Mod Double(width) Local horizontalBlend:Double = (Double(x) - sampleX0) * sampleFrequency For Local y:= 0 Until height Local sampleY0:Int = (y / samplePeriod) * samplePeriod Local sampleY1:Int = (sampleY0 + samplePeriod) Mod Double(height) Local verticalBlend:Double = (Double(y) - sampleY0) * sampleFrequency Local top:Double = Interpolate(baseNoise[sampleX0, sampleY0], baseNoise[sampleX1, sampleY0], horizontalBlend) Local bottom:Double = Interpolate(baseNoise[sampleX0, sampleY1], baseNoise[sampleX1, sampleY1], horizontalBlend) smoothNoise[octave, x, y] = Interpolate(top, bottom, verticalBlend) Next Next Next For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next Local amplitude:Double = 1.0 Local totalAmplitude:Double = 0.0 For Local octave := (octaveCount - 1) To 0 Step -1 amplitude *= persistance totalAmplitude += amplitude For Local x := 0 Until width For Local y := 0 Until height array[x, y] += smoothNoise[octave, x, y] * amplitude Next Next Next For Local x := 0 Until width For Local y := 0 Until height array[x, y] /= totalAmplitude Next Next End

[/crayon]

Attachments:

1. perlin.monkey2.zip

[impixiParticipant]

Hill algorithm:

(See attachment for runnable example)

Monkey

[crayon-5cb9d7a860638662215239 inline="true" ] Function GenerateHillMap:void(array:Double[,], numHills:UInt, maxHillRadius:Double, island:Bool = false) 'Generate a heightmap in a 2d array using the "hill" algorithm. 'numHills: number of "hills". Recommended range: 250 to 2000. 'maxHillRadiussize: maximum hill radius. For best results, value should be significantly 'less than the map's shortest dimension. 'island: create an island-like result. True/False If Not array Then Return Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next If island Then maxHillRadius *= 0.5 For Local n := 1 To numHills Local radius :Double = Floor(Rnd(0, maxHillRadius)) Local centrex:Double = Floor(Rnd(0, width)) Local centrey:Double = Floor(Rnd(0, height)) If island Local theta := Rnd(0.0, 359.0) Local distx := Floor(Rnd(0, width * 0.5 - radius)) Local disty := Floor(Rnd(0, height * 0.5 - radius)) centrex = width * 0.5 + (Cos(theta) * distx) centrey = height * 0.5 + (Sin(theta) * disty) Endif Local startx := centrex - radius If startx < 0 Then startx = 0 Local endx := centrex + radius If endx > width Then endx = width Local starty := centrey - radius If starty < 0 Then starty = 0 Local endy := centrey + radius If endy > height Then endy = height For Local x := startx Until endx For Local y := starty Until endy Local h:Double = (radius * radius) - (((x - centrex) * (x - centrex)) + ((y - centrey) * (y - centrey))) If (h > 0.0) Then array[x, y] += h Next Next Next '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0] For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next ''' End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

[crayon-5cb9d7a860638662215239 inline="true" ] Function GenerateHillMap:void(array:Double[,], numHills:UInt, maxHillRadius:Double, island:Bool = false) 'Generate a heightmap in a 2d array using the "hill" algorithm. 'numHills: number of "hills". Recommended range: 250 to 2000. 'maxHillRadiussize: maximum hill radius. For best results, value should be significantly    'less than the map's shortest dimension.    'island: create an island-like result. True/False   If Not array Then Return   Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next   If island Then maxHillRadius *= 0.5   For Local n := 1 To numHills   Local radius :Double = Floor(Rnd(0, maxHillRadius)) Local centrex:Double = Floor(Rnd(0, width)) Local centrey:Double = Floor(Rnd(0, height)) If island Local theta := Rnd(0.0, 359.0) Local distx := Floor(Rnd(0, width * 0.5 - radius)) Local disty := Floor(Rnd(0, height * 0.5 - radius)) centrex = width * 0.5 + (Cos(theta) * distx) centrey = height * 0.5 + (Sin(theta) * disty) Endif   Local startx := centrex - radius If startx < 0 Then startx = 0 Local endx := centrex + radius If endx > width Then endx = width Local starty := centrey - radius If starty < 0 Then starty = 0 Local endy := centrey + radius If endy > height Then endy = height    For Local x := startx Until endx For Local y := starty Until endy    Local h:Double = (radius * radius) - (((x - centrex) * (x - centrex)) + ((y - centrey) * (y - centrey)))        If (h > 0.0) Then array[x, y] += h      Next    Next      Next '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0]      For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next ''' End

[/crayon]

Attachments:

1. hillmap.monkey2.zip

[impixiParticipant]

Midpoint Displacement

(See attachment for runnable example)

Monkey

[crayon-5cb9d7a8669a4208564158 inline="true" ] Function GenerateMPDMap:Void(array:Double[,], grain:Float) 'Generate a heightmap in a 2d array using the "midpoint displacement" algorithm. 'grain: graininess. Suggested range 0.1 to 2.0 If Not array Then Return Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = -1.0 Next Next array[0, 0] = Rnd(0.0, 1.0) array[width - 1, 0] = Rnd(0.0, 1.0) array[0, height - 1] = Rnd(0.0, 1.0) array[width - 1, height - 1] = Rnd(0.0, 1.0) recurseMPD(array, 0, 0, width - 1, height - 1, grain, 1.0) '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0] For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next ''' End Function recurseMPD:Void(array:Double[,], x0:Int, y0:Int, x2:Int, y2:Int, grain:Double, level:Double) 'Recursive function used by the GenerateMPDMap function. Local MPD := Lambda:Double(x0:Int, y0:Int, x1:Int, y1:Int, x2:Int, y2:Int) Local r:Double = Rnd(-grain, grain) / level r += ((array[x0, y0] + array[x2, y2]) / 2.0) r = Clamp(r, Cast<Double>(0.0), Cast<Double>(1.0)) array[x1, y1] = r Return r End If (Not(((x2 - x0) < 2) And ((y2 - y0) < 2))) Local v:Double, i:Double level = 2.0 * level Local x1:Int = Ceil((x0 + x2) / 2.0) Local y1:Int = Ceil((y0 + y2) / 2.0) v = array[x1, y0] If (v = -1.0) Then v = MPD(x0, y0, x1, y0, x2, y0) i = v v = array[x2, y1] If (v = -1.0) Then v = MPD(x2, y0, x2, y1, x2, y2) i += v v = array[x1, y2] If (v = -1.0) Then v = MPD(x0, y2, x1, y2, x2, y2) i += v v = array[x0, y1] If (v = -1.0) Then v = MPD(x0, y0, x0, y1, x0, y2) i += v If (array[x1, y1] = -1.0) Then array[x1, y1] = i/4.0 recurseMPD(array, x0, y0, x1, y1, grain, level) recurseMPD(array, x1, y0, x2, y1, grain, level) recurseMPD(array, x1, y1, x2, y2, grain, level) recurseMPD(array, x0, y1, x1, y2, grain, level) Endif End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

[crayon-5cb9d7a8669a4208564158 inline="true" ] Function GenerateMPDMap:Void(array:Double[,], grain:Float) 'Generate a heightmap in a 2d array using the "midpoint displacement" algorithm. 'grain: graininess. Suggested range 0.1 to 2.0 If Not array Then Return   Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = -1.0 Next Next   array[0, 0] = Rnd(0.0, 1.0)     array[width - 1, 0] = Rnd(0.0, 1.0)     array[0, height - 1] = Rnd(0.0, 1.0)     array[width - 1, height - 1] = Rnd(0.0, 1.0)       recurseMPD(array, 0, 0, width - 1, height - 1, grain, 1.0)   '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0]      For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next '''   End   Function recurseMPD:Void(array:Double[,], x0:Int, y0:Int, x2:Int, y2:Int, grain:Double, level:Double) 'Recursive function used by the GenerateMPDMap function. Local MPD := Lambda:Double(x0:Int, y0:Int, x1:Int, y1:Int, x2:Int, y2:Int) Local r:Double = Rnd(-grain, grain) / level r += ((array[x0, y0] + array[x2, y2]) / 2.0) r = Clamp(r, Cast<Double>(0.0), Cast<Double>(1.0)) array[x1, y1] = r      Return r   End If (Not(((x2 - x0) < 2) And ((y2 - y0) < 2)))     Local v:Double, i:Double      level = 2.0 * level             Local x1:Int = Ceil((x0 + x2) / 2.0)      Local y1:Int = Ceil((y0 + y2) / 2.0)         v = array[x1, y0] If (v = -1.0) Then v = MPD(x0, y0, x1, y0, x2, y0) i = v   v = array[x2, y1] If (v = -1.0) Then v = MPD(x2, y0, x2, y1, x2, y2) i += v      v = array[x1, y2] If (v = -1.0) Then v = MPD(x0, y2, x1, y2, x2, y2) i += v   v = array[x0, y1] If (v = -1.0) Then v = MPD(x0, y0, x0, y1, x0, y2) i += v   If (array[x1, y1] = -1.0) Then array[x1, y1] = i/4.0 recurseMPD(array, x0, y0, x1, y1, grain, level) recurseMPD(array, x1, y0, x2, y1, grain, level) recurseMPD(array, x1, y1, x2, y2, grain, level) recurseMPD(array, x0, y1, x1, y2, grain, level) Endif End

[/crayon]

Attachments:

1. mpd.monkey2.zip

[PakzParticipant]

Any chance of a short description on how they work? (Couple of lines maybe?)

My current method for making heightmaps is like this :

Draw randomly sized rectangles on top of each other. When drawn ontop add the value together. At a certain high value stop the procedure and you are done.

The result looks pretty much like a heightmap. Is pretty easy to code too.

[codifiesParticipant]

very nice, I especially like the hill method, but notice sometimes a definite plus sign shape in them sometimes.

I assume you realise that seeding with millisecs will often have almost identical results (its millisecs from app start)

but nice work.

[impixiParticipant]

@pakz

Here are some links that explain, in depth, the algorithms that the above code is inspired/based on:

Perlin
http://devmag.org.za/2009/04/25/perlin-noise/

Hill algorithm.
http://www.stuffwithstuff.com/robot-frog/3d/hills/hill.html

Midpoint displacement (aka Diamond Square algorithm)
https://en.wikipedia.org/wiki/Diamond-square_algorithm

Your technique sounds similar to the “hill algorithm”, except you use rectangles instead of circles/ovals. I’d be interested in seeing your code!

[impixiParticipant]

@codifies

Yes, if you seed the RNG with the same number you should see the same results regardless of platform, since Monkey 2’s RNG algorithm is platform agnostic.

EDIT. Sorry, I misunderstood your statement. Yes, I realise Millisecs and Microsecs are derived from the application start time so the results are likely to be the same…

[codifiesParticipant]

don’t suppose you can improve on this?

Monkey

[crayon-5cb9d7a87758a928267105 inline="true" ] ' boiler plate just to ensure random is different each run local tv:timeval gettimeofday( varptr(tv) ) local t:long = tv.tv_sec * 1000 + tv.tv_usec SeedRnd(t)

1 2 3 4 5 6 7

[crayon-5cb9d7a87758a928267105 inline="true" ] ' boiler plate just to ensure random is different each run local tv:timeval gettimeofday( varptr(tv) ) local t:long = tv.tv_sec * 1000 + tv.tv_usec SeedRnd(t)

[/crayon]

[coconParticipant]

This looks good.

[impixiParticipant]

@codifies

That’s good enough, no improvement necessary.

For simple proof of concept code I usually don’t bother seeding with a unique number per run but I should. So I’m going to incorporate your code snippet, though slightly simplified.

Another way to do it, if you’re not generating something right at the start, is to seed with Microsecs at the point of first user interaction. That’s what I do for my game projects and simulations.

[impixiParticipant]

Particle deposition:

(See attachment for runnable example)

Monkey

[crayon-5cb9d7a87de44801340969 inline="true" ] Function GenerateParticleMap:Void(array:Double[,], particles:Int, clusters:Int, sticky:Bool = True, amts:Int[] = Null) 'Generate a heightmap in a 2d array using the "particle" algorithms. 'particles: number of particles to calculate per cluster. Minimum 1. 'clusters: number of clusters: higher number gives greater map density. Minimum 1. 'sticky: algorithm variation: True = sticky, False = rolling. 'amts: particle variation. Should be an integer array of 4 values. Suggested range -5 to 5. If Not array Then Return Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next If amts = Null Or amts.Length < 4 Then amts = New Int[](-1, 1, -1, 1) Local disp:Float = 1.0 If sticky 'Sticky style For Local m := 1 To clusters Local x := Floor(Rnd(0, width)) Local y := Floor(Rnd(0, height)) For Local n := 1 To particles If (((x < width) And (y < height) And (x >= 0) And (y >= 0))) array[x, y] += disp Select Floor(Rnd(0, amts.Length)) Case 0 x += amts[0] Case 1 x += amts[1] Case 2 y += amts[2] Case 3 y += amts[3] End Endif Next Next Else 'Rolling style For Local m := 1 To clusters Local x := Floor(Rnd(0, width)) Local y := Floor(Rnd(0, height)) For Local n := 1 To particles If (((x < width) And (y < height) And (x >= 0) And (y >= 0))) Local h := array[x, y] + disp array[x, y] = h Local startx := x - 1 If (startx < 0) Then startx = 0 Local endx := x + 1 If (endx > width) Then endx = width Local starty := y - 1 If (starty < 0) Then starty = 0 Local endy := y + 1 If (endy > height) Then endy = height For Local x2 := startx Until endx For Local y2 := starty Until endy Local h2 := array[x2, y2] If (h2 < h) Then array[x2, y2] += disp Next Next Endif Select Floor(Rnd(0, amts.Length)) Case 0 x += amts[0] Case 1 x += amts[1] Case 2 y += amts[2] Case 3 y += amts[3] End Next Next Endif '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0] For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next ''' End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

[crayon-5cb9d7a87de44801340969 inline="true" ] Function GenerateParticleMap:Void(array:Double[,], particles:Int, clusters:Int, sticky:Bool = True, amts:Int[] = Null) 'Generate a heightmap in a 2d array using the "particle" algorithms. 'particles: number of particles to calculate per cluster. Minimum 1.    'clusters: number of clusters: higher number gives greater map density. Minimum 1. 'sticky: algorithm variation: True = sticky, False = rolling. 'amts: particle variation. Should be an integer array of 4 values. Suggested range -5 to 5.   If Not array Then Return Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next If amts = Null Or amts.Length < 4 Then amts = New Int[](-1, 1, -1, 1) Local disp:Float = 1.0   If sticky 'Sticky style        For Local m := 1 To clusters      Local x := Floor(Rnd(0, width))        Local y := Floor(Rnd(0, height))        For Local n := 1 To particles    If (((x < width) And (y < height) And (x >= 0) And (y >= 0))) array[x, y] += disp        Select Floor(Rnd(0, amts.Length))         Case 0            x += amts[0]           Case 1             x += amts[1] Case 2 y += amts[2]             Case 3             y += amts[3]          End Endif Next      Next Else 'Rolling style       For Local m := 1 To clusters Local x := Floor(Rnd(0, width))        Local y := Floor(Rnd(0, height))     For Local n := 1 To particles         If (((x < width) And (y < height) And (x >= 0) And (y >= 0)))        Local h := array[x, y] + disp        array[x, y] = h        Local startx := x - 1           If (startx < 0) Then startx = 0            Local endx := x + 1            If (endx > width) Then endx = width            Local starty := y - 1           If (starty < 0) Then starty = 0           Local endy := y + 1            If (endy > height) Then endy = height           For Local x2 := startx Until endx For Local y2 := starty Until endy Local h2 := array[x2, y2]                If (h2 < h) Then array[x2, y2] += disp              Next Next      Endif       Select Floor(Rnd(0, amts.Length))          Case 0            x += amts[0]           Case 1         x += amts[1] Case 2 y += amts[2]          Case 3           y += amts[3]          End Next     Next Endif   '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0]      For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next '''      End

[/crayon]

Attachments:

1. particle.monkey2.zip

[impixiParticipant]

Fault Algorithm:

(See attachment for runnable example)

Monkey

[crayon-5cb9d7a885976262291933 inline="true" ] 'http://www.lighthouse3d.com/opengl/terrain/index.php?fault Function GenerateFaultMap:Void(array:Double[,], realism:Float) 'Generate a heightmap in a 2d array using the "fault line" algorithm. 'realism: number of fault lines: higher number (> 500) gives greater realism. Minimum 1. 'NOTE: This is a comparatively slow algorithm. If Not array Then Return Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next Local d := Sqrt((width * width) + (height * height)) Local disp:Double = 10.0 For Local n := 1 To realism Local v := Rnd(0, 359) Local a := Sin((v * (Pi / 180.0))) Local b := Cos((v * (Pi / 180.0))) Local c := (Rnd(0, 1) * d) - (d / 2) For Local x := 0 Until width For Local y := 0 Until height If (((a * x) + (b * y) - c) > 0.0) array[x, y] += disp Else array[x, y] -= disp Endif Next Next Next '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0] For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next ''' End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

[crayon-5cb9d7a885976262291933 inline="true" ] 'http://www.lighthouse3d.com/opengl/terrain/index.php?fault   Function GenerateFaultMap:Void(array:Double[,], realism:Float) 'Generate a heightmap in a 2d array using the "fault line" algorithm.    'realism: number of fault lines: higher number (> 500) gives greater realism. Minimum 1.    'NOTE: This is a comparatively slow algorithm.    If Not array Then Return   Local width := array.GetSize(0) Local height := array.GetSize(1) For Local x := 0 Until width For Local y := 0 Until height array[x, y] = 0.0 Next Next   Local d := Sqrt((width * width) + (height * height))    Local disp:Double = 10.0    For Local n := 1 To realism      Local v := Rnd(0, 359)    Local a := Sin((v * (Pi / 180.0)))        Local b := Cos((v * (Pi / 180.0)))        Local c := (Rnd(0, 1) * d) - (d / 2)   For Local x := 0 Until width        For Local y := 0 Until height If (((a * x) + (b * y) - c) > 0.0) array[x, y] += disp Else array[x, y] -= disp Endif Next Next Next   '''Normalise Local minv := array[0, 0] Local maxv := array[0, 0]      For Local x := 0 Until width For Local y:= 0 Until height If (array[x, y] < minv) minv = array[x, y] Else If (array[x, y] > maxv) Then maxv = array[x, y] Endif Next Next For Local x := 0 Until width For Local y:= 0 Until height array[x, y] = (array[x, y] - minv) / (maxv - minv) Next Next '''   End

[/crayon]

Attachments:

1. fault.monkey2.zip

[impixiParticipant]

Relevant theory links for the previous two examples…

Particle Deposition:
Generating heightmaps using particle deposition

Fault Algorithm:
http://www.lighthouse3d.com/opengl/terrain/index.php?fault

[nerobotParticipant]

Very nice!

One note: looking at these walls of code I have a question – is there way to make code box smaller? And I looked into “code” popup and found “Height” checkbox, that disabled by default.

I didn’t try it yet but it seems to be useful for big code blocks.

[impixiParticipant]

@nerobot

I can’t find a way to do it so I’m going to paste only the pertinent function(s) in each post body and “attach” the complete runnable example as a zip file…

EDIT: Still a “wall of code” but not quite as bad.

[Author]

Posts