C++ 不期望的规则柏林噪声

我试图在一个星球的球体上实现fBm。为了创建我的球体，我将它从立方体转换为这样的球体。 不幸的是，生成的fBm显示为镜像面片。此外，它仅在两个面上执行此操作（包装其他面的值）。 这会在渲染为图形时产生类似的拉伸外观

噪声函数是改进的噪声，如所述， 我为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 ))));
  }

float-fade（float-t）{return t*t*t*（t*（t*6-15）+10）}
浮点lerp（浮点t，浮点a，浮点b）{返回a+t*（b-a）；}
浮点梯度（整数散列、浮点x、浮点y、浮点z）{
int h=hash&15；//转换4位哈希代码
float u=h函数无法访问int p数组，因此我假设其中的值未定义。
一个快速修复方法是使数组保持静态，但这非常缓慢。
所以现在我需要传入数组。但我遇到了问题。
我在Dx11星球渲染项目中使用了下面的噪波函数。我还包括了一个fBm函数。我在WebGL着色器编程网站上找到了它（用GLSL编写）

它是由该网站的作者、神性的伊尼戈·奎莱兹（inigo quilez）撰写的

试一试，我希望能有所帮助。所有的功劳都应该归于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;
}

//基于散列的三维值噪波
//函数取自https://www.shadertoy.com/view/XslGRr
//由inigo quilez创建-iq/2013
//许可证知识共享署名非商业性ShareAlike 3.0未经移植的许可证。
//从GLSL移植到HLSL
cbuffer cbNoiseParameters
{
浮球；
浮子灵敏度；
浮动频率；
漂浮(rAmplitude),；
漂浮物；
浮球；
};
浮点散列（浮点n）
{
回流压裂（sin（n）*43758.5453）；
}
浮动噪声（浮动3 x）
{
//noise函数返回的值范围为-1.0f->1.0f
浮动3 p=地板（x）；
浮动3 f=压裂（x）；
f=f*f*（3.0-2.0*f）；
浮动n=p.x+p.y*57.0+113.0*p.z；
返回lerp（lerp（lerp（散列（n+0.0）、散列（n+1.0）、f.x），
lerp（散列（n+57.0）、散列（n+58.0）、f.x）、f.y），
lerp（lerp（散列（n+113.0）、散列（n+114.0）、f.x），
lerp（散列（n+170.0）、散列（n+171.0）、f.x、f.y）、f.z）；
}
浮动fBm（浮动3 vPt）
{
浮动八度音阶=_rOctaves；
浮动空隙率=_rlacurity；
浮动频率=_r频率；
浮动幅度=_斜率；
浮动增益=_rGain；
浮动偏移量=_rOffset；
浮动值=0.f；
对于（int i=0；i<八度；++i）
{
值+=噪声（vPt*频率）*振幅；
振幅*=增益；
频率*=空隙率；
}
返回值；
}
参见scrawkblog版本