Почему переключение с Mersenne Twister на другие PRNG в Gradient Noise Generator дает плохие результаты?

Я пытался создать обобщенный генератор градиентного шума (который не использует хэш-метод для получения градиентов). Код ниже:

class GradientNoise {
std::uint64_t m_seed;
std::uniform_int_distribution<std::uint8_t> distribution;
const std::array<glm::vec2, 4> vector_choice = {glm::vec2(1.0, 1.0), glm::vec2(-1.0, 1.0), glm::vec2(1.0, -1.0),
glm::vec2(-1.0, -1.0)};

public:
GradientNoise(uint64_t seed) {
m_seed = seed;
distribution = std::uniform_int_distribution<std::uint8_t>(0, 3);
}

// 0 -> 1
// just passes the value through, origionally was perlin noise activation
double nonLinearActivationFunction(double value) {
//return value * value * value * (value * (value * 6.0 - 15.0) + 10.0);
return value;
}

// 0 -> 1
//cosine interpolation
double interpolate(double a, double b, double t) {
double mu2 = (1 - cos(t * M_PI)) / 2;
return (a * (1 - mu2) + b * mu2);
}

double noise(double x, double y) {
std::mt19937_64 rng;
//first get the bottom left corner associated
// with these coordinates
int corner_x = std::floor(x);
int corner_y = std::floor(y);

// then get the respective distance from that corner
double dist_x = x - corner_x;
double dist_y = y - corner_y;

double corner_0_contrib; // bottom left
double corner_1_contrib; // top left
double corner_2_contrib; // top right
double corner_3_contrib; // bottom right

std::uint64_t s1 = ((std::uint64_t(corner_x) << 32) + std::uint64_t(corner_y) + m_seed);
std::uint64_t s2 = ((std::uint64_t(corner_x) << 32) + std::uint64_t(corner_y + 1) + m_seed);
std::uint64_t s3 = ((std::uint64_t(corner_x + 1) << 32) + std::uint64_t(corner_y + 1) + m_seed);
std::uint64_t s4 = ((std::uint64_t(corner_x + 1) << 32) + std::uint64_t(corner_y) + m_seed);// each xy pair turns into distance vector from respective corner, corner zero is our starting corner (bottom
// left)
rng.seed(s1);
corner_0_contrib = glm::dot(vector_choice[distribution(rng)], {dist_x, dist_y});

rng.seed(s2);
corner_1_contrib = glm::dot(vector_choice[distribution(rng)], {dist_x, dist_y - 1});rng.seed(s3);
corner_2_contrib = glm::dot(vector_choice[distribution(rng)], {dist_x - 1, dist_y - 1});rng.seed(s4);
corner_3_contrib = glm::dot(vector_choice[distribution(rng)], {dist_x - 1, dist_y});double u = nonLinearActivationFunction(dist_x);
double v = nonLinearActivationFunction(dist_y);double x_bottom = interpolate(corner_0_contrib, corner_3_contrib, u);
double x_top = interpolate(corner_1_contrib, corner_2_contrib, u);
double total_xy = interpolate(x_bottom, x_top, v);
return total_xy;
}
};

Затем я генерирую текстуру OpenGL для отображения следующим образом:

int width = 1024;
int height = 1024;
unsigned char *temp_texture = new unsigned char[width*height * 4];
double octaves[5] = {2,4,8,16,32};

for( int i = 0; i < height; i++){
for(int j = 0; j < width; j++){
double d_noise = 0;
d_noise += temp_1.noise(j/octaves[0], i/octaves[0]);
d_noise += temp_1.noise(j/octaves[1], i/octaves[1]);
d_noise += temp_1.noise(j/octaves[2], i/octaves[2]);
d_noise += temp_1.noise(j/octaves[3], i/octaves[3]);
d_noise += temp_1.noise(j/octaves[4], i/octaves[4]);
d_noise/=5;
uint8_t noise = static_cast<uint8_t>(((d_noise * 128.0) + 128.0));
temp_texture[j*4 + (i * width * 4) + 0] = (noise);
temp_texture[j*4 + (i * width * 4) + 1] = (noise);
temp_texture[j*4 + (i * width * 4) + 2] = (noise);
temp_texture[j*4 + (i * width * 4) + 3] = (255);
}
}

Которые дают хорошие результаты:

Но gprof говорит мне, что твистер Мерсенна занимает 62,4% моего времени и растет с большими текстурами. Ничто иное не занимает столько времени у человека. Несмотря на то, что твистер Mersenne работает быстро после инициализации, тот факт, что я инициализирую его каждый раз, когда использую его, кажется, делает его довольно медленным.

Эта инициализация на 100% необходима для того, чтобы убедиться, что одинаковые x и y генерируют один и тот же градиент в каждой целочисленной точке (поэтому вам нужна либо хеш-функция, либо каждый раз заполнять RNG).

Я попытался изменить PRNG и на линейный конгруэнтный генератор, и на Xorshiftplus, и хотя оба работали на несколько порядков быстрее, они дали странные результаты:

LCG (один раз, затем работает 5 раз перед использованием)

Xorshiftplus

После одной итерации

После 10000 итераций.

Я пробовал:

Запуск генератора несколько раз перед использованием выходных данных, это приводит к медленному выполнению или просто другим артефактам.

Используя выходные данные двух последовательных прогонов после начального заполнения, снова запустите PRNG и используйте значение после подопечных. Нет разницы в результате.

Что происходит? Что я могу сделать, чтобы получить более быстрые результаты того же качества, что и твистер Мерсенна?

ОК, БОЛЬШОЕ ОБНОВЛЕНИЕ:

Я не знаю, почему это работает, я знаю, что это как-то связано с использованным простым числом, но после небольшой возни кажется, что работает следующее:

Шаг 1, включите значения x и y в качестве начальных значений отдельно (и включите в них некоторое другое значение смещения или дополнительное начальное значение, это число должно быть простым / нетривиальным фактором)

Шаг 2. Используйте эти два начальных результата для заполнения генератора снова вернуться в функцию (так, как сказал Геза, семена были плохие)

Шаг 3, при получении результата вместо того, чтобы по модулю пытаться получить количество предметов (4), или & 3, по модулю результата на простое число первый затем применить & 3. Я не уверен, имеет ли значение праймер, являющийся мерсенновым, или нет.

Вот результат с использованием Prime = 257 и xorshiftplus! (обратите внимание, что я использовал 2048 на 2048 для этого, остальные были 256 на 256)