Logo
latest

General

  • Acerca de
    • Introducción
      • Antes de empezar
      • Acerca de Godot Engine
      • Acerca de la documentación
      • Organización de la documentación
    • Preguntas Frecuentes
      • ¿Qué puedo hacer con Godot? ¿Cuánto cuesta? ¿Dónde están los términos de licencia?
      • ¿Que plataformas soporta Godot?
      • ¿Qué lenguajes de programación están soportados en Godot?
      • ¿Qué es GDScript y por qué debería usarlo?
      • ¿Cuáles fueron las motivaciones para crear GDScript?
      • ¿Qué tipo de formatos para modelos 3D soporta Godot?
      • ¿Será [Inserte aquí un SDK cerrado como PhysX, GameWorks, etc.] soportado por Godot?
      • ¿Cómo deberían crearse los recursos para manejar múltiples resoluciones y relaciones de aspecto?
      • ¿Cómo puedo extender Godot?
      • ¡Me gustaría contribuir! ¿Cómo puedo empezar?
      • Tengo una idea genial para Godot. ¿Cómo puedo compartirla?
      • Por qué Godot no usa STL(Standard Template Library)
      • Por qué Godot no usa excepciones?
      • ¿Por qué Godot no enforza RTTI?
      • ¿Pro qué Godot no fuerza a los usuarios a implementar DoD (Diseño orientado a Datos)?
      • ¿Cómo puedo apoyar el desarrollo de Godot o contribuir?
      • ¿Quien esta trabajando en Godot? ¿Como puedo ponerme en contacto?
    • Registro de cambios en la Documentación
      • Nuevos tutoriales desde la versión 3.1
        • Flujo de trabajo del proyecto
        • 2D
        • Audio
        • Matemáticas
        • Entradas
        • Iternacionalización
        • Shading
        • Redes
        • VR
        • Plugins
        • Multi-threading
        • Creación de contenido
        • Optimización
        • Legal
      • Nuevos tutoriales desde la versión 3.0
        • Paso a paso
        • Scripting
        • Flujo de trabajo del proyecto
        • 2D
        • 3D
        • Física
        • Animación
        • GUI
        • Viewports
        • Shading
        • Plugins
        • Específico de plataformas
        • Multi-threading
        • Creación de contenido
        • Misceláneas
        • Compilando
        • Desarrollo del motor

