GLSL을위한 랜덤 / 노이즈 기능

GPU 드라이버 공급 업체는 일반적으로 noiseXGLSL에서 구현하기 를 귀찮게하지 않기 때문에 GPU 셰이더 내에서 사용하도록 최적화 된 "그래픽 랜덤 스위스 군용 칼" 유틸리티 기능 세트를 찾고 있습니다. GLSL을 선호하지만 모든 언어가 나를 위해 코드를 작성하면 GLSL로 직접 번역해도 괜찮습니다.

특히, 나는 기대할 것이다 :

a) 의사 난수 함수 -M 차원 시드에서 계산 된 [-1,1] 또는 [0,1]에 대한 N 차원의 균일 분포 (이상적으로는 값이 있지만 시드를 억제해도 괜찮습니다) 균일 한 결과 분포를 위해 0..1). 다음과 같은 것 :

float random  (T seed);
vec2  random2 (T seed);
vec3  random3 (T seed);
vec4  random4 (T seed);
// T being either float, vec2, vec3, vec4 - ideally.

b) Perlin Noise와 같은 연속적인 노이즈-다시 한번, N- 차원, +-균등 분포, 제한된 값 세트 및 잘 보임 (Perlin 레벨과 같은 모양을 구성하는 일부 옵션도 유용 할 수 있음). 다음과 같은 서명을 기대합니다.

float noise  (T coord, TT seed);
vec2  noise2 (T coord, TT seed);
// ...

난수 생성 이론에 그다지 많지 않으므로 미리 만들어진 솔루션 을 간절히 원 하지만 "아주 훌륭하고 효율적인 1D rand ()가 있습니다. 그 위에 좋은 N- 차원 rand ()를 만드는 방법 ... " .

매우 단순한 의사 난수처럼 보이는 물건을 위해 인터넷에서 찾은이 oneliner를 사용합니다.

float rand(vec2 co){
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

원하는 PRNG를 사용하여 노이즈 텍스처를 생성 한 다음 일반적인 방식으로 업로드하고 셰이더의 값을 샘플링 할 수도 있습니다. 원하는 경우 나중에 코드 샘플을 파낼 수 있습니다.

또한 Stefan Gustavson의 Perlin 및 Simplex 노이즈의 GLSL 구현에 대해서도이 파일 을 확인하십시오 .

간단한 정수 해시 함수를 사용하고 결과를 float의 가수에 삽입 할 수 있다는 것이 나에게 발생합니다. IIRC의 GLSL 사양은 32 비트 부호없는 정수와 IEEE binary32 float 표현을 보장하므로 완벽하게 이식 가능해야합니다.

나는 지금 이것을 시도했다. 결과는 매우 좋습니다 : 시도한 모든 입력에 대해 정적 인 것처럼 보이며 패턴이 전혀 보이지 않습니다. 대조적으로 인기있는 sin / fract 스 니펫은 동일한 입력이 주어지면 GPU의 대각선을 상당히 뚜렷하게 나타냅니다.

한 가지 단점은 GLSL v3.30이 필요하다는 것입니다. 그리고 그것은 충분히 빠르지 만, 나는 경험적으로 그 성능을 정량화하지 않았습니다. AMD의 Shader Analyzer는 HD5870에서 vec2 버전에 대해 클럭 당 13.33 픽셀을 청구합니다. sin / fract 스 니펫의 경우 클럭 당 16 픽셀과 대조됩니다. 따라서 조금 느려집니다.

여기 내 구현이 있습니다. 나는 자신의 기능을 쉽게 파생시킬 수 있도록 아이디어를 다양한 순열로 남겼습니다.

/*
    static.frag
    by Spatial
    05 July 2013
*/

#version 330 core

uniform float time;
out vec4 fragment;



// A single iteration of Bob Jenkins' One-At-A-Time hashing algorithm.
uint hash( uint x ) {
    x += ( x << 10u );
    x ^= ( x >>  6u );
    x += ( x <<  3u );
    x ^= ( x >> 11u );
    x += ( x << 15u );
    return x;
}



// Compound versions of the hashing algorithm I whipped together.
uint hash( uvec2 v ) { return hash( v.x ^ hash(v.y)                         ); }
uint hash( uvec3 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z)             ); }
uint hash( uvec4 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z) ^ hash(v.w) ); }



