terrain | Fantasy map generator | Map library

Something like this should work. It takes three 32-bit integers, and outputs a single 32-bit integer. If you want to turn the output into a double between 0 and 1, just divide by UINT32_MAX.

The input and output sizes can be adjusted.

You can also tweak the balance between output quality and speed. You'll notice that the middle section is just repeated 3 lines, remove or add more of them to make the output more or less biased.

Here's the C code.

For testing purposes, my go to is "Simple Free-Look Camera" by adamviola, you can find it on the asset library. When you download it, it will give you a camera.gd script that you can attach to a Camera in your scene (dragging the file from the File System panel to the Scene panel will do). Make the current of the Camera is set true. And that is all it takes.

The script mimics the basic movement of the editor camera, so you press right click to look around and WASD to fly. Q and E move vertically. And you can use the mouse wheel to change the fly speed.

Also, just like everything in the asset library it is gratis (which is why it is not an asset store). Also it is open source. So you can open it and study the code. And also it is libre, so you are also free to modify however you want. The above description of the controls should also help as starting point for what to look for in the code.

What follows is a short explanation of what the code of camera.gd does.

You can find in the code that it uses Input.set_mouse_mode to capture the mouse when you press right click. And it will store the relative motion when it gets a InputEventMouseMotion (this is in _input by the way) for later rotating the Camera using a combination of rotate_y and rotate_object_local (that part is in _update_mouselook). Horizontal mouse motion is translated to yaw, and vertical mouse motion is translated to pitch, the code also clamps the pitch.

It will also keep track of the state of the keys it is interested in. You can find the variables _w, _s, _a, _d, _q, _e on the top of the script, and updated on _input when it gets a InputEventKey. The state of those keys is used to compute a direction vector - on which it applies velocity and acceleration - and finally move the Camera with translate (you can find that on _update_movement). Note that translate is affected by the orientation of the Camera, so the z axis is where you are looking at.

The mouse wheel input is also taken on _input, and it updates a velocity multiplier which is applied in _update_movement.

It think the issue is in

First of all, let's look at your definition. Why did you insert a cut here? Let's see what happens without it:

You can set the ticks.colour= within guide_colorbar() by referencing via guides()... here ya go:

Figured out my own answer in the docs, I have switched to using immutable storage. Instead of using glBufferData I instead am using glBufferStorage

So

glBufferData(GL_SHADER_STORAGE_BUFFER, (mSize*mSize*mSize)*sizeof(float), mData, GL_STREAM_READ);

becomes

glBufferStorage(GL_SHADER_STORAGE_BUFFER, (mSize*mSize*mSize)*sizeof(float), NULL, GL_CLIENT_STORAGE_BIT | GL_MAP_READ_BIT);

and I have given it explicit flags to let me map it and a hint that the implementation of the buffer storage should come from client memory. Now when I call

glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, (mSize*mSize*mSize)*sizeof(float), mData);

I don't get hit with any performance warnings

If you have the elevation data in the format you desire then that is the easiest option: it just works. However, if you want a more customized solution, here's what I've done for a project using the Mapbox Terrain-RGB format:

I have a scale of colors from dark blue to light blue to white. I want to be able to specify how many steps are used from light blue to white (default is 10). This code uses GDAL Python bindings. The following code snippet was used for testing. It just outputs the color mapping to a GeoTIFF file. To get values between 0 and 1, simply use value *= 1/num_steps. You can use that value in the lookup table to get an RGB value. If you're only interested in outputting the colors, you can ignore everything involving gdal_translate. The colors will automatically be stored in a single-band GeoTIFF. If you do want to re-use those colors, note that this version ignores alpha values (if present). You can use gdal_translate to add those. That code snippet is also available at my gist here.

This is not a complete answer to your question, but I think it should give you a start on where to go. vDSP is part of Accelerate, and it's built to speed up mathematical operations on arrays. This code uses multiple steps, so probably could be more optimised, and it's not taking any other filters than linear into account, but I don't have enough knowledge to make the steps more effective. However, on my machine, vDSP is 4x faster than map for the following processing: