My use case: I generate heightmap terrain from random noise, already have code to produce a plane mesh at the given resolution by reading 2D noise at each vertice. What I want to do differently in one project is have the height data at a lower resolution from the terrain mesh... this is both to get smoother terrains, better performance by reading less noise data and storing less terrain info, and most importantly making terraforming simpler by having fewer edit points across a large grid with visual terrain drawn at higher resolution.

I need to know what's the interpolation system I have to use for generating a smooth mesh across a set of 2D points, essentially to produce a bezier 2D surface like a 1D curve. When a vertice on the heightmap is between any 4 height data points (X and Z axes) how do I make it take the average height of those points based on its distance from each one? For a simple example let's say I have the following point data:

  • X 0 - Y 0 = 1
  • X 0 - Y 1 = 0
  • X 1 - Y 0 = 0
  • X 1 - Y 1 = 1

If a vertice is at position X 0.5 - Y 0.5 so in the center, its height should (probably) be 0.5 in this case: It would increase the closer it got to either corner with 1 and decrease closer to either of the corners that have 0. When its position is exactly one of those corners then it's precisely 0 or 1.

Obviously I don't want spikes to form: Not looking for vector interpolation which would cause prism holes and pyramids, the surface should go like a sine wave between corners so each hole and bump located at a point should look like a hemisphere... ideally, if it's not too complicated, perhaps spikiness could be made a point property so I can choose how to blend between the two modes. For the sake of LOD and being able to hide distant terrains, I'll likely create an individual mesh between every 4 points... as such I wouldn't mind if the function running per patch only works with one set of corners long as neighbors end up perfectly seamless.

  • This is GLSL, not Godot shader script, but it should be adaptable.

    // Returns the weights for a cubic spline interpolation.
// This function is called by textureBicubic()
//
// References:
//  https://stackoverflow.com/questions/13501081/efficient-bicubic-filtering-code-in-glsl
//  http://www.java-gaming.org/index.php?topic=35123.0
vec4 
cubic_spline_weights(float v)
{
    vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
    vec4 s = n * n * n;
    float x = s.x;
    float y = s.y - 4.0 * s.x;
    float z = s.z - 4.0 * s.y + 6.0 * s.x;
    float w = 6.0 - x - y - z;
    return vec4(x, y, z, w) * (1.0/6.0);
}

// Func:    textureBicubic( sampler, texCoords )
//
// Desc:    Performs a texture lookup on the texture bound to 'sampler', but
//          instead of the standard (built-in) bilinear filtering, this call performs
//          bicubic spline filtering.
//
//          This provides rounder, smoother interpolation, w/o pyramid edges that
//          are prone to happen using bilinear.
//
// References:
//  https://stackoverflow.com/questions/13501081/efficient-bicubic-filtering-code-in-glsl
//  https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-20-fast-third-order-texture-filtering
//
vec4 
textureBicubic(sampler2D sampler, vec2 texCoords)
{
   vec2 texSize = textureSize(sampler, 0);
   vec2 invTexSize = 1.0 / texSize;

   texCoords = texCoords * texSize - 0.5;


    vec2 fxy = fract(texCoords);
    texCoords -= fxy;

    vec4 xcubic = cubic_spline_weights(fxy.x);
    vec4 ycubic = cubic_spline_weights(fxy.y);

    vec4 c = texCoords.xxyy + vec2 (-0.5, +1.5).xyxy;

    vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
    vec4 offset = c + vec4 (xcubic.yw, ycubic.yw) / s;

    offset *= invTexSize.xxyy;

    vec4 sample0 = texture(sampler, offset.xz);
    vec4 sample1 = texture(sampler, offset.yz);
    vec4 sample2 = texture(sampler, offset.xw);
    vec4 sample3 = texture(sampler, offset.yw);

    float sx = s.x / (s.x + s.y);
    float sy = s.z / (s.z + s.w);

    return mix(
       mix(sample3, sample2, sx), 
       mix(sample1, sample0, sx), 
       sy);
}

Haystack Thanks, indeed it should. Is there a builtin for doing it in GDScript, or an existing function anyone can share here?

    This is GLSL, not Godot shader script, but it should be adaptable.

    // Returns the weights for a cubic spline interpolation.
// This function is called by textureBicubic()
//
// References:
//  https://stackoverflow.com/questions/13501081/efficient-bicubic-filtering-code-in-glsl
//  http://www.java-gaming.org/index.php?topic=35123.0
vec4 
cubic_spline_weights(float v)
{
    vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
    vec4 s = n * n * n;
    float x = s.x;
    float y = s.y - 4.0 * s.x;
    float z = s.z - 4.0 * s.y + 6.0 * s.x;
    float w = 6.0 - x - y - z;
    return vec4(x, y, z, w) * (1.0/6.0);
}

// Func:    textureBicubic( sampler, texCoords )
//
// Desc:    Performs a texture lookup on the texture bound to 'sampler', but
//          instead of the standard (built-in) bilinear filtering, this call performs
//          bicubic spline filtering.
//
//          This provides rounder, smoother interpolation, w/o pyramid edges that
//          are prone to happen using bilinear.
//
// References:
//  https://stackoverflow.com/questions/13501081/efficient-bicubic-filtering-code-in-glsl
//  https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-20-fast-third-order-texture-filtering
//
vec4 
textureBicubic(sampler2D sampler, vec2 texCoords)
{
   vec2 texSize = textureSize(sampler, 0);
   vec2 invTexSize = 1.0 / texSize;

   texCoords = texCoords * texSize - 0.5;


    vec2 fxy = fract(texCoords);
    texCoords -= fxy;

    vec4 xcubic = cubic_spline_weights(fxy.x);
    vec4 ycubic = cubic_spline_weights(fxy.y);

    vec4 c = texCoords.xxyy + vec2 (-0.5, +1.5).xyxy;

    vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
    vec4 offset = c + vec4 (xcubic.yw, ycubic.yw) / s;

    offset *= invTexSize.xxyy;

    vec4 sample0 = texture(sampler, offset.xz);
    vec4 sample1 = texture(sampler, offset.yz);
    vec4 sample2 = texture(sampler, offset.xw);
    vec4 sample3 = texture(sampler, offset.yw);

    float sx = s.x / (s.x + s.y);
    float sy = s.z / (s.z + s.w);

    return mix(
       mix(sample3, sample2, sx), 
       mix(sample1, sample0, sx), 
       sy);
}