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.
Dieser Filter lässt sich als zerstörungsfreier Live-Filter anwenden. Sie finden ihn in dem Menü Ebene unter Neue Live-Filterebene.
In dem Dialogfeld des Filters stehen Ihnen die folgenden Einstellungen zur Verfügung:
Der Filter umfasst einige wichtige Komponenten, deren Aufgabe Sie kennen sollten, damit Sie mit dem Filter effektiv arbeiten können:
var v=vec2(rx, ry); var clr=vec3(R,G,B);
scurveinterp(R, B, 0.5)
verwenden. Hierdurch interpolieren Sie zwischen roten und blauen Kanaldaten mit einer Balance/Mischung von 50 % (da die Balance einen Wert zwischen 0 und 1 einnehmen kann).R/(a*2)
var v2=vec2(rx/w/2, ry/h/(b*2)); dir(v2*(a*2))*(c*2)
(die Klammern sind fett markiert)ry/h/(b*2)
. Stünde dieser Ausdruck nicht in Klammern, würde das Ergebnis ganz anders ausfallen.perlin(rx, ry, a, b)
, wobeia die Oktaven bestimmt b die Dauerhaftigkeit.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.
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.
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.
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) |