Textura procedimental

O filtro Textura procedimental permite realizar diversas manipulações de pixel usando funções predeterminadas e variáveis definidas pelo usuário. É possível escrever seus próprios filtros com parâmetros configuráveis.

Antes
Depois
Antes e depois. Um mapa de rugosidade é criado a partir de um mapa normal usando funções dot e debump. Em seguida, um modo de mesclagem Luz suave é usado para "reacender" uma renderização 3D.

Sobre o filtro Textura procedimental

Esse filtro pode ser aplicado como um filtro não destrutivo, em tempo real. Pode ser acessado por meio do menu Camada, na categoria Nova camada de filtro em tempo real.

Configurações

As configurações a seguir podem ser ajustadas na caixa de diálogo Filtro:


Usar o filtro

O filtro tem vários componentes chaves que devem ser compreendidos para usá-lo efetivamente:


Exemplos

Estes são alguns exemplos práticos de como o filtro de textura procedimental pode ser usado. Variáveis de entrada personalizadas são realçadas em negrito. Para seguir junto com eles, copie e cole a linha de código em uma nova linha de equação, defina destinos de canal se necessário e, em seguida, crie entradas personalizadas seguindo as entradas da tabela.

Vinheta redonda

Vinheta
var vignettew=vec2(rx, ry)/w; var vignetteh=vec2(rx, ry)/h; var productw=oscsc(vignettew); var producth=oscsc(vignetteh); scurveinterp(productw, producth, roundness)*(intensity*imultiplier)

Todos os três canais (R, G e B). Use um modo de mesclagem como Tela.

Tipo de entrada personalizado Nome da variável Explicação
entrada do intervalo [0,1] roundness Usada como uma variável em scurveinterp para controlar o arredondamento de vinheta.
entrada do intervalo [0,1] intensity Esse valor é multiplicado pelo resultado de scurveinterp para modificar a intensidade (brilho) da vinheta.
Entrada de número real imultiplier Esse número real é multiplicado pelo valorintensidade para dimensioná-la, resultando em um intervalo maior de brilho realizável.

Nessa expressão, há quatro declarações de variável. rx e ry são usados para criar dois resultados de vetor: vignettew e vignetteh. Os resultados de vetor são divididos pela largura e altura, respectivamente. A partir desses, calculamos productwe producth usando osciladores com curva S (oscsc). Finalmente, podemos interpolar entre esses dois resultados de produto usando um interpolador de curva S (scurveinterp). A mistura entre os dois resultados é controlada pela entrada personalizada roundness e o brilho é dimensionado de acordo com as entradas personalizadas intensity e imultiplier.

Porque rx e ry (posições relativas X e Y) são usados para a criação de vetor, o usuário pode clicar e arrastar na tela para determinar o ponto central (origem) da vinheta.

Quando o filtro é usado com um modo de mesclagem apropriado (usando a versão recomendada de filtro em tempo real), um efeito de vinheta adequado pode ser conseguido.

Máscara alfa diamante

Vinheta
var v=vec2(rx,ry)/w; smoothoschlin(oschcr(v/(dsize*dmult)), dsmooth)

Destino apenas o canal alfa (A).

Tipo de entrada personalizado Nome da variável Explicação
entrada do intervalo [0,1] dsmooth Controla a suavização de arestas da máscara.
entrada do intervalo [0,1] dsize Determina o tamanho da máscara.
Entrada de número real dmult Dimensiona dsize por um multiplicador para permitir tamanhos de máscara maior/menor.

Aqui, iremos converter os resultados de criação de vetor usando rx e rypara a variável v (dividindo o resultado pela largura do documento, w). O resultado v passa por um oscilador harmônico com um spline Catmull-Rom (oschcr), que por sua vez passa por um oscilador linear harmônico suave (smoothoschlin). Dentro da função oschcr, v é dividido por dsize*dmult, que controla o tamanho geral. dsmooth é usado dentro da função smoothoschlin para influenciar a suavidade e desfoque das bordas. Quando o destino do canal é definido como apenas alfa (A), essa expressão cria um efeito de máscara alfa diamante.

Porque rx e ry (posições relativas X e Y) são usados para a criação de vetor, o usuário pode clicar e arrastar na tela para alterar a posição do efeito de máscara.


Funções

Abaixo está uma tabela de funções que podem ser usados na seção Equações, onde:

Quando uma função usa argumentos T ou V, o tamanho do vetor precisa ser o mesmo para todos os argumentos. Eles não são intercambiáveis.

Função Uso Notas
Matemática comum
abs abs(T) Arredondar valor para inteiro absoluto
acos acos(T)
asin asin(T)
atan atan(T)
atan2 atan2(T, T)
average média (T, T,...) (argumentos variáveis)
ceil ceil(T) Arredondar valor para cima
copysign copysign(T, T sign)
cos cos(T)
dim dim(T x, T y)
floor floor(T) Arredondar valor para baixo
fma fma(T a, T b, T c) Calcula (a*b) + c
fmod fmod (T, T)
fraction fraction(T)
idiv idiv(T, T)
irem irem(T, T)
lerp lerp(T a, T b, T t) Interpolação linear entre dois valores, balanceados determinado por t entre 0-1
max max(T, T,...) (argumentos variáveis)
mid mid(T, T)
min min(T, T,...) (argumentos variáveis)
mix mix(T a, T b, T t) Mesmo que lerp
pow pow(T x, T y) x à potência de y
powr powr(T x, T y) x à potência de y onde x> 0
round round(T)
roundup roundup(T)
rounddown rounddown(T)
sign sign(T)
sin sin(T)
sq sq(T)
sqrt sqrt(T) Raiz quadrada
tan tan(T)
trunc trunc(T) Formato abreviado para truncate
truncate truncate(T)
rgbtoi rgbtoi(S r, S g, Sb) ou rgbtoi(V rgb)
whole whole(T)
Conversão de intervalo numérico
tocui tocui(T) Para intervalo de unidade fechado entre 0-1
tohcui tohcui(T) Para intervalo de unidade fechado entre -1-1 (harmônica)
Contenção
saturate saturate(T)
clamp clamp(T) ou clamp(T, T min, T max)
clampmin clampmin(T, T min)
clampmax clampmax(T, T max)
Funções geométricas
cross cross(V3, V3) Calcular o produto cruzado de dois componentes Vector3 (XYZ)
dist dist(V a, V b) Formato abreviado para distance
dist_sq dist_sq(V a, V b) Formato abreviado para distance_squared
distance distance(V a, V b)
distance_squared distance_squared(V a, V b)
dot dot(V, V)
length length(V) or length(S, S, ...)
length_squared length_squared(V) or length_squared(S, S, ...)
norm norm(V) Formato abreviado para normalise ou normalize
normalise normalise(V)
normalize normalize(V)
Vector creation
vec2 vec2(S) or vec2(S, S) Ideal para a criação de vetores de posicionamento XY, por exemplo vec2(rx, ry)
vec3 vec3(S) or vec3(S, S, S) Pode ser usado para criar vetores de dados de cor, por exemplo vec3(R, G, B)
vec4 vec4(S) or vec4(S, S, S, S)
vec5 vec5(S) or vec5(S, S, S, S, S)
vec6 vec6(S) or vec6(S, S, S, S, S, S)
tovec3 tovec3(V)
tovec4 tovec4(V)
tovec5 tovec5(V)
tovec6 tovec6(V)
Vector manipulation
rev rev(V)
rotl rotl(V) Gira o vetor para a esquerda
rotr rotr(V) Gira o vetor para a direita
swap12 swap12(V)
swap13 swap13(V)
swap23 swap23(V)
swapxy swapxy(V)
swapxz swapxz(V)
swapyz swapyz(V)
swaprg swaprg(V)
swaprb swaprb(V)
swapgb swapgb(V)
neg1 neg1(V)
neg2 neg2(V)
neg3 neg3(V)
neg12 neg12(V)
negx negx(V)
negy negy(V)
negz negz(V)
negxy negxy(V)
negr negr(V)
negg negg(V)
negb negb(V)
negrg negrg(V)
Utilitários de vetor
debump debump(S r, S g, S b)
Interpolação
scurveinterp scurveinterp(T a, T b, T t)
sininterp sininterp(T a, T b, T t)
cubicinterp cubicinterp(T a, T b, T c, T d, T t)
scurveinterpolant scurveinterpolant(T cui)
sininterpolant sininterpolant(T cui)
scerp scerp(T a, T b, T t) Formato abreviado para scurveinterp
serp serp(T a, T b, T t) Formato abreviado para sininterp
cerp cerp(T a, T b, T c, T d, T t) Formato abreviado para cubicinterp
cubic scerp(T a, T b, T c, T d, T t) Formato abreviado para cubicinterp
scint scint(T cui) Formato abreviado para scurverinterpolant
sint sint(T cui) Formato abreviado para sininterpolant
Etapas
mapcui mapcui(T v, T edge0, T edge1)
step step(T edge, T v)
stepn stepn(T edge, T v)
smoothsteplin smoothsteplin(T edge0, T edge1, T v) ou smoothsteplin(T in0, T in1, T out1, T out0, T v)
smoothstep smoothstep(T edge0, T edge1, T v) ou smoothstep(T in0, T in1, T out1, T out0, T v)
smoothstepsc smoothstepsc(T edge0, T edge1, T v) ou smoothstepsc(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) ou smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepcs smoothstepcs(T edge0, T edge1, T v) ou smoothstepcs(T in0, T in1, T out1, T out0, T v)
smoothstepsq smoothstepsq(T edge0, T edge1, T v) ou smoothstepsq(T in0, T in1, T out1, T out0, T v)
smoothstepsqi smoothstepsqi(T edge0, T edge1, T v) ou smoothstepsqi(T in0, T in1, T out1, T out0, T v)
smoothstepcb smoothstepcb(T edge0, T edge1, T v) ou smoothstepcb(T in0, T in1, T out1, T out0, T v)
smoothstepcbi smoothstepcbi(T edge0, T edge1, T v) ou smoothstepcbi(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) ou smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepsini smoothstepsini(T edge0, T edge1, T v) ou smoothstepsini(T in0, T in1, T out1, T out0, T v)
smoothstepcr smoothstepcr(T edge0, T edge1, T v) ou smoothstepcr(T in0, T in1, T out1, T out0, T v)
smoothstepcri smoothstepcri(T edge0, T edge1, T v) ou smoothstepcri(T in0, T in1, T out1, T out0, T v)
smoothsteprt smoothsteprt(T edge0, T edge1, T v) ou smoothsteprt(T in0, T in1, T out1, T out0, T v)
smoothsteprti smoothsteprti(T edge0, T edge1, T v) ou smoothsteprti(T in0, T in1, T out1, T out0, T v)
smoothstepnlin smoothstepnlin(T edge1, T edge0, T v)
smoothstepn smoothstepn(T edge1, T edge0, T v)
smoothstepnsc smoothstepnsc(T edge1, T edge0, T v)
smoothstepnsin smoothstepnsin(T edge1, T edge0, T v)
smoothstepncs smoothstepncs(T edge1, T edge0, T v)
smoothstepnsq smoothstepnsq(T edge1, T edge0, T v)
smoothstepnsqi smoothstepnsqi(T edge1, T edge0, T v)
smoothstepncb smoothstepncb(T edge1, T edge0, T v)
smoothstepncbi smoothstepncbi(T edge1, T edge0, T v)
smoothstepnpsini smoothstepnpsini(T edge1, T edge0, T v)
smoothstepncr smoothstepncr(T edge1, T edge0, T v)
smoothstepncri smoothstepncri(T edge1, T edge0, T v)
smoothstepnrt smoothstepnrt(T edge1, T edge0, T v)
smoothstepnrti smoothstepnrti(T edge1, T edge0, T v)
Quantização
quantize quantize(T band, T v) ou quantize(T band, T smooth, T v)
quantizelin quantizelin(T band, T smooth, T v)
quantizesc quantizesc(T band, T smooth, T v)
quantizesin quantizesin(T band, T smooth, T v)
quantizecs quantizecs(T band, T smooth, T v)
Osciladores
osci osci(S)
osci(S, S)
osci(V2)
Oscilação padrão, aceita entradas escalares ou vetoriais
oscsc oscsc(S)
oscsc(S, S)
oscsc(V2)
Oscilador com curva S
oscsin oscsin(S)
oscsin(S, S)
oscsin(V2)
osccs osccs(S)
osccs(S, S)
osccs(V2)
osccubic osccubic(S)
osccubic(S, S)
osccubic(V2)
oscsq oscsq(S)
oscsq(S, S)
oscsq(V2)
oscsqi oscsqi(S)
oscsqi(S, S)
oscsqi(V2)
osccb osccb(S)
osccb(S, S)
osccb(V2)
osccbi osccbi(S)
osccbi(S, S)
osccbi(V2)
oscpsin oscpsin(S)
oscpsin(S, S)
oscpsin(V2)
oscpsini oscpsini(S)
oscpsini(S, S)
oscpsini(V2)
osccr osccr(S)
osccr(S, S)
osccr(V2)
osccri osccri(S)
osccri(S, S)
osccri(V2)
oscrt oscrt(S)
oscrt(S, S)
oscrt(V2)
oscrti oscrti(S)
oscrti(S, S)
oscrti(V2)
smoothosclin smoothosclin(S, S smoothingwidth)
smoothosclin(S, S, S smoothingwidth)
smoothosclin(V2, S smoothingwidth)
smoothosc smoothosc(S, S smoothingwidth)
smoothosc(S, S, S smoothingwidth)
smoothosc(V2, S smoothingwidth)
smoothoscsc smoothoscsc(S, S smoothingwidth)
smoothoscsc(S, S, S smoothingwidth)
smoothoscsc(V2, S smoothingwidth)
smoothoscsin smoothoscsin(S, S smoothingwidth)
smoothoscsin(S, S, S smoothingwidth)
smoothoscsin(V2, S smoothingwidth)
smoothosccs smoothosccs(S, S smoothingwidth)
smoothosccs(S, S, S smoothingwidth)
smoothosccs(V2, S smoothingwidth)
Osciladores harmônicos
oschi oschi(S)
oschi(S, S)
oschi(V2)
osch osch(S)
osch(S, S)
osch(V2)
oschsc oschsc(S)
oschsc(S, S)
oschsc(V2)
oschsin oschsin(S)
oschsin(S, S)
oschsin(V2)
oschcs oschcs(S)
oschcs(S, S)
oschcs(V2)
oschcubic oschcubic(S)
oschcubic(S, S)
oschcubic(V2)
oschsq oschsq(S)
oschsq(S, S)
oschsq(V2)
oschsqi oschsqi(S)
oschsqi(S, S)
oschsqi(V2)
oschcb oschcb(S)
oschcb(S, S)
oschcb(V2)
oschcbi oschcbi(S)
oschcbi(S, S)
oschcbi(V2)
oschhsin oschhsin(S)
oschhsin(S, S)
oschhsin(V2)
oschhsini oschhsini(S)
oschhsini(S, S)
oschhsini(V2)
oschcr oschcr(S)
oschcr(S, S)
oschcr(V2)
oschcri oschcri(S)
oschcri(S, S)
oschcri(V2)
oschrt oschrt(S)
oschrt(S, S)
oschrt(V2)
oschrti oschrti(S)
oschrti(S, S)
oschrti(V2)
smoothoschlin smoothoschlin(S, S smoothingwidth)
smoothoschlin(S, S, S smoothingwidth)
smoothoschlin(V2, S smoothingwidth)
smoothosch smoothosch(S, S smoothingwidth)
smoothosch(S, S, S smoothingwidth)
smoothosch(V2, S smoothingwidth)
smoothoschsc smoothoschsc(S, S smoothingwidth)
smoothoschsc(S, S, S smoothingwidth)
smoothoschsc(V2, S smoothingwidth)
smoothoschsin smoothoschsin(S, S smoothingwidth)
smoothoschsin(S, S, S smoothingwidth)
smoothoschsin(V2, S smoothingwidth)
smoothoschcs smoothoschcs(S, S smoothingwidth)
smoothoschcs(S, S, S smoothingwidth)
smoothoschcs(V2, S smoothingwidth)
Ruído simples
noisei noisei(S)
noisei(S, S)
noisei(S, S, S)
noisei(V2)
noisei(V3)
noise noise(S)
noise(S, S)
noise(S, S, S)
noise(V2)
noise(V3)
Ruído linear
noisesc noisesc(S)
noisesc(S, S)
noisesc(S, S, S)
noisesc(V2)
noisesc(V3)
Ruído de curva S
noisesin noisesin(S)
noisesin(S, S)
noisesin(S, S, S)
noisesin(V2)
noisesin(V3)
noisecs noisecs(S)
noisecs(S, S)
noisecs(S, S, S)
noisecs(V2)
noisecs(V3)
noisecubic noisecubic(S)
noisecubic(S, S)
noisecubic(S, S, S)
noisecubic(V2)
noisecubic(V3)
noisesq noisesq(S)
noisesq(S, S)
noisesq(S, S, S)
noisesq(V2)
noisesq(V3)
noisesqi noisesqi(S)
noisesqi(S, S)
noisesqi(S, S, S)
noisesqi(V2)
noisesqi(V3)
noisecb noisecb(S)
noisecb(S, S)
noisecb(S, S, S)
noisecb(V2)
noisecb(V3)
noisecbi noisecbi(S)
noisecbi(S, S)
noisecbi(S, S, S)
noisecbi(V2)
noisecbi(V3)
noisepsin noisepsin(S)
noisepsin(S, S)
noisepsin(S, S, S)
noisepsin(V2)
noisepsin(V3)
noisepsini noisepsini(S)
noisepsini(S, S)
noisepsini(S, S, S)
noisepsini(V2)
noisepsini(V3)
noisecr noisecr(S)
noisecr(S, S)
noisecr(S, S, S)
noisecr(V2)
noisecr(V3)
noisecri noisecri(S)
noisecri(S, S)
noisecri(S, S, S)
noisecri(V2)
noisecri(V3)
noisert noisert(S)
noisert(S, S)
noisert(S, S, S)
noisert(V2)
noisert(V3)
noiserti noiserti(S)
noiserti(S, S)
noiserti(S, S, S)
noiserti(V2)
noiserti(V3)
Ruído harmônico simples
noisehi noisehi(S)
noisehi(S, S)
noisehi(S, S, S)
noisehi(V2)
noisehi(V3)
noiseh noiseh(S)
noiseh(S, S)
noiseh(S, S, S)
noiseh(V2)
noiseh(V3)
noisehsc noisehsc(S)
noisehsc(S, S)
noisehsc(S, S, S)
noisehsc(V2)
noisehsc(V3)
noisehsin noisehsin(S)
noisehsin(S, S)
noisehsin(S, S, S)
noisehsin(V2)
noisehsin(V3)
noisehcs noisehcs(S)
noisehcs(S, S)
noisehcs(S, S, S)
noisehcs(V2)
noisehcs(V3)
noisehcubic noisehcubic(S)
noisehcubic(S, S)
noisehcubic(S, S, S)
noisehcubic(V2)
noisehcubic(V3)
noisehsq noisehsq(S)
noisehsq(S, S)
noisehsq(S, S, S)
noisehsq(V2)
noisehsq(V3)
noisehsqi noisehsqi(S)
noisehsqi(S, S)
noisehsqi(S, S, S)
noisehsqi(V2)
noisehsqi(V3)
noisehcb noisehcb(S)
noisehcb(S, S)
noisehcb(S, S, S)
noisehcb(V2)
noisehcb(V3)
noisehcbi noisehcbi(S)
noisehcbi(S, S)
noisehcbi(S, S, S)
noisehcbi(V2)
noisehcbi(V3)
noisehpsin noisehpsin(S)
noisehpsin(S, S)
noisehpsin(S, S, S)
noisehpsin(V2)
noisehpsin(V3)
noisehpsini noisehpsini(S)
noisehpsini(S, S)
noisehpsini(S, S, S)
noisehpsini(V2)
noisehpsini(V3)
noisehcr noisehcr(S)
noisehcr(S, S)
noisehcr(S, S, S)
noisehcr(V2)
noisehcr(V3)
noisehcri noisehcri(S)
noisehcri(S, S)
noisehcri(S, S, S)
noisehcri(V2)
noisehcri(V3)
noisehrt noisehrt(S)
noisehrt(S, S)
noisehrt(S, S, S)
noisehrt(V2)
noisehrt(V3)
noisehrti noisehrti(S)
noisehrti(S, S)
noisehrti(S, S, S)
noisehrti(V2)
noisehrti(V3)
Perlin Noise
perlin perlin(S x, I octaves, S persistence)
perlin(S x, S y, I octaves, S persistence)
perlin(V2 pt, I octaves, S persistence)
perlinsc perlinsc(S x, I octaves, S persistence)
perlinsc(S x, S y, I octaves, S persistence)
perlinsc(V2 pt, I octaves, S persistence)
perlinsin perlinsin(S x, I octaves, S persistence)
perlinsin(S x, S y, I octaves, S persistence)
perlinsin(V2 pt, I octaves, S persistence)
perlincubic perlincubic(S x, I octaves, S persistence)
perlincubic(S x, S y, I octaves, S persistence)
perlincubic(V2 pt, I octaves, S persistence)
perlincs perlincs(S x, I octaves, S persistence)
perlincs(S x, S y, I octaves, S persistence)
perlincs(V2 pt, I octaves, S persistence)
Perlin Noise harmônico
perlinh perlinh(S x, I octaves, S persistence)
perlinh(S x, S y, I octaves, S persistence)
perlinh(V2 pt, I octaves, S persistence)
perlinhsc perlinhsc(S x, I octaves, S persistence)
perlinhsc(S x, S y, I octaves, S persistence)
perlinhsc(V2 pt, I octaves, S persistence)
perlinhsin perlinhsin(S x, I octaves, S persistence)
perlinhsin(S x, S y, I octaves, S persistence)
perlinhsin(V2 pt, I octaves, S persistence)
perlinhcubic perlinhcubic(S x, I octaves, S persistence)
perlinhcubic(S x, S y, I octaves, S persistence)
perlinhcubic(V2 pt, I octaves, S persistence)
perlinhcs perlinhcs(S x, I octaves, S persistence)
perlinhcs(S x, S y, I octaves, S persistence)
perlinhcs(V2 pt, I octaves, S persistence)
Ruído Voronoi
cellnoise cellnoise(S x, S y)
cellnoise(S x, S y, S spread)
cellnoise2 cellnoise2(S x, S y, I degree)
cellnoisedist cellnoisedist(S x, S y)
cellnoisedist(S x, S y, S spread)
cellnoiseedge cellnoiseedge(S x, S y, S sz, S softness)
Ruído direcional
diri diri(S)
diri(S, S)
diri(V2)
dir dir(S)
dir(S, S)
dir(V2)
dirsc dirsc(S)
dirsc(S, S)
dirsc(V2)
dirsin dirsin(S)
dirsin(S, S)
dirsin(V2)
dircs dircs(S)
dircs(S, S)
dircs(V2)
udiri udiri(S)
udiri(S, S)
udiri(V2)
udir udir(S)
udir(S, S)
udir(V2)
udirsc udirsc(S)
udirsc(S, S)
udirsc(V2)
udirsin udirsin(S)
udirsin(S, S)
udirsin(V2)
udircs udircs(S)
udircs(S, S)
udircs(V2)
dir3i dir3i(S)
dir3i(S, S)
dir3i(V2)
dir3 dir3(S)
dir3(S, S)
dir3(V2)
dir3sc dir3sc(S)
dir3sc(S, S)
dir3sc(V2)
dir3sin dir3sin(S)
dir3sin(S, S)
dir3sin(V2)
dir3cs dir3cs(S)
dir3cs(S, S)
dir3cs(V2)
udir3i udir3i(S)
udir3i(S, S)
udir3i(V2)
udir3 udir3(S)
udir3(S, S)
udir3(V2)
udir3sc udir3sc(S)
udir3sc(S, S)
udir3sc(V2)
udir3sin udir3sin(S)
udir3sin(S, S)
udir3sin(V2)
udir3cs udir3cs(S)
udir3cs(S, S)
udir3cs(V2)

CONSULTE TAMBÉM: