Synthetisierte Textur

Mit dem Filter "Synthetisierte Textur" lässt sich eine Reihe von Pixelmanipulationen über vordefinierte Funktionen und selbst definierte Variablen durchführen. Sie können so im Grunde Ihre eigenen Filter mit konfigurierbaren Parametern schreiben.

Vorher
Nachher
Vorher und nachher. Aus einer Normal Map wird mit den Funktionen dot und debump eine Bump Map erstellt. Anschließend wird die 3D-Darstellung mit dem Mischmodus Weiches Licht neu ausgeleuchtet.

Info: Der Filter "Synthetisierte Textur"

Dieser Filter lässt sich als zerstörungsfreier Live-Filter anwenden. Sie finden ihn in dem Menü Ebene unter Neue Live-Filterebene.

Einstellungen

In dem Dialogfeld des Filters stehen Ihnen die folgenden Einstellungen zur Verfügung:


Arbeiten mit dem Filter

Der Filter umfasst einige wichtige Komponenten, deren Aufgabe Sie kennen sollten, damit Sie mit dem Filter effektiv arbeiten können:


Beispiele

Hier einige praktische Beispiele, wie sich der Filter für synthetisierte Texturen einsetzen lässt. Selbst definierte Eingabevariablen sind fett formatiert. Um Sie zu verwenden, kopieren Sie die Codezeile, fügen sie in eine neue Gleichungszeile ein, legen die Kanalziele fest (falls notwendig) und erstellen dann selbst definierte Eingaben nach den Einträgen der Tabelle.

Runde Vignette

Vignette
var vignettew=vec2(rx, ry)/w; var vignetteh=vec2(rx, ry)/h; var productw=oscsc(vignettew); var producth=oscsc(vignetteh); scurveinterp(productw, producth, Rundheit)*(Intensität*I-Multiplikator)

Zielt auf alle drei Kanäle ab (R, G und B). Verwenden Sie einen Mischmodus, wie z. B. Negativ multiplizieren.

Selbst definierter Eingabetyp Variablenname Erklärung
[0,1] Bereichseingabe Rundheit Wird als Variable in scurveinterp verwendet, um die Rundheit der Vignette zu steuern.
[0,1] Bereichseingabe Intensität Dieser Wert wird mit dem Ergebnis von scurveinterp multipliziert, um die Intensität (Helligkeit) der Vignette zu ändern.
Reellzahlige Eingabe I-Multiplikator Diese reelle Zahl wird mit dem Wert Intensität multipliziert, um ihn zu skalieren, sodass sich eine größere Bandbreite möglicher Helligkeitswerte erzielen lässt.

In diesem Ausdruck haben wir vier Variablendeklarationen: rx und ry werden für die Erstellung von zwei Vektorergebnissen verwendet: vignettew und vignetteh Die Vektorergebnisse werden durch die Breite bzw. Höhe dividiert. Aus diesen Werten berechnen wir dann productw und producth mithilfe von Oszillatoren für S-Kurven (oscsc). Als Letztes interpolieren wir zwischen diesen beiden Produktergebnissen mithilfe eines Interpolators für S-Kurven (scurveinterp). Die Mischung der beiden Ergebnisse wird durch die selbst definierte Eingabe Rundheit bestimmt und die Helligkeit wird durch die selbst definierten Eingaben Intensität und I-Multiplikator skaliert.

Da für die Vektorerstellungrx und ry (relative X- und Y-Positionen) verwendet werden, können Sie einfach auf der Leinwand klicken und ziehen, um den Mittelpunkt (Ursprung) der Vignette festzulegen.

Wenn Sie den Filter mit einem passenden Mischmodus einsetzen (wir empfehlen hierfür die Version als Live-Filter), lässt sich ein gute Vignettierung erzeugen.

Rautenförmige Alphamaske

Vignette
var v=vec2(rx,ry)/w; smoothoschlin(oschcr(v/(dgross*dmult)), dglatt)

Wählen Sie als Ziel nur den Alphakanal (A) aus.

Selbst definierter Eingabetyp Variablenname Erklärung
[0,1] Bereichseingabe dglatt Bestimmt die Glättung der Maskenkanten.
[0,1] Bereichseingabe dgross Bestimmt die Größe der Maske.
Reellzahlige Eingabe dmult Skaliert dgross mit einem Multiplikator, damit sich größere und kleinere Masken erstellen lassen.

Hier weisen wir das Ergebnis der Vektorerstellung mit rx und ry der Variable v zu (und Teilen das Ergebnis durch die Dokumentbreite w). Das Ergebnis v wird dann durch einen harmonischen Oscillator mit "Catmull-Rom"-Spline geleitet (oschcr), der wiederum durch einen glatten harmonischen Linearoszillator (smoothoschlin) geleitet wird. Innerhalb der Funktion oschcr wird v durch dgross*dmult geteilt, was die Gesamtgröße festlegt. dglatt wird innerhalb der Funktion smoothoschlin verwendet, um die Glättung und Unschärfe der Kanten zu beeinflussen. Wenn Sie das Kanalziel nur auf den Alphakanal (A) einstellen, erzeugt dieser Ausdruck einen Effekt mit rautenförmiger Alphamaske.

Da für die Vektorerstellungrx und ry (relative X- und Y-Positionen) verwendet werden, können Sie einfach auf der Leinwand klicken und ziehen, um die Position des Maskierungseffekts zu ändern.


Funktionen

Nachfolgend finden Sie alle Funktionen, die Sie in dem Abschnitt "Gleichungen" verwenden können. Für alle gilt:

Verwenden Funktionen T- oder V-Argumente, muss die Vektorgröße für alle Argumente identisch sein. Sie sind nicht austauschbar.

Funktionen Verwendung Anmerkungen
Allgemeine Mathematik
abs abs(T) Rundet den Wert auf einen absolute ganze Zahl.
acos acos(T)
asin asin(T)
atan atan(T)
atan2 atan2(T, T)
average average(T, T, ...) (Variablenargumente)
ceil ceil(T) Rundet den Wert auf.
copysign copysign(T, T sign)
cos cos(T)
dim dim(T x, T y)
floor floor(T) Rundet den Wert ab.
fma fma(T a, T b, T c) Berechnet (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) Lineare Interpolation zwischen zwei Werten, ausgeglichen bestimmt durch t zwischen 0 und 1.
max max(T, T, ...) (Variablenargumente)
mid mid(T, T)
min min(T, T, ...) (Variablenargumente)
mix mix(T a, T b, T t) Entspricht lerp
pow pow(T x, T y) x hoch y
powr powr(T x, T y) x hoch y wobei x>0
round round(T)
roundup roundup(T)
rounddown rounddown(T)
sign sign(T)
sin sin(T)
sq sq(T)
sqrt sqrt(T) Quadratwurzel
tan tan(T)
trunc trunc(T) Kurzfassung für truncate (Kürzen).
truncate truncate(T)
rgbtoi rgbtoi(S r, S g, Sb) oder rgbtoi(V rgb)
whole whole(T)
Umwandlung von Zahlenbereichen
tocui tocui(T) Für das geschlossene Einheitsintervall zwischen 0 und 1.
tohcui tohcui(T) Für das geschlossene Einheitsintervall zwischen -1 und 1 (harmonisch).
Festlegen von Werte
saturate saturate(T)
clamp clamp(T) oder clamp(T, T min, T max)
clampmin clampmin(T, T min)
clampmax clampmax(T, T max)
Geometrische Funktionen
cross cross(V3, V3) Berechnet das Kreuzprodukt von zwei Vector3-Komponenten (XYZ)
dist dist(V a, V b) Kurzfassung für distance (Distanz)
dist_sq dist_sq(V a, V b) Kurzfassung für distance_squared (Distanzquadrat)
distance distance(V a, V b)
distance_squared distance_squared(V a, V b)
dot dot(V, V)
length length(V) oder length(S, S, ...)
length_squared length_squared(V) oder length_squared(S, S, ...)
norm norm(V) Kurzfassung für normalise oder normalize (Normalisieren)
normalise normalise(V)
normalize normalize(V)
Erstellen von Vektoren
vec2 vec2(S) oder vec2(S, S) Praktisch für die Erstellung von Vektoren aus XY-Positionen, wie z. B. vec2(rx, ry)
vec3 vec3(S) oder vec3(S, S, S) Lässt sich für die Erstellung von Vektoren aus Farbdaten verwenden, wie z. B. vec3(R, G, B)
vec4 vec4(S) oder vec4(S, S, S, S)
vec5 vec5(S) oder vec5(S, S, S, S, S)
vec6 vec6(S) oder vec6(S, S, S, S, S, S)
tovec3 tovec3(V)
tovec4 tovec4(V)
tovec5 tovec5(V)
tovec6 tovec6(V)
Manipulation von Vektoren
rev rev(V)
rotl rotl(V) Vektor nach links drehen.
rotr rotr(V) Vektor nach rechts drehen.
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)
Vektorhilfsfunktionen
debump debump(S r, S g, S b)
Interpolation
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) Kurzfassung für scurveinterp
serp serp(T a, T b, T t) Kurzfassung für sininterp
cerp cerp(T a, T b, T c, T d, T t) Kurzfassung für cubicinterp
cubic scerp(T a, T b, T c, T d, T t) Kurzfassung für cubicinterp
scint scint(T cui) Kurzfassung für scurverinterpolant
sint sint(T cui) Kurzfassung für sininterpolant
Schrittfunktionen
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) oder smoothsteplin(T in0, T in1, T out1, T out0, T v)
smoothstep smoothstep(T edge0, T edge1, T v) oder smoothstep(T in0, T in1, T out1, T out0, T v)
smoothstepsc smoothstepsc(T edge0, T edge1, T v) oder smoothstepsc(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) oder smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepcs smoothstepcs(T edge0, T edge1, T v) oder smoothstepcs(T in0, T in1, T out1, T out0, T v)
smoothstepsq smoothstepsq(T edge0, T edge1, T v) oder smoothstepsq(T in0, T in1, T out1, T out0, T v)
smoothstepsqi smoothstepsqi(T edge0, T edge1, T v) oder smoothstepsqi(T in0, T in1, T out1, T out0, T v)
smoothstepcb smoothstepcb(T edge0, T edge1, T v) oder smoothstepcb(T in0, T in1, T out1, T out0, T v)
smoothstepcbi smoothstepcbi(T edge0, T edge1, T v) oder smoothstepcbi(T in0, T in1, T out1, T out0, T v)
smoothstepsin smoothstepsin(T edge0, T edge1, T v) oder smoothstepsin(T in0, T in1, T out1, T out0, T v)
smoothstepsini smoothstepsini(T edge0, T edge1, T v) oder smoothstepsini(T in0, T in1, T out1, T out0, T v)
smoothstepcr smoothstepcr(T edge0, T edge1, T v) oder smoothstepcr(T in0, T in1, T out1, T out0, T v)
smoothstepcri smoothstepcri(T edge0, T edge1, T v) oder smoothstepcri(T in0, T in1, T out1, T out0, T v)
smoothsteprt smoothsteprt(T edge0, T edge1, T v) oder smoothsteprt(T in0, T in1, T out1, T out0, T v)
smoothsteprti smoothsteprti(T edge0, T edge1, T v) oder 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)
Quantelung
quantize quantize(T band, T v) oder 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)
Oszillatoren
osci osci(S)
osci(S, S)
osci(V2)
Standardoszillation, akzeptiert Skalar- oder Vektoreingaben.
oscsc oscsc(S)
oscsc(S, S)
oscsc(V2)
Szillator mit S-Kurve
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)
Harmonische Oszillatoren
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)
Einfaches Rauschen
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)
Lineares Rauschen
noisesc noisesc(S)
noisesc(S, S)
noisesc(S, S, S)
noisesc(V2)
noisesc(V3)
S-kurviges Rauschen
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)
Harmonisches Einfaches Rauschen
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-Rauschen
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)
Harmonisches Perlin-Rauschen
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)
Voronoi-Rauschen
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)
Gerichtetes Rauschen
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)

SIEHE AUCH: