Texture procedurale

Il filtro Texture procedurale consente di eseguire una serie di manipolazioni dei pixel utilizzando funzioni predefinite e variabili definite dall'utente. In sostanza, è possibile scrivere i propri filtri utilizzando parametri configurabili.

Prima
Dopo
Prima e dopo. Una mappa dei rilievi viene creata da una mappa normale utilizzando le funzioni punto e debump, quindi viene utilizzata la modalità di fusione Luce soffusa per "applicare nuovamente l'illuminazione" a un rendering 3D.

Informazioni sul filtro Texture procedurale

Questo filtro può essere applicato come filtro interattivo non distruttivo. È possibile accedervi tramite il menu Livello, dalla categoria Nuovo livello filtri live.

Impostazioni

Nella finestra di dialogo del filtro è possibile regolare le impostazioni seguenti:


Uso del filtro

Il filtro ha diversi componenti chiave che è necessario capire al fine di utilizzarlo in modo efficace:


Esempi

Ecco alcuni esempi concreti relativi alle modalità in cui è possibile utilizzare il filtro trama procedurale. Le variabili di input personalizzate sono evidenziate in grassetto. Per seguirle, copiare e incollare la riga di codice in una nuova riga di equazione, impostare le indicizzazioni del canale se necessario, quindi creare input personalizzati seguendo le voci della tabella.

Vignetta arrotondata

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

Indicizzare tutti e tre i canali (R, G e B). Utilizzare una modalità di fusione, ad esempio Schermo.

Tipo di input personalizzato Nome della variabile Spiegazione
input intervallo [0,1] roundness Utilizzato come una variabile in scurveinterp per controllare la rotondità della vignetta.
input intervallo [0,1] intensity Questo valore viene moltiplicato per il risultato scurveinterp al fine di modificare l’intensità (luminosità) della vignetta.
Input numero reale imultiplier Questo numero reale viene moltiplicato per il valore intensity al fine di ridimensionarlo, generando un intervallo maggiore di luminosità ottenibile.

In questa espressione, sono presenti quattro dichiarazioni di variabili. rx e ry vengono utilizzati per creare due risultati vettoriali: vignettew e vignetteh. I risultati vettoriali sono divisi rispettivamente per larghezza e altezza. Da tali risultati, è possibile calcolare productw e producth utilizzando gli oscillatori curva a S (oscsc). Infine, si esegue un’interpolazione tra questi due risultati di prodotto utilizzando una curva a S interpolante (scurveinterp). La miscelazione tra i due risultati è controllata dall’input personalizzato roundness e la luminosità viene ridimensionata in base agli input personalizzati intensity e imultiplier.

Poiché rx e ry (posizioni relative X e Y) vengono utilizzati per creazioni vettoriali, l’utente può fare clic e trascinare sulla tela per determinare il centro (origine) della vignetta.

Quando il filtro viene utilizzato con una modalità di fusione appropriata (si raccomanda l’uso della versione filtro live), è possibile ottenere un effetto vignettatura desiderato.

Maschera alfa diamante

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

Indicizza solo il canale alfa (A).

Tipo di input personalizzato Nome della variabile Spiegazione
input intervallo [0,1] dsmooth Controlla l’attenuazione dei bordi della maschera.
input intervallo [0,1] dsize Determina la dimensione della maschera.
Input numero reale dmult Ridimensiona dsize mediante un moltiplicatore al fine di consentire dimensioni della maschera più grandi o più piccole.

In questo caso, i risultati di una creazione vettoriale vengono assegnati utilizzandorx e ry nella variabile v (dividendo il risultato per la larghezza del documento w). Il risultato v viene quindi inserito attraverso un oscillatore armonico con una Catmull-Rom spline (oschcr), che a sua volta viene inserita attraverso un oscillatore lineare armonico attenuato (smoothoschlin). Nella funzione oschcr, v viene diviso per dsize*dmult, che controlla le dimensioni complessive. dsmooth viene utilizzato all’interno della funzione smoothoschlin per influenzare l’attenuazione e la sfocatura dei bordi. Quando l’indicizzazione del canale è impostata solo su alfa (A), questa espressione crea un effetto maschera diamante alfa.

Rx e ry (le posizioni relative X e Y) vengono utilizzate per creazioni vettoriali, l’utente può fare clic e trascinare sulla tela per modificare la posizione dell’effetto della maschera.


Funzioni

Di seguito viene riportata una tabella con le funzioni che possono essere utilizzate nella sezione equazioni, dove:

Quando una funzione accetta argomenti T o V, la dimensione del vettore deve essere la stessa per tutti gli argomenti. Non sono intercambiabili.

Funzione Utilizzo Note
Funzioni matematiche comuni
abs abs(T) Valore arrotondato del numero intero assoluto
acos acos(T)
asin asin(T)
atan atan(T)
atan2 atan2(T, T)
media media (T, T...) (argomenti variabili)
ceil ceil(T) Arrotonda per eccesso
copysign copysign (T, segno T)
cos cos(T)
dim dim(T x, T y)
floor floor(T) Arrotonda per difetto
fma fma(T a, T b, T c) Calcola (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) Interpolazione lineare tra due valori, bilanciamento determinato da t tra 0-1
max max(T, T...) (argomenti variabili)
mid mid(T, T)
min min(T, T...) (argomenti variabili)
mix mix(T a, T b, T t) Identica a lerp
pow pow(T x, T y) x alla potenza di y
powr powr(T x, T y) x alla potenza di y dove x> 0
round round(T)
roundup roundup(T)
rounddown rounddown(T)
sign sign(T)
sin sin(T)
sq sq(T)
sqrt sqrt(T) Radice quadrata
tan tan(T)
trunc trunc(T) Abbreviazione di troncamento
truncate truncate(T)
rgbtoi rgbtoi(S r, S g, Sb) or rgbtoi(V rgb)
whole whole(T)
Conversione di un intervallo numerico
tocui tocui(T) Per intervallo chiuso unità compreso tra 0-1
tohcui tohcui(T) Per intervallo chiuso unità compreso tra -1-1 (armonico)
Bloccaggio
saturate saturate(T)
clamp clamp(T) or clamp(T, T min, T max)
clampmin clampmin(T, T min)
clampmax clampmax(T, T max)
Funzioni geometriche
cross cross(V3, V3) Calcola il prodotto incrociato di due componenti Vector3 (XYZ)
dist dist(V a, V b) Abbreviazione di distanza
dist_sq dist_sq(V a, V b) Abbreviazione di 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) Abbreviazione di normalise o normalize
normalise normalise(V)
normalize normalize(V)
Creazione di vettori
vec2 vec2(S) or vec2(S, S) È l’ideale per creare vettori di posizione XY, ad es. vec2(rx, ry)
vec3 vec3(S) or vec3(S, S, S) Può essere utilizzato per creare vettori a partire da dati di colore, ad es. 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)
Manipolazione vettori
rev rev(V)
rotl rotl(V) Ruota vettore a sinistra
rotr rotr(V) Ruota vettore a destra
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à vettori
debump debump(S r, S g, S b)
Interpolazione
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) Abbreviazione di scurveinterp
serp serp(T a, T b, T t) Abbreviazione di sininterp
cerp cerp(T a, T b, T c, T d, T t) Abbreviazione di cubicinterp
cubic scerp(T a, T b, T c, T d, T t) Abbreviazione di cubicinterp
scint scint(T cui) Abbreviazione di scurverinterpolant
sint sint(T cui) Abbreviazione di sininterpolant
Scorrimento
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) or smoothsteplin(T in0, T in1, T out1, T out0, T v)
smoothstep smoothstep(T edge0, T edge1, T v) or smoothstep(T in0, T in1, T out1, T out0, T v)
smoothstepsc smoothstepsc(T edge0, T edge1, T v) or smoothstepsc(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) or smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepcs smoothstepcs(T edge0, T edge1, T v) or smoothstepcs(T in0, T in1, T out1, T out0, T v)
smoothstepsq smoothstepsq(T edge0, T edge1, T v) or smoothstepsq(T in0, T in1, T out1, T out0, T v)
smoothstepsqi smoothstepsqi(T edge0, T edge1, T v) or smoothstepsqi(T in0, T in1, T out1, T out0, T v)
smoothstepcb smoothstepcb(T edge0, T edge1, T v) or smoothstepcb(T in0, T in1, T out1, T out0, T v)
smoothstepcbi smoothstepcbi(T edge0, T edge1, T v) or smoothstepcbi(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) or smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepsini smoothstepsini(T edge0, T edge1, T v) or smoothstepsini(T in0, T in1, T out1, T out0, T v)
smoothstepcr smoothstepcr(T edge0, T edge1, T v) or smoothstepcr(T in0, T in1, T out1, T out0, T v)
smoothstepcri smoothstepcri(T edge0, T edge1, T v) or smoothstepcri(T in0, T in1, T out1, T out0, T v)
smoothsteprt smoothsteprt(T edge0, T edge1, T v) or smoothsteprt(T in0, T in1, T out1, T out0, T v)
smoothsteprti smoothsteprti(T edge0, T edge1, T v) or 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)
Quantizzazione
quantize quantize(T band, T v) or 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)
Oscillatori
osci osci(S)
osci(S, S)
osci(V2)
Oscillazioni standard, accetta input di valori scalari o vettoriali
oscsc oscsc(S)
oscsc(S, S)
oscsc(V2)
Oscillatore 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)
Oscillatori armonici
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)
Disturbo semplice
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)
Disturbo lineare
noisesc noisesc(S)
noisesc(S, S)
noisesc(S, S, S)
noisesc(V2)
noisesc(V3)
Disturbo 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)
Disturbo armonico semplice
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)
Disturbo Perlin
perlin Perlin (S x, ottave I, persistenza S)
perlin (S x, y S, ottave I, persistenza S)
perlin (pt V2, ottave I, persistenza S)
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)
Disturbo Perlin armonico
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)
Disturbo 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)
Disturbo direzionale
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)

CONSULTARE ANCHE: