ฟังก์ชั่นสุ่ม / เสียงรบกวนสำหรับ GLSL

ในฐานะที่เป็นผู้ผลิต GPU คนขับรถมักจะไม่รำคาญที่จะดำเนินการnoiseXใน GLSL ฉันมองหา"กราฟิกสุ่มมีดทหารสวิส"ชุดยูทิลิตี้ฟังก์ชั่นที่ดีที่สุดโดยเฉพาะอย่างยิ่งกับการใช้งานภายใน shaders GPU ฉันชอบ GLSL แต่รหัสภาษาใด ๆ ที่จะทำเพื่อฉันฉันตกลงกับการแปลเป็นของตัวเองเพื่อ GLSL

โดยเฉพาะฉันคาดหวัง:

a) ฟังก์ชั่นสุ่มหลอก - N-dimension, การกระจายแบบสม่ำเสมอเหนือ [-1,1] หรือสูงกว่า [0,1], คำนวณจากเมล็ด M-dimension (เป็นการดีที่มีค่าใด ๆ แต่ฉันก็โอเคกับการยับยั้งเมล็ด เพื่อ, พูด, 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 แรนด์ที่ดีและมีประสิทธิภาพมากและให้ฉันอธิบาย คุณวิธีที่จะทำให้ N-มิติแรนด์ (ดี) ด้านบนของมัน ..."

สำหรับสิ่งที่ดูหลอกง่ายมากฉันใช้ oneliner นี้ที่ฉันพบบนอินเทอร์เน็ตที่ไหนสักแห่ง:

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

นอกจากนี้คุณยังสามารถสร้างพื้นผิวเสียงโดยใช้สิ่งที่คุณต้องการ PRNG จากนั้นอัปโหลดตามปกติและตัวอย่างค่าใน shader ของคุณ ฉันสามารถขุดตัวอย่างโค้ดได้ในภายหลังหากคุณต้องการ

นอกจากนี้ให้ตรวจสอบไฟล์นี้สำหรับการใช้งาน GLSL ของเสียง Perlin และ Simplex โดย Stefan Gustavson

มันเกิดขึ้นกับฉันว่าคุณสามารถใช้ฟังก์ชันแฮชจำนวนเต็มอย่างง่ายและแทรกผลลัพธ์ลงใน Mantant ของ float IIRC ข้อมูลจำเพาะ GLSL รับประกันจำนวนเต็มที่ไม่ได้ลงชื่อ 32 บิตและการแทนค่าทศนิยม IEEE binary32 float ดังนั้นจึงควรพกพาได้อย่างสมบูรณ์แบบ

ฉันได้ลองทำสิ่งนี้แล้ว ผลลัพธ์เป็นสิ่งที่ดีมาก: ดูเหมือนว่าจะคงที่กับทุกอินพุตที่ฉันพยายามไม่มีรูปแบบที่มองเห็นได้เลย ในทางตรงกันข้ามความนิยมตัวอย่างของ sin / fract มีเส้นทแยงมุมที่เด่นชัดบน GPU ของฉันเนื่องจากอินพุตเดียวกัน

ข้อเสียอย่างหนึ่งคือต้องมี GLSL v3.30 และถึงแม้ว่ามันจะดูเร็วพอ แต่ฉันก็ไม่ได้ทำการคำนวณเชิงประจักษ์ เครื่องวิเคราะห์ Shader ของ AMD อ้างว่า 13.33 พิกเซลต่อนาฬิกาสำหรับรุ่น vec2 ใน HD5870 คมชัดด้วย 16 พิกเซลต่อนาฬิกาสำหรับตัวอย่างข้อมูล sin / fract ดังนั้นจึงช้าลงเล็กน้อย

นี่คือการดำเนินการของฉัน ฉันทิ้งมันไว้ในการเรียงลำดับความคิดที่หลากหลายเพื่อให้ง่ายต่อการได้รับฟังก์ชั่นของคุณเอง

/*
    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 เป็นเพียงแค่ผู้คนยืนยันที่จะดาวน์โหลดเวอร์ชันเก่า รุ่นที่อยู่ในลิงค์ที่คุณให้ไว้จะใช้พื้นผิว 2D 8 บิตเท่านั้น

เวอร์ชันใหม่โดย Ian McEwan จาก Ashima และตัวฉันเองไม่ได้ใช้พื้นผิว แต่ทำงานที่ความเร็วประมาณครึ่งหนึ่งบนแพลตฟอร์มเดสก์ท็อปทั่วไปที่มีแบนด์วิธพื้นผิวจำนวนมาก บนแพลตฟอร์มมือถือรุ่นที่ไม่มีพื้นผิวนั้นอาจเร็วกว่าเพราะพื้นผิวมักจะเป็นคอขวดที่สำคัญ

แหล่งเก็บข้อมูลที่เราดูแลอย่างแข็งขันคือ:

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

ดู Gold Noise ในเบราว์เซอร์ของคุณตอนนี้!

ฟังก์ชันนี้ปรับปรุงการกระจายแบบสุ่มบนฟังก์ชันปัจจุบันในคำตอบ @appas ณ วันที่ 9 กันยายน 2017:

ฟังก์ชั่น @appas ยังไม่สมบูรณ์เนื่องจากไม่มีการจัดหาเมล็ดพันธุ์ (uv ไม่ใช่เมล็ด - เหมือนกันสำหรับทุกเฟรม) และไม่ทำงานกับชิปเซ็ตที่มีความแม่นยำต่ำ เสียงทองจะทำงานที่ความแม่นยำต่ำโดยค่าเริ่มต้น (เร็วกว่ามาก)

นอกจากนี้ยังมีการนำไปใช้งานที่ดีที่อธิบายไว้ที่นี่โดย McEwan และ @StefanGustavson ซึ่งดูเหมือนว่าเสียง Perlin แต่ "ไม่ต้องการการตั้งค่าใด ๆ เช่นไม่ใช่พื้นผิวหรือชุดอาร์เรย์เพียงแค่เพิ่มลงในซอร์สโค้ด shader ของคุณแล้วโทรไปที่ใดก็ได้"

มีประโยชน์มากโดยเฉพาะอย่างยิ่งเนื่องจากการใช้งานก่อนหน้าของ Gustavson ซึ่ง @dep ที่เชื่อมโยงใช้ใช้พื้นผิว 1D ซึ่งไม่ได้รับการสนับสนุนใน GLSL ES (ภาษา shader ของ WebGL)

ใช้สิ่งนี้:

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

คุณสามารถหาคำอธิบายได้ในการปรับปรุงมาตรฐาน GLSL แรนด์ () แบบมาตรฐานสำหรับ Canonical สำหรับ OpenGL ES 2.0

เพิ่งค้นพบเสียงรบกวน 3 มิติสำหรับ GPU นี้มันเป็นสิ่งที่เร็วที่สุด:

#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 zigzag แบบสุ่ม

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

ฉันยังได้พบเสียงเพอร์ลิน 1-2-3-4d บนเว็บไซต์กวดวิชาเจ้าของ shadertoy inigo quilez perlin และ voronoi และอื่น ๆ เขามีการใช้งานและรหัสที่รวดเร็วสำหรับพวกเขา

แฮช: ทุกวันนี้ 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));
}

โปรดดูตัวอย่างด้านล่างวิธีเพิ่มเสียงสีขาวให้กับพื้นผิวที่แสดงผล การแก้ปัญหาคือการใช้พื้นผิวที่สอง: เสียงที่เป็นต้นฉบับและเสียงสีขาวบริสุทธิ์เช่นนี้: เสียงสีขาวของ wiki

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

ฉันแปลหนึ่งในการนำ Java ของ Ken Perlin ไปใช้ใน 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);
}

ฉันแปลจากภาคผนวก B จากบทที่ 2 ของ Ken Perlin's Noise Hardware ที่แหล่งข้อมูลนี้:

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

นี่คือร่มเงาสาธารณะที่ฉันทำกับ Shader Toy ที่ใช้ฟังก์ชั่นเสียงรบกวนที่โพสต์:

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

ฉันขอแนะนำหนังสือของ shaders เพราะมันไม่เพียง แต่ให้คำอธิบายที่ดีแบบโต้ตอบของเสียง แต่แนวคิด shader อื่น ๆ เช่นกัน

แก้ไข:

อาจสามารถปรับโค้ดที่แปลให้เหมาะสมโดยใช้ฟังก์ชันการเร่งด้วยฮาร์ดแวร์ที่มีอยู่ใน GLSL จะอัปเดตโพสต์นี้ถ้าฉันลงเอยด้วยการทำเช่นนี้