Comenzando

  • Paso a paso
    • Introducción al editor de Godot
      • Administrador de proyectos
        • Crear o importar un proyecto
      • Una primera mirada al editor de Godot
      • Los espacios de trabajo
      • Modificando la interfaz
        • Mover y cambiar el tamaño de los paneles
    • Escenas y nodos
      • Introducción
      • Nodos
      • Escenas
      • Editor
      • Configurando el proyecto
      • Continuará…
    • Instanciar
      • Introducción
      • Instanciar con ejemplos
      • Instancias múltiples
      • Editar instancias
      • Conclusión
    • Instanciar (continuación)
      • Resumen
      • Lenguaje de diseño
      • ¡Sobrecarga de información!
    • Scripting
      • Introducción
        • GDScript
        • VisualScript
        • .NET / C#
        • GDNative / C++
      • Scripting de una escena
        • Configuración de la escena
        • Añadir un script
        • El papel del script
        • Manejando una señal
    • Scripting (continuación)
      • Procesamiento
      • Grupos
      • Notificaciones
      • Funciones de anulación
      • Creación de nodos
      • Instanciación de escenas
      • Registrar scripts como clases
    • Señales
      • Introducción
      • Ejemplo de Timer
        • Conectar señales por código
      • Señales personalizadas
      • Conclusión
    • Tu primer juego
      • Sinopsis
      • Configuración del proyecto
        • Organizando el proyecto
      • Escena del jugador
        • Estructura de nodos
        • Animación del sprite
        • Movimiento del jugador
        • Seleccionar animaciones
        • Preparacion para las colisiones
      • Escena del enemigo
        • Configuración del Nodo
        • Script del enemigo
      • Escena principal
        • Agregando enemigos
        • Script Principal
      • HUD
        • ScoreLabel
        • MessageLabel
        • StartButton
        • Conectando HUD a Main
        • Removiendo los viejos «creeps»
      • Finalizando
        • Imagen de fondo
        • Efectos de sonido
        • Atajo del teclado
      • Archivos del Proyecto
    • Exportar
      • Sinopsis
      • Preparación del proyecto
      • Configurando la escena principal
      • Plantillas de exportación
      • Exportar Preajustes
      • Exportando por plataforma
        • PC(Linux/macOS/Windows)
        • Android
        • iOS
        • HTML5 (web)
    • Filosofía del diseño de Godot
      • Diseño orientado a objetos y composición
      • Paquete con todo incluído
      • Código abierto
      • Dirigido por la comunidad
      • El editor de Godot es un juego de Godot
      • Motores 2D y 3D separados
    • Diseño de interfaces con nodos Control
      • Los 5 elementos más comunes de la UI
        • TextureRect
        • TextureButton
        • TextureProgress
        • Label
        • NinePatchRect
      • Existen dos flujos de trabajo para crear UIs responsivas
      • Posicionamiento preciso de elementos UI con anclajes
        • Cómo cambiar el anclaje
        • Los anclajes son relativos al container principal
        • Los márgenes cambian con el anclaje
        • Usar etiquetas size para cambiar la forma en que los elementos de la UI llenan el espacio disponible
      • Disposición automática de los nodos de control con contenedores
        • Los 5 contenedores más útiles
    • Diseñar una pantalla de título
      • Cómo diseñar tu UI del juego
      • Diseñar el menú principal
        • Desglosar el prototipo de UI
        • Prepara la escena del Menú Principal
        • Añade los sprites de la UI
        • Añade contenedores para colocar elementos de UI automáticamente
        • Desglosar el prototipo de UI
    • Diseñando la GUI
      • Desglose de la UI
      • Crea el GUI base
        • Crear la base de las barras
        • Reemplaza las fuentes de los Label
        • Añade la barra de progreso
      • Diseña los contadores de bombas y esmeraldas
      • Convierte la barra y el contador en componentes de UI reutilizables
      • Utiliza la herencia de escena para crear los elementos restantes
        • Hereda la escena Bar para construir el LifeBar
        • Diseño de la barra de energía
        • Prepara los contadores de bombas y esmeraldas
      • Añade los componentes de la UI a la GUI final
      • Coloca el GUI en la maqueta del juego
    • Controla la UI del juego con código
      • Introducción
      • Descarga y explora el proyecto de inicio
      • Configura el Lifebar del Player con max_health
      • Actualizar la salud con una señal cuando el jugador recibe un golpe
      • Animar la pérdida de vida con el nodo Tween
      • Asignar animated_health a LifeBar
      • Desvanecer la barra cuando el jugador muere
    • Pantalla de introducción
      • Tutorial
      • Configurando
    • Animaciones
      • Introducción
      • Agregar un reproductor de animaciones
      • Crear una animación
      • Editando la animación
    • Recursos
      • Nodos y recursos
      • Externo vs built-in
      • Cargando recursos desde código
      • Cargando escenas
      • Liberando recursos
      • Creando tus propios Resources
    • Sistema de archivos
      • Introducción
      • Implementación
      • project.godot
      • Delimitador de ruta
      • Ruta del recurso
      • Ruta de usuario
      • Sistema de archivos del host
      • Inconvenientes
    • Árbol de Escenas
      • Introducción
      • MainLoop
      • Árbol de Escenas
      • Viewport raíz
      • Árbol de escenas
      • Orden del árbol
      • «Activación» entrando en el Árbol de escenas
      • Cambiando la escena actual
    • Singletons (AutoLoad)
      • Introducción
      • AutoLoad
      • Conmutador de escenas personalizado
        • Global.gd
  • Manual del editor
    • De Unity a Godot Engine
      • Diferencias
      • El editor
      • El sistema de escenas
      • Organización del proyecto
      • ¿Dónde están mis prefabs?
      • Correspondencia del glosario
      • Scripting: GDScript, C# y Visual Script
        • Diseño
        • Conexiones: grupos y señales
        • Serialización de scripts
      • Usando Godot en C++
    • Tutorial de línea de comandos
      • Command line reference
      • Ruta
      • Configuración de la ruta del proyecto
      • Creación de un proyecto
      • Ejecutar el editor
      • Borrar una escena
      • Ejecutar el juego
      • Depuración
      • Exportar
      • Ejecutar un script
    • Uso de un editor de texto externo
  • Scripting
    • GDScript
      • Bases de GDScript
        • Introducción
        • Lenguaje
        • Tipos integrados
        • Datos
      • GDScript: Introducción a los lenguajes dinámicos
        • Acerca de
        • Naturaleza dinámica
        • Arreglos
        • Diccionarios
        • For y While
        • While
        • Itineradores personalizados
        • Tipado dinámico (duck typing)
      • GDScript exports
        • Introduction to exports
        • Ejemplos
        • Exportando «bit flags»
        • Exportando arrays
      • Guía de estilo de GDScript
        • Formatting
        • Convenciones para la definición de nombres
        • Code order
        • Static typing
      • Tipado estático en GDScript
        • Un breve vistazo a los tipos estáticos
        • Cómo utilizar tipos estáticos
        • Tipado estático o dinámico: apégate a un estilo
        • Sistema de advertencias
        • Casos en los que no puedes especificar tipos
        • Sumario
      • Cadenas de formato en GDScript
        • Utilización en GDScript
        • Parámetros múltiples
        • Especificadores de formato
        • Relleno
        • Secuencias de escape
        • Ejemplos de métodos de formateo
    • VisualScript
      • Qué es Visual Scripting
      • Comenzando con Visual Scripting
        • Creando un Script
        • Añadiendo una función
      • Nodos y terminología
        • Propiedades de los nodos
        • Puertos y conexiones
        • Agregando nodos
        • Agregando más nodos
    • C#
      • Introducción
        • Configuración C# para Godot
        • Configuración de un editor externo
        • Creando un script de C#
        • Ajustes del proyecto y flujo de trabajo
        • Ejemplo
        • Diferencias generales entre C# y GDScript
        • Problemas actuales y problemas conocidos
        • Rendimiento de C# en Godot
        • Uso de los paquetes NuGet en Godot
        • Profiling your C# code
        • Configuring VS 2019 for debugging
      • Características
        • Conversión de tipo y casting
        • Señales en C#
        • Preprocessor defines
      • Diferencias con la API de GDScript
        • Diferencias generales
        • Ámbito Global
        • Palabra clave export
        • Palabra clave signal
        • Instancias únicas
        • Cadena
        • Basis
        • Transform2D
        • Plano
        • Rect2
        • Quat
        • Arreglo
        • Diccionario
        • Variant
        • Comunicándose con otros lenguajes de scripting
        • Yield
        • Otras diferencias
      • Guía de estilo de C#
        • Especificación del lenguaje
        • Formatting
        • Convenciones para la definición de nombres
        • Variables locales tipadas implícitamente
        • Otras consideraciones
    • Cross-language scripting
      • Instantiating nodes
        • Instantiating C# nodes from GDScript
        • Instantiating GDScript nodes from C#
      • Accessing fields
        • Accessing C# fields from GDScript
        • Accessing GDScript fields from C#
      • Calling methods
        • Calling C# methods from GDScript
        • Calling GDScript methods from C#
  • Flujo de trabajo del proyecto
    • Configuración del proyecto
      • Organización del proyecto
        • Introducción
        • Organización
        • Importando
    • Flujo de trabajo de los Assets
      • Proceso de importación
        • Importando recursos en Godot 3.0+
        • Cambiando parámetros de importación
        • Reimportación automática
        • Archivos generados
        • Cambiar el tipo de recurso importado
        • Cambiar los parámetros de importación por defecto
        • ¡La sencillez es la clave!
      • Importando imágenes
        • ¿Por qué importarlas?
        • Importando texturas
        • Supported image formats
        • Compresión
        • Indicadores
        • Procesos
      • Importar muestras de audio
        • ¿Por qué importar?
        • Buenas prácticas
      • Importar traducciones
        • Juegos e internacionalización
        • Formato de traducción
        • Importador CSV
      • Importando escenas 3D
        • Importador de escenas de Godot
        • Flujos de trabajo de importación
        • Opciones de Importación
        • Opciones de animación
        • Herencia de escenas
        • Consejos para la Importación
      • Exportador ESCN de Blender
        • Detalles sobre exportar
        • Deshabilitar objetos específicos
        • Integración a la línea de compilación (build pipeline)
    • Exportar
      • Exportando proyectos
        • ¿Porqué exportar?
        • Menú de exportación
        • Exportando desde la línea de comandos
      • Exportando paquetes, parches y mods
        • Casos de uso
        • Visión general de los archivos PCK
        • Generando archivos PCK
        • Abrir archivos PCK en tiempo de ejecución
        • Sumario
      • Etiquetas de características
        • Introducción
        • Características por defecto
        • Funcionalidades personalizadas
        • Sobrescribir los ajustes del proyecto
        • Sobreescritura de valores por defecto
        • Personalización de la Compilación
      • Exportación para PC
      • Exportando para iOS
        • Requerimientos
        • Exportar un proyecto de Godot a Xcode
        • Consideraciones activas del desarrollo
        • Servicios para iOS
      • Exportación para Windows Universal Platform
        • Limitaciones en Xbox One
        • Creación de un certificado de firma
        • Firma del paquete
        • Instalando el paquete
      • Exportación para Android
        • Descargar el SDK de Android
        • Instalar OpenJDK u Oracle JDK
        • Crear un debug.keystore
        • Asegúrate de que tienes adb
        • Instalándolo en Godot
        • Providing launcher icons
        • Exportar para la Google Play Store
        • Optimizing the APK size
      • Exportar para la Web
        • WebGL 2
        • Limitaciones
        • Entrega de archivos
        • Opciones de exportación
        • Llamada a JavaScript desde script
      • Despliegue con un solo clic
        • Suena bien, ¿qué es?
        • Pasos para el despliegue con un solo clic
      • Compilación personalizada para Android
        • Set up the custom build environment
        • Install the Android SDK (command-line version)
        • Instalar Android SDK (Android Studio)
        • Enabling the custom build and exporting
      • Cambiar el icono de la aplicación en Windows
        • Cambiar el icono de la barra de tareas
        • Cambiar el ícono del archivo
        • Probando el resultado
        • Requerimientos de archivos de íconos (ICO)
    • Buenas prácticas
      • Introducción
      • Las escenas y scripts de Godot son clases
        • Dando sentido a las clases en Godot
        • Rendimiento del scripting y PackedScene
        • Escenas y scripts son objetos
      • Organización de la escena
        • Cómo crear relaciones de manera eficiente
        • Eligiendo una estructura de árbol de nodos
      • Cuándo usar escenas y cuándo scripts
        • Tipos anónimos
        • Tipos con nombre
        • Conclusión
      • Autoloads frente a nodos corrientes
      • El problema del audio con cortes
      • Gestionando funcionalidad o datos compartidos
      • Cuándo deberías usar un Autoload
      • Cuándo y cómo evitar el uso de nodos para todo
      • Interfaces en Godot
        • Obteniendo referencias a objetos
        • Acceso a datos o lógica desde un objeto
      • Notificaciones en Godot
        • _process vs. _physics_process vs. *_input
        • _init versus inicialización versus export
        • _ready vs. _enter_tree vs. NOTIFICATION_PARENTED
      • Selección de tipos de datos
        • Array vs. Diccionario vs. Objeto
        • Enumeraciones: int vs. string
        • AnimatedTexture vs. AnimatedSprite vs. AnimationPlayer vs. AnimationTree
      • Recomendaciones de lógica
        • Cargar (load) vs. pre-cargar (preload)
        • Large levels: static vs. dynamic

