en to sl translation catalogue (172 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
sl: float abs(float x)
    absolutna vrednost x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
sl: float deg(float angle)
    radiani v stopinje

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
sl: float rad(float angle)
    stopinje v radiane

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
sl: float cosd(float angle)
    cosinus v stopinjah

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
sl: float sind(float angle)
    sinus v stopinjah

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
sl: float tand(float angle)
    tangens v stopinjah

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
sl: float acosd(float value)
    arcs cosinus v stopinjah

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
sl: float asind(float value)
    arcus sinus v stopinjah

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
sl: float atand(float value)
    arcus tangens v stopinjah

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
sl: float atan2d(float y,float x)
    arcus tangens v stopinjah y/x med -180 in 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
sl: float cos(float angle)
    cosinus v radianih

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
sl: float sin(float angle)
    sinus v radianih

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
sl: float tan(float angle)
    tangens v radianih

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
sl: float acos(float value)
    arcus cosinus v radianih

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
sl: float asin(float value)
    arcus sinus v radianih

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
sl: float atan(float value)
    arcus tangens v radianih

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
sl: float atan2(float y,float x)
    arcus tangens v radianih y/x med -PI in PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
sl: float cosh(float angle)
    hiperbolični cosinus v radianih

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
sl: float sinh(float angle)
    hiperbolični sinus v radianih

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
sl: float tanh(float angle)
    hiperbolični tangens v radianih

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
sl: float acosh(float value)
    hiperbolični arcus cosinus v radianih

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
sl: float asinh(float value)
    hiperbolični arcus sinus v radianih

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
sl: float atanh(float value)
    hiperbolični arcus tangens v radianih

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
sl: float clamp(float x,float lo,float hi)
    omeji x na obseg [lo,hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
sl: float round(float x)
    najbližje celo število x-a

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
sl: float max(float a,float b)
    večji izmed a in b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
sl: float min(float a,float b)
    manjši izmed a in b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
sl: float trunc(float a)
    najbližje celo število proti ničli

[ctx: builtin|]
en: float floor(float a)
    next lower integer
sl: float floor(float a)
    naslednje manjše celo število

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
sl: float ceil(float a)
    naslednje večje celo število

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
sl: float invert(float a)
    Določeno kot 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
sl: float cbrt(float x)
    kubni koren

[ctx: builtin|]
en: float sqrt(float x)
    square root
sl: float sqrt(float x)
    kvadratni koren

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
sl: float exp(float x)
    E na potenco x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
sl: float pow(float x, float y)
    x na potenco y, na voljo tudi kot ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
sl: float log(float x)
    Naravni logaritem

[ctx: builtin|]
en: float log10(float x)
    Base 10 logarithm
sl: float log10(float x)
    Logaritem z osnovo 10

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
sl: float fmod(float x,float y)
    ostanek pri x/y (na voljo tudi kot 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
sl: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Upošteva absolutna vrednost vsakega izraza šuma. To daje valovit videz

[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
sl: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Upošteva absolutna vrednost vsakega izraza šuma. To daje valovit videz

[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
sl: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    Upošteva absolutna vrednost vsakega izraza šuma. To daje valovit videz

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
sl: float compress(float x,float lo,float hi)
    Preslika x iz [0,1] v [lo,hi]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
sl: float expand(float x,float lo,float hi)
    Preslika x iz [lo,hi] v [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]
sl: float fit(float x,float a1,float b1,float a2,float b2)
    Linearno preslika x iz [a1,b1] v [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
sl: float gamma(float x, float g)
    Gama korekcija x-a s faktorjem gama 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))
sl: float bias(float x, float g)
    Varianca game, kjer vrednosti manjše od 0,5 vlečejo krivuljo navzdol
    in vrednosti večje od 0.5 vlečejo krivuljo navzor
    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.
sl: float contrast(float x, float c)
    Prilagodi kontrast.&nbsp; Za c od 0 do 0,5, je kontrast zmanjšan.&nbsp; Za c &gt; 0,5, je kontrast povečan.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
sl: float boxstep(float x,float a)
     če x < a potem 0 sicer 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
sl: float linearstep(float x, float a, float b)
     če x &lt; a potem 0, če x &gt; b potem 1, in
    x linearno prehaja ko &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
sl: float smoothstep(float x,float a,float b)
     če x &lt; a potem 0, če x &gt; b potem 1, in
    x gladko (kubično) prehaja ko 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
sl: float gasussstep(float x,float a,float b)
     če x &lt; a potem 0, če x &gt; b potem 1, in
    x gladko (eksponentno) prehaja, ko 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
sl: remap(float x, float source, float range, float falloff, float interp)
    Splošna funkcija preslikave.
    Ko je x znotraj +/- <i>obsega</i> vira, je rezultat ena.
    Rezultat pade na nič preko tega obsega na razdalji <i>padanja</i>.
    Obliko padanja nadzira <i>interp</i>. Številske vrednosti
    lahko se uporabijo konstante z imenom:
    &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

[ctx: builtin|]
en: mix(float a,float b,float alpha)
    Blend of a and b according to alpha.
sl: mix(float a,float b,float alpha)
    Mešanica a in b glede na alpha.

[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.
sl: color  hsi(color x, float h, float s, float i, float map=1)
    Funkcija hsi premakne odtenek za h (v stopinjah) in
    nasičenost in intenzivnost prilagodi za s in i.
    Na voljo je še preslikava, ki bo nadzorovala premik - 
    popoln premik se bo zgodil, ko bo preslikava ena in
    noben premik ne bo zgodil, ko je preslikava nič.
    Premik bo pomanjšan za vrednosti med nič in ena.

[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.
sl: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    Funkcija midhsi je podobna funkciji hsi, razen, da je kontrolna
    preslikava centrirana okoli srednje točke (vrednost 0,5)
    in lahko spreminja premik v obe smeri.

[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.
sl: color rgbtohsl(color rgb)
    Pretvorba barvnega prostora RGB v HSL.
    HSL (angl. Hue, Saturation, Lightness) je odtenek, nasičenost, osvetljenost
    (vse v intervalu [0..1]). Te funkcije so bile razširjene tudi tako, da podpirajo
    vrednosti rgb in hsl zunaj obsega [0..1] na razumen način.&nbsp; Za
    katerokoli vrednost rgb ali hsl (razen negativnih vrednosti s) je pretvorba
    dobro definirana in reverzibilna.

[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.
sl: color hsltorgb(color hsl)
    Pretvorba barvnega prostora HSL v RGB.
    HSL (angl. Hue, Saturation, Lightness) je odtenek, nasičenost, osvetljenost
    (vse v intervalu [0..1]). Te funkcije so bile razširjene tudi tako, da podpirajo
    vrednosti rgb in hsl zunaj obsega [0..1] na razumen način.&nbsp; Za
    katerokoli vrednost rgb ali hsl (razen negativnih vrednosti s) je pretvorba
    dobro definirana in reverzibilna.

[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.
sl: color saturate(color val, float amt)
    Lestvico nasičenosti barve pomnoži z amt.
    Barva je pomanjšana okoli vrednosti osvetlitve rec709,
    negativni rezultati pa so pritrjeni na nič.

[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.
sl: float rand ( [float min, float max], [float seed] )
    Slučajno število med [min, max] (ali [0, 1] če ni določeno).
    Če je določen brst, bo uporabljen kot dodatek k notranjim brstom inje lahko uporabljen za tvorbo več ločenih generatorjev slučajnih števil.

[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.
sl: float hash(float seed1,[float seed2, ...])
    Kot rand a brez notranjih brstov. Dodati je možno poljubno število brstov
    in rezultat bo slučajna funkcija na osnovi vseh teh brstov.

[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)
sl: 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 )
    Izvorni Perlinov šum na lokaciji (C2 interpolacija)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
sl: float snoise ( vector v)
    predznačen šun v obsegu od -1 do 1 izoblikovan z izvirnim Perlinovem šumom na lokaciji(C2 interpolacija)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
sl: vector vnoise ( vector v)
    vektorski šum oblikovan z originalnim Perlinovim šumom na lokaciji (C2 interpolacija)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
sl: color cnoise ( vector v)
    barvni šum oblikovan z originalnim Perlinovim šumom na lokaciji (C2 interpolacija)

[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)
sl: float snoise4 ( vector v,float t)
    4D predznačen šum v obsegu od -1 do 1 oblikovan z originalnim Perlinovim šumom na lokaciji (C2 interpolacija)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
sl: vector vnoise4 ( vector v,float t)
    4D vektorski šum oblikovan z originalnim Perlinovim šumom na lokaciji (C2 interpolacija)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
sl: color cnoise4 ( vector v,float t)
    4D barvni šum oblikovan z originalnim Perlinovim šumom na lokaciji (C2 interpolacija)

[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.
sl: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fraktalno Brownovo gibanje) je večfrekvenčna funkcija šuma.
    Osnovna frekvenca je enaka funkciji "šuma". Skupno številofrekvenc nadzirajo oktave. Lacunarnost je razmik med frekvencami - vrednost 2 pomeni, da je vsaka oktava dvakratnik prejšnje frekvence. Ojačenje nadzoruje, za koliko je posamezna frekvenca povečanaglede na prejšnjo frekvenco.

[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.
sl: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fraktalno Brownovo gibanje) je večfrekvenčna funkcija šuma.
    Osnovna frekvenca je enaka funkciji "šuma". Skupno število frekvenc nadzirajo oktave. Lacunarnost je razmik med frekvencami - vrednost 2 pomeni, da je vsaka oktava dvakratnik prejšnje frekvence. Ojačenje nadzoruje, za koliko je posamezna frekvenca povečana glede na prejšnjo frekvenco.

[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.
sl: float cellnoise(vector v)
    cellnoise ustvari polje konstantnih barvnih kock na podlagi lokacije števila.
    To je enako kot funkcija prman cellnoise.

[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.
sl: color cellnoise(vector v)
    cellnoise ustvari polje konstantnih barvnih kock na podlagi lokacije števila.
    To je enako kot funkcija prman cellnoise.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
sl: float pnoise ( vector v, vector period )
    periodični šum

[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.
sl: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    voronoi je celični vzorec šumov. To je vzburjena različica celičnega šuma.

[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.
sl: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    vrne barvo v celičnem vzorcu. To je vzburjena različica celičnega šuma.

[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.
sl: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    vrne center voronoiove celice.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
sl: float dist(vector a, vector b)
    razdalja med dvema točkama

[ctx: builtin|]
en: float length(vector v)
    length of vector
sl: float length(vector v)
    dolžina vektorja

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
sl: float hypot(vector v)
    dolžina 2d vektorja [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
sl: float dot(vector a,vector b)
    skalarni produkt vektorjev

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
sl: vector norm(vector v)
    vektor, pomanjšan na dolžino enote

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
sl: vector cross(vector a,vector b)
    vektorski produkt

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
sl: float angle(vector a,vector b)
    kot med dvema vektorjema (v radianih)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
sl: vector angle(vector a,vector b)
    normalizirani vektor, pravokoten na a in b, pomanjšan na dolžino enote

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
sl: vector rotate(vector v,vector axis,float angle)
    vrti v okoli osi za dani kot (v radianih)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
sl: vector up(vector P,vector upvec)
    vrti v tako, da os Y kaže v dani smeri

[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)``.
sl: int cycle(int index, int loRange, int hiRange )
    Preklaplja med vrednostmi loRange in hiRange na podlagi danega indeksa.
    To je odmik funkcije "mod". Rezultat je izračunan kot ``loRange + value % (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.
sl: nt pick(float index, int loRange, int hiRange, [float weights, ...] )
    Naključno izbira vrednosti med loRange in hiRange glede na priloženi indeks
    (ki je samodejno zgoščena).
    &nbsp;Vrednosti bodo porazdeljene v skladu
    s priloženimi utežmi.&nbsp; Za vse nedobavljene uteži se predpostavlja
    da so 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]).
sl: color swatch(float index, color choice0, color choice1, color choice2, [...])
    Izbere eno od ponujenih barvnih izbir glede na indeks (domnevnov območju [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]).
sl: float choose(float index,float choice1, float choice2, [...])
    Izbere eno od ponujenih izbir glede na indeks (predvideno v območju [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.
sl: float wchoose(float index,float choice1, float weight1, float choice2, float weight2, [...] )
    Izbere eno od ponujenih možnosti na podlagi indeksa (domnevno v obsegu [0..1]).
    Vrednosti se porazdelijo glede na priložene uteži.

[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]
sl: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpolira nabor vrednosti na navedeni parameter, kjer so y1, ..., yn 
    porazdeljeni enakomerno na [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)
sl: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpolira 1D rampo, določeno s kontrolnimi točkami pri 'param'. Kontrolne točke so določene
    s trojkami parametrov pos_i, val_i in interp_i. Interpolacijske kode so
    0 - nič, 1 - linearno, 2 - gladko, 3 - zlepljeno,
    4-monotona (ne nihajoči zlepek)

[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)
sl: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpolira barvno rampo, določeno s kontrolnimi točkami pri "param". Kontrolne točkeso določene
    s trojkami parametrov pos_i, val_i in interp_i. Interpolacijske kode so
    0 - nič, 1 - linearno, 2 - gladko, 3 - zlepljeno,
    4 - monotona (ne nihajoči zlepek)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
sl: getVar(string varName,vector defaultValue)
    vrne vrednost varName, če spremenljivka obstaja, sicer vrne defaultValue

[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.
sl: float printf(string format,[vec0, vec1,  ...])
    Natisne niz v STDOUT, dovoljeni parametri formatiranja so "%v" in "%f".
    Vrnjeni parameter je prazen, vendar ga je treba dodeliti spremenljivki.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
sl: sprintf(string format, [double|string, double|string, ...])
    Vrne niz oblikovan iz danih vrednosti. Glejte "man sprintf" zapodrobnosti o formatu.

[ctx: ExprControlCollection|]
en: Add new variable
sl: Dodaj novo spremenljivko

[ctx: ErrorMessages|]
en: Expected string or float[d]
sl: Pričakovana string ali float[d]

[ctx: ErrorMessages|]
en: Expected float[d]
sl: Pričakovana float[d]

[ctx: ErrorMessages|]
en: Expected float[%1]
sl: Pričakovana float[%1]

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
sl: Neujemanje tipov, prvo: '%1'; drugo: '%2'

[ctx: ErrorMessages|]
en: Expected float or float[3]
sl: Pričakovan float ali float[3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
sl: Pričakovan argument '%1' , dobil '%2'

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
sl: Napačno število argumentov, mora biti od 1 do 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
sl: Napačno število argumentov, mora biti večkratnik 3 plus 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
sl: Napačno število argumentov, mora biti 1 ali več

[ctx: ErrorMessages|]
en: First argument must be a string
sl: Prvi argument mora biti niz

[ctx: ErrorMessages|]
en: Incomplete format specifier
sl: Nepopoln določilnik formata

[ctx: ErrorMessages|]
en: No variable named '%1'
sl: Ni spremenljivke z imenom '%1'

[ctx: ErrorMessages|]
en: Function '%1' has no definition
sl: Funkcija '%1' nima definicije

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
sl: Operacija prirejanja ima napačen tip '%1'

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
sl: Tipi pogojev niso združljivi

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
sl: Spremenljivka '%1' je nedosledno določena v pogojih

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
sl: Premalo argumentov za funkcijo '%1'

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
sl: Preveč argumentov za funkcijo '%1'

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
sl: Izraz je ustvaril tip '%1', je nezdružljiv z želenim tipom '%2'

[ctx: ErrorMessages|]
en: Syntax error near '%1'
sl: Skladenjska napaka blizu '%1'

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
sl: Nepričakovan konec izraza blizu '%1'

[ctx: ErrorMessages|]
en: Unexpected end of format string
sl: Nepričakovan konec niza formata

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
sl: Neveljaven niz formata, dovoljen je samo %v ali %f

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
sl: Napačno število argumentov za niz formata

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
sl: Neznana napaka (sporočilo = %1)

[ctx: ExprAddDialog|]
en: Variable
sl: Spremenljivka

[ctx: ExprAddDialog|]
en: Lookup
sl: Pogled

[ctx: ExprAddDialog|]
en: Curve
sl: Krivulja

[ctx: ExprAddDialog|]
en: Color Curve
sl: Barvna krivulja

[ctx: ExprAddDialog|]
en: Default
sl: Privzeto

[ctx: ExprAddDialog|]
en: Vector
sl: Vektor

[ctx: ExprAddDialog|]
en: Color
sl: Barva

[ctx: ExprAddDialog|]
en: Rainbow
sl: Mavrica

[ctx: ExprAddDialog|]
en: Shades of Gray
sl: Odtenki sive

[ctx: ExprAddDialog|]
en: Colors
sl: Barve

[ctx: ExprAddDialog|]
en: Swatch
sl: Vzorec barve

[ctx: ExprAddDialog|]
en: string
sl: niz

[ctx: ExprAddDialog|]
en: file
sl: datoteka

[ctx: ExprAddDialog|]
en: directory
sl: direktorij

[ctx: ExprAddDialog|]
en: String Name
sl: Ime niza

[ctx: ExprAddDialog|]
en: String Type
sl: Vrsta niza

[ctx: ExprAddDialog|]
en: String Default
sl: Privzeti niz

[ctx: ExprAddDialog|]
en: String
sl: Niz

[ctx: ExprBrowser|]
en: Save Expression
sl: Shrani izraz

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
sl: Datoteke %1 ni bilo mogoče odpreti za pisanje

[ctx: ExprBrowser|]
en: Error
sl: Napaka

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
sl: Datoteke %1 ni bilo mogoče odpreti za pisanje. Ali je samo za branje?

[ctx: CCurveScene|]
en: Delete Point
sl: Briši točko

[ctx: ExprColorCurve|]
en: Selected Position:
sl: Izbrana pozicija:

[ctx: ExprColorCurve|]
en: Selected Color:
sl: Izbrana barva:

[ctx: ExprColorCurve|]
en: None
sl: Nobena

[ctx: ExprColorCurve|]
en: Linear
sl: Linearno

[ctx: ExprColorCurve|]
en: Smooth
sl: Gladko

[ctx: ExprColorCurve|]
en: Spline
sl: Zlepek

[ctx: ExprColorCurve|]
en: MSpline
sl: MZlepek

[ctx: ExprColorCurve|]
en: &Expand...
sl: Razširi...

[ctx: ExprColorFrame|]
en: Delete Swatch
sl: Zbriši vzorec barve

[ctx: ExprColorFrame|]
en: Cancel
sl: Prekliči

[ctx: ExprColorSwatchWidget|]
en: &Add...
sl: Dodaj...

[ctx: ExprCompletionModel|]
en: Local
sl: Lokalno

[ctx: StringControl|]
en: Please choose a file
sl: Izberite datoteko

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

[ctx: CurveScene|]
en: Delete Point
sl: Zbriši točko

[ctx: ExprCurve|]
en: Selected Position:
sl: Izbrana pozicija:

[ctx: ExprCurve|]
en: Selected Value:
sl: Izbrana vrednost:

[ctx: ExprCurve|]
en: None
sl: Nobena

[ctx: ExprCurve|]
en: Linear
sl: Linearno

[ctx: ExprCurve|]
en: Smooth
sl: Gladko

[ctx: ExprCurve|]
en: Spline
sl: Zlepek

[ctx: ExprCurve|]
en: MSpline
sl: MZlepek

[ctx: ExprCurve|]
en: &Expand...
sl: Razširi...

[ctx: ExprEditor|]
en: Expression Editor
sl: Urejevalnik izraza

[ctx: ExprFileDialog|]
en: Open
sl: Odpri

[ctx: ExprFileDialog|]
en: Favorites
sl: Priljubljene

[ctx: ExprTextEdit|]
en: Pop-up Help
sl: Pogovorno okno pomoči
