Logo
latest

Allgemein

  • Über
    • Einführung
      • Bevor du beginnst
      • Über die Godot Engine
      • Über die Dokumentation
      • Aufbau der Dokumentation
    • Häufig gestellte Fragen
      • Was kann ich mit Godot machen? Wie viel kostet es? Wie lauten die Lizenzbedingungen?
      • Welche Plattformen werden von Godot unterstützt?
      • Welche Programmiersprachen werden in Godot unterstützt?
      • Was ist GDScript und warum sollte ich es verwenden?
      • Was war die Motivation, GDScript zu entwickeln?
      • Welche Arten von 3D-Modellformaten unterstützt Godot?
      • Wird [Closed-Source-SDK à la FMOD, GameWorks, etc. hier einfügen] in Godot unterstützt werden?
      • Wie sollten Assets für einen optimalen Umgang mit unterschiedlichen Bildschirmauflösungen und Seitenverhältnissen angelegt werden?
      • Wie kann ich Godot erweitern?
      • Ich würde gerne mitwirken! Wie kann ich anfangen?
      • Ich habe eine tolle Idee für Godot. Wie kann ich sie teilen?
      • Warum verwendet Godot nicht STL (Standard Template Library)
      • Weshalb verwendet Godot keine „exceptions“?
      • Weshalb erzwingt Godot keine RTTI?
      • Warum zwingt Godot seine Benutzer nicht zur Implementierung von DoD (Data oriented Design)?
      • Wie kann ich die Entwicklung der Godot Engine unterstützen oder einen (finanziellen) Beitrag leisten?
      • Wer arbeitet an Godot? Wie kann ich euch kontaktieren?
    • Änderungen Dokumentation
      • Neue Tutorials seit Version 3.1
        • Projekt-Workflow
        • 2D
        • Audio
        • Mathematik
        • Eingaben
        • Internationalisierung
        • Shading
        • Networking
        • VR
        • Erweiterungen
        • Multi-Threading
        • Inhalte erstellen
        • Optimierungen
        • Rechtliches
      • Neue Tutorials seit Version 3.0
        • Schritt für Schritt
        • Scripting
        • Projekt-Workflow
        • 2D
        • 3D
        • Physik
        • Animation
        • GUI
        • Ansichtsfenster
        • Shading
        • Erweiterungen
        • Plattformspezifisches
        • Multi-Threading
        • Inhalte erstellen
        • Verschiedenes
        • Kompilieren
        • Engine-Entwicklung

Erste Schritte

  • Schritt für Schritt
    • Einführung in den Godot-Editor
      • Projektverwaltung
        • Erzeugen oder Importieren eines Projekts
      • Dein erster Blick auf Godots Editor
      • Die Arbeitsbereiche
      • Oberfläche anpassen
        • Docks verschieben und skalieren
    • Szenen und Nodes
      • Einführung
      • Nodes („Knoten“)
      • Szenen
      • Editor
      • Konfigurieren des Projekts
      • Fortsetzung folgt…
    • Instanziieren
      • Einführung
      • Instanziieren anhand eines Beispiels
      • Mehrere Instanzen
      • Instanzen bearbeiten
      • Fazit
    • Instanziieren (Fortsetzung)
      • Wiederholung
      • Designsprache
      • Informationsüberfluss!
    • Scripting
      • Einführung
        • GDScript
        • VisualScript
        • .NET / C#
        • GDNative / C++
      • Eine Szene skripten
        • Eine Szene einrichten
        • Ein Skript hinzufügen
        • Die Rolle des Skriptes
        • Mit einem Signal umgehen
    • Scripting (Fortsetzung)
      • Prozessverarbeitung
      • Gruppen
      • Benachrichtigungen
      • Überschreibbare Funktionen
      • Nodes erstellen
      • Szenen in­s­tan­zi­ie­ren
      • Skripte als Klassen registrieren
    • Signale
      • Einführung
      • Timer Beispiel
        • Signale im Code verbinden
      • Benutzerdefinierte Signale
      • Fazit
    • Dein erstes Spiel
      • Übersicht
      • Projektkonfiguration
        • Projektorganisation
      • Spieler-Szene
        • Node Struktur
        • Sprite-Animation
        • Den Spieler Bewegen
        • Animationen
        • Vorbereitung auf Kollisionen
      • Feind-Szene
        • Node einrichten
        • Feind-Skript
      • Hauptszene
        • Mobs spawnen
        • Main Skript
      • HUD
        • ScoreLabel (HighScore)
        • MessageLabel (Nachrichten)
        • StartButton (Startknopf)
        • Verbinde das HUD mit Main
        • Entfernen von alten Monstern
      • Fertigstellung
        • Hintergrund
        • Soundeffekte
        • Tastenkürzel
      • Projektdateien
    • Exportieren
      • Übersicht
      • Vorbereitung des Projekts
      • Die Hauptszene festlegen
      • Exportvorlagen
      • Exportvoreinstellungen
      • Exportieren nach Plattform
        • PC (Linux/macOS/Windows)
        • Android
        • iOS
        • HTML5 (web)
    • Godots Design-Philosophie
      • Objektorientiertes Design und Komposition
      • Rundum-sorglos-Paket
      • Open Source
      • Community-gesteuert
      • Der Godot Editor ist ein Godot Spiel
      • Separate 2D- und 3D-Engines
    • Gestaltung von Benutzeroberflächen mit den Kontroll-Nodes
      • Die 5 häufigsten UI Elemente
        • TextureRect (Textur-Rechteck)
        • TextureButton (Textur-Knopf)
        • TextureProgress (Texturfortschritt)
        • Label
        • NinePatchRect (Rechteck)
      • Es gibt zwei Arbeitsroutinen um zugängliche Benutzeroberflächen zu entwerfen
      • Platziere UI Elemente präzise mit Ankern
        • Wie man den Anker ändert
        • Anker sind relativ zum parent Container
        • Seitenränder ändern sich mit dem Anker
        • Verwende Größenmarkierungen um zu verändern, wie Benutzeroberflächen Elemente den verfügbaren Platz ausfüllen
      • Arrangiere Control Nodes automatisch mit Containern
        • Die 5 nützlichsten Container
    • Erstelle einen Titelbildschirm
      • Wie du die Benutzeroberfläche deines Spiels gestaltest
      • Entwerfe das Hauptmenü
        • Aufgliederung des UI-Entwurfs
        • Vorbereitung der Hauptmenü-Szene
        • Hinzufügen der UI-Sprites
        • Füge Container ein, um UI-Elemente automatisch zu platzieren
        • Aufgliederung des UI-Entwurfs
    • Gestaltung der Oberfläche
      • Aufbau der UI
      • Erstellen der grundlegenden GUI
        • Erstellen der Grundlage der Leiste
        • Ersetzen des Fonts fürs Label
        • Hinzufügen der Fortschrittsleiste
      • Das Design des Bomben- und Smaragdzählers
      • Verwandel die Leiste und den Zähler in wiederverwendbare Komponenten für die grafische Oberfläche
      • Verwenden von Szenenvererbung, um die verbleibenden Elemente zu erstellen
        • Erbe von der Leistenszene um einen Lebensbalken zu erstellen
        • Entwerfe die Energieleiste
        • Bereite die Zähler für die Bomben und die Smaragde vor
      • Füge nun die UI-Komponente der finalen Oberfläche hinzu
      • Platziere die Oberfläche auf den Spielentwurf
    • Kontrolliere das Spiele-UI mit Code
      • Intro
      • Lade und sieh dir das Startprojekt an
      • Setze die Lifebar so mit der maximalen Gesundheit des Spielers
      • Aktualisiere die Lebensanzeige mithilfe eines Signals, wenn der Spieler getroffen wird
      • Animieren Sie den Verlust von Leben mit dem Tween-Knoten
      • Weisen Sie der LifeBar die animierte _health zu
      • Blenden den Balken aus, wenn der Spieler stirbt
    • Begrüßungsbildschirm
      • Tutorial
      • Einrichtung
    • Animationen
      • Einführung
      • Hinzufügen eines Animationsplayers
      • Erstellen einer Animation
      • Bearbeiten einer Animation
    • Ressourcen
      • Nodes und Ressourcen
      • Extern vs. integriert
      • Laden von Ressourcen via Code
      • Laden von Szenen
      • Ressourcen freigeben
      • Eigene Ressourcen erstellen
    • Dateisystem
      • Einführung
      • Implementation
      • project.godot
      • Path delimiter
      • Resource path
      • User path
      • Host file system
      • Drawbacks
    • SceneTree
      • Einführung
      • MainLoop
      • SceneTree
      • Root viewport
      • Scene tree
      • Tree order
      • „Becoming active“ by entering the Scene Tree
      • Changing current scene
    • Singletons (AutoLoad)
      • Einführung
      • Autoload
      • Custom scene switcher
        • Global.gd
  • Editor manual
    • Von Unity zur Godot Engine
      • Unterschiede
      • The editor
      • The scene system
      • Project organization
      • Where are my prefabs?
      • Glossary correspondence
      • Scripting: GDScript, C# and Visual Script
        • Design
        • Connections: groups and signals
        • Skript-Serialisierung
      • Using Godot in C++
    • Command line tutorial
      • Command line reference
      • Pfad
      • Setting the project path
      • Creating a project
      • Running the editor
      • Erasing a scene
      • Running the game
      • Debugging
      • Exportieren
      • Running a script
    • Using an external text editor
  • Scripting
    • GDScript
      • GDScript Grundlagen
        • Einführung
        • Sprache
        • Eingebaute Typen
        • Daten
      • GDScript: An introduction to dynamic languages
        • Über
        • Dynamic nature
        • Arrays
        • Dictionaries
        • For & while
        • While
        • Benutzerdefinierte Iteratoren
        • Duck typing
      • GDScript exports
        • Introduction to exports
        • Beispiele
        • Exporting bit flags
        • Arrays exportieren
      • GDScript Style Guide
        • Formatting
        • Benennungsrichtlinien
        • Code order
        • Static typing
      • Statische Typisierung in GDScript
        • A brief look at static typing
        • How to use static typing
        • Typed or dynamic: stick to one style
        • Warning system
        • Cases where you can’t specify types
        • Zusammenfassung
      • GDScript Zeichenketten formatieren
        • Verwendung in GDScript
        • Mehrere Platzhalter
        • Formatbezeichner
        • Versatz
        • Escape-Sequenz
        • Beispiele für Formatierungsverfahren
    • VisualScript
      • What is Visual Scripting
      • Getting started with Visual Scripting
        • Erstellen eines Skripts
        • Hinzufügen einer Funktion
      • Nodes and terminology
        • Node-Eigenschaften
        • Ports und Verbindungen
        • Nodes hinzufügen
        • Weitere Nodes hinzufügen
    • C#
      • Einführung
        • C# für Godot einrichten
        • Einen externen Editor konfigurieren
        • Erstellen eines C# Skripts
        • Project setup and workflow
        • Example
        • General differences between C# and GDScript
        • Current gotchas and known issues
        • Performance of C# in Godot
        • Using NuGet packages in Godot
        • Profiling your C# code
        • Configuring VS 2019 for debugging
      • Funktionen
        • Type conversion and casting
        • C# Signale
        • Preprocessor defines
      • API differences to GDScript
        • General differences
        • Global scope
        • Export keyword
        • Signal keyword
        • Singletons
        • String
        • Basis
        • Transform2D
        • Plane
        • Rect2
        • Quat
        • Array
        • Wörterbuch
        • Variant
        • Communicating with other scripting languages
        • Yield
        • Other differences
      • C# Style Guide
        • Language specification
        • Formatting
        • Benennungsrichtlinien
        • Implicitly typed local variables
        • Other considerations
    • 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#
  • Projekt-Workflow
    • Projektkonfiguration
      • Project organization
        • Einführung
        • Organization
        • Importing
    • Assets workflow
      • Import process
        • Importing assets in Godot 3.0+
        • Changing import parameters
        • Automatic reimport
        • Files generated
        • Changing import resource type
        • Changing default import parameters
        • Simplicity is key!
      • Bilder importieren
        • Why import them?
        • Texturen importieren
        • Supported image formats
        • Kompression
        • Flags
        • Process
      • Importing audio samples
        • Why import?
        • Best practices
      • Importing translations
        • Games and internationalization
        • Translation format
        • CSV importer
      • 3D-Szenen importieren
        • Godot scene importer
        • Import workflows
        • Import-Optionen
        • Animationsoptionen
        • Szenenvererbung
        • Import hints
      • Blender ESCN exporter
        • Details on exporting
        • Disabling specific objects
        • Build pipeline integration
    • Exportieren
      • Projekte exportieren
        • Wozu exportieren?
        • Export-Menü
        • Von der Kommandozeile exportieren
      • Exporting packs, patches, and mods
        • Anwendungsfälle
        • Overview of PCK files
        • Generating PCK files
        • Opening PCK files at runtime
        • Zusammenfassung
      • Feature-Tags
        • Einführung
        • Default features
        • Custom features
        • Projekteinstellungen überschreiben
        • Default overrides
        • Den Build anpassen
      • Exporting for PC
      • Exporting for iOS
        • Requirements
        • Export a Godot project to Xcode
        • Active development considerations
        • Services for iOS
      • Exporting for Universal Windows Platform
        • Limitations on Xbox One
        • Creating a signing certificate
        • Signing the package
        • Installing the package
      • Exporting for Android
        • Download the Android SDK
        • Install OpenJDK or Oracle JDK
        • Create a debug.keystore
        • Make sure you have adb
        • Setting it up in Godot
        • Providing launcher icons
        • Export für den Google Play Store
        • Optimizing the APK size
      • Exporting for the Web
        • WebGL 2
        • Limitations
        • Serving the files
        • Export options
        • Calling JavaScript from script
      • One-click deploy
        • Sounds good, what is it?
        • Steps for one-click deploy
      • Custom builds for Android
        • Set up the custom build environment
        • Install the Android SDK (command-line version)
        • Install the Android SDK (Android Studio)
        • Enabling the custom build and exporting
      • Changing application icon for Windows
        • Changing the taskbar icon
        • Changing the file icon
        • Testing the result
        • ICO file requirements
    • Best practices
      • Einführung
      • Godot scenes and scripts are classes
        • Making sense of classes in Godot
        • Scripting performances and PackedScene
        • Scenes and scripts are objects
      • Szenenorganisation
        • How to build relationships effectively
        • Auswahl einer Node Tree-Struktur
      • When to use scenes versus scripts
        • Anonymous types
        • Benannte Typen
        • Fazit
      • Autoloads versus regular nodes
      • The cutting audio issue
      • Managing shared functionality or data
      • When you should use an Autoload
      • When and how to avoid using nodes for everything
      • Godot Schnittstellen
        • Objektreferenzen erlangen
        • Accessing data or logic from an object
      • Benachrichtigungen in Godot
        • _process vs. _physics_process vs. *_input
        • _init vs. initialization vs. export
        • _ready vs. _enter_tree vs. NOTIFICATION_PARENTED
      • Data preferences
        • Array vs. Dictionary vs. Object
        • Enumerations: int vs. string
        • AnimatedTexture vs. AnimatedSprite vs. AnimationPlayer vs. AnimationTree
      • Logic preferences
        • Loading vs. preloading
        • Large levels: static vs. dynamic

Anleitungen

  • 2D
    • Canvas-Ebenen
      • Viewport und CanvasItem
      • CanvasLayers
    • Viewport and canvas transforms
      • Einführung
      • Canvas transform
      • Global canvas transform
      • Stretch transform
      • Transform order
      • Transform functions
      • Feeding custom input events
    • Using tilemaps
      • Einführung
      • Projektkonfiguration
      • TileMap node
      • Creating a TileSet
      • Collisionsformen
      • Atlas tiles
      • Tips and tricks
    • Partikelsysteme (2D)
      • Intro
        • Particle nodes
        • ParticlesMaterial
        • Texture
      • Time parameters
        • Lifetime
        • One Shot
        • Preprocess
        • Speed Scale
        • Explosiveness
        • Randomness
        • Fixed FPS
        • Fract Delta
      • Drawing parameters
        • Visibility Rect
        • Lokale Koordinaten
        • Draw Order
      • ParticlesMaterial settings
        • Spread
        • Gravity
        • Initial Velocity
        • Angular Velocity
        • Spin Velocity
        • Orbit Velocity
        • Linear Acceleration
        • Radial Acceleration
        • Tangential Acceleration
        • Damping
        • Angle
        • Scale
        • Farbe
        • Hue variation
      • Emissionformen
        • Emissionsmaske
        • Emissionsfarben
    • 2D movement overview
      • Einführung
      • Setup
      • 8-way movement
      • Rotation + movement
      • Rotation + movement (mouse)
      • Click-and-move
      • Zusammenfassung
    • 2D lights and shadows
      • Einführung
      • Setup
      • Nodes („Knoten“)
      • Lights
      • Shadows
      • Schritt für Schritt
    • 2D Meshes
      • Einführung
      • Optimizing pixels drawn
      • Converting Sprites to 2D meshes
    • Custom drawing in 2D
      • Why?
      • But…
      • OK, how?
      • Updating
      • An example: drawing circular arcs
        • Arc function
        • Draw the arc on the screen
        • Arc polygon function
        • Dynamic custom drawing
      • Werkzeuge
    • 2D Sprite-Animation
      • Einführung
      • Individual images with AnimatedSprite
        • Erstellen und regeln einer Animation
      • Sprite sheet with AnimatedSprite
      • Bildbogen (Sprite) mit Animationsspieler
        • Controlling an AnimationPlayer animation
      • Zusammenfassung
  • 3D
    • Introduction to 3D
      • Spatial node
      • 3D Inhalt
        • DCC-created models
        • Generierte Geometrie
        • Immediate geometry
        • 2D in 3D
      • Umgebung
      • 3D viewport
        • Koordinatensystem
        • Space and manipulation gizmos
        • View menu
        • Standard Umgebung
        • Kameras
        • Lights
    • Verwendung von 3D-Transformationen
      • Einführung
      • Problems of Euler angles
        • Axis order
        • Interpolation
        • Say no to Euler angles
      • Introducing transforms
        • Manipulating transforms
        • Precision errors
        • Obtaining information
        • Setting information
        • Interpolation mit Quaternionen
      • Transforms are your friend
    • 3D performance and limitations
      • Einführung
      • Rendering
        • Reuse shaders and materials
        • Pixel cost vs vertex cost
        • Texture compression
        • Transparent objects
        • Level of detail (LOD)
        • Use instancing (MultiMesh)
        • Bake lighting
    • Spatial Material
      • Einführung
      • Flags
        • Transparent
        • Use Shadow to Opacity
        • Unshaded
        • Vertex Lighting
        • No Depth Test
        • Use Point Size
        • World Triplanar
        • Fixed Size
        • Do Not Receive Shadows
        • Disable Ambient Light
        • Ensure Correct Normals
      • Vertex Color
        • Use as Albedo
        • Is sRGB
      • Parameters
        • Diffuse Mode
        • Specular Mode
        • Blend Mode
        • Cull Mode
        • Depth Draw Mode
        • Line Width
        • Point Size
        • Billboard Mode
        • Billboard Keep Scale
        • Grow
        • Use Alpha Scissor
      • Material colors, maps and channels
        • Albedo
        • Metallic
        • Roughness
        • Emission
        • Normalmap
        • Rim
        • Clearcoat
        • Anisotropy
        • Ambient Occlusion
        • Tiefe
        • Subsurface Scattering
        • Transmission
        • Refraction
        • Detail
        • UV1 and UV2
        • Triplanar Mapping
      • Proximity and distance fade
      • Render priority
    • Lights and shadows
      • Einführung
      • Light nodes
        • Shadow mapping
        • Directional shadow mapping
        • Omni shadow mapping
        • Spot shadow mapping
    • Reflection probes
      • Einführung
      • Einrichtung
      • Interior vs exterior
      • Blending
      • Reflection atlas
    • GI Probes
      • Einführung
      • Einrichtung
      • Lichter hinzufügen
      • Reflections
      • Interior vs exterior
      • Tweaking
      • Quality
    • Baked lightmaps
      • Einführung
      • Visueller Vergleich
      • Einrichtung
        • Unwrap from your 3D DCC
        • Unwrap from within Godot
        • Unwrap on scene import
        • Checking UV2
      • Die Szene einrichten
        • Configure bounds
        • Setting up meshes
        • Setting up lights
        • Baking quality
      • Baking
        • Backen konfigurieren
      • Dynamische Objekte
    • Environment und Post-Processing
      • Umgebung
        • Camera node
        • WorldEnvironment-Node
        • Standard Umgebung
      • Environment-Einstellungen
        • Hintergrund
        • Ambient Light
        • Fog
        • Tonemap
        • Auto Exposure (HDR)
      • Mid- und Post-Processing-Effekte
        • 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
      • Einführung
      • 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
      • Einführung
      • Beispielprojekt
      • Creating a MeshLibrary
      • Collisions
      • Materials
      • Exporting the MeshLibrary
      • Using GridMap
      • Using GridMap in code
    • Using MultiMeshInstance
      • Einführung
      • Setting up the nodes
      • MultiMesh-Einstellungen
        • Target Surface
        • Source Mesh
        • Mesh Up Axis
        • Random Rotation
        • Random Tilt
        • Random Scale
        • Scale
        • Amount
    • CSG
      • Einführung in CSG nodes
        • CSG tools features
        • CSGPolygon
        • Benutzerdefinierte Meshes
        • CSGCombiner
        • Ablaufsteuerung
      • Prototyping a level
    • FPS tutorial
      • Teil 1
        • Einführung
        • Teilübersicht
        • Getting everything ready
        • Making the FPS movement logic
        • Giving the player a flash light and the option to sprint
        • Final notes
      • Part 2
        • Teilübersicht
        • 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
        • Final notes
      • Part 3
        • Teilübersicht
        • Changing levels
        • Adding ammo
        • Adding reloading to the weapons
        • Adding reloading to the player
        • Adding sounds
        • Final notes
      • Part 4
        • Teilübersicht
        • Adding joypad input
        • Adding mouse scroll wheel input
        • Adding the health pickups
        • Adding the ammo pickups
        • Adding breakable targets
        • Final notes
      • Part 5
        • Teilübersicht
        • Hinzufügen von Granaten
        • Adding grenades to the player
        • Adding the ability to grab and throw RigidBody nodes to the player
        • Adding a turret
        • Final notes
      • Part 6
        • Teilübersicht
        • Adding the main menu
        • Making the Globals singleton
        • Adding the debug menu
        • Adding a pause menu
        • Starting the respawn system
        • Finishing the respawn system
        • Writing a sound system we can use anywhere
        • Final notes
    • Animating thousands of objects
      • Animating thousands of fish with MultiMeshInstance
        • Einen Fisch animieren
        • Making a school of fish
        • Animating a school of fish
      • Controlling thousands of fish with Particles
  • Audio
    • Audiobusse
      • Einführung
      • Decibel scale
      • Audiobusse
      • Playback of audio through a bus
      • Effekte hinzufügen
        • Amplify
        • BandLimit and BandPass
        • Chorus
        • Compressor
        • Delay
        • Distortion
        • EQ
        • EQ6, EQ10, EQ21
        • Filter
        • HighPassFilter, HighShelfFilter
        • Limiter
        • LowPassFilter, LowShelfFilter
        • NotchFilter
        • Panner
        • Phaser
        • PitchShift
        • Record
        • Reverb
        • SpectrumAnalyzer
        • StereoEnhance
      • Automatic bus disabling
      • Bus rearrangement
      • Default bus layout
    • Audio streams
      • Einführung
      • AudioStream
      • AudioStreamPlayer
      • AudioStreamPlayer2D
      • AudioStreamPlayer3D
        • Reverb buses
        • Doppler
    • Sync the gameplay with audio and music
      • Einführung
      • Using the system clock to sync
      • Using the sound hardware clock to sync
    • Recording with microphone
      • The structure of the demo
  • Physik
    • Physics introduction
      • Kollisionsobjekte
        • Collision Shapes
        • Physics process callback
        • Kollisionsebenen und -masken
      • Area2D
      • StaticBody2D
      • RigidBody2D
        • Rigid body modes
        • Using RigidBody2D
        • Contact reporting
      • KinematicBody2D
        • Kinematic collision response
    • RigidBody
      • What is a rigid body?
      • How to control a rigid body
      • The „look at“ method
    • Using Area2D
      • Einführung
      • What is an area?
      • Area properties
      • Overlap detection
      • Area influence
        • Point gravity
        • Beispiele
    • Using KinematicBody2D
      • Einführung
      • What is a kinematic body?
      • Bewegung und Kollisionen
        • move_and_collide
        • move_and_slide
        • move_and_slide_with_snap
      • Which movement method to use?
      • Beispiele
        • Movement and walls
        • Bouncing/reflecting
        • Platformer movement
    • Ray-casting
      • Einführung
      • Space
      • Accessing space
      • Raycast query
      • Collision exceptions
      • Collision Mask
      • 3D ray casting from screen
    • Ragdoll system
      • Einführung
      • Ragdoll einrichten
        • Rig erstellen
        • Rig optimieren
        • Anpassen der Kollisionsform (Collision Shape)
        • Joints adjustment
      • Simulating the ragdoll
        • Collision layer and mask
    • Kinematic character (2D)
      • Einführung
      • Physics process
      • Eine Szene einrichten
      • Den kinematischen Charakter bewegen
    • SoftBody
      • Grundlegende Einrichtung
      • Cloak simulation
  • Mathematik
    • Vector math
      • Einführung
      • Coordinate systems (2D)
      • Vector operations
        • Member access
        • Adding vectors
        • Scalar multiplication
      • Practical applications
        • Movement
        • Pointing toward a target
      • Unit vectors
        • Normalization
        • Reflection
      • Dot product
        • Facing
      • Cross product
        • Normalen ermitteln
        • Auf ein Ziel richten
      • Mehr Informationen
    • Advanced vector math
      • Flächen
        • Abstand zur Fläche
        • Away from the origin
        • Constructing a plane in 2D
        • Some examples of planes
      • Collision detection in 3D
    • Matrices and transforms
      • Einführung
        • 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)
    • Interpolation
      • Vektorinterpolation
      • Interpolation transformieren
      • Glatte Bewegung
    • Beziers, curves and paths
      • Quadratic Bezier
      • Cubic Bezier
      • Füge Kontrollpunkte hinzu
      • Curve2D, Curve3D, Path and Path2D
      • Evaluating
      • Drawing
      • Traversal
  • Animation
    • Einführung in die 2D-Animation
      • Übersicht
      • Einen AnimationPlayer-Node anlegen
      • Computer animation relies on keyframes
      • Tutorial: Creating a simple animation
        • Eine Szene einrichten
        • Adding a track
        • The second keyframe
        • Run the animation
        • Back and forth
        • Track settings
      • Keyframes for other properties
      • Edit keyframes
      • Advanced: Call Method tracks
    • Cutout animation
      • What is it?
      • Cutout animation in Godot
      • Making of GBot
      • Setting up the rig
      • Adjusting the pivot
      • RemoteTransform2D node
      • Completing the skeleton
      • Skeletons
      • IK chains
      • Animationsoptionen
        • Setting keyframes and excluding properties
      • Erstellen einer Schlafpose
      • Modifying rotation only
      • Keyframing IK chains
      • Visually move a sprite behind its parent
      • Setting easing curves for multiple keys
      • 2D Skeletal deform
    • 2D-Skelette
      • Einführung
      • Setup
      • Polygone erstellen
      • Skelett erstellen
      • Polygone deformieren
      • Internal vertices
    • AnimationTree
      • Einführung
      • Einen AnimationTree erstellen
      • Erstellen eines Baums
      • Blend tree
        • Blend2 / Blend3
        • OneShot
        • Seek
        • Zeitskalierung
        • Übergang
        • BlendSpace2D
        • BlendSpace1D
        • StateMachine
      • Wurzelbewegung
      • Controlling from code
      • State machine travel
  • Eingaben
    • InputEvent
      • What is it?
      • How does it work?
      • Anatomy of an InputEvent
      • Actions
      • InputMap
    • Input-Beispiele
      • Einführung
      • Events versus polling
      • Eingabe-Events
      • InputMap
        • Aktionen aufnehmen
      • Tastaturereignisse
        • Tastatur-Platzhalter-Modifikatoren
      • Mauseingabe-Events
        • Mouse buttons
        • Mausbewegung
      • Berühr-Eingabe-Events
    • Mouse and input coordinates
      • Über
      • Hardware display coordinates
      • Viewport display coordinates
    • Customizing mouse cursor
      • Using project settings
      • Using a script
      • Demo project
      • Cursor list
  • I/O
    • Background loading
      • ResourceInteractiveLoader
      • Nutzung
        • Obtaining a ResourceInteractiveLoader
        • Polling
        • Load progress (optional)
        • Forcing completion (optional)
        • Obtaining the resource
      • Example
      • Using multiple threads
        • Use a semaphore
        • Not blocking main thread during the polling
      • Example class
        • Example:
    • Data paths
      • Path separators
      • Resource path
      • User path (persistent data)
      • Editor data paths
        • Self-contained mode
    • Saving games
      • Einführung
      • Identify persistent objects
      • Serializing
      • Saving and reading data
      • Some notes
    • Encrypting save games
      • Why?
      • How?
  • Internationalisierung
    • Internationalizing games
      • Einführung
      • Configuring the imported translation
      • Localizing resources
      • Converting keys to text
      • Making controls resizable
      • TranslationServer
      • Command line
      • Translating the project name
    • 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
    • Locales
  • GUI
    • GUI skinning
      • Oh, beautiful GUI!
      • Motiv
      • 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
      • Eingang
        • Eingabe-Events
        • Benachrichtigungen
    • Size and anchors
      • Erstellen eines Control-Baums, der zentriert ist
    • Containers
      • Container layout
      • Size flags (Größeneinstellungen)
      • Kontainer-Shader-Typen
        • Box Containers
        • Grid Container
        • Margin Container
        • Tab Container
        • Split Container
        • PanelContainer
        • ScrollContainer
        • Viewport-Kontainer
      • Angepasste Container erstellen
    • BBCode in RichTextLabel
      • Einführung
      • Using BBCode
      • Reference
        • Built-in color names
        • Hexadecimal color codes
        • Image vertical offset
      • Animation effects
        • Wave
        • Tornado
        • Shake
        • Fade
        • Rainbow
      • Custom BBCode tags and text effects
        • _process_custom_fx
        • Ghost
        • Pulse
        • Matrix
  • Ansichtsfenster
    • Ansichtsfenster
      • Einführung
      • Eingang
      • Listener
      • Cameras (2D & 3D)
      • Scale & stretching
      • Worlds
      • Aufnahme
      • Viewport Container
      • Rendering
      • Render target
    • Multiple resolutions
      • The problem of multiple resolutions
      • One size fits all
      • Base size
      • Resizing
      • Stretch settings
        • Stretch Mode
        • Stretch Aspect
        • Stretch Shrink
        • From scripts
        • Reducing aliasing on downsampling
        • Mit einem Signal (Seitenverhältnis) umgehen
        • Field of view scaling
    • Using a Viewport as a texture
      • Einführung
      • Setting up the Viewport
      • Applying the texture
      • Making the planet texture
      • Dem Planeten Farbe verleihen
      • Making an ocean
    • Benutzerdefiniertes Post-Processing
      • Einführung
      • Single pass Post-Processing
      • Multi-pass Post-Processing
  • Shading
    • Shading reference
      • Shaders
        • Einführung
        • Shader-Typen
        • Render-Modi
        • Prozessor-Ablaufsteuerungsfunktionen
      • Shading language
        • Einführung
        • Data types
        • Arrays
        • Konstanten
        • Structs
        • Operatoren
        • Flow control
        • Discarding
        • Funktionen
        • Standardfunktionen
      • Spatial shaders
        • Render-Modi
        • eingebaute Eckpunkt-Typen
        • eingebaute Fragmente-Typen
        • Einfache eingebaute Typen (Licht)
      • CanvasItem shaders
        • Render-Modi
        • eingebaute Eckpunkt-Typen
        • eingebaute Fragmente-Typen
        • Einfache eingebaute Typen (Licht)
      • Partikel-Shader
        • Render-Modi
        • eingebaute Eckpunkt-Typen
    • Dein erstes Shader-Spiel
      • Was sind Shader?
        • Einführung
        • But what are they?
        • Struktur eines Shaders
        • Teilübersicht
      • Ihr erster CanvasItem-Shader
        • Einführung
        • Setup
        • Ihr erster CanvasItem-Shader
        • Ihre erste Fragmentfunktion
        • Your first vertex function
        • Fazit
      • Ihr erster Spatial-Shader
        • Where to assign my material
        • Einrichtung
        • Shader magic
        • Noise heightmap
        • Uniforms
        • Interacting with light
      • Your first Spatial shader: part 2
        • Your first spatial fragment function
        • Animating with TIME
        • Advanced effects: waves
    • Shader materials
      • Einführung
      • 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
      • Schau die Anleitungen an
      • Download the source code
    • Screen-reading shaders
      • Einführung
      • SCREEN_TEXTURE built-in texture
      • SCREEN_TEXTURE example
      • Behind the scenes
      • Back-buffer logic
      • DEPTH_TEXTURE
    • Migrating to Godot’s shading language
      • Einführung
      • GLSL
        • Shader programs
        • Vertex-Attribute
        • gl_Position (OpenGL)
        • Varyings
        • Main
        • Konstanten
        • Macros
        • Variablen
        • Coordinates
        • Precision
      • Shadertoy
        • Typen
        • mainImage
        • Variablen
        • Coordinates
      • The Book of Shaders
        • Typen
        • Main
        • Variablen
        • Coordinates
    • Fortgeschrittenes Post-Processing
      • Einführung
      • Full screen quad
      • Tiefentextur
      • Eine Optimierung
  • Networking
    • High level multiplayer
      • High level vs low level API
      • Mid level abstraction
      • Initializing the network
      • Managing connections
      • RPC
      • Back to lobby
      • Starting the game
        • Player scenes
        • Synchronizing game start
      • Synchronizing the game
        • Network master
        • Master- und Marionettenschlüsselwörter
    • Making HTTP requests
      • Preparing scene
      • Scripting
      • Sending data to server
    • HTTP client class
    • SSL certificates
      • Einführung
      • Approach 1: self signed cert
      • Approach 2: CA cert
    • 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
  • Nutzerinhaltesammlung
    • About the Asset Library
      • Types of assets
      • Häufig gestellte Fragen
        • Can paid assets be uploaded to the asset library?
    • Using the AssetLib
      • On the website
        • Übersicht
        • Searching
        • Breakdown of an asset
        • Registering and logging in
      • In the editor
    • Submitting to the Asset Library
      • Einführung
      • Submission guidelines
        • Requirements
        • 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
        • Einführung
        • Getting everything ready
        • VR-Schnittstelle anlegen
        • Creating the controllers
        • Creating a base class for interactable VR objects
        • Reducing motion sickness
        • Final notes
      • VR starter tutorial part 2
        • Einführung
        • Adding destroyable targets
        • Adding a pistol
        • Adding a shotgun
        • Eine Bombe hinzufügen
        • Ein Schwert hinzufügen
        • Ziel-UI aktualisieren
        • Adding the final special RigidBody
        • Final notes
  • Erweiterungen
    • Editor plugins
      • Installing plugins
        • Finding plugins
        • Installing a plugin
        • Enabling a plugin
      • Making plugins
        • Erweiterungen
        • Creating a plugin
        • A custom node
        • Going beyond
      • Eine einfache Erweiterung erstellen (Hauptbildschirm)
        • Was dieses Tutorial abdeckt
        • Initializing the plugin
        • Szenen
        • Hauptbildschirms-Szene
        • Tabbed panel scene
        • Connecting the two scenes in the plugin script
        • Try the plugin
      • Import plugins
        • Einführung
        • Configuration
        • The EditorImportPlugin class
        • Options and presets
        • The import method
        • Platform variants and generated files
        • Trying the plugin
      • Räumliche Gizmo-Plugins
        • Einführung
        • The EditorSpatialGizmoPlugin
        • Einfacher Ansatz
        • Alternative approach
      • Inspector plugins
        • Setup
        • EditorInspectorPlugin
        • EditorProperty
      • Visual Shader plugins
    • GDNative
      • GDNative C example
        • Einführung
        • Prerequisites
        • Our C source
        • Kompilieren
        • Creating the GDNativeLibrary (.gdnlib) file
        • Creating the NativeScript (.gdns) file
      • GDNative C++ example
        • Einführung
        • Projekt einrichten
        • Building the C++ bindings
        • Eine einfache Erweiterung erstellen
        • Compiling the plugin
        • Using the GDNative module
        • Eigenschaften hinzufügen
        • Signale
        • NativeScript 1.1 vs NativeScript 1.0
        • Next steps
    • Android Erweiterungen
      • Creating Android plugins (Godot 4.0+)
        • Einführung
        • Android Erweiterung
        • Troubleshooting
  • Plattformspezifisches
    • Android in-app purchases
      • Getting the product details
      • Check if user purchased an item
      • Simple Purchase
      • Consumables and Non-Consumables
      • Testphase
    • Services for 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
    • Customizing the Web export HTML page
      • Placeholder substitution
      • The Engine object
      • Starting an Engine instance
      • Configuring start-up behaviour
      • Customizing the presentation
      • Accessing the Emscripten Module
    • Konsolenunterstützung unter Godot
      • Official support
      • Third-party support
  • Multi-Threading
    • Using multiple threads
      • Threads
      • Erstellen eines Threads
      • Mutexes
      • Semaphores
    • Thread safe APIs
      • Threads
      • Global scope
      • Scene tree
      • GDScript Arrays, Dictionaries
      • Ressourcen
  • Inhalte erstellen
    • Procedural geometry
      • Using the ArrayMesh
        • Kettenskulptur
        • 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
      • Werkzeuge
        • Kettenskulptur
        • MeshDataTool
        • SurfaceTool
        • GenerierteGeometrie
      • Which one should I use?
    • Bäume erstellen
      • Beginne mit einem Baum
      • Malen mit Vertex-Farben
      • Schreibe einen eigenen Shader für das Laub
      • Shader verbessern
  • Optimierungen
    • Optimization using Servers
      • Servers
      • RIDs
      • Erstellen eines Bildes
      • Instantiating a Mesh into 3D space
      • Creating a 2D RigidBody and moving a sprite with it
      • Daten bekommen von den Servern
    • Optimization using MultiMeshes
      • Mehrere-Skulpturen
      • Ein Beispiel von Multimeshes
  • Verschiedenes
    • Fixing jitter and stutter
      • What are jitter and stutter?
      • Distinguishing between them
      • Jitter
      • Stutter
        • Windows
        • Linux (X11)
        • Mac OS
        • Android
        • iOS
      • Reporting stutter or jitter problems
    • Handling quit requests
      • Quitting
      • Handling the notification
    • Pausing games
      • Pause?
      • How pausing works
      • White-listing nodes
      • Example
    • Binary serialization API
      • Einführung
      • 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
    • Running code in the editor
      • What is tool?
      • How to use it
      • Probier es aus
    • Change scenes manually
    • Differences between GLES2 and GLES3
      • Partikel
      • SCREEN_TEXTURE mip-maps
      • DEPTH_TEXTURE
      • Farbraum
      • HDRI
      • SpatialMaterial features
      • Eigenschaften von Umgebungsvariablen
      • GIProbes
      • Contact shadows
      • Light performance
      • Texture compression
      • Übergangsformen
      • Shading language
        • textureSize() workaround
      • Built in variables and render modes
    • Szenen in­s­tan­ti­ie­ren
      • Beispiel für Geschosse
    • State design pattern
      • Einführung
      • Script setup
      • Projektkonfiguration
  • Debuggen
    • Overview of debugging tools
      • Debug menu options
        • Mit Fern-Fehlerbehebung starten
        • Kleine Programmdatei über ein Netzwerkdateisystem
        • Collision-Shapes sichtbar
        • Navigation sichtbar
        • Szenenänderungen synchronisieren
        • Skriptänderungen synchronisieren
      • Script editor debug tools and options
      • Debug project settings
        • Settings
        • GDScript
        • Shapes
      • Debugging tools
        • Debugger
        • Fehler
        • Profiler
        • Netzwerk-Profiler
        • Monitore
        • Video Memory
        • Verschiedenes
      • Remote in scene dock
  • Rechtliches
    • Complying with Licenses
      • What are licenses?
      • Requirements
      • Fazit
        • Credits screen
        • Lizenzbildschirm
        • Output log
        • Accompanying file
        • Printed manual
      • Third Party licenses
        • FreeType-Schriften
        • ENet
        • MBedTLS

Entwicklung

  • Kompilieren
    • Getting the source
      • Downloading the Godot source code
    • Introduction to the buildsystem
      • SCons
      • Setup
      • Platform selection
      • Resulting binary
      • Werkzeuge
      • Ziel
      • Bits
      • Other build options
      • Exportvorlagen
    • Compiling for Windows
      • Requirements
      • Setting up SCons
      • Installing Visual Studio caveats
      • Downloading Godot’s source
      • Kompilieren
        • 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)
      • Requirements
        • Distro-specific one-liners
      • Kompilieren
      • Building export templates
      • Using Clang and LLD for faster development
    • Compiling for macOS
      • Requirements
      • Kompilieren
      • Cross-compiling for macOS from Linux
    • Compiling for Android
      • Note
      • Requirements
      • 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
      • Requirements
      • Kompilieren
      • Ausführen
    • Cross-compiling for iOS on Linux
      • Disclaimer
      • Requirements
      • Configuring the environment
        • darling-dmg
        • Preparing the SDK
        • Toolchain
      • Compiling Godot for iPhone
        • Producing fat binaries
    • Compiling for Universal Windows Platform
      • Requirements
      • Kompilieren
      • Creating UWP export templates
      • Running UWP apps with Visual Studio
    • Compiling for the Web
      • Requirements
      • Building export templates
      • Building per asm.js translation or LLVM backend
    • Compiling with Mono
      • Requirements
      • Umgebungsvariablen
      • Enable the Mono module
      • Generate the glue
        • Notes
      • Rebuild with Mono glue
      • Beispiele
        • Beispiel (Windows)
        • Beispiel (X11)
      • Data directory
        • Exportvorlagen
        • Editor
      • Targeting Android
      • Kommandozeilenoptionen
    • Optimizing a build for size
      • Rationale
      • 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
      • Schritt für Schritt
      • Possible Errors
  • Engine-Entwicklung
    • Einführung in Godot Entwicklung
      • Architekturdiagramm
      • Debuggen des Editor mit gdb
    • IDE konfigurieren
      • QT Creator
        • Projekt importieren
        • Build and run
        • Updating sources after pulling latest commits
        • Code style configuration
      • K-Develop
      • Xcode
        • Projektkonfiguration
        • Schema-Setup
      • Visual Studio Code
      • Android Studio
        • Projektkonfiguration
      • CLion
    • Core types
      • Definitions
        • References:
      • Memory model
      • Allocating memory
        • References:
      • Containers
        • References:
      • String
        • References:
      • StringName
        • References:
      • Math types
        • References:
      • NodePath
        • References:
      • RID
        • References:
    • Variant class
      • Über
        • References:
      • Containers: Dictionary and Array
        • References:
    • Object class
      • General definition
        • References:
      • Registering an Object
        • References:
      • Konstanten
      • Properties (set/get)
      • Binding properties using _set/_get/_get_property_list
      • Dynamic casting
      • Signale
      • References
        • References:
      • Ressourcen:
        • 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
    • Benutzerdefinierte Ressourcenformat -Lader
      • Einführung
        • References
      • What for?
      • What not?
        • References
      • Creating a ResourceFormatLoader
      • Creating a ResourceFormatSaver
      • Creating custom data types
        • Considerations
        • References
      • Registrierung des neuen Dateiformats
        • References
      • Loading it on GDScript
    • Custom AudioStreams
      • Einführung
        • References:
      • What for?
      • Create an AudioStream
        • References:
      • Create an AudioStreamPlayback
        • Resampling
        • References:
    • Benutzerdefinierte Godot Server
      • Einführung
        • References
      • What for?
      • Erstellen eines Godot Servers
      • Custom managed resource data
        • References
      • Registrierung der Klasse in GDScript
        • Bind methods
      • MessageQueue
        • References:
      • Summing it up
        • Notes
  • Editor development
    • Einführung
    • Editor icons
      • Creating icons
      • Icon optimization
      • Integrating and sharing the icons
      • Troubleshooting
      • References:
  • Godot file formats
    • TSCN file format
      • Dateistruktur
        • Entries inside the file
      • The scene tree
        • NodePath
        • Skelett
        • BoneAttachment
        • Animationsspieler
      • Ressourcen
        • External resources
        • Internal resources
        • Kettenskulptur
        • Animation