Tutoriales

  • 2D
    • Canvas layers
      • Viewport y Canvas items
      • CanvasLayers
    • Transformación de Viewport y Canvas
      • Introducción
      • Transformación del canvas
      • Transformación global del canvas
      • Stretch transform
      • Orden de Transform
      • Funciones de Transform
      • Generando eventos de entrada personalizados
    • Usando tilemaps
      • Introducción
      • Configuración del proyecto
      • TileMap node
      • Creando un Tileset
      • Formas de Colisión
      • Atlas tiles
      • Tips and tricks
    • Sistemas de partículas (2D)
      • Introducción
        • Particle nodes
        • ParticlesMaterial
        • Textura
      • Parámetros de Tiempo (Time)
        • Lifetime (Tiempo de vida)
        • One Shot (Una Vez)
        • Preprocess (Preproceso)
        • Speed Scale (Escala de Velocidad)
        • Explosiveness (Explosividad)
        • Randomness (Aleatoriedad)
        • Fixed FPS (FPS Fijo)
        • Fract Delta
      • Parámetros de Dibujo (Drawing)
        • Visibility Rect (Rectángulo de Visibilidad)
        • Coordenadas Locales
        • Draw Order (Orden de Dibujo)
      • Ajustes de ParticlesMaterial
        • Spread (Propagación)
        • Gravity (Gravedad)
        • Initial Velocity (Velocidad Inicial)
        • Angular Velocity (Velocidad Angular)
        • Spin Velocity (Velocidad de Giro)
        • Orbit Velocity (Velocidad de la Órbita)
        • Linear Acceleration (Aceleración Lineal)
        • Radial Acceleration (Aceleración Radial)
        • Tangential Acceleration (Aceleración Tangencial)
        • Damping (Amortiguación)
        • Angle (Ángulo)
        • Escala
        • Color
        • Hue variation (Variación de tono)
      • Formas de Emisión
        • Máscara de Emisión
        • Colores de Emisión
    • Movimiento en 2D
      • Introducción
      • Organización
      • Movimiento en 8 sentidos
      • Rotación + movimiento
      • Rotación + movimiento (ratón)
      • Clic y mover
      • Sumario
    • Luces 2D y sombras
      • Introducción
      • Organización
      • Nodos
      • Luces
      • Sombras
      • Paso a paso
    • Mallas 2D
      • Introducción
      • Optimizing pixels drawn
      • Convirtiendo Sprites a mallas 2D
    • Dibujos personalizados en 2D
      • ¿Por qué?
      • Pero…
      • Bien, ¿cómo?
      • Actualizando
      • Un ejemplo: dibujando arcos de curva
        • Función arco
        • Dibujar el arco en pantalla
        • Función de polígono arco
        • Dibujos personalizados dinámicos
      • Herramientas
    • Animación de Sprite 2D
      • Introducción
      • Individual images with AnimatedSprite
        • Controlando la animación
      • Sprite sheet with AnimatedSprite
      • Sprite sheet con AnimationPlayer
        • Controlling an AnimationPlayer animation
      • Sumario
  • 3D
    • Introducción al 3D
      • Nodo Spatial
      • Contenido 3D
        • Modelos creados por DCC
        • Geometría generada
        • Geometría inmediata
        • 2D en 3D
      • Entorno
      • Vista 3D
        • Sistema de coordenadas
        • Gizmos de espacio y manipulación
        • Menú Ver
        • Entorno por defecto
        • Cámaras
        • Luces
    • Usando transformaciones 3D
      • Introducción
      • Problemas de los ángulos de Euler
        • Orden de los ejes
        • Interpolación
        • Di no a los ángulos de Euler
      • Introducción a Transforms
        • Manipulando Transforms
        • Errores de precisión
        • Obteniendo información
        • Asignando valores
        • Interpolando con quaternions
      • Los Transforms son tus amigos
    • Rendimiento y limitaciones del 3D
      • Introducción
      • Renderización
        • Reutilizar shaders y materiales
        • Coste de los píxeles vs coste de los vértices
        • Compresión de texturas
        • Objetos transparentes
        • Nivel de detalle (LOD)
        • Usar la instanciación (MultiMesh)
        • Bake de iluminación
    • Material Spatial
      • Introducción
      • Indicadores
        • Transparente
        • Use Shadow to Opacity
        • Unshaded (Sin sombra)
        • Vertex Lighting (Iluminación de vértices)
        • Sin prueba de profundidad
        • Usar Point Size (Tamaño de punto)
        • World Triplanar (Mundo Triplanar)
        • Fixed Size (Tamaño fijo)
        • Do Not Receive Shadows (No recibir sombras)
        • Disable Ambient Light
        • Ensure Correct Normals
      • Vertex Color (Color de vértice)
        • Use as Albedo (Usar como Albedo)
        • Is sRGB
      • Parámetros
        • Diffuse Mode (Modo difuso)
        • Specular Mode (Modo Specular)
        • Blend Mode
        • Cull Mode
        • Depth Draw Mode
        • Line Width (Ancho de línea)
        • Point Size (Tamaño de puntos)
        • Billboard Mode
        • Billboard Keep Scale
        • Grow
        • Usar Alpha Scissor
      • Color de materiales, mapas y canales
        • Albedo
        • Metallic
        • Roughness
        • Emission
        • Normalmap
        • Rim
        • Clearcoat
        • Anisotropy
        • Ambient Occlusion
        • Profundidad
        • Subsurface Scattering
        • Transmission
        • Refraction
        • Detail
        • UV1 y UV2
        • Mapeado Triplanar
      • Desvanecimiento de proximidad y distancia
      • Prioridad de Renderización
    • Luces y sombras
      • Introducción
      • Nodos de luz
        • Shadow Mapping (Mapeo de sombras)
        • Mapeo de sombras direccional
        • Mapeo de sombras omnidireccional
        • Mapeo de sombras focal
    • Reflection probes
      • Introducción
      • Configurando
      • Interior vs exterior
      • Blending
      • Reflection atlas
    • GI Probes
      • Introducción
      • Configurando
      • Agregando luces
      • Reflections
      • Interior vs exterior
      • Tweaking
      • Quality
    • Baked lightmaps
      • Introducción
      • Comparaciones visuales
      • Configurando
        • Desplegar desde de su 3D DCC
        • Desplegar desde Godot
        • Unwrap al importar escena
        • Checking UV2
      • Configurando la escena
        • Configure bounds
        • Configurando mallas
        • Configurando luces
        • Calidad de baking
      • Baking
        • Configurando el bake
      • Objetos dinámicos
    • Entorno y post proceso
      • Entorno
        • Nodo Camera
        • Nodo WorldEnvironment
        • Entorno por defecto
      • Opciones de Environment
        • Imagen de fondo
        • Ambient Light
        • Fog
        • Tonemap
        • Auto Exposure (HDR)
      • Efectos de medio y post proceso
        • Screen-Space Reflections (SSR)
        • Screen-Space Ambient Occlusion (SSAO)
        • Depth of Field / Far Blur
        • Depth of Field / Near Blur
        • Glow
        • Adjustments
    • Light transport in game engines
      • Introducción
      • Computer displays
      • Scene linear & asset pipelines
        • sRGB transfer function to display linear ratios on image import
        • Hardware sRGB transfer function to display linear conversion
        • Scene linear to display referred nonlinear
      • Parameters of HDR
    • Using gridmaps
      • Introducción
      • Proyecto ejemplo
      • Creating a MeshLibrary
      • Collisions
      • Materiales
      • Exportación de MeshLibrary
      • Using GridMap
      • Usando Gridmap en código
    • Using MultiMeshInstance
      • Introducción
      • Setting up the nodes
      • Configuración de MultiMesh
        • Target Surface
        • Source Mesh
        • Mesh Up Axis
        • Random Rotation
        • Random Tilt
        • Random Scale
        • Escala
        • Amount
    • CSG
      • Introducción a nodos CSG
        • Funcionalidades de herramientas CSG
        • CSGPolygon
        • Mallas personalizadas
        • CSGCombiner
        • Orden de procesamiento
      • Prototyping a level
    • Tutorial FPS
      • Parte 1
        • Introducción al tutorial
        • Resumen
        • Preparando todo
        • Making the FPS movement logic
        • Giving the player a flash light and the option to sprint
        • Notas finales
      • Part 2
        • Resumen
        • Making a system to handle animations
        • Getting the animations ready
        • Creating the bullet scene
        • Creating the first weapon
        • Creating the other two weapons
        • Making the weapons work
        • Creating some test subjects
        • Notas finales
      • Part 3
        • Resumen
        • Changing levels
        • Adding ammo
        • Adding reloading to the weapons
        • Adding reloading to the player
        • Adding sounds
        • Notas finales
      • Part 4
        • Resumen
        • Adding joypad input
        • Adding mouse scroll wheel input
        • Agregando los items de salud
        • Agregando los items de municiones
        • Adding breakable targets
        • Notas finales
      • Part 5
        • Resumen
        • Añadir granadas
        • Adding grenades to the player
        • Adding the ability to grab and throw RigidBody nodes to the player
        • Adding a turret
        • Notas finales
      • Part 6
        • Resumen
        • Adding the main menu
        • Haciendo el singleton Globals
        • Adding the debug menu
        • Adding a pause menu
        • Starting the respawn system
        • Finishing the respawn system
        • Writing a sound system we can use anywhere
        • Notas finales
    • Animación de miles de objetos
      • Animación de miles de objetos con MultiMeshInstance
        • Animando un objeto
        • Making a school of fish
        • Animating a school of fish
      • Controlling thousands of fish with Particles
  • Audio
    • Buses de audio
      • Introducción
      • Decibel scale
      • Buses de audio
      • Playback of audio through a bus
      • Agregando efectos
        • Amplify
        • BandLimit and BandPass
        • Chorus
        • Compresor
        • Retraso
        • Distorsion
        • EQ
        • EQ6, EQ10, EQ21
        • Filtro
        • HighPassFilter, HighShelfFilter
        • Limitador
        • LowPassFilter, LowShelfFilter
        • NotchFilter
        • Panner
        • Phaser
        • PitchShift
        • Record
        • Reverb
        • SpectrumAnalyzer
        • StereoEnhance
      • deshabilitador automatico de «Bus»
      • Reorganizamiento de «Bus»
      • Default bus layout
    • Corriente de Audio
      • Introducción
      • AudioStream
      • AudioStreamPlayer
      • AudioStreamPlayer2D
      • AudioStreamPlayer3D
        • Reverb buses
        • Doppler
    • Sync the gameplay with audio and music
      • Introducción
      • Using the system clock to sync
      • Using the sound hardware clock to sync
    • Recording with microphone
      • The structure of the demo
  • Física
    • Introducción a la física
      • Objetos de colisión
        • Figuras de Colisión
        • Llamada interna para procesamiento de física
        • Capas y Máscaras de Colisión
      • Area2D
      • StaticBody2D
      • RigidBody2D
        • Modos de cuerpos rígidos
        • Usando RigidBody2D
        • Reporte de contactos
      • KinematicBody2D
        • Respuesta de colisión cinemática
    • RigidBody
      • ¿Qué es RigidBody?
      • Cómo controlar un cuerpo rígido
      • The «look at» method
    • Using Area2D
      • Introducción
      • What is an area?
      • Area properties
      • Overlap detection
      • Area influence
        • Point gravity
        • Ejemplos
    • Usando KinematicBody2D
      • Introducción
      • ¿Qué es un cuerpo cinemático?
      • Movimiento y Colisión
        • move_and_collide
        • move_and_slide
        • move_and_slide_with_snap
      • ¿Cuál método de movimiento hay que usar?
      • Ejemplos
        • Movimiento y paredes
        • Rebote/reflejo
        • Movimiento de juego de plataformas
    • Ray casting
      • Introducción
      • Espacio
      • Accediendo al espacio
      • Consulta de Raycast
      • Excepciones de colisión
      • Máscara de colisión
      • Ray casting 3D desde la pantalla
    • Sistema de ragdoll
      • Introducción
      • Creando el ragdoll
        • Creación de huesos físicos
        • Limpiando el esqueleto
        • Ajuste de formas de colisión
        • Joints adjustment
      • Simulando el ragdoll
        • Capas y máscaras de colisión
    • Personaje cinemático (2D)
      • Introducción
      • Physics process
      • Configuración de la escena
      • Moviendo el personaje cinemático
    • SoftBody
      • Configuración básica
      • Cloak simulation
  • Matemáticas
    • Matemáticas vectoriales
      • Introducción
      • Sistemas de coordenadas (2D)
      • Operaciones vectoriales
        • Acceso para miembros
        • Añadir vectores
        • Multiplicación escalar
      • Aplicaciones prácticas
        • Movimiento
        • Apuntar hacia un objetivo
      • Vectores unitarios
        • Normalización
        • Reflexión
      • Producto punto
        • Orientación
      • Producto vectorial
        • Calculando normales
        • Apuntando a un objetivo
      • Más información
    • Matemática vectorial avanzada
      • Planos
        • Distancia del plano
        • Alejado del origen
        • Construyendo un plano en 2D
        • Algunos ejemplos de planos
      • Detección de colisiones en 3D
    • Matrices y transformaciones
      • Introducción
        • Matrix components and the Identity matrix
        • Scaling the transformation matrix
        • Rotating the transformation matrix
        • Basis of the transformation matrix
        • Translating the transformation matrix
        • Putting it all together
        • Shearing the transformation matrix (advanced)
      • Practical applications of transforms
        • Converting positions between transforms
        • Moving an object relative to itself
        • Applying transforms onto transforms
        • Inverting a transformation matrix
      • How does it all work in 3D?
        • Representing rotation in 3D (advanced)
    • Interpolación
      • Interpolación de vectorial
      • Interpolación de matriz de transformación
      • Suavizando el movimiento
    • Beziers, curves and paths
      • Quadratic Bezier
      • Cubic Bezier
      • Agregando puntos de control
      • Curve2D, Curve3D, Path and Path2D
      • Evaluating
      • Drawing
      • Traversal
  • Animación
    • Introducción a las características de la animación 2D
      • Sinopsis
      • Crear un nodo AnimationPlayer
      • La animación por computadora se basa en fotogramas clave
      • Tutorial: Crear una animación simple
        • Configuración de la escena
        • Añadir una pista
        • El segundo fotograma clave
        • Reproducir la animación
        • De un lado a otro
        • Ajustes de pista
      • Keyframes for other properties
      • Edit keyframes
      • Advanced: Call Method tracks
    • Cutout animation
      • What is it?
      • Cutout animation in Godot
      • Creando a GBot
      • Setting up the rig
      • Adjusting the pivot
      • RemoteTransform2D node
      • Completing the skeleton
      • Skeletons
      • IK chains
      • Recomendaciones para animaciones
        • Asignando keyframes y excluyendo propiedades
      • Creando una posición de descanso
      • Modifying rotation only
      • Keyframing IK chains
      • Visually move a sprite behind its parent
      • Setting easing curves for multiple keys
      • 2D Skeletal deform
    • Esqueletos 2D
      • Introducción
      • Organización
      • Creando los polígonos
      • Creando el esqueleto
      • Deformando los polígonos
      • Vértices internos
    • AnimationTree
      • Introducción
      • Creando un AnimationTree
      • Creando un árbol
      • Blend tree
        • Blend2 / Blend3
        • OneShot (Una Vez)
        • Seek
        • TimeScale
        • Transition
        • BlendSpace2D
        • BlendSpace1D
        • StateMachine
      • Root motion
      • Controlando desde código
      • State machine travel
  • Entradas
    • InputEvent
      • What is it?
      • ¿Cómo funciona?
      • Anatomía de un InputEvent
      • Acciones
      • InputMap
    • Ejemplo de Input
      • Introducción
      • Events versus polling
      • Input events
      • InputMap
        • Capturando acciones
      • Eventos de teclado
        • Modificadores de teclado
      • Mouse events
        • Botones de mouse
        • Movimiento del mouse
      • Touch events
    • Mouse y coordenadas de entrada
      • Acerca de
      • Coordenadas de pantalla basadas en hardware
      • Coordenadas de pantalla de Viewport
    • Personalizando el puntero del mouse
      • Usando Ajustes del Proyecto
      • Utilizando un script
      • Proyecto de ejemplo
      • Cursor list
  • I/O
    • Background loading
      • ResourceInteractiveLoader
      • Uso
        • Obtaining a ResourceInteractiveLoader
        • Polling
        • Load progress (optional)
        • Forcing completion (optional)
        • Obtaining the resource
      • Ejemplo
      • Using multiple threads
        • Use a semaphore
        • Not blocking main thread during the polling
      • Example class
        • Ejemplo:
    • Data paths
      • Path separators
      • Ruta del recurso
      • User path (persistent data)
      • Editor data paths
        • Self-contained mode
    • Saving games
      • Introducción
      • Identify persistent objects
      • Serializing
      • Saving and reading data
      • Some notes
    • Encrypting save games
      • ¿Por qué?
      • How?
  • Iternacionalización
    • Internacionalizando los juegos
      • Introducción
      • Configuración de la traducción importada
      • Localización de recursos
      • Conversión de claves a texto
      • Redimensionar los controles
      • TranslationServer
      • Línea de comandos
      • Traducir el nombre del proyecto
    • Localization using gettext
      • Advantages
      • Disadvantages
      • Caveats
      • Installing gettext tools
      • Creating the PO template (POT) manually
      • Creating the PO template (POT) using pybabel
      • Creating a messages file from a PO template
      • Loading a messages file in Godot
      • Updating message files to follow the PO template
      • Checking the validity of a PO file or template
    • Localización
  • GUI
    • Skinning GUI
      • ¡Oh, hermosa GUI!
      • Tema
      • Theme options
      • Customizing a control
      • Creating a theme
      • Example: theming a button
    • Custom GUI controls
      • So many controls…
      • Drawing
        • Checking control size
        • Checking focus
      • Sizing
      • Entrada
        • Input events
        • Notificaciones
    • Size and anchors
      • Centrando un control
    • Containers
      • Esquema de Containers
      • Size flags
      • Tipos de Container
        • Box Containers
        • Grid Container
        • Margin Container
        • Tab Container
        • Split Container
        • Panel Container
        • Scroll Container
        • ViewportContainer
      • Creando contenedores personalizados
    • BBCode in RichTextLabel
      • Introducción
      • Using BBCode
      • Reference
        • Built-in color names
        • Códigos Hexadecimales de color
        • Image vertical offset
      • Animation effects
        • Wave
        • Tornado
        • Shake
        • Fade
        • Rainbow
      • Custom BBCode tags and text effects
        • _process_custom_fx
        • Ghost
        • Pulse
        • Matrix
  • Viewports
    • Viewports
      • Introducción
      • Entrada
      • Listener
      • Cameras (2D & 3D)
      • Scale & stretching
      • Worlds
      • Captura
      • Viewport Container
      • Renderización
      • Render target
    • Multiple resolutions
      • El problema de las resoluciones múltiples
      • One size fits all
      • Base size
      • Resizing
      • Stretch settings
        • Stretch Mode
        • Stretch Aspect
        • Stretch Shrink
        • Desde scripts
        • Reducing aliasing on downsampling
        • Trabajando con relaciones de aspecto
        • Field of view scaling
    • Using a Viewport as a texture
      • Introducción
      • Configurando el Viewport
      • Applying the texture
      • Haciendo la textura del planeta
      • Coloreando el planeta
      • Haciendo un océano
    • Post procesado personalizado
      • Introducción
      • Post procesado de paso simple
      • Post procesado de pasos múltiples
  • Shading
    • Referencia de shading
      • Shaders
        • Introducción
        • Tipos de Shaders
        • Modos de renderizado
        • Funciones de procesamiento
      • Lenguaje de shading
        • Introducción
        • Tipos de datos
        • Arreglos
        • Constantes
        • Structs
        • Operadores
        • Control de Flujo
        • Descartando
        • Funciones
        • Funciones integradas
      • Spatial shaders
        • Modos de renderizado
        • Vertex built-ins
        • Fragment built-ins
        • Light built-ins
      • Shaders CanvasItem
        • Modos de renderizado
        • Vertex built-ins
        • Fragment built-ins
        • Light built-ins
      • Shaders Particle
        • Modos de renderizado
        • Vertex built-ins
    • Tu primer shader
      • ¿Qué son los shaders?
        • Introducción
        • But what are they?
        • Estructura de un shader
        • Reseña técnica
      • Tu primer shader CanvasItem
        • Introducción
        • Organización
        • Tu primer shader CanvasItem
        • Tu primera función fragment
        • Your first vertex function
        • Conclusión
      • Tu primer shader Spatial
        • Where to assign my material
        • Configurando
        • Shader magic
        • Noise heightmap
        • Uniforms
        • Interactuar con la luz
      • Your first Spatial shader: part 2
        • Your first spatial fragment function
        • Animating with TIME
        • Efectos avanzados: olas
    • Shader materials
      • Introducción
      • Creating a ShaderMaterial
      • Converting to ShaderMaterial
    • VisualShaders
      • Creating a VisualShader
      • Using the Visual Shader Editor
      • Visual Shader nodes
        • Expression node
        • Fresnel node
        • Boolean node
        • If node
        • Switch node
    • Intro to shaders: 2D and 3D water
      • Mira los tutoriales
      • Descarga código fuente
    • Screen-reading shaders
      • Introducción
      • SCREEN_TEXTURE built-in texture
      • SCREEN_TEXTURE example
      • Behind the scenes
      • Back-buffer logic
      • DEPTH_TEXTURE
    • Migrando al lenguaje de shaders de Godot
      • Introducción
      • GLSL
        • Shader programs
        • Vertex attributes
        • gl_Position
        • Varyings
        • Main
        • Constantes
        • Macros
        • Variables
        • Coordenadas
        • Precisión
      • Shadertoy
        • Tipos
        • mainImage
        • Variables
        • Coordenadas
      • The Book of Shaders
        • Tipos
        • Main
        • Variables
        • Coordenadas
    • Post procesamiento avanzado
      • Introducción
      • Quad de pantalla completa
      • Depth texture
      • Una optimización
  • Redes
    • Multijugador de alto nivel
      • Alto nivel VS bajo nivel API
      • Abstracción de nivel medio
      • Inicializando la red
      • Administrar conexiones
      • RPC
      • De vuelta al lobby
      • Comenzando el juego
        • Escenas del jugador
        • Sincronizando el inicio del juego
      • Sincronizando el juego
        • Red maestra
        • Palabras clave master y puppet
    • Haciendo solicitudes HTTP
      • Preparando la escena
      • Scripting
      • Enviando datos al servidor
    • Clase cliente HTTP
    • Certificados SSL
      • Introducción
      • Enfoque 1: certificado autofirmado
      • Enfoque 2: certificado CA
    • WebSocket
      • HTML5 and WebSocket
      • Using WebSocket in Godot
        • Minimal client example
        • Minimal server example
        • Advanced chat demo
    • WebRTC
      • HTML5, WebSocket, WebRTC
        • WebSocket
        • WebRTC
      • Using WebRTC in Godot
        • Minimal connection example
        • Local signaling example
        • Remote signaling with WebSocket
  • Biblioteca de Assets
    • Acerca de la Biblioteca de Assets
      • Types of assets
      • Preguntas Frecuentes
        • ¿Se pueden subir assets de pago a la biblioteca de assets?
    • Usando el AssetLib
      • En el sitio web
        • Sinopsis
        • Búsqueda
        • Breakdown of an asset
        • Registering and logging in
      • In the editor
    • Submitting to the Asset Library
      • Introducción
      • Submission guidelines
        • Requerimientos
        • Recommendations
      • Submitting
  • VR
    • AR/VR primer
      • AR/VR server
      • New AR/VR nodes
      • Other things to consider
    • VR starter tutorial
      • VR starter tutorial part 1
        • Introducción
        • Preparando todo
        • Iniciando con la VR
        • Creating the controllers
        • Creating a base class for interactable VR objects
        • Reducing motion sickness
        • Notas finales
      • VR starter tutorial part 2
        • Introducción
        • Añadir objetivos destruibles
        • Añadir una pistola
        • Añadir una escopeta
        • Añadir una bomba
        • Añadir una espada
        • Actualización de la UI de destino
        • Adding the final special RigidBody
        • Notas finales
  • Plugins
    • Plugins del editor
      • Installing plugins
        • Finding plugins
        • Installing a plugin
        • Enabling a plugin
      • Creando plugins
        • Acerca de los plugins
        • Creando un plugin
        • A custom node
        • Going beyond
      • Creando plugins para pantalla principal
        • Qué cubre este tutorial
        • Inicializando el plugin
        • Escenas
        • Escena de pantalla inicial
        • Escena de panel con pestañas
        • Connecting the two scenes in the plugin script
        • Prueba el plugin
      • Import plugins
        • Introducción
        • Configuration
        • The EditorImportPlugin class
        • Options and presets
        • The import method
        • Platform variants and generated files
        • Trying the plugin
      • Plugins de gizmos Spatial
        • Introducción
        • The EditorSpatialGizmoPlugin
        • Enfoque simple
        • Alternative approach
      • Inspector plugins
        • Organización
        • EditorInspectorPlugin
        • EditorProperty
      • Visual Shader plugins
    • GDNative
      • GDNative C example
        • Introducción
        • Prerequisites
        • Our C source
        • Compilando
        • Creating the GDNativeLibrary (.gdnlib) file
        • Creating the NativeScript (.gdns) file
      • GDNative C++ ejemplo
        • Introducción
        • Configurando el proyecto
        • Building the C++ bindings
        • Creación de un simple plugin
        • Compilando el plugin
        • Using the GDNative module
        • Agregando propiedades
        • Señales
        • NativeScript 1.1 vs NativeScript 1.0
        • Next steps
    • Plugins de Android
      • Creating Android plugins (Godot 4.0+)
        • Introducción
        • Plugin de Android
        • Troubleshooting
  • Específico de plataformas
    • Android in-app purchases
      • Getting the product details
      • Check if user purchased an item
      • Simple Purchase
      • Consumables and Non-Consumables
      • Prueba
    • Servicios para iOS
      • Asynchronous methods
      • Store Kit
        • purchase
        • request_product_info
        • restore_purchases
      • Game Center
        • post_score
        • award_achievement
        • reset_achievements
        • request_achievements
        • request_achievement_descriptions
        • show_game_center
      • Multi-platform games
    • Personalizando la página HTML de exportación a Web
      • Sustitución de parámetros
      • El objeto Engine
      • Comenzando una instancia de Engine
      • Configurando comportamiento de inicio
      • Personalizando la presentación
      • Accediendo el módulo Emscripten
    • Soporte de consolas en Godot
      • Official support
      • Soporte de herramientas de terceros
  • Multi-threading
    • Using multiple threads
      • Hilos
      • Creando un hilo
      • Mutexes
      • Semaphores
    • API thread safe
      • Hilos
      • Ámbito Global
      • Árbol de escenas
      • Arreglos y diccionarios GDScript
      • Recursos
  • Creación de contenido
    • Procedural geometry
      • Using the ArrayMesh
        • ArrayMesh
        • Generating geometry
        • Saving
      • Using the MeshDataTool
      • Using the SurfaceTool
      • Using ImmediateGeometry
      • What is geometry?
      • What is a Mesh?
      • What a Mesh is
        • Surfaces
        • Surface array
      • Herramientas
        • ArrayMesh
        • MeshDataTool
        • SurfaceTool
        • ImmediateGeometry
      • Which one should I use?
    • Creando árboles
      • Empieza con un árbol
      • Pintar con Vertex Colors
      • Write a custom shader for the leaves
      • Mejorando el shader
  • Optimización
    • Optimization using Servers
      • Servidores
      • RIDs
      • Creando un sprite
      • Instantiating a Mesh into 3D space
      • Creating a 2D RigidBody and moving a sprite with it
      • Obteniendo datos de servidores
    • Optimization using MultiMeshes
      • MultiMeshes
      • Ejemplo de Multimesh
  • Misceláneas
    • Fixing jitter and stutter
      • What are jitter and stutter?
      • Distinguiéndolos
      • Jitter
      • Stutter
        • Windows
        • Linux (X11)
        • macOS
        • Android
        • iOS
      • Reporting stutter or jitter problems
    • Handling quit requests
      • Quitting
      • Handling the notification
    • Pausing games
      • Pause?
      • How pausing works
      • White-listing nodes
      • Ejemplo
    • Binary serialization API
      • Introducción
      • Packet specification
        • 0: null
        • 1: bool
        • 2: int
        • 3: float/real
        • 4: String
        • 5: Vector2
        • 6: Rect2
        • 7: Vector3
        • 8: Transform2D
        • 9: Plane
        • 10: Quat
        • 11: AABB
        • 12: Basis
        • 13: Transform
        • 14: Color
        • 15: NodePath
        • 16: RID (unsupported)
        • 17: Object (unsupported)
        • 18: Dictionary
        • 19: Array
        • 20: PoolByteArray
        • 21: PoolIntArray
        • 22: PoolRealArray
        • 23: PoolStringArray
        • 24: PoolVector2Array
        • 25: PoolVector3Array
        • 26: PoolColorArray
    • Ejecutando código en el editor
      • What is tool?
      • Cómo usarlo
      • Try it out
    • Cambiar escenas manualmente
    • Diferencias entre GLES2 y GLES3
      • Partículas
      • SCREEN_TEXTURE mip-maps
      • DEPTH_TEXTURE
      • Espacio de color
      • HDR
      • Características de SpatialMaterial
      • Características de Environment
      • GIProbes
      • Contact shadows
      • Rendimiento de luces
      • Compresión de texturas
      • Blend shapes
      • Lenguaje de shading
        • textureSize() workaround
      • Built in variables and render modes
    • Instanciando con señales
      • Ejemplo de disparos
    • State design pattern
      • Introducción
      • Script setup
      • Configuración del proyecto
  • Depurar
    • Overview of debugging tools
      • Debug menu options
        • Exportar con Depuración Remota
        • Exportación Mini con Recursos en Red
        • Ver Formas de Colisión
        • Navegación Visible
        • Sincronizar cambios de escena
        • Sincronizar Cambios en Scripts
      • Script editor debug tools and options
      • Debug project settings
        • Settings
        • GDScript
        • Shapes
      • Debugging tools
        • Depurador
        • Errores
        • Profiler
        • Profiler de Red
        • Monitores
        • Video Memory
        • Otros
      • Remote in scene dock
  • Legal
    • Cumpliendo con las licencias
      • What are licenses?
      • Requerimientos
      • Inclusión
        • Credits screen
        • Pantalla de licencias
        • Output log
        • Accompanying file
        • Manual impreso
      • Licencias de terceros
        • FreeType
        • ENet
        • MBedTLS

Desarrollo

  • Compilando
    • Consiguiendo el código fuente
      • Descargando el código fuente de Godot
    • Introduction to the buildsystem
      • SCons
      • Organización
      • Platform selection
      • Resulting binary
      • Herramientas
      • Objetivo
      • Bits
      • Other build options
      • Plantillas de exportación
    • Compiling for Windows
      • Requerimientos
      • Setting up SCons
      • Installing Visual Studio caveats
      • Downloading Godot’s source
      • Compilando
        • Selecting a compiler
        • Running SCons
      • Development in Visual Studio or other IDEs
      • Cross-compiling for Windows from other operating systems
        • Troubleshooting
      • Creating Windows export templates
    • Compiling for X11 (Linux, *BSD)
      • Requerimientos
        • Distro-specific one-liners
      • Compilando
      • Building export templates
      • Using Clang and LLD for faster development
    • Compilando para macOS
      • Requerimientos
      • Compilando
      • Cross-compiling for macOS from Linux
    • Compiling for Android
      • Note
      • Requerimientos
      • Setting up the buildsystem
      • Building the export templates
        • Adding support for x86 devices
        • Cleaning the generated export templates
      • Using the export templates
        • Installing the templates
      • Troubleshooting
        • Application not installed
        • Application exits immediately
    • Compiling for iOS
      • Requerimientos
      • Compilando
      • Ejecutar
    • Cross-compiling for iOS on Linux
      • Disclaimer
      • Requerimientos
      • Configuring the environment
        • darling-dmg
        • Preparing the SDK
        • Toolchain
      • Compiling Godot for iPhone
        • Producing fat binaries
    • Compiling for Universal Windows Platform
      • Requerimientos
      • Compilando
      • Creating UWP export templates
      • Running UWP apps with Visual Studio
    • Compiling for the Web
      • Requerimientos
      • Building export templates
      • Building per asm.js translation or LLVM backend
    • Compiling with Mono
      • Requerimientos
      • Variables de entorno
      • Enable the Mono module
      • Generar el pegamento
        • Notes
      • Rebuild with Mono glue
      • Ejemplos
        • Ejemplo (Windows)
        • Ejemplo (X11)
      • Data directory
        • Plantillas de exportación
        • Editor
      • Targeting Android
      • Opciones de la línea de comandos
    • Optimizing a build for size
      • Fundamentos
      • Disabling 3D
      • Disabling advanced GUI nodes
      • Disabling unwanted modules
      • Optimizing for size instead of speed
      • Compiling with link-time optimization
      • Stripping binaries
      • Using UPX to compress binaries
    • Compiling with script encryption key
      • Paso a paso
      • Possible Errors
  • Desarrollo del motor
    • Introduction to Godot development
      • Architecture diagram
      • Debugging the editor with gdb
    • Configuring an IDE
      • Qt Creator
        • Importing the project
        • Build and run
        • Updating sources after pulling latest commits
        • Code style configuration
      • KDevelop
      • Xcode
        • Configuración del proyecto
        • Configuración del scheme
      • Visual Studio Code
      • Android Studio
        • Configuración del proyecto
      • CLion
    • Core types
      • Definitions
        • References:
      • Memory model
      • Allocating memory
        • References:
      • Containers
        • References:
      • Cadena
        • References:
      • StringName
        • References:
      • Math types
        • References:
      • NodePath
        • References:
      • RID
        • References:
    • Variant class
      • Acerca de
        • References:
      • Containers: Dictionary and Array
        • References:
    • Object class
      • General definition
        • References:
      • Registering an Object
        • References:
      • Constantes
      • Properties (set/get)
      • Binding properties using _set/_get/_get_property_list
      • Dynamic casting
      • Señales
      • References
        • References:
      • Recursos:
        • References:
      • Resource loading
        • References:
      • Resource saving
        • References:
    • Inheritance class tree
      • Object
      • Reference
      • Control
      • Node2D
      • Spatial
    • Custom modules in C++
      • Modules
      • What for?
      • Creating a new module
      • Using the module
      • Customizing module types initialization
      • Improving the build system for development
      • Writing custom documentation
      • Adding custom editor icons
      • Summing up
    • Binding to external libraries
      • Modules
      • Using the module
    • Cargadores de recursos en formato personalizado
      • Introducción
        • References
      • What for?
      • What not?
        • References
      • Creating a ResourceFormatLoader
      • Creating a ResourceFormatSaver
      • Creando tipos de datos personalizados
        • Considerations
        • References
      • Registrando un nuevo formato de archivo
        • References
      • Loading it on GDScript
    • Custom AudioStreams
      • Introducción
        • References:
      • What for?
      • Create an AudioStream
        • References:
      • Create an AudioStreamPlayback
        • Resampling
        • References:
    • Servidores Godot personalizados
      • Introducción
        • References
      • What for?
      • Creando un servidor Godot
      • Custom managed resource data
        • References
      • Registrar una clase en GDScript
        • Bind methods
      • MessageQueue
        • References:
      • Summing it up
        • Notes
  • Editor development
    • Introducción
    • Editor icons
      • Creating icons
      • Icon optimization
      • Integrating and sharing the icons
      • Troubleshooting
      • References:
  • Godot file formats
    • TSCN file format
      • Estructura del archivo
        • Entries inside the file
      • El árbol de escenas
        • NodePath
        • Esqueleto
        • BoneAttachment
        • AnimationPlayer
      • Recursos
        • External resources
        • Internal resources
        • ArrayMesh
        • Animación

Comunidad

  • Contributing
    • Formas de contribuir
      • Contribuyendo con el código
      • Testing and reporting issues
        • Testing development versions
        • Filing an issue on GitHub
      • Contributing to the documentation
    • Best practices for engine contributors
      • Introducción
      • Lenguaje
      • Best Practices
        • #1: The problem always comes first
        • #2: The problem has to exist
        • #3: The problem has to be complex or frequent
        • #4: The solution must be discussed with others
        • #5: To each problem, its own solution
        • #6: Cater to common use cases, leave the door open for the rare ones
        • #7: Solutions must be local
        • #8: Don’t use complex canned solutions for simple problems
    • Pull request workflow
      • Git source repository
      • Forking and cloning
      • Branching
      • Updating your branch
      • Making changes
      • Pushing changes to a remote
      • Issuing a pull request
      • Modifying a pull request
      • Mastering the PR workflow: the rebase
      • Deleting a Git branch
    • Code style guidelines
      • C++ and Objective-C
        • Using clang-format locally
        • Header includes
      • Java
      • Python
    • Bug triage guidelines
      • Issues management
        • Labels
        • Milestones
    • Documentation guidelines
      • How to contribute
      • The “Edit on GitHub” link
      • What makes good documentation?
      • Titles
      • Translating existing pages
      • Licencia
    • Docs writing guidelines
      • 7 rules for clear English
        • Use the direct voice
        • Use precise action verbs
        • Avoid verbs that end in -ing
        • Remove unnecessary adverbs and adjectives
        • Ban these 8 words
        • Use explicit references
        • Use “s to show possession
        • Use the Oxford comma to enumerate anything
      • How to write methods and classes
        • Dynamic vs static typing
        • Use real-world code examples where appropriate
        • Give an overview of the node in the brief description
        • Mention what methods return if it’s useful
        • Use «if true» to describe booleans
        • Use [code] around arguments
      • Common vocabulary to use in Godot’s documentation
      • Keyboard shortcut guidelines
      • Pautas para la contribución de imágenes
    • Contribuir a la Referencia de Clases
      • How to contribute
      • Comenzar con GitHub
        • Fork Godot
        • How to keep your local clone up-to-date
        • Actualización de la plantilla de documentación
        • Solicitar push o pull de sus cambios
      • Cómo editar una clase XML
        • Cómo escribir la referencia de la clase
        • Mejorar el formato con etiquetas de estilo BBcode
        • ¡No sé que hace este método!
        • Traducciones
  • Canales de la comunidad
    • Preguntas y respuestas
    • IRC en Freenode
    • Otros chats
    • Comunidades basadas en lenguajes
    • Redes sociales
    • Foro
  • Tutoriales y recursos
    • Donde empezar
    • Vídeo tutoriales
    • Tutoriales en texto
    • Devlogs
    • Recursos
Godot Engine
  • Docs »
  • Plugins »
  • Plugins del editor
  • View page source

Plugins del editor¶

  • Installing plugins
  • Creando plugins
  • Creando plugins para pantalla principal
  • Import plugins
  • Plugins de gizmos Spatial
  • Inspector plugins
  • Visual Shader plugins
Next Previous

© Copyright 2014-2020, Juan Linietsky, Ariel Manzur and the Godot community (CC-BY 3.0) Revision 3547c4ff.

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest
Versions
latest
Downloads
html
On Read the Docs
Project Home
Builds
Free document hosting provided by Read the Docs.