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.
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.
As configurações a seguir podem ser ajustadas na caixa de diálogo Filtro:
O filtro tem vários componentes chaves que devem ser compreendidos para usá-lo efetivamente:
var v = vec2 (rx, ry); var clr=vec3(R,G,B);
scurveinterp(R, B, 0.5)
. Isso seria interpolar entre os dados de canal vermelho e azul com um equilíbrio/mistura de 50% (o equilíbrio pode ser um valor entre 0 e 1).R/(a*2)
var v2=vec2(rx/w/2, ry/h/(b*2)); dir(v2*(a*2))*(c*2)
(os parênteses são realçados em negrito)ry/h/(b*2)
. Se essa expressão não estiver entre parênteses, o resultado será diferente.perlin(rx, ry, a, b)
—onde a controla oitavas e b controla persistência.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.
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.
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.
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) |