// Construct a float with half-open range [0:1] using low 23 bits.
// All zeroes yields 0.0, all ones yields the next smallest representable value below 1.0.
float floatConstruct( uint m ) {
    const uint ieeeMantissa = 0x007FFFFFu; // binary32 mantissa bitmask
    const uint ieeeOne      = 0x3F800000u; // 1.0 in IEEE binary32

    m &= ieeeMantissa;                     // Keep only mantissa bits (fractional part)
    m |= ieeeOne;                          // Add fractional part to 1.0

    float  f = uintBitsToFloat( m );       // Range [1:2]
    return f - 1.0;                        // Range [0:1]
}



// Pseudo-random value in half-open range [0:1].
float random( float x ) { return floatConstruct(hash(floatBitsToUint(x))); }
float random( vec2  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( vec3  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( vec4  v ) { return floatConstruct(hash(floatBitsToUint(v))); }





void main()
{
    vec3  inputs = vec3( gl_FragCoord.xy, time ); // Spatial and temporal inputs
    float rand   = random( inputs );              // Random per-pixel value
    vec3  luma   = vec3( rand );                  // Expand to RGB

    fragment = vec4( luma, 1.0 );
}

스크린 샷 :

이미지 편집 프로그램에서 스크린 샷을 검사했습니다. 256 개의 색상이 있으며 평균값은 127입니다. 이는 분포가 균일하고 예상 범위를 포함 함을 의미합니다.

Gustavson의 구현은 1D 텍스처를 사용합니다.

아닙니다. 2005 년 이후가 아닙니다. 사람들이 구 버전 다운로드를 고집하는 것뿐입니다. 제공 한 링크에있는 버전은 8 비트 2D 텍스처 만 사용합니다.

Ashima의 Ian McEwan과 새 버전은 텍스처를 사용하지 않지만 텍스처 대역폭이 많은 일반 데스크탑 플랫폼에서 속도의 약 절반 속도로 실행됩니다. 모바일 플랫폼에서 텍스처링은 종종 병목 현상으로 인해 텍스처리스 버전이 더 빠를 수 있습니다.

적극적으로 유지 관리되는 소스 저장소는 다음과 같습니다.

https://github.com/ashima/webgl-noise

텍스처리스 및 텍스처 사용 버전의 노이즈 컬렉션이 여기 있습니다 (2D 텍스처 만 사용).

http://www.itn.liu.se/~stegu/simplexnoise/GLSL-noise-vs-noise.zip

질문이 있으시면 언제든지 저에게 직접 이메일을 보내주십시오 (내 이메일 주소는 classicnoise*.glsl소스 에서 찾을 수 있습니다 ).

골드 노이즈

// Gold Noise ©2015 dcerisano@standard3d.com
// - based on the Golden Ratio
// - uniform normalized distribution
// - fastest static noise generator function (also runs at low precision)

float PHI = 1.61803398874989484820459;  // Φ = Golden Ratio   

float gold_noise(in vec2 xy, in float seed){
       return fract(tan(distance(xy*PHI, xy)*seed)*xy.x);
}

지금 브라우저에서 골드 노이즈를보십시오!

이 함수는 2017 년 9 월 9 일 현재 @appas 'answer의 현재 함수에 대한 임의 분포를 개선했습니다.

@appas 함수도 시드가 제공되지 않아 (uv는 시드가 아니고 – 모든 프레임에 동일), 낮은 정밀도 칩셋에서 작동하지 않기 때문에 불완전합니다. 골드 노이즈는 기본적으로 낮은 정밀도로 실행됩니다 (훨씬 빠름).

멋진 구현 설명도 있습니다 여기에 소음 펄린 같은 외모,하지만 "어떤 설정, 즉하지 질감도 균일 한 배열을 필요로하지 않습니다. 그냥 쉐이더 소스 코드에 추가하고 당신이 원하는 목적지를 호출"고 McEwan은과 @StefanGustavson에 의해.

@dep에 연결된 Gustavson의 이전 구현 이 GLSL ES (WebGL의 셰이더 언어) 에서 지원되지 않는 1D 텍스처를 사용한다는 점에서 특히 유용합니다 .

이것을 사용하십시오 :

highp float rand(vec2 co)
{
    highp float a = 12.9898;
    highp float b = 78.233;
    highp float c = 43758.5453;
    highp float dt= dot(co.xy ,vec2(a,b));
    highp float sn= mod(dt,3.14);
    return fract(sin(sn) * c);
}

이것을 사용하지 마십시오 :

float rand(vec2 co){
    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}

OpenGL ES 2.0의 정식 단일 라이너 GLSL rand () 개선 에서 설명을 찾을 수 있습니다.

GPU에 대한이 3d 노이즈 버전을 찾았습니다.

#ifndef __noise_hlsl_
#define __noise_hlsl_

// 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

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);
}

#endif

1d Perlin의 직선, 들쭉날쭉 한 버전, 본질적으로 임의의 lfo 지그재그.

half  rn(float xx){         
    half x0=floor(xx);
    half x1=x0+1;
    half v0 = frac(sin (x0*.014686)*31718.927+x0);
    half v1 = frac(sin (x1*.014686)*31718.927+x1);          

    return (v0*(1-frac(xx))+v1*(frac(xx)))*2-1*sin(xx);
}

또한 shadertoy 소유자 inigo quilez perlin tutorial 웹 사이트 및 voronoi 등에서 1-2-3-4d perlin 노이즈를 발견했으며, 그에 대한 빠른 구현 및 코드가 있습니다.

해시 : 요즘 webGL2.0이 있으므로 (w) GLSL에서 정수를 사용할 수 있습니다. -> 휴대용 포터블 해시 (못생긴 플로트 해시와 비슷한 비용)를 위해 이제 "심각한"해싱 기술을 사용할 수 있습니다. IQ는 https://www.shadertoy.com/view/XlXcW4 (및 그 이상) 에서 일부를 구현했습니다.

예 :

  const uint k = 1103515245U;  // GLIB C
//const uint k = 134775813U;   // Delphi and Turbo Pascal
//const uint k = 20170906U;    // Today's date (use three days ago's dateif you want a prime)
//const uint k = 1664525U;     // Numerical Recipes

vec3 hash( uvec3 x )
{
    x = ((x>>8U)^x.yzx)*k;
    x = ((x>>8U)^x.yzx)*k;
    x = ((x>>8U)^x.yzx)*k;

    return vec3(x)*(1.0/float(0xffffffffU));
}

렌더링 된 텍스처에 화이트 노이즈를 추가하는 방법의 예를 아래에서 참조하십시오. 이것처럼, 원래의 순수한 백색 잡음 :이 솔루션은 두 개의 텍스처를 사용하는 화이트 노이즈 위키

private static final String VERTEX_SHADER =
    "uniform mat4 uMVPMatrix;\n" +
    "uniform mat4 uMVMatrix;\n" +
    "uniform mat4 uSTMatrix;\n" +
    "attribute vec4 aPosition;\n" +
    "attribute vec4 aTextureCoord;\n" +
    "varying vec2 vTextureCoord;\n" +
    "varying vec4 vInCamPosition;\n" +
    "void main() {\n" +
    "    vTextureCoord = (uSTMatrix * aTextureCoord).xy;\n" +
    "    gl_Position = uMVPMatrix * aPosition;\n" +
    "}\n";

private static final String FRAGMENT_SHADER =
        "precision mediump float;\n" +
        "uniform sampler2D sTextureUnit;\n" +
        "uniform sampler2D sNoiseTextureUnit;\n" +
        "uniform float uNoseFactor;\n" +
        "varying vec2 vTextureCoord;\n" +
        "varying vec4 vInCamPosition;\n" +
        "void main() {\n" +
                "    gl_FragColor = texture2D(sTextureUnit, vTextureCoord);\n" +
                "    vec4 vRandChosenColor = texture2D(sNoiseTextureUnit, fract(vTextureCoord + uNoseFactor));\n" +
                "    gl_FragColor.r += (0.05 * vRandChosenColor.r);\n" +
                "    gl_FragColor.g += (0.05 * vRandChosenColor.g);\n" +
                "    gl_FragColor.b += (0.05 * vRandChosenColor.b);\n" +
        "}\n";

공유 된 프래그먼트에는 uNoiseFactor 매개 변수가 포함되어 있으며, 이는 주 애플리케이션에 의해 모든 렌더링에서 업데이트됩니다.

float noiseValue = (float)(mRand.nextInt() % 1000)/1000;
int noiseFactorUniformHandle = GLES20.glGetUniformLocation( mProgram, "sNoiseTextureUnit");
GLES20.glUniform1f(noiseFactorUniformHandle, noiseFactor);

Ken Perlin의 Java 구현 중 하나를 GLSL로 변환하여 ShaderToy의 두 프로젝트에서 사용했습니다.

아래는 내가 한 GLSL 해석입니다.

int b(int N, int B) { return N>>B & 1; }
int T[] = int[](0x15,0x38,0x32,0x2c,0x0d,0x13,0x07,0x2a);
int A[] = int[](0,0,0);

int b(int i, int j, int k, int B) { return T[b(i,B)<<2 | b(j,B)<<1 | b(k,B)]; }

int shuffle(int i, int j, int k) {
    return b(i,j,k,0) + b(j,k,i,1) + b(k,i,j,2) + b(i,j,k,3) +
        b(j,k,i,4) + b(k,i,j,5) + b(i,j,k,6) + b(j,k,i,7) ;
}

float K(int a, vec3 uvw, vec3 ijk)
{
    float s = float(A[0]+A[1]+A[2])/6.0;
    float x = uvw.x - float(A[0]) + s,
        y = uvw.y - float(A[1]) + s,
        z = uvw.z - float(A[2]) + s,
        t = 0.6 - x * x - y * y - z * z;
    int h = shuffle(int(ijk.x) + A[0], int(ijk.y) + A[1], int(ijk.z) + A[2]);
    A[a]++;
    if (t < 0.0)
        return 0.0;
    int b5 = h>>5 & 1, b4 = h>>4 & 1, b3 = h>>3 & 1, b2= h>>2 & 1, b = h & 3;
    float p = b==1?x:b==2?y:z, q = b==1?y:b==2?z:x, r = b==1?z:b==2?x:y;
    p = (b5==b3 ? -p : p); q = (b5==b4 ? -q : q); r = (b5!=(b4^b3) ? -r : r);
    t *= t;
    return 8.0 * t * t * (p + (b==0 ? q+r : b2==0 ? q : r));
}

float noise(float x, float y, float z)
{
    float s = (x + y + z) / 3.0;  
    vec3 ijk = vec3(int(floor(x+s)), int(floor(y+s)), int(floor(z+s)));
    s = float(ijk.x + ijk.y + ijk.z) / 6.0;
    vec3 uvw = vec3(x - float(ijk.x) + s, y - float(ijk.y) + s, z - float(ijk.z) + s);
    A[0] = A[1] = A[2] = 0;
    int hi = uvw.x >= uvw.z ? uvw.x >= uvw.y ? 0 : 1 : uvw.y >= uvw.z ? 1 : 2;
    int lo = uvw.x <  uvw.z ? uvw.x <  uvw.y ? 0 : 1 : uvw.y <  uvw.z ? 1 : 2;
    return K(hi, uvw, ijk) + K(3 - hi - lo, uvw, ijk) + K(lo, uvw, ijk) + K(0, uvw, ijk);
}

이 소스에서 Ken Perlin의 노이즈 하드웨어 2 장 부록 B에서 번역했습니다.

https://www.csee.umbc.edu/~olano/s2002c36/ch02.pdf

게시 된 노이즈 기능을 사용하는 셰이더 토이에서 한 공개 셰이드는 다음과 같습니다.

https://www.shadertoy.com/view/3slXzM

연구 중에 소음에 관한 다른 좋은 소스는 다음과 같습니다.

https://thebookofshaders.com/11/

https://mzucker.github.io/html/perlin-noise-math-faq.html

https://rmarcus.info/blog/2018/03/04/perlin-noise.html

http://flafla2.github.io/2014/08/09/perlinnoise.html

https://mrl.nyu.edu/~perlin/noise/

https://rmarcus.info/blog/assets/perlin/perlin_paper.pdf

https://developer.nvidia.com/gpugems/GPUGems/gpugems_ch05.html

노이즈에 대한 훌륭한 대화식 설명뿐만 아니라 다른 셰이더 개념도 제공하므로 셰이더를 강력히 권장합니다.

편집하다:

GLSL에서 사용 가능한 일부 하드웨어 가속 기능을 사용하여 변환 된 코드를 최적화 할 수 있습니다. 내가이 일을 끝내면이 게시물을 업데이트 할 것입니다.