# How to scale down noise intensity?

I'm currently making a planet and for that, I added noise, to create terrain on the surface. The method I'm using is creating simplex noise (that ends up looking like the image below)

And I write that data to an image file, like the one above this text, and from there, I bind the noise image to my sphere, like below

And finally, through some shader code, I offset some sphere vertices using the noise. The problem I'm experiencing is the noise intensity is way more than I expected or wanted it to be. This is how intense the noise is

As you can see, it looks more like an explosion than a planet, and I don't know how to scale the noise down, so it's not as intense as shown below. I'm using FNL (FastNoise Lite) for the noise for better context. Below is some of my code (the code that's important and specific to this problem)

Here is the function where I create the noise

#ifndef NOISE_H_INCLUDED
#define NOISE_H_INCLUDED

#include <FastNoiseLite/C/FastNoiseLite.h>
#include <time.h>

void write_noise_2d(int w, int h, int channels_num)
{
// create random seed for noise
srand(time(NULL));
float seed = (float)rand()/RAND_MAX;
// initialize noise
fnl_state noise = fnlCreateState();
noise.noise_type = FNL_NOISE_OPENSIMPLEX2;
noise.octaves = 8;
noise.lacunarity = 2.0f;
noise.gain = 0.5f;
noise.seed = (int)seed;
printf("Seed: %i\n", seed);
noise.fractal_type = FNL_FRACTAL_FBM;
// create data array for noise
float* noise_data = malloc(w * h * channels_num * sizeof(float));
int index = 0;
// create noise throughout the entire image
for(int x=0; x<w; x++)
{
for(int y=0; y<h; y++)
{
noise_data[index++] = (1 + fnlGetNoise2D(&noise, x, y)) * 128;
}
}

stbi_write_jpg("textures/noisemap.jpg", w, h, channels_num, noise_data, w * channels_num);
free(noise_data);
}

#endif // NOISE_H_INCLUDED


Here is the code where I use the noise data

// write noise data from FNL to texture
write_noise_2d(512, 512, 2);
// now we load the noise map back into the program to be used later
unsigned int texture;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
// from what I heard no need to specify gl_repeat because that is the default
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_MIPMAP);

// image stats
int width, height, num_channels;
unsigned char* data = stbi_load("textures/noisemap.jpg", &width, &height, &num_channels, 0);
if(data)
{
// image options
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height, 0, GL_RED, GL_UNSIGNED_SHORT, data);
glGenerateMipmap(GL_TEXTURE_2D);

// send to the GPU for processing
set_int(earthlike, "noisemap", 0);
printf("Loaded noise map of %i by %i\n", width, height);
}
else
{
}
// deallocate data that's no longer needed
stbi_image_free(data);
remove("textures/noisemap.jpg");


Here's where I apply the noise data to the sphere (offset the sphere vertices)

#version 450 core

// determines what type of tessellation to do
layout(triangles, equal_spacing, cw) in;

in vec3 vertex_coord[];
// output vec
out vec3 vert;
// simplex noise goes here
uniform sampler2D noisemap;
// allows for object transformations
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out float height;

void main()
{
// gets barycentric coordinates from the triangles
vec3 x = gl_TessCoord.x * vertex_coord[0];
vec3 y = gl_TessCoord.y * vertex_coord[1];
vec3 z = gl_TessCoord.z * vertex_coord[2];
// used for texturing, terrain, and other various maps (moisture, temperature, etc.)
height = texture(noisemap, vec2(vec3(gl_TessCoord.x, gl_TessCoord.y, gl_TessCoord.z))).r;
// makes every triangle an equal distance from the center through normalizion (that's how spheres are formed)
vec3 pos = normalize(x + y + z) * height;
// output tessellated shape
gl_Position = projection * view * model * vec4(pos, 1.0);
}


float deepestValley = 0.8f;