[impixiParticipant]

*Very* basic example:

Monkey

[crayon-5cba94c4334ce361864731 inline="true" ]#Import "<std>" #Import "<mojo>" #Import "<mojox>" '#Import "shadedDark12.png" Using std.. Using mojo.. Using mojox.. Function Main() New AppInstance New MyWindow App.Run() End '------ Class MyWindow Extends Window Method New() Super.New( "Button Demo",640,480,WindowFlags.Resizable ) SaveString(CreateButtonTheme(), AssetsDir() + "/myTheme.json") Local theme:=App.Theme.Load("asset::myTheme.json") Local image:Image = CreateButtonImage(200, 40) 'Local image := Image.Load( "asset::shadedDark12.png" ) Local button:=New PushButton("", image) button.Style = GetStyle("myButton") button.Layout="float" button.Gravity=New Vec2f( .5,.5 ) button.MaxSize=New Vec2i( 100,0 ) ClearColor = Color.LightGrey button.Clicked=Lambda() Alert( "Well done sir!" ) End ContentView=button End End '---- Generated Content: Function CreateButtonTheme:String() Local strJson:String strJson += "{~n~qextends~q:~qdefault~q,~n" strJson += "~qstyles~q:{~n" strJson += "~t~qmyButton~q:{~n" strJson += "~t~t~qstates~q:{~n" strJson += "~t~t~t~qhover~q:{~n" strJson += "~t~t~t~t~qiconColor~q:~q#FFFF00FF~q~n~t~t~t},~n" strJson += "~t~t~t~qactive~q:{~n" strJson += "~t~t~t~t~qiconColor~q:~q#FF0000FF~q~n~t~t~t}~n" strJson += "~n~t~t}~n" strJson += "~t}~n}~n}" Print strJson Return strJson End Function CreateButtonImage:Image(w:Int, h:Int) Local img:Image = New Image(w, h) Local canvas:=New Canvas(img) canvas.Clear(Color.None) canvas.Color=Color.White canvas.DrawRect(0, 0, w, h) canvas.Color=Color.Black canvas.DrawText("My Image", 0, 0) canvas.Flush() Return img 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

[crayon-5cba94c4334ce361864731 inline="true" ]#Import "<std>" #Import "<mojo>" #Import "<mojox>" '#Import "shadedDark12.png" Using std.. Using mojo.. Using mojox..   Function Main() New AppInstance New MyWindow App.Run() End   '------   Class MyWindow Extends Window Method New() Super.New( "Button Demo",640,480,WindowFlags.Resizable ) SaveString(CreateButtonTheme(), AssetsDir() + "/myTheme.json") Local theme:=App.Theme.Load("asset::myTheme.json") Local image:Image = CreateButtonImage(200, 40) 'Local image := Image.Load( "asset::shadedDark12.png" )   Local button:=New PushButton("", image) button.Style = GetStyle("myButton") button.Layout="float" button.Gravity=New Vec2f( .5,.5 ) button.MaxSize=New Vec2i( 100,0 )   ClearColor = Color.LightGrey   button.Clicked=Lambda() Alert( "Well done sir!" ) End   ContentView=button End   End   '---- Generated Content:   Function CreateButtonTheme:String() Local strJson:String strJson += "{~n~qextends~q:~qdefault~q,~n" strJson += "~qstyles~q:{~n" strJson += "~t~qmyButton~q:{~n" strJson += "~t~t~qstates~q:{~n" strJson += "~t~t~t~qhover~q:{~n" strJson += "~t~t~t~t~qiconColor~q:~q#FFFF00FF~q~n~t~t~t},~n" strJson += "~t~t~t~qactive~q:{~n" strJson += "~t~t~t~t~qiconColor~q:~q#FF0000FF~q~n~t~t~t}~n" strJson += "~n~t~t}~n" strJson += "~t}~n}~n}"   Print strJson   Return strJson End   Function CreateButtonImage:Image(w:Int, h:Int) Local img:Image = New Image(w, h) Local canvas:=New Canvas(img) canvas.Clear(Color.None) canvas.Color=Color.White canvas.DrawRect(0, 0, w, h) canvas.Color=Color.Black canvas.DrawText("My Image", 0, 0) canvas.Flush() Return img End

[/crayon]

[impixiParticipant]

There’s no denying we *are* limiting mx23d’s potential user base by going with gles3, but IMO it’s worth it. It’ll make my life a ton easier, and the new features are likely to allow entirely new approaches to terrains, sprites, environmental effects and a bunch of other stuff.

I agree. An emphatic vote for GLES3 from me…

Then there are new features such as geometry shaders (which I *really* want to play with!), transform feedback (eg: render to ‘vertex buffer’), and a bunch of other features that just plain make stuff ‘go faster’ such as uniform buffers, geometry instancing (draw a bunch of models in one hit), vertex arrays and so on.

..Though geometry shaders are a capability of GLES3.2 (released 2015), so support for that particular feature might be very limited?

https://en.wikipedia.org/wiki/OpenGL_ES

[impixiParticipant]

Utilising a graphics subsystem higher than gles2 would kill off the emscripten (i.e. browser) target in the near term because gles3 (via WebGl 2.0) isn’t supported yet by most browsers.

http://caniuse.com/#feat=webgl2

Also, gles2 underlies the current mojo incarnation so mixing 2d with 3d might not be possible if Mark uses gles3 for 3d.

My personal ideal would be a Vulkan/Metal/DX12-based engine, ditching support for all the old stuff and incapable target platforms, but that would probably take ten times longer and alienate most of monkey2’s potential user-base.

So, I see Mark’s current plan as “realistic” and something to look forward to, as, like with everything, there are positives as well as negatives.

[impixiParticipant]

Nice. Looks like a realistic plan. Can’t wait to see the results.

[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.

[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

[impixiParticipant]

Fault Algorithm:

(See attachment for runnable example)

Monkey

[crayon-5cba94c441ea1805065635 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-5cba94c441ea1805065635 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]

Particle deposition:

(See attachment for runnable example)

Monkey

[crayon-5cba94c44657e967639515 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-5cba94c44657e967639515 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]

@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]

@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…

[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]

Midpoint Displacement

(See attachment for runnable example)

Monkey

[crayon-5cba94c454f5d278496750 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-5cba94c454f5d278496750 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

[impixiParticipant]

Hill algorithm:

(See attachment for runnable example)

Monkey

[crayon-5cba94c45b64e898542817 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-5cba94c45b64e898542817 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]

@danilo. Very interesting, thanks for the info… Don’t you just love all the complexity and “edge cases” associated with software development?

[impixiParticipant]

Do you need to double the font sizes?

I’d assume it depends on the amount of DPI. Higher amounts would require higher multiples font size. IIRC, Ted2 fonts are really small by default. I have to use the “zoom” functionality of the “View” menu item – but only on the first run.

Not sure about your problem above. Would have to see the relevant code… You might need an additional RequestRender call somewhere or to manually adjust View rects, etc…

[Author]

Posts