Funções aleatórias / ruído para GLSL
https://stackoverflow.com/questions/4200224
-
25-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Como os fornecedores de motorista da GPU geralmente não se preocupam em implementar noiseX em GLSL, estou procurando um "Faca de randomização de randomização gráfica" do exército " Conjunto de funções de utilidade, de preferência otimizado para usar nos shaders da GPU. Eu prefiro o GLSL, mas o código qualquer idioma fará por mim, estou bem em traduzi -lo por conta própria para GLSL.
Especificamente, eu esperaria:
a) Funções pseudo-aleatórias -D-dimensional, distribuição uniforme sobre [-1,1] ou mais de [0,1], calculada a partir de sementes dimensionais M (idealmente sendo qualquer valor, mas estou bem em ter a semente restringida a, digamos, 0. .1 para distribuição uniforme de resultados). Algo como:
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) Ruído contínuo Como o ruído perlin- novamente, a distribuição n-dimensional, +- uniforme, com conjunto de valores restritos e, bem, parece bom (algumas opções para configurar a aparência como os níveis perlin também podem ser úteis). Eu esperaria assinaturas como:
float noise (T coord, TT seed);
vec2 noise2 (T coord, TT seed);
// ...
Eu não gosto muito de teoria aleatória de geração de números, então eu mais ansiosamente iria para um solução pré-fabricada, mas eu também apreciaria respostas como "Aqui está um 1D Rand () muito bom e eficiente, e deixe-me explicar como fazer um bom n-dimensional rand () em cima dele ..." .
Solução
Para coisas muito simples de pseudorandom, eu uso este oliner que encontrei na internet em algum lugar:
float rand(vec2 co){
return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}
Você também pode gerar uma textura de ruído usando o que desejar, depois enviá -lo da maneira normal e provar os valores no seu shader; Eu posso desenterrar uma amostra de código mais tarde, se desejar.
Além disso, confira este ficheiro Para implementações GLSL do Perlin e Simplex Ruído, de Stefan Gustavson.
Outras dicas
A implementação de Gustavson usa uma textura 1D
Não, não, não, desde 2005. É apenas que as pessoas insistem em baixar a versão antiga. A versão que está no link que você forneceu usa apenas texturas 2D de 8 bits.
A nova versão de Ian McEwan, de Ashima, e eu, não usamos uma textura, mas funciona a cerca da metade da velocidade em plataformas típicas de desktop com muita largura de banda de textura. Em plataformas móveis, a versão sem textura pode ser mais rápida porque a textura geralmente é um gargalo significativo.
Nosso repositório de origem mantido ativamente é:
https://github.com/ashima/webgl-noise
Uma coleção das versões de ruído sem textura e uso de textura está aqui (usando apenas texturas 2D):
http://www.itn.liu.se/~stegu/simplexnoise/glsl-noise-vs-loise.zip
Se você tiver alguma dúvida específica, sinta-se à vontade para me enviar um e-mail diretamente (meu endereço de e-mail pode ser encontrado no classicnoise*.glsl fontes.)
Ocorre -me que você pode usar uma função simples de hash inteiro e inserir o resultado no Mantissa de um flutuador. O IIRC, as especificações GLSL, garante números inteiros não assinados de 32 bits e representação de flutuação do IEEE Binário32, para que seja perfeitamente portátil.
Eu tentei isso agora. Os resultados são muito bons: parece exatamente como estática com todas as entradas que tentei, sem padrões visíveis. Em contraste, o snippet Popular Sin/Fract tem linhas diagonais razoavelmente pronunciadas na minha GPU, com as mesmas entradas.
Uma desvantagem é que ela requer GLSL v3.30. E embora pareça rápido o suficiente, eu não quantifiquei empiricamente seu desempenho. O analisador Shader da AMD reivindica 13,33 pixels por relógio para a versão VEC2 em um HD5870. Contraste com 16 pixels por relógio para o trecho sin/fract. Portanto, é certamente um pouco mais lento.
Aqui está minha implementação. Deixei em várias permutações da idéia para facilitar a obtenção de suas próprias funções.
/*
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 );
}
Captura de tela:
Eu inspecionei a captura de tela em um programa de edição de imagens. Existem 256 cores e o valor médio é 127, o que significa que a distribuição é uniforme e abrange a faixa esperada.
Ruído de ouro
// Gold Noise ©2015 dcerisano@standard3d.com
// - based on the Golden Ratio, PI and Square Root of Two
// - superior distribution
// - fastest noise generator function
// - works with all chipsets (including low precision)
float PHI = 1.61803398874989484820459 * 00000.1; // Golden Ratio
float PI = 3.14159265358979323846264 * 00000.1; // PI
float SQ2 = 1.41421356237309504880169 * 10000.0; // Square Root of Two
float gold_noise(in vec2 coordinate, in float seed){
return fract(tan(distance(coordinate*(seed+PHI), vec2(PHI, PI)))*SQ2);
}
Veja Ruído de ouro no seu navegador agora!
Esta função melhorou a distribuição aleatória sobre a função atual na resposta de @appas a partir de 9 de setembro de 2017:
A função @appas também está incompleta, dado que não há semente fornecida (o UV não é uma semente - o mesmo para cada quadro) e não funciona com chipsets de baixa precisão. O ruído de ouro funciona com baixa precisão por padrão (muito mais rápido).
Há também uma boa implementação descrita aqui Por McEwan e @stefangustavson que se parecem com ruído de perlin, mas "não requer nenhuma configuração, ou seja, não texturas nem matrizes uniformes. Basta adicioná -lo ao seu código -fonte do shader e chamá -lo onde quiser".
Isso é muito útil, especialmente porque a implementação anterior de Gustavson, que @dep vinculada, usa uma textura 1D, que é não suportado no GLSL es (A linguagem do shader do webgl).
Acabei de encontrar esta versão do 3D ruído para a GPU, Aldeddedly é a mais rápida disponível:
#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
Uma versão reta e irregular do 1D Perlin, essencialmente um Zigzag LFO aleatório.
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);
}
Também encontrei 1-2-3-4D ruído de perlin no site do proprietário da Shadetoy, Inigo Quilez Perlin, e Voronoi e assim por diante, ele tem implementações e códigos rápidos completos para eles.
HASH: Atualmente, o webgl2.0 existe, portanto, os números inteiros estão disponíveis no (w) GLSL. -> Para hash portátil de qualidade (a um custo semelhante ao feio hashes de flutuação), agora podemos usar técnicas de hash "sérias". QI implementou alguns em https://www.shaderoy.com/view/xlxcw4 (e mais)
Por exemplo:
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));
}
Use isto:
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);
}
Não use isso:
float rand(vec2 co){
return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
}
Você pode encontrar a explicação em Melhorias para o canônico One-Liner GLSL Rand () para OpenGL ES 2.0
Por favor, veja abaixo um exemplo de como adicionar ruído branco à textura renderizada. A solução é usar duas texturas: ruído branco original e puro, como este: Wiki White Ruído
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";
O fragmento compartilhado contém parâmetro unoiseFactor, que é atualizado em todas as renderizações pelo aplicativo principal:
float noiseValue = (float)(mRand.nextInt() % 1000)/1000;
int noiseFactorUniformHandle = GLES20.glGetUniformLocation( mProgram, "sNoiseTextureUnit");
GLES20.glUniform1f(noiseFactorUniformHandle, noiseFactor);
Traduzi uma das implementações Java de Ken Perlin no GLSL e a usei em alguns projetos em Shadetoy.
Abaixo está a interpretação GLSL que fiz:
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);
}
Eu o traduzi do Apêndice B do capítulo 2 do hardware de ruído de Ken Perlin nesta fonte:
https://www.csee.umbc.edu/~olano/s2002c36/ch02.pdf
Aqui está uma tonalidade pública que fiz no brinquedo shader que usa a função de ruído postada:
https://www.shaderoy.com/view/3slxzm
Algumas outras boas fontes que encontrei sobre o assunto de ruído durante minha pesquisa incluem:
https://thebookofshaders.com/11/
https://mzucker.github.io/html/perlin-noise-math-daq.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/gpugums/gpugums/gpugums_ch05.html
Eu recomendo o livro dos shaders, pois ele não apenas fornece uma ótima explicação interativa de ruído, mas também outros conceitos de shader.
EDITAR:
Pode ser capaz de otimizar o código traduzido usando algumas das funções aceleradas de hardware disponíveis no GLSL. Atualizarei este post se eu acabar fazendo isso.
