mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
341 lines
12 KiB
ReStructuredText
341 lines
12 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_VisualShaderNodeFloatFunc:
|
|
|
|
VisualShaderNodeFloatFunc
|
|
=========================
|
|
|
|
**Hereda:** :ref:`VisualShaderNode<class_VisualShaderNode>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
|
|
|
Una función escalar de punto flotante que se utilizará dentro del gráfico de shader visual.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Acepta un escalar de punto flotante (``x``) en el puerto de entrada y lo transforma de acuerdo con :ref:`function<class_VisualShaderNodeFloatFunc_property_function>`.
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Propiedades
|
|
----------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+----------------------------------------------------------+--------------------------------------------------------------------+--------+
|
|
| :ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` | :ref:`function<class_VisualShaderNodeFloatFunc_property_function>` | ``13`` |
|
|
+----------------------------------------------------------+--------------------------------------------------------------------+--------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Enumeraciones
|
|
--------------------------
|
|
|
|
.. _enum_VisualShaderNodeFloatFunc_Function:
|
|
|
|
.. rst-class:: classref-enumeration
|
|
|
|
enum **Function**: :ref:`🔗<enum_VisualShaderNodeFloatFunc_Function>`
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_SIN:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_SIN** = ``0``
|
|
|
|
Devuelve el seno del parámetro. Se traduce a ``sin(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_COS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_COS** = ``1``
|
|
|
|
Devuelve el coseno del parámetro. Se traduce a ``cos(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_TAN:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_TAN** = ``2``
|
|
|
|
Devuelve la tangente del parámetro. Se traduce a ``tan(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ASIN:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ASIN** = ``3``
|
|
|
|
Devuelve el arcoseno del parámetro. Se traduce a ``asin(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ACOS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ACOS** = ``4``
|
|
|
|
Devuelve el arcocoseno del parámetro. Se traduce a ``acos(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ATAN:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ATAN** = ``5``
|
|
|
|
Devuelve la arcotangente del parámetro. Se traduce a ``atan(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_SINH:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_SINH** = ``6``
|
|
|
|
Devuelve el seno hiperbólico del parámetro. Se traduce a ``sinh(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_COSH:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_COSH** = ``7``
|
|
|
|
Devuelve el coseno hiperbólico del parámetro. Se traduce a ``cosh(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_TANH:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_TANH** = ``8``
|
|
|
|
Devuelve la tangente hiperbólica del parámetro. Se traduce a ``tanh(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_LOG:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_LOG** = ``9``
|
|
|
|
Devuelve el logaritmo natural del parámetro. Se traduce a ``log(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_EXP:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_EXP** = ``10``
|
|
|
|
Devuelve la exponenciación natural del parámetro. Se traduce a ``exp(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_SQRT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_SQRT** = ``11``
|
|
|
|
Devuelve la raíz cuadrada del parámetro. Se traduce a ``sqrt(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ABS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ABS** = ``12``
|
|
|
|
Devuelve el valor absoluto del parámetro. Se traduce a ``abs(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_SIGN:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_SIGN** = ``13``
|
|
|
|
Extrae el signo del parámetro. Se traduce a ``sign(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_FLOOR:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_FLOOR** = ``14``
|
|
|
|
Encuentra el entero más cercano menor o igual que el parámetro. Se traduce a ``floor(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ROUND:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ROUND** = ``15``
|
|
|
|
Encuentra el entero más cercano al parámetro. Se traduce a ``round(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_CEIL:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_CEIL** = ``16``
|
|
|
|
Encuentra el entero más cercano que es mayor o igual que el parámetro. Se traduce a ``ceil(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_FRACT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_FRACT** = ``17``
|
|
|
|
Calcula la parte fraccionaria del argumento. Se traduce a ``fract(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_SATURATE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_SATURATE** = ``18``
|
|
|
|
Restringe el valor entre ``0.0`` y ``1.0`` usando ``min(max(x, 0.0), 1.0)``.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_NEGATE:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_NEGATE** = ``19``
|
|
|
|
Niega el ``x`` usando ``-(x)``.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ACOSH:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ACOSH** = ``20``
|
|
|
|
Devuelve el arcocoseno hiperbólico del parámetro. Se traduce a ``acosh(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ASINH:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ASINH** = ``21``
|
|
|
|
Devuelve el arcoseno hiperbólico del parámetro. Se traduce a ``asinh(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ATANH:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ATANH** = ``22``
|
|
|
|
Devuelve la arco tangente hiperbólica del parámetro. Se traduce a ``atanh(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_DEGREES:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_DEGREES** = ``23``
|
|
|
|
Convierte una cantidad en radianes a grados. Se traduce a ``degrees(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_EXP2:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_EXP2** = ``24``
|
|
|
|
Devuelve 2 elevado a la potencia del parámetro. Se traduce a ``exp2(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_INVERSE_SQRT:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_INVERSE_SQRT** = ``25``
|
|
|
|
Devuelve la inversa de la raíz cuadrada del parámetro. Se traduce a ``inversesqrt(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_LOG2:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_LOG2** = ``26``
|
|
|
|
Devuelve el logaritmo en base 2 del parámetro. Se traduce a ``log2(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_RADIANS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_RADIANS** = ``27``
|
|
|
|
Convierte una cantidad en grados a radianes. Se traduce a ``radians(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_RECIPROCAL:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_RECIPROCAL** = ``28``
|
|
|
|
Encuentra el valor recíproco de dividir 1 por ``x`` (es decir, ``1 / x``).
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ROUNDEVEN:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ROUNDEVEN** = ``29``
|
|
|
|
Encuentra el entero par más cercano al parámetro. Se traduce a ``roundEven(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_TRUNC:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_TRUNC** = ``30``
|
|
|
|
Devuelve un valor igual al entero más cercano a ``x`` cuyo valor absoluto no es mayor que el valor absoluto de ``x``. Se traduce a ``trunc(x)`` en el lenguaje de shaders de Godot.
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_ONEMINUS:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_ONEMINUS** = ``31``
|
|
|
|
Resta el escalar ``x`` de 1 (es decir, ``1 - x``).
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_constant_FUNC_MAX:
|
|
|
|
.. rst-class:: classref-enumeration-constant
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **FUNC_MAX** = ``32``
|
|
|
|
Representa el tamaño del enum :ref:`Function<enum_VisualShaderNodeFloatFunc_Function>`.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Propiedades
|
|
--------------------------------------------------------
|
|
|
|
.. _class_VisualShaderNodeFloatFunc_property_function:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **function** = ``13`` :ref:`🔗<class_VisualShaderNodeFloatFunc_property_function>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_function**\ (\ value\: :ref:`Function<enum_VisualShaderNodeFloatFunc_Function>`\ )
|
|
- :ref:`Function<enum_VisualShaderNodeFloatFunc_Function>` **get_function**\ (\ )
|
|
|
|
Una función que se aplicará al escalar.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
|
|
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
|
|
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
|