Textura de procedimiento

El filtro Textura de procedimiento le permite realizar una serie de manipulaciones de píxeles usando funciones predeterminadas y variables definidas por el usuario. Es posible escribir de forma práctica sus propios filtros con parámetros configurables.

Antes
Después
Antes y después. Se crea un mapa de rugosidad a partir de un mapa normal usando las funciones dot y debump; después se utiliza un modo de fusión Luz suave para "volver a iluminar" un renderizado 3D.

Acerca del filtro Textura de procedimiento

Este filtro se puede aplicar como un filtro en tiempo real no destructivo. Se puede acceder a él a través del menú Capa, en la categoría Nueva capa de filtro en tiempo real.

Parámetros

Se pueden ajustar los siguientes parámetros en el cuadro de diálogo de filtros:


Uso del filtro

El filtro tiene varios componentes clave que deben entenderse para utilizarlo de manera efectiva:


Ejemplos

A continuación se incluyen algunos ejemplos prácticos de cómo se puede usar el filtro de textura de procedimiento. Las variables de entrada personalizadas se resaltan en negrita. Para seguirlas, copie y pegue la línea de código en una nueva línea de ecuación, establezca objetivos por canal si es necesario y, a continuación, cree entradas personalizadas siguiendo las entradas de la tabla.

Viñeta redonda

Viñeta
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)

Apunte a los tres canales (R, G y B). Use un modo de fusión como Pantalla.

Tipo de entrada personalizado Nombre de la variable Explicación
Entrada de rango de [0,1] roundness Se utiliza como variable en scurveinterp para controlar la redondez de la viñeta.
Entrada de rango de [0,1] intensity Este valor se multiplica por el resultado de scurveinterp para modificar la intensidad (brillo) de la viñeta.
Entrada de número real imultiplier Este número real se multiplica por el valor de intensidad para escalarlo, lo que da como resultado un mayor rango de brillo alcanzable.

En esta expresión, tenemos cuatro declaraciones de variables. rx y ry se utilizan para crear dos resultados vectoriales: vignettew y vignetteh. Los resultados del vector se dividen por el ancho y la altura, respectivamente. A partir de estos, calculamos productw y producth mediante osciladores de curva S (oscsc). Finalmente, interpolamos los resultados de estos dos productos utilizando un interpolante de curva S (scurveinterp). La mezcla entre los dos resultados es controlada por la entrada personalizada roundness, mientras que el brillo es escalado por las entradas personalizadas intensity e imultiplier.

Dado que rx y ry (las posiciones X e Y relativas) se utilizan para la creación del vector, el usuario puede hacer clic y arrastrar en el lienzo para determinar el punto central (origen) de la viñeta.

Cuando el filtro se usa con un modo de fusión apropiado (se recomienda usar la versión Filtro en tiempo real), se puede lograr un efecto de viñeta adecuado.

Máscara de rombo alfa

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

Apunte solo al canal alfa (A).

Tipo de entrada personalizado Nombre de la variable Explicación
Entrada de rango de [0,1] dsmooth Controla el suavizado de los bordes de la máscara.
Entrada de rango de [0,1] dsize Determina el tamaño de la máscara.
Entrada de número real dmult Escala dsize por un multiplicador para permitir tamaños de máscara más grandes o más pequeños.

Aquí, convertimos los resultados de la creación de vectores usando rx y ry a la variable v (dividiendo el resultado por el ancho del documento, w). El resultado v se pasa por un oscilador armónico con un spline Catmull-Rom (oschcr), que a su vez se pasa por un oscilador armónico lineal suave (smoothoschlin). En la función oschcr, v se divide por dsize*dmult, que controla el tamaño global. dsmooth se utiliza dentro de la función smoothoschlin para influir en la suavidad y el desenfoque de los bordes. Cuando el objetivo del canal se establece en solo alfa (A), esta expresión crea un efecto de máscara de rombo alfa.

Dado que rx y ry (las posiciones X e Y relativas) se utilizan para la creación del vector, el usuario puede hacer clic y arrastrar en el lienzo para alterar la posición del efecto de máscara.


Funciones

A continuación se muestra una tabla de funciones que se pueden utilizar en la sección Ecuaciones, donde:

Cuando una función adopta argumentos T o V, el tamaño del vector debe ser el mismo para todos los argumentos. No son intercambiables.

