en to pt_BR translation catalogue (168 entries)

[ctx: builtin|]
en: float abs(float x)
    absolute value of x
pt_BR: float abs(float x)
    valor absoluto de x

[ctx: builtin|]
en: float deg(float angle)
    radians to degrees
pt_BR: float deg(float angle)
    radianos para graus

[ctx: builtin|]
en: float rad(float angle)
    degrees to radians
pt_BR: float rad(float angle)
    graus para radianos

[ctx: builtin|]
en: float cosd(float angle)
    cosine in degrees
pt_BR: float cosd(float angle)
    cosseno em graus

[ctx: builtin|]
en: float sind(float angle)
    sine in degrees
pt_BR: float sind(float angle)
    seno em graus

[ctx: builtin|]
en: float tand(float angle)
    tangent in degrees
pt_BR: float tand(float angle)
    tangente em graus

[ctx: builtin|]
en: float acosd(float value)
    arc cosine in degrees
pt_BR: float acosd(float value)
    arco cosseno em graus

[ctx: builtin|]
en: float asind(float value)
    arc sine in degrees
pt_BR: float asind(float value)
    arco seno em graus

[ctx: builtin|]
en: float atand(float value)
    arc tangent in degrees
pt_BR: float atand(float value)
    arco tangente em graus

[ctx: builtin|]
en: float atan2d(float y,float x)
    arc tangent in degrees of y/x between -180 and 180
pt_BR: float atan2d(float y,float x)
    arco tangente em graus de y/x entre -180 e 180

[ctx: builtin|]
en: float cos(float angle)
    cosine in radians
pt_BR: float cos(float angle)
    cosseno em radianos

[ctx: builtin|]
en: float sin(float angle)
    sine in radians
pt_BR: float sin(float angle)
    seno em radianos

[ctx: builtin|]
en: float tan(float angle)
    tangent in radians
pt_BR: float tan(float angle)
    tangente em radianos

[ctx: builtin|]
en: float acos(float value)
    arc cosine in radians
pt_BR: float acos(float value)
    arco cosseno em radianos

[ctx: builtin|]
en: float asin(float value)
    arc sine in radians
pt_BR: float asin(float value)
    arco seno em radianos

[ctx: builtin|]
en: float atan(float value)
    arc tangent in radians
pt_BR: float atan(float value)
    arco tangente em radianos

[ctx: builtin|]
en: float atan2(float y,float x)
    arc tangent in radians of y/x between -PI and PI
pt_BR: float atan2(float y,float x)
    arco tangente em radianos de y/x entre -PI e PI

[ctx: builtin|]
en: float cosh(float angle)
    hyperbolic cosine in radians
pt_BR: float cosh(float angle)
    cosseno hiperbólico em radianos

[ctx: builtin|]
en: float sinh(float angle)
    hyperbolic sine in radians
pt_BR: float sinh(float angle)
    seno hiperbólico em radianos

[ctx: builtin|]
en: float tanh(float angle)
    hyperbolic tangent in radians
pt_BR: float tanh(float angle)
    tangente hiperbólica em radianos

[ctx: builtin|]
en: float acosh(float value)
    hyperbolic arc cosine in radians
pt_BR: float acosh(float value)
    arco cosseno hiperbólico em radianos

[ctx: builtin|]
en: float asinh(float value)
    hyperbolic arc sine in radians
pt_BR: float asinh(float value)
    arco seno hiperbólico em radianos

[ctx: builtin|]
en: float atanh(float value)
    hyperbolic arc tangent in radians
pt_BR: float atanh(float value)
    arco tangente hiperbólico em radianos

[ctx: builtin|]
en: float clamp(float x,float lo,float hi)
    constrain x to range [lo,hi]
pt_BR: float clamp(float x,float lo,float hi)
    restringir x ao intervalo [lo, hi]

[ctx: builtin|]
en: float round(float x)
    nearest integer to x
pt_BR: float round(float x)
    o número inteiro mais próximo a x

[ctx: builtin|]
en: float max(float a,float b)
    greater of a and b
pt_BR: float max(float a,float b)
    maior de a e b

[ctx: builtin|]
en: float min(float a,float b)
    lesser of a and b
pt_BR: float min(float a,float b)
    menor de a e b

[ctx: builtin|]
en: float trunc(float a)
    nearest integer towards zero
pt_BR: float trunc(float a)
    o número inteiro mais próximo de zero

[ctx: builtin|]
en: float floor(float a)
    next lower integer
pt_BR: float floor(float a)
    próximo inteiro inferior

[ctx: builtin|]
en: float ceil(float a)
    next higher integer
pt_BR: float ceil(float a)
    próximo inteiro superior

[ctx: builtin|]
en: float invert(float a)
    Defined as 1-x
pt_BR: float invert(float a)
    Definido como 1-x

[ctx: builtin|]
en: float cbrt(float x)
    cube root
pt_BR: float cbrt(float x)
    raiz cúbica

[ctx: builtin|]
en: float sqrt(float x)
    square root
pt_BR: float sqrt(float x)
    raiz quadrada

[ctx: builtin|]
en: float exp(float x)
    E raised to the x power
pt_BR: float exp(float x)
    <i>e</i> elevado à potência de x

[ctx: builtin|]
en: float pow(float x, float y)
    x to the y power, also available as ^
pt_BR: float pow(float x, float y)
    x elevado à potência de y, também disponível como ^

[ctx: builtin|]
en: float log(float x)
    Natural logarithm
pt_BR: float log(float x)
    Logaritmo natural

[ctx: builtin|]
en: float log10(float x)
    Base 10 logarithm
pt_BR: float log10(float x)
    Logaritmo de base 10

[ctx: builtin|]
en: float fmod(float x,float y)
    remainder of x/y (also available as % operator)
pt_BR: float fmod(float x,float y)
    restante de x/y (também disponível como operador % )

