en to pl translation catalogue (180 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
pl: float abs(float x)
    wartość bezwzględna z "x"

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
pl: float deg(float kąt)
    radiany na stopnie

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
pl: float rad(float kąt)
    stopnie na radiany

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
pl: float cosd(float kąt)
    kosinus w stopniach

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
pl: float sind(float kąt)
    sinus w stopniach

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
pl: float tand(float kąt)
    tangens w stopniach

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
pl: float acosd(float wartość)
    arkus kosinus w stopniach

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
pl: float asind(float wartość)
    arkus sinus w stopniach

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
pl: float atand(float wartość)
    arkus tangens w stopniach

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
pl: float atan2d(float y,float x)
    arkus tangens w stopniach z "y/x" w zakresie -180 oraz 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
pl: float cos(float kąt)
    kosinus w radianach

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
pl: float sin(float kąt)
    sinus w radianach

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
pl: float tan(float kąt)
    tangens w radianach

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
pl: float acos(float wartość)
    arkus kosinus w radianach

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
pl: float asin(float wartość)
    arkus sinus w radianach

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
pl: float atan(float wartość)
    arkus tangens w radianach

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
pl: float atan2(float y,float x)
    arkus tangens w radianach z "y/x" w zakresie -PI oraz PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
pl: float cosh(float kąt)
    hiperboliczny kosinus w radianach

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
pl: float sinh(float kąt)
    hiperboliczny sinus w radianach

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
pl: float tanh(float kąt)
    hiperboliczny tangens w radianach

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
pl: float acosh(float wartość)
    hiperboliczny arkus kosinus w radianach

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
pl: float asinh(float wartość)
    hiperboliczny arkus sinus w radianach

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
pl: float atanh(float wartość)
    hiperboliczny arkus tangens w radianach

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
pl: float clamp(float x,float lo,float hi)
    wiąże x do zakresu [lo,hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
pl: float round(float x)
    najbliższa liczba całkowita przy x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
pl: float max(float a,float b)
    większe spośród a oraz b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
pl: float mix(float a,float b)
    mniejsze spośród a oraz b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
pl: float trunc(float a)
    najbliższa liczba całkowita w stronę zera

[ctx: builtin|]
en: float floor(float a)
    next lower integer
pl: float floor(float a)
    następna niższa liczba całkowita

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
pl: float ceil(float a)
    następna wyższa liczba całkowita

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
pl: float invert(float a)
    Określone jako 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
pl: float cbrt(float x)
    pierwiastek sześcienny

[ctx: builtin|]
en: float sqrt(float x)
    square root
pl: float sqrt(float x)
    pierwiastek kwadratowy

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
pl: float exp(float x)
    E podniesione do potęgi x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
pl: float pow(float x, float y)
    x do potęgi y, dostępne również jako ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
pl: float log(float x)
    Logarytm naturalny

[ctx: builtin|]
en: float log10(float x)
    Base 10 logarithm
pl: float log10(float x)
    Podstawa algorytmu 10

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
pl: float fmod(float x,float y)
    reszta z x/y (dostępne również jako operator %)

[ctx: builtin|]
en: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
pl: float turbulence(vector v,int oktawy=6,float lakunarność=2,float wzmocnienie=.5)
    Brana jest bezwzględna wartość każdego wyrażenia szumu. Nadaje to wzburzony wygląd

[ctx: builtin|]
en: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
pl: color cturbulence(vector v,int oktawy=6,float lakunarność=2,float wzmocnienie=.5)
    Brana jest bezwzględna wartość każdego wyrażenia szumu. Nadaje to wzburzony wygląd

[ctx: builtin|]
en: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Absolute value of each noise term is taken. This gives billowy appearance
pl: vector vturbulence(vector v,int oktawy=6,float lakunarność=2,float wzmocnienie=.5)
    Brana jest bezwzględna wartość każdego wyrażenia szumu. Nadaje to wzburzony wygląd

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
pl: float compress(float x,float lo,float hi)
    Ponownie mapuje x w [0,1] do [lo,hi]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
pl: float expand(float x,float lo,float hi)
    Ponownie mapuje x w [lo,hi] do [0,1]

[ctx: builtin|]
en: float fit(float x,float a1,float b1,float a2,float b2)
    Linearly remaps x in [a1,b1] to [a2,b2]
pl: float fit(float x,float a1,float b1,float a2,float b2)
    Liniowo mapuje ponownie x w [a1,b1] do [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
pl: float gamma(float x, float g)
    Poprawka gammy "x" ze współczynnikiem gammy "g"

[ctx: builtin|]
en: float bias(float x, float g)
    Variation of gamma where values less than 0.5 pull the curve down
    and values greater than 0.5 pull the curve up
    pow(x,log(b)/log(0.5))
pl: float bias(float x, float g)
    Odmiana gammy, gdzie wartości mniejsze niż 0,5 ściągają krzywą na dół
    a wartości większe niż 0.5 ciągną krzywą w górę
    pow(x,log(b)/log(0.5))

[ctx: builtin|]
en: float contrast(float x, float c)
    Adjust the contrast.&nbsp; For c from 0 to 0.5, the contrast is decreased.&nbsp; For c &gt; 0.5, the contrast is increased.
pl: float contrast(float x, float c)
    Dostosuje kontrast.&nbsp; Dla "c" od 0 do 0,5, kontrast jest zmniejszany.&nbsp; Dla "c" > 0,5, kontrast jest zwiększany.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
pl: float boxstep(float x,float a)
     jeśli x < a to 0 w przeciwnym przypadku 1

[ctx: builtin|]
en: float linearstep(float x, float a, float b)
     if x &lt; a then 0, if x &gt; b then 1, and
    x transitions linearly when a &lt; x &lt; b
pl: float linearstep(float x, float a, float b)
     jeśli x &lt; a to 0, jeśli x &gt; b to 1 oraz
    x przechodzi liniowo, gdy a &lt; x &lt; b

[ctx: builtin|]
en: float smoothstep(float x,float a,float b)
     if x &lt; a then 0, if x &gt; b then 1, and
    x transitions smoothly (cubic) when a &lt; x &lt; b
pl: float smoothstep(float x,float a,float b)
     jeśli x &lt; a to 0, jeśli x &gt; b to 1 oraz
    x przechodzi gładko (sześciennie), gdy a &lt; x &lt; b

[ctx: builtin|]
en: float gasussstep(float x,float a,float b)
     if x &lt; a then 0, if x &gt; b then 1, and
    x transitions smoothly (exponentially) when a &lt; x &lt; b
pl: float gasussstep(float x,float a,float b)
     jeśli x &lt; a to 0, jeśli x &gt; b to 1 oraz
    x przechodzi gładko (wykładniczo), gdy a &lt; x &lt; b

[ctx: builtin|]
en: remap(float x, float source, float range, float falloff, float interp)
    General remapping function.
    When x is within +/- <i>range</i> of source, the result is one.
    The result falls to zero beyond that range over <i>falloff</i> distance.
    The falloff shape is controlled by <i>interp</i>. Numeric values
    or named constants may be used:
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>linear</b> = 0
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>smooth</b> = 1
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>gaussian</b> = 2
pl: remap(float x, float źródło, float zakres, float spadek, float interp)
    Ogólna funkcja ponownie mapująca.
    Gdy x jest w <i>zakres</i> +/-  źródła, to wynik jest równy jeden.
    Wynik spada do zera poza tym zakresem w odległości <i>spadek</i>.
    Kształt spadku jest określany przez <i>interp</i>. Można używać wartości numerycznych
    lub nazwanych stałych:
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>linowy</b> = 0
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>wygładzony</b> = 1
    &nbsp;&nbsp;&nbsp;&nbsp;int <b>gausa</b> = 2

[ctx: builtin|]
en: mix(float a,float b,float alpha)
    Blend of a and b according to alpha.
pl: mix(float a,float b,float alpha)
    Zmieszanie "a" oraz "b" wg alfy.

[ctx: builtin|]
en: color  hsi(color x, float h, float s, float i, float map=1)
    The hsi function shifts the hue by h
    (in degrees) and scales the saturation and intensity by s and i
    respectively.&nbsp; A map may be supplied which will control the shift
    - the full shift will happen when the map is one and no shift will
    happen when the map is zero.&nbsp; The shift will be scaled back for
    values between zero and one.
pl: color  hsi(color x, float h, float s, float i, float map=1)
    Funkcja hsi przesuwa odcień o wartość "h"
    (w stopniach) i skaluje nasycenie oraz natężenie odpowiednio o wartość "s" oraz "i"
    .&nbsp; Można podać mapę, która będzie sterować przesunięciem
    - pełne przesunięcie nastąpi, gdy mapa jest równa jeden, a brak przesunięcia nastąpi
    gdy mapa jest równa zero.&nbsp; Przesunięcie powróci do swojej pierwotnej
    wartości pomiędzy zero i jeden.

[ctx: builtin|]
en: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    The midhsi function is just like the hsi function except that
    the control map is centered around the mid point (value of 0.5)
    and can scale the shift in both directions.
pl: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    Funkcja midhsi jest taka sama jak hsi z wyjątkiem, że 
    mapa sterująca jest wyśrodkowana względem punktu środkowego (wartość 0.5)
    i może skalować przesunięcie w obu kierunkach.

[ctx: builtin|]
en: color rgbtohsl(color rgb)
    RGB to HSL color space conversion.
    HSL is Hue, Saturation, Lightness (all in range [0..1] )
    These functions have also been extended to support rgb and hsl values
    outside of the range [0..1] in a reasonable way.&nbsp; For any rgb or
    hsl value (except for negative s values), the conversion is
    well-defined and reversible.
pl: color rgbtohsl(color rgb)
    Przekształcenie przestrzeni barw RGB na HSL.
    HSL to Hue (z ang. odcień), Saturation (z ang. nasycenie), Lightness (z ang. jasność) (wszystkie w zakresie[0..1] )
    Funkcje te zostały także rozszerzone o obsługę wartości rgb oraz hsl
    spoza zakresu [0..1] w sensowny sposób.&nbsp; Dla każdej wartości rgb czy
    hsl (poza ujemnymi wartościami "s"), przekształcenie
    jest jednoznacznie określone i odwracalne.

[ctx: builtin|]
en: color hsltorgb(color hsl)
    HSL to RGB color space conversion.
    HSL is Hue, Saturation, Lightness (all in range [0..1] )
    These functions have also been extended to support rgb and hsl values
    outside of the range [0..1] in a reasonable way.&nbsp; For any rgb or
    hsl value (except for negative s values), the conversion is
    well-defined and reversible.
pl: color hsltorgb(color hsl)
    Przekształcenie przestrzeni barw HSL na RGB.
    HSL to Hue (z ang. odcień), Saturation (z ang. nasycenie), Lightness (z ang. jasność) (wszystkie w zakresie[0..1] )
    Funkcje te zostały także rozszerzone o obsługę wartości rgb oraz hsl
    spoza zakresu [0..1] w sensowny sposób.&nbsp; Dla każdej wartości rgb czy
    hsl (poza ujemnymi wartościami "s"), przekształcenie
    jest jednoznacznie określone i odwracalne.

[ctx: builtin|]
en: color saturate(color val, float amt)
    Scale saturation of color by amt.
    The color is scaled around the rec709 luminance value,
    and negative results are clamped at zero.
pl: color saturate(color val, float amt)
    Skaluje nasycenie barwy o wartość "amt".
    Barwa jest skalowana wokół wartości luminancji rec709,
    a wartości ujemne są przycinane do zera.

[ctx: builtin|]
en: float rand ( [float min, float max], [float seed] )
    Random number between [min, max] (or [0, 1] if unspecified).
    If a seed is supplied, it will be used in addition to the internal seeds and may be used to create multiple distinct generators.
pl: float rand ( [float min, float max], [float seed] )
    Losowa liczba pomiędzy [min, max] (lub [0, 1] jeśli nie określono).
    Jeśli podano ziarno losowości, to zostanie ono wykorzystane jako dodatkowe do wewnętrznych ziaren losowości i może być użyte do stworzenia wielu odmiennych generatorów.

[ctx: builtin|]
en: float hash(float seed1,[float seed2, ...])
    Like rand, but with no internal seeds. Any number of seeds may be given
    and the result will be a random function based on all the seeds.
pl: float hash(float seed1,[float seed2, ...])
    Tak jak rand lecz bez wewnętrznych ziaren losowości. Można podać dowolną
    liczbę ziaren losowości, a wynikiem będzie losowa funkcja na podstawie wszystkich ziaren losowości.

[ctx: builtin|]
en: float noise ( vector v )
    float noise ( float x, float y )
    float noise ( float x, float y, float z )
    float noise ( float x, float y, float z, float w )
    Original perlin noise at location (C2 interpolant)
pl: float noise ( vector v )
    float noise ( float x, float y )
    float noise ( float x, float y, float z )
    float noise ( float x, float y, float z, float w )
    Pierwotny szum perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
pl: float snoise ( vector v)
    Szum w zakresie od -1 do 1 utworzony z pierwotnego szumu perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
pl: vector vnoise (vector v)
    Szum wektorowy utworzony z pierwotnego szumu perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
pl: color cnoise ( vector v)
    Szum kolorowy utworzony z pierwotnego szumu perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: float snoise4 ( vector v,float t)
    4D signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
pl: float snoise4 ( vector v,float t)
    Szum 4D ze znakiem w zakresie od -1 do 1 utworzony z pierwotnego szumu perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
pl: vector vnoise4 ( vector v,float t)
    Szum wektorowy 4D utworzony z pierwotnego szumu perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
pl: color cnoise4 ( vector v,float t)
    Szum kolorowy 4D utworzony z pierwotnego szumu perlin w miejscu (C2 interpolant)

[ctx: builtin|]
en: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) is a multi-frequency noise function. 
    The base frequency is the same as the "noise" function. The total number of frequencies is controlled by octaves. The lacunarity is the spacing between the frequencies - a value of 2 means each octave is twice the previous frequency. The gain controls how much each frequency is scaled relative to the previous frequency.
pl: float fbm(vector v,int oktawy=6,float lakunarność=2,float wzmocnienie=.5)
    fbm (Fraktalny ruch Browna) jest wieloczęstotliwościową funkcją szumu. 
    Podstawowa częstotliwość jest taka sama jak funkcja "szumu". Całkowita liczba częstotliwości sterowanych przez oktawy. Lakunarność jest odległościąpomiędzy częstotliwościami - wartość równa 2 oznacza, że każda oktawa madwukrotnie wyższą częstotliwość poprzedniej. Wzmocnienie określa o ilekażda częstotliwość jest skalowana względem poprzedniej częstotliwości.

[ctx: builtin|]
en: vector vfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
pl: vector vfbm(vector v, int oktawy=6, float lakunarność=2, float wzmocnienie=.5 )

[ctx: builtin|]
en: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) is a multi-frequency noise function. 
    The base frequency is the same as the "noise" function. The total 
    number of frequencies is controlled by octaves. The lacunarity is the 
    spacing between the frequencies - a value of 2 means each octave is 
    twice the previous frequency. The gain controls how much each 
    frequency is scaled relative to the previous frequency.
pl: float fbm4(vector v,float czas,int oktaves=6,float lakunarność=2,float wzmocnienie=.5)
    fbm (Fraktalny ruch Browna) jest wieloczęstotliwościową funkcją szumu. 
    Podstawowa częstotliwość jest taka sama jak funkcja "szumu". Całkowita 
    liczba częstotliwości sterowanych przez oktawy. Lakunarność jest odległością 
    pomiędzy częstotliwościami - wartość równa 2 oznacza, że każda oktawa ma 
    dwukrotnie wyższą częstotliwość poprzedniej. Wzmocnienie określa o ile 
    każda częstotliwość jest skalowana względem poprzedniej częstotliwości.

[ctx: builtin|]
en: vector vfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
pl: vector vfbm4(vector v,float czas,int oktawy=6,float lakunarność=2,float wzmocnienie=.5)

[ctx: builtin|]
en: color cfbm(vector vint octaves=6,float lacunarity=2,float gain=.5)
pl: color cfbm(vector vint oktawy=6,float lakunarność=2,float wzmocnienie=.5)

[ctx: builtin|]
en: color cfbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
pl: color cfbm4(vector v,float czas,int oktawy=6,float lakunarność=2,float wzmocnienie=.5)

[ctx: builtin|]
en: float cellnoise(vector v)
    cellnoise generates a field of constant colored cubes based on the integer location.
    This is the same as the prman cellnoise function.
pl: float cellnoise(vector v)
    cellnoise tworzy pole sześcianów o stałej barwie na podstawie położenia liczb całkowitych.
    Jest to to samo co funkcja szumu komórkowego prman.

[ctx: builtin|]
en: color cellnoise(vector v)
    cellnoise generates a field of constant colored cubes based on the integer location.
    This is the same as the prman cellnoise function.
pl: color cellnoise(vector v)
    cellnoise tworzy pole sześcianów o stałej barwie na podstawie położenia liczb całkowitych.
    Jest to to samo co funkcja szumu komórkowego prman.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
pl: float pnoise ( vector v, vector okres )
    szum okresowy

[ctx: builtin|]
en: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    voronoi is a cellular noise pattern. It is a jittered variant of cellnoise.
pl: float voronoi(vector v, int rodzaj=1,float postrzępienie=0.5, float fbmSkala=0, int fbmOktawy=4,float fbmLakunarność=2, float fbmWzmocnienie=.5)
    voronoi jest komórkowym wzorcem szumu. Jest postrzępioną odmianą cellnoise.

[ctx: builtin|]
en: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    returns color in cellular pattern. It is a jittered variant of cellnoise.
pl: color cvoronoi(vector v, int rodzaj=1,float postrzępienie=0.5, float fbmSkala=0, int fbmOktawy=4,float fbmLakunarność=2, float fbmWzmocnienie=.5)
    zwraca barwę we wzorcu komórkowym. Jest postrzępioną odmianą cellnoise.

[ctx: builtin|]
en: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    returns center of voronoi cell.
pl: color pvoronoi(vector v, int rodzaj=1,float postrzępienie=0.5, float fbmSkala=0, int fbmOktawy=4,float fbmLakunarność=2, float fbmWzmocnienie=.5)
    zwraca środek komórki voronoi.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
pl: float dist(vector a, vector b)
    odległość pomiędzy dwoma punktami

[ctx: builtin|]
en: float length(vector v)
    length of vector
pl: float length(vector v)
    długość wektora

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
pl: float hypot(vector v)
    długość wektora 2D [x, y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
pl: float dot(vector a,vector b)
    iloczyn skalarny wektorów

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
pl: vector norm(vector v)
    wektor przeskalowany do długości jednostkowej

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
pl: vector cross(vector a,vector b)
    iloczyn wektorowy wektorów

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
pl: float angle(vector a,vector b)
    kąt pomiędzy dwoma wektorami (w radianach)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
pl: vector angle(vector a,vector b)
    znormalizowany wektor prostopadły do "a" oraz "b", przeskalowany do jednostki długości

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
pl: vector rotate(vector v,vector oś,float kąt)
    obraca "v" wokół osi o dany kąt (w radianach)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
pl: vector up(vector P,vector upvec)
    obraca v tak, że oś Y jest skierowana w górę danego kierunku

[ctx: builtin|]
en: int cycle(int index, int loRange, int hiRange )
    Cycles through values between loRange and hiRange based on supplied index.
    This is an offset "mod" function. The result is computed as ``loRange + value % (hiRange-loRange+1)``.
pl: int cycle(int index, int loRange, int hiRange )
    Krąży pomiędzy wartościami spomiędzy zakresu loRange oraz hiRange na podstawie podanego indeksu.
     Jest to funkcja przesunięcia "mod". Wynik jest obliczony jako ``loRange + wartość % (hiRange-loRange+1)``.

[ctx: builtin|]
en: int pick(float index, int loRange, int hiRange, [float weights, ...] )
    Picks values randomly between loRange and hiRange based on supplied index (which is
    automatically hashed).&nbsp; The values will be distributed according
    to the supplied weights.&nbsp; Any weights not supplied are assumed to
    be 1.0.
pl: int pick(float index, int loRange, int hiRange, [float weights, ...] )
    Wybiera wartości losowo spomiędzy loRange oraz hiRange na podstawie podanego indeksu (dla którego
     jest obliczany hasz).&nbsp; Wartości zostaną rozłożone wg podanych wag.&nbsp; Gdy wartość wagi jest niepodana, to przyjmuje się
    1.0.

[ctx: builtin|]
en: color swatch(float index, color choice0, color choice1, color choice2, [...])
    Chooses one of the supplied color choices based on the index (assumed to be in range [0..1]).
pl: color swatch(float indeks, color wybór0, color wybór1, color wybór2, [...])
    Wybiera jedną z dostępnych barw na podstawie indeksu (zakłada się, że z zakresu [0..1]).

[ctx: builtin|]
en: float choose(float index,float choice1, float choice2, [...])
    Chooses one of the supplied choices based on the index (assumed to be in range [0, 1]).
pl: float choose(float indeks,float wybór1, float wybór2, [...])
    Wybiera jeden z możliwych wyborów na podstawie indeksu (zakłada się, że z zakresu [0, 1]).

[ctx: builtin|]
en: float wchoose(float index,float choice1, float weight1, float choice2, float weight2, [...] )
    Chooses one of the supplied choices based on the index (assumed to be in range [0..1]).
    The values will be distributed according to the supplied weights.
pl: float wchoose(float indeks,float wybór1, float waga1, float wybór2, float waga2, [...] )
    Wybiera jeden z możliwych wyborów na podstawie indeksu (zakłada się, że z zakresu [0..1]).
    Wartości zostaną rozłożone wg podanych wag.

[ctx: builtin|]
en: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpolates a set of values to the parameter specified where y1, ..., yn are
    distributed evenly from [0..1]
pl: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpoluje zestaw wartości do danego parametru, gdzie y...1, ..., yn
    są rozłożone równo w zakresie [0..1]

[ctx: builtin|]
en: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpolates a 1D ramp defined by control points at 'param'. Control points are specified 
    by triples of parameters pos_i, val_i, and interp_i. Interpolation codes are 
    0 - none, 1 - linear, 2 - smooth, 3 - spline, 
    4 - monotone (non oscillating spline)
pl: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpoluje rampę 1D określoną punktami tworzącymi poprzez 'param'. Punkty tworzące są określane  
    trójkami parametrów pos_i, val_i oraz interp_i. Kody interpolacji to  
    0 - brak, 1 - liniowa, 2 - wygładzona, 3 - krzywa sklejana, 
    4 - monotoniczna (nieoscylacyjna krzywa sklejana)

[ctx: builtin|]
en: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpolates color ramp given by control points at 'param'. Control points are specified 
    by triples of parameters pos_i, val_i, and interp_i. Interpolation codes are 
    0 - none, 1 - linear, 2 - smooth, 3 - spline, 
    4 - monotone (non oscillating spline)
pl: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpoluje rampę barw określoną punktami tworzącymi poprzez 'param'. Punkty tworzące są określane  
    trójkami parametrów pos_i, val_i oraz interp_i. Kody interpolacji to  
    0 - brak, 1 - liniowa, 2 - wygładzona, 3 - krzywa sklejana, 
    4 - monotoniczna (nieoscylacyjna krzywa sklejana)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
pl: getVar(string nazwaZmiennej,vector wartośćDomyślna)
    zwraca wartość nazwaZmiennej, jeśli zmienna istnieje, w przeciwnym przypadku zwraca wartośćDomyślna

[ctx: builtin|]
en: float printf(string format,[vec0, vec1,  ...])
    Prints out a string to STDOUT, Format parameters allowed are "%v" and "%f".
    Return parameter is empty, but must be assigned to a variable.
pl: float printf(string format,[vec0, vec1,  ...])
    Wyświetla ciąg znaków na STDOUT, dozwolone parametry formatujące to "%v" oraz"%f".
    Wartość zwracana jest pusta, lecz musi zostać przypisana do zmiennej.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
pl: sprintf(string format, [double|string, double|string, ...])
    Zwraca ciąg znaków sformatowany wg podanych wartości.  Zobacz 'man sprintf' po więcej szczegółów nt. formatowania.

[ctx: ExprControlCollection|]
en: Add new variable
pl: Dodaj nową zmienną

[ctx: ErrorMessages|]
en: Expected string or float[d]
pl: Oczekiwany ciąg znaków lub float[d]

[ctx: ErrorMessages|]
en: Expected float[d]
pl: Oczekiwany float[d]

[ctx: ErrorMessages|]
en: Expected float[%1]
pl: Oczekiwano float[%1]

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
pl: Niezgodność rodzaju, pierwszy: '%1'; drugi: '%2'

[ctx: ErrorMessages|]
en: Expected float or float[3]
pl: Oczekiwany float lub float[3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
pl: Oczekiwano '%1' jako argumentu, dostano '%2'

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
pl: Zła liczba argumentów, powinno być od 1 do 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
pl: Zła liczba argumentów, powinna być wielokrotnością 3 plus 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
pl: Zła liczba argumentów, powinno być 1 lub więcej

[ctx: ErrorMessages|]
en: First argument must be a string
pl: Pierwszym argumentem musi być ciąg znaków

[ctx: ErrorMessages|]
en: Incomplete format specifier
pl: Niezupełne określenie formatu

[ctx: ErrorMessages|]
en: No variable named '%1'
pl: Brak zmiennej o nazwie '%1'

[ctx: ErrorMessages|]
en: Function '%1' has no definition
pl: Funkcja '%1' nie ma definicji

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
pl: Działanie przypisania ma niepoprawny rodzaj '%1'

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
pl: Rodzaje warunków nie są zgodne

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
pl: Zmienna '%1' jest określona w warunkach niejednoznacznie

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
pl: Zbyt mało argumentów dla funkcji '%1'

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
pl: Zbyt wiele argumentów dla funkcji '%1'

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
pl: Rodzaj wytworzonego wyrażenia '%1' jest niezgodny z żądanym rodzajem '%2'

[ctx: ErrorMessages|]
en: Syntax error near '%1'
pl: Błąd składni w pobliżu '%1'

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
pl: Nieoczekiwany koniec wyrażenia w pobliżu '%1'

[ctx: ErrorMessages|]
en: Unexpected end of format string
pl: Nieoczekiwany koniec ciągu z formatowaniem

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
pl: Nieprawidłowy format ciągu znaków, dopuszczalne są tylko %v oraz %f

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
pl: Zła liczba argumentów dla ciągu z formatem

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
pl: Nieznany błąd (wiadomość = %1)

[ctx: ExprAddDialog|]
en: Variable
pl: Zmienna

[ctx: ExprAddDialog|]
en: Lookup
pl: Znajdź

[ctx: ExprAddDialog|]
en: Curve
pl: Krzywa

[ctx: ExprAddDialog|]
en: Color Curve
pl: Krzywa barwy

[ctx: ExprAddDialog|]
en: Default
pl: Domyślne

[ctx: ExprAddDialog|]
en: Max
pl: Maks

[ctx: ExprAddDialog|]
en: Float
pl: Liczba zmiennoprzecinkowa

[ctx: ExprAddDialog|]
en: Vector
pl: Wektor

[ctx: ExprAddDialog|]
en: Color
pl: Barwa

[ctx: ExprAddDialog|]
en: Rainbow
pl: Tęcza

[ctx: ExprAddDialog|]
en: Shades of Gray
pl: Odcienie szarości

[ctx: ExprAddDialog|]
en: Colors
pl: Barwy

[ctx: ExprAddDialog|]
en: Swatch
pl: Łata

[ctx: ExprAddDialog|]
en: string
pl: ciąg znaków

[ctx: ExprAddDialog|]
en: file
pl: plik

[ctx: ExprAddDialog|]
en: directory
pl: katalog

[ctx: ExprAddDialog|]
en: String Name
pl: Nazwa ciągu znaków

[ctx: ExprAddDialog|]
en: String Type
pl: Rodzaj ciągu znaków

[ctx: ExprAddDialog|]
en: String Default
pl: Domyślny ciąg znaków

[ctx: ExprAddDialog|]
en: String
pl: Ciąg znaków

[ctx: ExprBrowser|]
en: Save Expression
pl: Zapisz wyrażenie

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
pl: Nie można otworzyć pliku %1 do zapisu

[ctx: ExprBrowser|]
en: Error
pl: Błąd

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
pl: Nie można otworzyć pliku %1 do zapisu. Czy jest on tylko do odczytu?

[ctx: CCurveScene|]
en: Delete Point
pl: Usuń punkt

[ctx: ExprColorCurve|]
en: Selected Position:
pl: Wybrane położenie:

[ctx: ExprColorCurve|]
en: Selected Color:
pl: Zaznaczona barwa:

[ctx: ExprColorCurve|]
en: None
pl: Brak

[ctx: ExprColorCurve|]
en: Linear
pl: Liniowa

[ctx: ExprColorCurve|]
en: Smooth
pl: Wygładzona

[ctx: ExprColorCurve|]
en: Spline
pl: Krzywa sklejana

[ctx: ExprColorCurve|]
en: &Expand...
pl: &Rozwiń...

[ctx: ExprColorFrame|]
en: Delete Swatch
pl: Usuń łatkę

[ctx: ExprColorFrame|]
en: Cancel
pl: Anuluj

[ctx: ExprColorSwatchWidget|]
en: &Add...
pl: Dod&aj...

[ctx: ExprCompletionModel|]
en: Local
pl: Lokalna

[ctx: StringControl|]
en: Please choose a file
pl: Wybierz plik

[ctx: StringControl|]
en: Images (*.tif *.tx *.jpg *.ptx *.png)
pl: Obrazy (*.tif *.tx *.jpg *.ptx *.png)

[ctx: CurveControl|]
en: Pos:
pl: Położenie:

[ctx: CurveControl|]
en: Val:
pl: Wartość:

[ctx: CCurveControl|]
en: Pos:
pl: Położenie:

[ctx: CCurveControl|]
en: Val:
pl: Wartość:

[ctx: CurveScene|]
en: Delete Point
pl: Usuń punkt

[ctx: ExprCurve|]
en: Selected Position:
pl: Wybrane położenie:

[ctx: ExprCurve|]
en: Selected Value:
pl: Zaznaczona wartość:

[ctx: ExprCurve|]
en: None
pl: Brak

[ctx: ExprCurve|]
en: Linear
pl: Liniowa

[ctx: ExprCurve|]
en: Smooth
pl: Wygładzona

[ctx: ExprCurve|]
en: Spline
pl: Krzywa sklejana

[ctx: ExprCurve|]
en: &Expand...
pl: &Rozwiń...

[ctx: ExprEditor|]
en: Expression Editor
pl: Edytor wyrażeń

[ctx: ExprFileDialog|]
en: Open
pl: Otwórz

[ctx: ExprFileDialog|]
en: Favorites
pl: Ulubione

[ctx: ExprTextEdit|]
en: Pop-up Help
pl: Pomoc podręczna