Community

  • Mach mit!
    • Ways to contribute
      • Contributing code
      • Testing and reporting issues
        • Testing development versions
        • Filing an issue on GitHub
      • Contributing to the documentation
    • Best practices for engine contributors
      • Einführung
      • Sprache
      • 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
        • Meilensteine
    • Richtlinien Dokumentation
      • How to contribute
      • The ‚Edit on GitHub‘ link
      • Was macht eine gute Dokumentation aus?
      • Überschriften
      • Übersetzen vorhandener Seiten
      • Lizenz
    • Richtlinien Dokumentation schreiben
      • 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
      • Image contribution guidelines
    • Contribute to the Class Reference
      • How to contribute
      • Get started with GitHub
        • Fork Godot
        • How to keep your local clone up-to-date
        • Updating the documentation template
        • Push and request a pull of your changes
      • How to edit class XML
        • How to write the class reference
        • Improve formatting with BBcode style tags
        • I don’t know what this method does!
        • Lokalisierung
  • Gemeinschaftskanäle
    • Fragen & Antworten
    • IRC auf Freenode
    • Andere Chats
    • Language-based communities
    • Soziale Netzwerke
    • Forum
  • Tutorials und Ressourcen
    • Where to start
    • Videotutorials
    • Text-Anleitungen
    • Devlogs
    • Ressourcen
Godot Engine
  • Docs »
  • Scripting »
  • C#
  • View page source

C#¶

  • Einführung
  • Funktionen
  • API differences to GDScript
  • C# Style Guide
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.