[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
pt_BR: float turbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    O valor absoluto de cada termo de ruído é considerado. Isso dá uma aparência ondulada

[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
pt_BR: color cturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    O valor absoluto de cada termo de ruído é considerado. Isso dá uma aparência ondulada

[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
pt_BR: vector vturbulence(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    O valor absoluto de cada termo de ruído é considerado. Isso dá uma aparência ondulada

[ctx: builtin|]
en: float compress(float x,float lo,float hi)
    Remaps x in [0,1] to [lo,hi]
pt_BR: float compress(float x,float lo,float hi)
    Remapeia x em [0,1] para [lo, hi]

[ctx: builtin|]
en: float expand(float x,float lo,float hi)
    Remaps x in [lo,hi] to [0,1]
pt_BR: float expand(float x,float lo,float hi)
    Remapeia x em [lo, hi] para [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]
pt_BR: float fit(float x,float a1,float b1,float a2,float b2)
    Remapeia linearmente x em [a1,b1] para [a2,b2]

[ctx: builtin|]
en: float gamma(float x, float g)
    Gamma correction of x with gamma factor g
pt_BR: float gamma(float x, float g)
    Correção gama de x com fator 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))
pt_BR: float bias(float x, float g)
    Variação de gama onde valores menores que 0,5 puxam a curva
    para baixo e valores maiores que 0,5 puxam a curva para cima
    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.
pt_BR: float contrast(float x, float c)
    Ajusta o contraste.&nbsp; Para c de 0 a 0.5, o contraste é diminuído.&nbsp; Para c &gt; 0.5, o contraste é aumentado.

[ctx: builtin|]
en: float boxstep(float x,float a)
     if x < a then 0 otherwise 1
pt_BR: float boxstep(float x,float a)
    se x < a então 0, caso contrário 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
pt_BR: float linearstep(float x,float a,float b)
    se x &lt; a então 0, se x &gt; b então 1 e
    x transita linearmente quando 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
pt_BR: float smoothstep(float x,float a,float b)
    se x &lt; a então 0, se x &gt; b então 1 e
    x transita suavemente (cúbico) quando 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
pt_BR: float gasussstep(float x,float a,float b)
    se x &lt; a então 0, se x &gt; b então 1 e
    x transita suavemente (exponencialmente) quando 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
pt_BR: remap(float x, float source, float range, float falloff, float interp)
    Função de remapeamento geral.
    Quando x está dentro de +/- <i>range</i> de <i>source</i>, o resultado é 1.
    O resultado cai para zero na distância <i>falloff</i> além do intervalo <i>range</i>.
    A forma de queda é controlada por <i>interp</i>. Valores numéricos
    ou constantes nomeadas podem ser usadas:
    &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.
pt_BR: mix(float a,float b,float alpha)
    Mistura de a e b de acordo com alfa.

[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.
pt_BR: color  hsi(color x, float h, float s, float i, float map=1)
    A função hsi muda a matiz em h
    (em graus) e dimensiona a saturação e a intensidade por s e i
    respectivamente.&nbsp; Um mapa pode ser fornecido para controlar a mudança
    - a mudança completa acontecerá quando o mapa for um e nenhuma mudança
    acontecerá quando o mapa é zero.&nbsp; A mudança será reduzida para
    valores entre zero e um.

[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.
pt_BR: color midhsi(color x, float h, float s, float i, float map, float falloff=1, int interp=0)
    A função midhsi é como a função hsi, exceto que
    o mapa de controle é centralizado em torno do ponto médio (valor de 0.5)
    e pode escalar a mudança em ambas as direções.

[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.
pt_BR: color rgbtohsl(color rgb)
    Conversão de espaço de cores RGB em HSL.
    HSL significa Matiz, Saturação, Luminosidade (todos no intervalo [0..1])
    Essas funções também foram estendidas para oferecer suporte aos valores
    RGB e HSL fora do intervalo [0..1] de uma forma razoável. &nbsp;Para qualquer
    valor RGB ou HSL (exceto para valores s negativos), a conversão é bem
    definida e reversível.

[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.
pt_BR: color hsltorgb(color hsl)
    Conversão de espaço de cor HSL em RGB. 
    HSL significa Matiz, Saturação, Luminosidade (todos no intervalo [0..1])
    Essas funções também foram estendidas para oferecer suporte aos valores
    RGB e HSL fora do intervalo [0..1] de uma forma razoável. &nbsp; Para qualquer
    valor RGB ou HSL (exceto para valores s negativos), a conversão é bem
    definida e reversível.

[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.
pt_BR: color saturate(color val, float amt)
    Escala de saturação de cor por quantidade.
    A cor é dimensionada em torno do valor de luminância rec709, 
    e os resultados negativos são fixados em zero.

[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.
pt_BR: float rand ( [float min, float max], [float seed] )
    Número aleatório entre [mín, máx] (ou [0, 1] se não especificado).
    Se uma semente (seed) for fornecida, ela será usada adicionalmente às sementes internas e pode ser usado para criar múltiplos geradores distintos.

[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.
pt_BR: float hash(float seed1,[float seed2, ...])
    Como rand, mas sem seeds (sementes) internas. Qualquer número de
    sementes pode ser fornecido e o resultado será uma função aleatória
    baseada em todas as sementes.

[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)
pt_BR: 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)
    Ruído perlin original no local (interpolante C2)

[ctx: builtin|]
en: float snoise ( vector v)
    signed noise w/ range -1 to 1 formed with original perlin noise at location (C2 interpolant)
pt_BR: float snoise (vector v)
    ruído sinalizado com faixa -1 a 1 formado com ruído perlin original no local(Interpolante C2)

[ctx: builtin|]
en: vector vnoise ( vector v)
    vector noise formed with original perlin noise at location (C2 interpolant)
pt_BR: vector vnoise (vector v)
    ruído vetorial formado com ruído perlin original no local (interpolante C2)

[ctx: builtin|]
en: color cnoise ( vector v)
    color noise formed with original perlin noise at location (C2 interpolant)
pt_BR: color cnoise (vector v)
    ruído de cor formado com ruído perlin original no local (interpolante C2)

[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)
pt_BR: float snoise4 (vector v,float t)
    ruído sinalizado 4D com faixa -1 a 1 formado com ruído perlin original nalocalização (C2 interpolante)

[ctx: builtin|]
en: vector vnoise4 ( vector v,float t)
    4D vector noise formed with original perlin noise at location (C2 interpolant)
pt_BR: vector vnoise4 ( vector v,float t)
    ruído de vetor 4D formado com ruído perlin original no local (interpolante C2)

[ctx: builtin|]
en: color cnoise4 ( vector v,float t)
    4D color noise formed with original perlin noise at location (C2 interpolant)
pt_BR: color cnoise4 ( vector v,float t)
    ruído de cor 4D formado com ruído perlin original no local (interpolante C2)

[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.
pt_BR: float fbm(vector v,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) é uma função de ruído multifrequêncial.
    A frequência base é igual à função "noise". O número total de frequências é controlado por <i>octaves</i>. A <i>lacunarity</i> é o espaçamento entre as frequências - um valor de 2 significa que cada oitava é duas vezes a frequência anterior. O <i>gain</i> controla quanto cada frequência é escalada em relação à frequência anterior.

[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.
pt_BR: float fbm4(vector v,float time,int octaves=6,float lacunarity=2,float gain=.5)
    fbm (Fractal Brownian Motion) é uma função de ruído multifrequencial. 
    A frequência base é igual à função "ruído". O número total 
    de frequências é controlado por oitavas. A lacunaridade é o 
    espaçamento entre as frequências - um valor de 2 significa que cada oitava
    é duas vezes a frequência anterior. O ganho controla quanto cada 
    frequência é escalada em relação à frequência anterior.

[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.
pt_BR: float cellnoise(vector v)
    cellnoise gera um campo de cubos coloridos constantes com base no número
    inteiro da localização. Este é o mesmo que a função cellnoise do 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.
pt_BR: color cellnoise(vector v)
    cellnoise gera um campo de cubos coloridos constantes com base no número
    inteiro da localização. Este é o mesmo que a função cellnoise do prman.

[ctx: builtin|]
en: float pnoise ( vector v, vector period )
    periodic noise
pt_BR: float pnoise ( vector v, vector period )
    ruído periódico

[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.
pt_BR: float voronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    voronoi é um padrão de ruído celular. É uma variante instável do 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.
pt_BR: color cvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    retorna a cor no padrão celular. É uma variante instável do ruído da célula.

[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.
pt_BR: color pvoronoi(vector v, int type=1,float jitter=0.5, float fbmScale=0, int fbmOctaves=4,float fbmLacunarity=2, float fbmGain=.5)
    retorna o centro da célula de voronoi.

[ctx: builtin|]
en: float dist(vector a, vector b)
    distance between two points
pt_BR: float dist(vector a, vector b)
    distância entre dois pontos

[ctx: builtin|]
en: float length(vector v)
    length of vector
pt_BR: float length(vector v)
    comprimento do vetor

[ctx: builtin|]
en: float hypot(vector v)
    length of 2d vector [x,y]
pt_BR: float hypot(vector v)
    comprimento do vetor 2d [x,y]

[ctx: builtin|]
en: float dot(vector a,vector b)
    vector dot product
pt_BR: float dot(vector a,vector b)
    produto de ponto vetorial

[ctx: builtin|]
en: vector norm(vector v)
    vector scaled to unit length
pt_BR: vector norm(vector v)
    vetor dimensionado para unidade de comprimento

[ctx: builtin|]
en: vector cross(vector a,vector b)
    vector cross product
pt_BR: vector cross(vector a,vector b)
    produto vetorial de vetor

[ctx: builtin|]
en: float angle(vector a,vector b)
    angle between two vectors (in radians)
pt_BR: float angle(vector a,vector b)
    ângulo entre dois vetores (em radianos)

[ctx: builtin|]
en: vector angle(vector a,vector b)
    normalized vector orthogonal to a and b scaled to unit length
pt_BR: vector angle(vector a,vector b)
    vetor ortogonal normalizado entre a e b dimensionado para comprimento unitário

[ctx: builtin|]
en: vector rotate(vector v,vector axis,float angle)
    rotates v around axis by given angle (in radians)
pt_BR: vector rotate(vector v,vector axis,float angle)
    gira v em torno do eixo por determinado ângulo (em radianos)

[ctx: builtin|]
en: vector up(vector P,vector upvec)
    rotates v such that the Y axis points in the given up direction
pt_BR: vector up(vector P,vector upvec)
    gira v de modo que o eixo Y aponta na direção dada

[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)``.
pt_BR: int cycle(int index, int loRange, int hiRange )
    Percorre os valores entre loRange e hiRange baseado no índice fornecido. 
    Esta é uma função "mod" de deslocamento. O resultado é computado como ``loRange + valor % (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.
pt_BR: int pick(float index, int loRange, int hiRange, [float weights, ...] )
    Escolhe valores aleatoriamente entre loRange e hiRange com base no índice
    fornecido (que é automaticamente marcado). &nbsp; Os valores serão distribuídos
    de acordo com aos pesos fornecidos. &nbsp; Quaisquer pesos não fornecidos
    são assumidos como ser 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]).
pt_BR: color swatch(float index, color choice0, color choice1, color choice2, [...])
    Escolhe uma das opções de cores fornecidas com base no índice (assumido
    como no intervalo [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]).
pt_BR: float choose(float index,float choice1, float choice2, [...])
    Escolhe uma das opções fornecidas com base no índice (presume-se que esteja no intervalo [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.
pt_BR: float wchoose(float index,float choice1, float weight1, float choice2, float weight2, [...] )
    Escolhe uma das opções fornecidas com base no índice (presume-se que esteja no intervalo [0..1]). 
    Os valores serão distribuídos de acordo com os pesos fornecidos.

[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]
pt_BR: float spline(float param,float y1,float y2,float y3,float y4,[...])
    
    Interpola um conjunto de valores para o parâmetro especificado onde y1, ..., yn são 
    distribuídos uniformemente de [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)
pt_BR: float curve(float param,float pos0,float val0,int interp0,float pos1,float val1,int interp1,[...])
    
    Interpola uma rampa 1D definida por pontos de controle em 'param'. Pontos de
     controle são especificados por triplos de parâmetros pos_i, val_i e interp_i. Os
    códigos de interpolação são
    0 - nenhum, 1 - linear, 2 - suave, 3 - spline, 
    4 - monótono (spline não oscilante)

[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)
pt_BR: color curve(float param,float pos0,color val0,int interp0,float pos1,color val1,int interp1,[...])
    
    Interpola a rampa de cores fornecida pelos pontos de controle em 'param'. Pontos de controle são especificados 
    por triplos de parâmetros pos_i, val_i e interp_i. Os códigos de interpolação são 
    0 - nenhum, 1 - linear, 2 - suave, 3 - spline, 
    4 - monótono (spline não oscilante)

[ctx: builtin|]
en: getVar(string varName,vector defaultValue)
    return value of varName if variable exists, otherwise return defaultValue
pt_BR: getVar(string varName,vector defaultValue)
    valor de retorno de varName se a variável existir; caso contrário, retorne valor padrão

[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.
pt_BR: float printf(string format,[vec0, vec1,  ...])
    Imprime um texto na STDOUT, os parâmetros de formato permitidos são "%v" e "%f".
    O retorno do parâmetro é vazio, mas deve ser atribuído a uma variável.

[ctx: builtin|]
en: sprintf(string format, [double|string, double|string, ...])
    Returns a string formatted from the given values.  See 'man sprintf' for format details.
pt_BR: sprintf(string format, [double|string, double|string, ...])
    Retorna um texto formatado a partir dos valores fornecidos. Veja 'man sprintf' para detalhes do formato.

[ctx: ExprControlCollection|]
en: Add new variable
pt_BR: Adicionar nova variável

[ctx: ErrorMessages|]
en: Expected string or float[d]
pt_BR: Texto ou ponto flutuante esperado [d]

[ctx: ErrorMessages|]
en: Expected float[d]
pt_BR: Ponto flutuante esperado [d]

[ctx: ErrorMessages|]
en: Expected float[%1]
pt_BR: Ponto flutuante esperado [%1]

[ctx: ErrorMessages|]
en: Type mismatch, first: '%1'; second: '%2'
pt_BR: Digite incompatibilidade, primeiro: '%1'; segundo: '%2'

[ctx: ErrorMessages|]
en: Expected float or float[3]
pt_BR: Ponto flutuante ou flutuação esperada [3]

[ctx: ErrorMessages|]
en: Expected '%1' for argument, got '%2'
pt_BR: Esperado '%1' para o argumento, obtido '%2'

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 to 7
pt_BR: Número errado de argumentos, deve ser de 1 a 7

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be multiple of 3 plus 1
pt_BR: Número errado de argumentos, deve ser múltiplo de 3 mais 1

[ctx: ErrorMessages|]
en: Wrong number of arguments, should be 1 or more
pt_BR: Número errado de argumentos, deve ser 1 ou mais

[ctx: ErrorMessages|]
en: First argument must be a string
pt_BR: O primeiro argumento deve ser um texto

[ctx: ErrorMessages|]
en: Incomplete format specifier
pt_BR: Especificador de formato incompleto

[ctx: ErrorMessages|]
en: No variable named '%1'
pt_BR: Nenhuma variável chamada '%1'

[ctx: ErrorMessages|]
en: Function '%1' has no definition
pt_BR: A função '%1' não tem definição

[ctx: ErrorMessages|]
en: Assignment operation has incorrect type '%1'
pt_BR: A operação de atribuição tem o tipo incorreto '%1'

[ctx: ErrorMessages|]
en: Types of conditional are not compatible
pt_BR: Tipos de condicionais não são compatíveis

[ctx: ErrorMessages|]
en: Variable '%1' defined in conditionals inconsistently
pt_BR: Variável '%1' definida nas condicionais de forma inconsistente

[ctx: ErrorMessages|]
en: Too few arguments for function '%1'
pt_BR: Poucos argumentos para a função '%1'

[ctx: ErrorMessages|]
en: Too many arguments for function '%1'
pt_BR: Muitos argumentos para a função '%1'

[ctx: ErrorMessages|]
en: Expression generated type '%1', incompatible with desired type '%2'
pt_BR: Expressão gerada tipo '%1', incompatível com o tipo desejado '%2'

[ctx: ErrorMessages|]
en: Syntax error near '%1'
pt_BR: Erro de sintaxe próximo a '%1'

[ctx: ErrorMessages|]
en: Unexpected end of expression near '%1'
pt_BR: Fim de expressão inesperada próximo a '%1'

[ctx: ErrorMessages|]
en: Unexpected end of format string
pt_BR: Fim inesperado do texto de formato

[ctx: ErrorMessages|]
en: Invalid format string, only %v or %f is allowed
pt_BR: Texto de formato inválido, apenas %v ou %f são permitidos.

[ctx: ErrorMessages|]
en: Wrong number of arguments for format string
pt_BR: Número errado de argumentos do texto de formato

[ctx: ErrorMessages|]
en: Unknown error (message = %1)
pt_BR: Erro desconhecido (mensagem = %1)

[ctx: ExprAddDialog|]
en: Variable
pt_BR: Variável

[ctx: ExprAddDialog|]
en: Lookup
pt_BR: Procurar

[ctx: ExprAddDialog|]
en: Curve
pt_BR: Curva

[ctx: ExprAddDialog|]
en: Color Curve
pt_BR: Curva de cor

[ctx: ExprAddDialog|]
en: Default
pt_BR: Padrão

[ctx: ExprAddDialog|]
en: Min
pt_BR: Mín

[ctx: ExprAddDialog|]
en: Max
pt_BR: Máx

[ctx: ExprAddDialog|]
en: Float
pt_BR: Ponto flutuante

[ctx: ExprAddDialog|]
en: Vector
pt_BR: Vetor

[ctx: ExprAddDialog|]
en: Color
pt_BR: Cor

[ctx: ExprAddDialog|]
en: Rainbow
pt_BR: Arco-íris

[ctx: ExprAddDialog|]
en: Shades of Gray
pt_BR: Tons de cinza

[ctx: ExprAddDialog|]
en: Colors
pt_BR: Cores

[ctx: ExprAddDialog|]
en: Swatch
pt_BR: Amostra

[ctx: ExprAddDialog|]
en: string
pt_BR: texto

[ctx: ExprAddDialog|]
en: file
pt_BR: arquivo

[ctx: ExprAddDialog|]
en: directory
pt_BR: pasta

[ctx: ExprAddDialog|]
en: String Name
pt_BR: Nome do texto

[ctx: ExprAddDialog|]
en: String Type
pt_BR: Tipo de texto

[ctx: ExprAddDialog|]
en: String Default
pt_BR: Texto padrão

[ctx: ExprAddDialog|]
en: String
pt_BR: Texto

[ctx: ExprBrowser|]
en: Save Expression
pt_BR: Salvar expressão

[ctx: ExprBrowser|]
en: Could not open file %1 for writing
pt_BR: Não foi possível abrir o arquivo %1 para gravação

[ctx: ExprBrowser|]
en: Error
pt_BR: Erro

[ctx: ExprBrowser|]
en: Could not open file %1 for writing.  Is it read-only?
pt_BR: Não foi possível abrir o arquivo %1 para gravação. É somente leitura?

[ctx: CCurveScene|]
en: Delete Point
pt_BR: Excluir ponto

[ctx: ExprColorCurve|]
en: Selected Position:
pt_BR: Posição selecionada:

[ctx: ExprColorCurve|]
en: Selected Color:
pt_BR: Cor selecionada:

[ctx: ExprColorCurve|]
en: None
pt_BR: Nenhuma

[ctx: ExprColorCurve|]
en: Smooth
pt_BR: Suave

[ctx: ExprColorCurve|]
en: &Expand...
pt_BR: &Expandir...

[ctx: ExprColorFrame|]
en: Delete Swatch
pt_BR: Excluir amostra

[ctx: ExprColorFrame|]
en: Cancel
pt_BR: Cancelar

[ctx: ExprColorSwatchWidget|]
en: &Add...
pt_BR: &Adicionar...

[ctx: StringControl|]
en: Please choose a file
pt_BR: Escolha um arquivo

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

[ctx: CurveScene|]
en: Delete Point
pt_BR: Excluir ponto

[ctx: ExprCurve|]
en: Selected Position:
pt_BR: Posição selecionada:

[ctx: ExprCurve|]
en: Selected Value:
pt_BR: Valor selecionado:

[ctx: ExprCurve|]
en: None
pt_BR: Nenhum

[ctx: ExprCurve|]
en: Smooth
pt_BR: Suave

[ctx: ExprCurve|]
en: &Expand...
pt_BR: &Expandir...

[ctx: ExprEditor|]
en: Expression Editor
pt_BR: Editor de expressão

[ctx: ExprFileDialog|]
en: Open
pt_BR: Abrir

[ctx: ExprFileDialog|]
en: Favorites
pt_BR: Favoritos

[ctx: ExprTextEdit|]
en: Pop-up Help
pt_BR: Ajuda flutuante
