Нежелательный регулярный шум Перлина

Я пытаюсь внедрить fBm в сферу для планеты. Чтобы создать свою сферу, я превращаю ее в такую ​​из куба.
К сожалению, генерируемый fBm выглядит как зеркальные патчи. Кроме того, он делает это только на 2 гранях (оборачивая значения для других граней).
Это приводит к аналогично растянутому виду при визуализации как сфера

Функция шума — это улучшенный шум, как описано Кен Перлин,
Я адаптировал это для HLSL:

  float fade(float t) { return t * t * t * (t * (t * 6 - 15) + 10); }

float lerp(float t, float a, float b) { return a + t * (b - a); }

float grad(int hash, float x, float y, float z) {
int h = hash & 15;                      // CONVERT LO 4 BITS OF HASH CODE
float u = h<8 ? x : y,                 // INTO 12 GRADIENT DIRECTIONS.
v = h<4 ? y : h==12||h==14 ? x : z;
return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
}
int p[512] = { 151,...180 }; //0-255 twice

float noise(float x, float y, float z) {int X = (int)floor(x) & 255;                  // FIND UNIT CUBE THAT
int Y = (int)floor(y) & 255;                  // CONTAINS POINT.
int Z = (int)floor(z) & 255;
x -= floor(x);                                // FIND RELATIVE X,Y,Z
y -= floor(y);                                // OF POINT IN CUBE.
z -= floor(z);
float u = fade(x),                                // COMPUTE FADE CURVES
v = fade(y),                                // FOR EACH OF X,Y,Z.
w = fade(z);
int A = p[X  ]+Y, AA = p[A]+Z, AB = p[A+1]+Z,      // HASH COORDINATES OF
B = p[X+1]+Y, BA = p[B]+Z, BB = p[B+1]+Z;      // THE 8 CUBE CORNERS,

return lerp(w, lerp(v, lerp(u, grad(p[AA  ], x  , y  , z   ),  // AND ADD
grad(p[BA  ], x-1, y  , z   )), // BLENDED
lerp(u, grad(p[AB  ], x  , y-1, z   ),  // RESULTS
grad(p[BB  ], x-1, y-1, z   ))),// FROM  8
lerp(v, lerp(u, grad(p[AA+1], x  , y  , z-1 ),  // CORNERS
grad(p[BA+1], x-1, y  , z-1 )), // OF CUBE
lerp(u, grad(p[AB+1], x  , y-1, z-1 ),
grad(p[BB+1], x-1, y-1, z-1 ))));
}

Эта реализация работала, как и ожидалось в предыдущем проекте, однако для этого проекта вместо этого создается сглаженная сетка, когда я использую положение вершины в качестве входных данных.
Это единичный куб, поэтому значения не являются целыми, но я не могу понять, почему он не создает типичную текстуру шума Перлина.

Любая помощь будет принята с благодарностью, я предоставлю больше информации, если это необходимо.

3

Решение

Функция не может получить доступ к массиву целых чисел p, поэтому я предполагаю, что значения в нем не определены.
Быстрое решение состоит в том, чтобы сделать массив статичным, но это действительно медленно.
Так что теперь мне нужно передать в массив. Но у меня проблемы с этим.

0

Другие решения

Я использую функцию шума ниже в проекте рендеринга планеты Dx11. Я включил функцию FBM тоже. Я нашел это (написано на GLSL) на веб-сайте программирования шейдеров WebGL ShaderToy.

Он был написан богоподобным Иниго Квилезом, который создал сайт.

Попробуйте, я надеюсь, что это поможет. Вся заслуга должна идти в Inigo Quilez за его работу. Портировать его в HLSL тривиально. Я тестировал только в шейдерной модели 5, но я уверен, что она будет работать как минимум под 4.

// hash based 3d value noise
// function taken from https://www.shadertoy.com/view/XslGRr
// Created by inigo quilez - iq/2013
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

// ported from GLSL to HLSL

cbuffer cbNoiseParameters
{
float _rOctaves;
float _rLacunarity;
float _rFrequency;
float _rAmplitude;
float _rGain;
float _rOffset;
};

float hash( float n )
{
return frac(sin(n)*43758.5453);
}

float noise( float3 x )
{
// The noise function returns a value in the range -1.0f -> 1.0f

float3 p = floor(x);
float3 f = frac(x);

f       = f*f*(3.0-2.0*f);
float n = p.x + p.y*57.0 + 113.0*p.z;

return lerp(lerp(lerp( hash(n+0.0), hash(n+1.0),f.x),
lerp( hash(n+57.0), hash(n+58.0),f.x),f.y),
lerp(lerp( hash(n+113.0), hash(n+114.0),f.x),
lerp( hash(n+170.0), hash(n+171.0),f.x),f.y),f.z);
}

float fBm( float3 vPt )
{
float octaves       = _rOctaves;
float lacunarity    = _rLacunarity;
float frequency     = _rFrequency;
float amplitude     = _rAmplitude;
float gain          = _rGain;
float offset        = _rOffset;
float value         = 0.f;

for( int i = 0; i < octaves; ++ i )
{
value += noise( vPt * frequency ) * amplitude;

amplitude *= gain;
frequency *= lacunarity;
}

return value;
}
0

По вопросам рекламы [email protected]