Función Uso Notas
Matemáticas comunes
abs abs(T) Redondeo del valor al entero absoluto
acos acos(T)
asin asin(T)
atan atan(T)
atan2 atan2(T, T)
promedio average(T, T, ...) (argumentos variables)
ceil ceil(T) Redondeo ascendente al valor
copysign copysign(T, T sign)
cos cos(T)
dim dim(T x, T y)
floor floor(T) Redondeo descendente al valor
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) Interpolación lineal entre dos valores, equilibrado determinado por t entre 0-1
max max(T, T, ...) (argumentos variables)
mid mid(T, T)
min min(T, T, ...) (argumentos variables)
mix mix(T a, T b, T t) Igual que lerp
pow pow(T x, T y) x elevada a y
powr powr(T x, T y) x elevada a y donde x>0
round round(T)
roundup roundup(T)
rounddown rounddown(T)
sign sign(T)
sin sin(T)
sq sq(T)
sqrt sqrt(T) Raíz cuadrada
tan tan(T)
trunc trunc(T) Abreviatura de truncate
truncate truncate(T)
rgbtoi rgbtoi(S r, S g, Sb) o rgbtoi(V rgb)
whole whole(T)
Conversión de rango numérico
tocui tocui(T) A intervalo de unidad cerrado entre 0-1
tohcui tohcui(T) A intervalo de unidad cerrado entre -1-1 (armónico)
Pinzado
saturate saturate(T)
clamp clamp(T) o clamp(T, T min, T max)
clampmin clampmin(T, T min)
clampmax clampmax(T, T max)
Funciones geométricas
cross cross(V3, V3) Calcular producto cruzado de dos componentes (XYZ) de Vector3
dist dist(V a, V b) Abreviatura de distance
dist_sq dist_sq(V a, V b) Abreviatura de distance_squared
distance distance(V a, V b)
distance_squared distance_squared(V a, V b)
dot dot(V, V)
length length(V) o length(S, S, ...)
length_squared length_squared(V) o length_squared(S, S, ...)
norm norm(V) Abreviatura de normalise o normalize
normalise normalise(V)
normalize normalize(V)
Creación vectorial
vec2 vec2(S) o vec2(S, S) Adecuada para crear vectores a partir de la posición XY; por ejemplo: vec2(rx, ry)
vec3 vec3(S) o vec3(S, S, S) Se puede utilizar para crear vectores a partir de datos de color; por ejemplo: vec3(R, G, B)
vec4 vec4(S) o vec4(S, S, S, S)
vec5 vec5(S) o vec5(S, S, S, S, S)
vec6 vec6(S) o vec6(S, S, S, S, S, S)
tovec3 tovec3(V)
tovec4 tovec4(V)
tovec5 tovec5(V)
tovec6 tovec6(V)
Manipulación vectorial
rev rev(V)
rotl rotl(V) Rotación vectorial a la izquierda
rotr rotr(V) Rotación vectorial a la derecha
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)
Utilidades vectoriales
debump debump(S r, S g, S b)
Interpolación
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) Abreviatura de scurveinterp
serp serp(T a, T b, T t) Abreviatura de sininterp
cerp cerp(T a, T b, T c, T d, T t) Abreviatura de cubicinterp
cubic scerp(T a, T b, T c, T d, T t) Abreviatura de cubicinterp
scint scint(T cui) Abreviatura de scurveinterpolant
sint sint(T cui) Abreviatura de sininterpolant
Escalonamiento
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) o smoothsteplin(T in0, T in1, T out1, T out0, T v)
smoothstep smoothstep(T edge0, T edge1, T v) o smoothstep(T in0, T in1, T out1, T out0, T v)
smoothstepsc smoothstepsc(T edge0, T edge1, T v) o smoothstepsc(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) o smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepcs smoothstepcs(T edge0, T edge1, T v) o smoothstepcs(T in0, T in1, T out1, T out0, T v)
smoothstepsq smoothstepsq(T edge0, T edge1, T v) o smoothstepsq(T in0, T in1, T out1, T out0, T v)
smoothstepsqi smoothstepsqi(T edge0, T edge1, T v) o smoothstepsqi(T in0, T in1, T out1, T out0, T v)
smoothstepcb smoothstepcb(T edge0, T edge1, T v) o smoothstepcb(T in0, T in1, T out1, T out0, T v)
smoothstepcbi smoothstepcbi(T edge0, T edge1, T v) o smoothstepcbi(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) o smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepsini smoothstepsini(T edge0, T edge1, T v) o smoothstepsini(T in0, T in1, T out1, T out0, T v)
smoothstepcr smoothstepcr(T edge0, T edge1, T v) o smoothstepcr(T in0, T in1, T out1, T out0, T v)
smoothstepcri smoothstepcri(T edge0, T edge1, T v) o smoothstepcri(T in0, T in1, T out1, T out0, T v)
smoothsteprt smoothsteprt(T edge0, T edge1, T v) o smoothsteprt(T in0, T in1, T out1, T out0, T v)
smoothsteprti smoothsteprti(T edge0, T edge1, T v) o 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)
Cuantización
quantize quantize(T band, T v) o 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)
Oscilación estándar, acepta entradas escalares o vectoriales
oscsc oscsc(S)
oscsc(S, S)
oscsc(V2)
Oscilador con 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 armó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)
Ruido simple
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)
Ruido lineal
noisesc noisesc(S)
noisesc(S, S)
noisesc(S, S, S)
noisesc(V2)
noisesc(V3)
Ruido 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)
Ruido armónico simple
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)
Ruido Perlin
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)
Ruido armónico Perlin
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)
Ruido 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)
Ruido direccional
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 TAMBIÉN: