demo version: Godot 4.4 rc-3 .NETThis tool allow you Import PMX model. And import vmd animation to animate camera and model. This plugin depends on BulletSharpPInvoke.You can get libbullectc.dll from BulletSharpPInvoke's demo. Copy it to project directory. The link is below.https://github.com/AndresTraks/BulletSharpPInvoke/releasesTo compile BulletSharpPInvoke, you can check out my fork.https://github.com/sselecirPyM/BulletSharpPInvokeVideo Tutorial (Chinese):https://www.bilibili.com/video/BV1pKY3e5EHn/
Juego de aviones (Plane game demo)Este es el primer proyecto que les enseño a mis alumnos de creación de videojuegos con Godot.Es un Juego / Template que tiene un menú de selección de nivel, y un nivel en el que podés luchar contra 3 tipos de enemigos distintos.Ideal para estudiar el código y aprender conceptos básicos de godotmás info sobre los cursos en gamedevargentina.comEng:Plane game demoThis is the first project I teach my students in game development with Godot.It is a Game / Template that has a level selection menu, and a level in which you can fight against 3 different types of enemies.Ideal for studying the code and learning basic concepts of Godotmore info about the courses at gamedevargentina.com
*ATTENTION!!*This is very old build of my game and I plan to remove it sooner or later. The latest version can be found on Gamejolt.A rough remake of the first FNAF entry in the Godot Engine.It is recommended that you use v4.2.1 stable official version of Godot.
a basic 5x5 lights out puzzle demo,all assets and shaders are custom made and free to use under CC0
A blazing-quick user-oriented MetaMask login system for Godot multiplayer games. This login system has been designed first and foremost for Desktop Windows applications that would require a MetaMask / Public ETH address as a logging method option for a server-controlled multiplayer environment.
Simple demo project for an enemy AI that moves when not seen by the player.
This is a simple multiplayer demo that has a client and separate server running in the same project. The client is the authority for player movement, while the server handles visibility between peers. This has been a headache to wrap my head around so hopefully it helps someone else struggling out there.
This is a small platform shooter demo with menus, stats, huds, basic enemy and sounds, feel free to use how you see it fits.
Demo project for the Antialiased Line2D add-on. The add-on's code is included in this asset.Find the Antialiased Line2D add-on at: https://godotengine.org/asset-library/asset/3103
This demo shows how to load levels from txt files for tilemaps, though the same ideas could be applied to non tilemap levels.Goes with my tutorial video here: https://youtu.be/MJGahJywGi0
This project shows how to create custom BBCode Tags for RichTextLabelsGoes with my tutorial video here: https://youtu.be/8CZfqdUd3bM
This demo shows how to make an enemy follow the player using NavigationRegion2D.Goes with my tutorial video here (and linked below): https://youtu.be/Ykz7W9BHzPg
This demo shows how to rotate tilemap tiles using code.Goes with my tutorial here: https://youtu.be/WtiLCtOVC54View all my assets here: https://godotengine.org/asset-library/asset?user=ThinkWithGames
A rough remake of the first FNAF entry in the Godot Engine.It is recommended that you use v4.2.1 stable official version of Godot.
This demo shows how to make a simple multiplayer online drawing app where players can both draw on a tilemap.Video link here and below: https://youtu.be/lIZ3qOo6OfU
A tool for testing joypad input and generating controller mapping strings.See documentation: https://docs.godotengine.org/en/latest/tutorials/inputs/controllers_gamepads_joysticks.htmlLanguage: GDScriptRenderer: Compatibility
This is a demo for an OpenXR project where player movement is handled with a XRorigin3D as a base node.This is based on the Origin centric solution as explained in the room scale manual page: https://docs.godotengine.org/en/stable/tutorials/xr/xr_room_scale.html#origin-centric-solutionHow it works:With modern VR equipment the user is able to move around a large playspace.This is often refered to as roomscale VR.The position of the headset and controllers are tracked in reference to a fixed point within this playspace.This is often a point on the ground at the center of the playspace mapped out by the user when setting up their guardian.In Godot the center of this playspace is represented by the `XROrigin3D` node with camera and controllers being tracked through resp. `XRCamera3D` and `XRController3D` child nodes which can thus not be positioned by the user.The misunderstandings this causes in handling player movement is described in detail in the XR room scale manual page, a highly recommended read before continuing with this demo: https://docs.godotengine.org/en/stable/tutorials/xr/xr_room_scale.htmlThis demo implements the origin body centric solution to the player movement problem.This is an older approach to setting up movement in XR which keeps the origin point more clearly mapped in the virtual world.With this setup it is easier to see how elements are tracked and how the body is moving within the tracked environment.However moving the player through controller input requires a lot more math as we need to move the origin point to drive player movement.Action map:This project does not use the default action map but instead configures an action map that just contains the actions required for this example to work. This so we remove any clutter and just focus on the functionality being demonstrated.There are only two actions needed for this example:- aim_pose is used to position the XR controllers- move is used as the input for our movement"Move" being the hero here. This action is only bound to one of the two controllers, by default making it a right hand option. Godot will always associate the move action with the controller that is bound to it.The code example assumes either controller could trigger the move action. Switching from right to left hand is a separate topic out of scope of this demonstration.Also following OpenXR guidelines only bindings for controllers with which the project has been tested are supplied. XR Runtimes should provide proper re-mapping however not all follow this guideline. You may need to add a binding for the platform you are using to the action map.Running on PCVR:This project can be run as normal for PCVR. Ensure that an OpenXR runtime has been installed.This project has been tested with the Oculus client and SteamVR OpenXR runtimes.Note that Godot currently can't run using the WMR OpenXR runtime. Install SteamVR with WMR support.Running on standalone VR:You must install the Android build templates and OpenXR loader plugin and configure an export template for your device.Please follow the instructions for deploying on Android in the manual: https://docs.godotengine.org/en/stable/tutorials/xr/deploying_to_android.htmlLanguage: GDScriptRenderer: Compatibility
This is a demo for an OpenXR project where player movement is handled with a CharacterBody3D as a base node.This is based on the Character body centric solution as explained in the room scale manual page: https://docs.godotengine.org/en/stable/tutorials/xr/xr_room_scale.html#character-body-centric-solutionHow it works:With modern VR equipment the user is able to move around a large playspace.This is often refered to as roomscale VR.The position of the headset and controllers are tracked in reference to a fixed point within this playspace.This is often a point on the ground at the center of the playspace mapped out by the user when setting up their guardian.In Godot the center of this playspace is represented by the `XROrigin3D` node with camera and controllers being tracked through resp. `XRCamera3D` and `XRController3D` child nodes which can thus not be positioned by the user.The misunderstandings this causes in handling player movement is described in detail in the XR room scale manual page, a highly recommended read before continuing with this demo: https://docs.godotengine.org/en/stable/tutorials/xr/xr_room_scale.htmlThis demo implements the character body centric solution to the player movement problem.Virtual movement by the player (e.g. movement through controller input) in this demo is handled similarly to a non-XR Godot game.Physical movement by the player will result in the character body attempting to move to the players new location.If successful the XROrigin node is moved in the opposite direction of the players movement.If unsuccessful the character body stays behind, the further the player moves the more we black out the screen.Action map:This project does not use the default action map but instead configures an action map that just contains the actions required for this example to work. This so we remove any clutter and just focus on the functionality being demonstrated.There are only two actions needed for this example:- aim_pose is used to position the XR controllers- move is used as the input for our movement"Move" being the hero here. This action is only bound to one of the two controllers, by default making it a right hand option. Godot will always associate the move action with the controller that is bound to it.The code example assumes either controller could trigger the move action. Switching from right to left hand is a separate topic out of scope of this demonstration.Also following OpenXR guidelines only bindings for controllers with which the project has been tested are supplied. XR Runtimes should provide proper re-mapping however not all follow this guideline. You may need to add a binding for the platform you are using to the action map.Running on PCVR:This project can be run as normal for PCVR. Ensure that an OpenXR runtime has been installed.This project has been tested with the Oculus client and SteamVR OpenXR runtimes.Note that Godot currently can't run using the WMR OpenXR runtime. Install SteamVR with WMR support.Running on standalone VR:You must install the Android build templates and OpenXR loader plugin and configure an export template for your device.Please follow the instructions for deploying on Android in the manual: https://docs.godotengine.org/en/stable/tutorials/xr/deploying_to_android.htmlLanguage: GDScriptRenderer: Compatibility
An example showing how to take screenshots of the screen.Language: GDScriptRenderer: Compatibility
A demo showing a GUI instanced within a 3D scene using viewports, as well as forwarding mouse and keyboard input to the GUI.Language: GDScriptRenderer: Compatibility
This sample project showcases an implementation of dynamic split screen, also called Voronoi split screen.Details:A dynamic split screen system displays a single screen when the two players are close but a splitted view when they move apart.The splitting line can take any angle depending on the players' position, so it won't be either vertical or horizontal.This system was popularized by the LEGO videogames.How it works:Two cameras are placed inside two separate viewports and their texture, as well as some other parameters, are passed to a shader attached to a TextureRect filling the whole screen.The `SplitScreen` shader, with the help of the `CameraController` script, chooses wich texture to display on each pixel to achieve the effect.The cameras are placed on the segment joining the two players, either in the middle if they're close enough or at a fixed distance otherwise.How to use it:Open and launch the project inside the Godot engine, then use WASD to move the first player (in red) and IJKL (or arrow keys) to move the second player (in blue).The `camera_controller.gd` script sets parameters to tune the distance at which the screen splits and also the width and color of the splitting line.Language: Godot shader language and GDScriptRenderer: Compatibility
This demo shows how to downscale the 3D resolution without affecting 2D elements, to improve performance without making the UI blurry.See documentation for details: https://docs.godotengine.org/en/stable/tutorials/3d/resolution_scaling.htmlLanguage: GDScriptRenderer: Forward+
A demo showing how a 3D scene can be shown within a 2D one using viewports.How it works:The 3D robot is rendered to a custom Viewport node rather than the main Viewport. In the code, `get_texture()` is called on the Viewport to get a ViewportTexture, which is then assigned to the sprite's texture.Language: GDScriptRenderer: Compatibility
A demo showing how a 2D scene can be shown within a 3D scene using viewports.How it works:The Pong game is rendered to a custom Viewport node rather than the main Viewport. In the code, `get_texture()` is called on the Viewport to get a ViewportTexture, which is then assigned to the quad's material's albedo texture.Language: GDScriptRenderer: Compatibility
This contains multiple plugin demos, all placed in a project for convenience.Due to GitHub issue #36713, you need to open the project to import the assets once, then close, then open: https://github.com/godotengine/godot/issues/36713See the documentation on editor plugins for more information: https://docs.godotengine.org/en/latest/tutorials/plugins/editor/index.htmlHow it works:This project contains 4 plugins:- The custom node plugin shows how to create a custom node type using `add_custom_type()`.- The material import plugin shows how to make a plugin handle importing a custom file type (`*.mtxt`). - The material creator plugin shows how to add a custom dock with some simple functionality. - The main screen plugin is a minimal example of how to create a plugin with a main screen.Check the `README.md` files included in each plugin's folder for more information.To use these plugins in another project, copy any of these folders to the `addons/` folder in a Godot project, and then enable them in the project settings menu.For example, the path would look like: `addons/custom_node/`Plugins can be distributed and installed from the UI. If you make a ZIP archive that contains the folder, Godot will recognize it as a plugin and will allow you to install it.This can be done via the terminal: `zip -r custom_node.zip custom_node/*`Language: GDScriptRenderer: Compatibility
This is a sample showing how to use WebSockets along with the Multiplayer API in Godot: https://docs.godotengine.org/en/stable/tutorials/networking/high_level_multiplayer.htmlLanguage: GDScriptRenderer: Compatibility
This is a minimal sample of connecting two peers to each other using WebSockets.Language: GDScriptRenderer: Compatibility
This is a demo of a simple chat implemented using WebSockets, showing both how to host a websocket server from Godot and how to connect to it.Language: GDScriptRenderer: Compatibility
A multiplayer implementation of the classic pong game. One of the players should press "Host", while the other should type in the host's IP address and press "Join".NOTE: The non-multiplayer version is available here: https://godotengine.org/asset-library/asset/2728Language: GDScriptRenderer: Compatibility
A multiplayer implementation of the classic bomberman game. One of the players should press "Host", while other player(s) should type in the host's IP address and press "Join".Language: GDScriptRenderer: Compatibility
A simple Pong game. This demo shows best practices for game development in Godot, including signals: https://docs.godotengine.org/en/latest/getting_started/step_by_step/signals.htmlHow it works:The walls, paddle, and ball are all Area2D nodes. When the ball touches the walls or the paddles, they emit signals and modify the ball.NOTE: There is a GDScript version available here: https://godotengine.org/asset-library/asset/2728Language: C#Renderer: Compatibility
A simple Pong game. This demo shows best practices for game development in Godot, including signals: https://docs.godotengine.org/en/latest/getting_started/step_by_step/signals.htmlHow it works:The walls, paddle, and ball are all Area2D nodes. When the ball touches the walls or the paddles, they emit signals and modify the ball.NOTE: There is a C# version available here: https://godotengine.org/asset-library/asset/2796Language: GDScriptRenderer: Compatibility
A demo showing the use of various sensors: an accelerometer, a gyroscope, and a magnetometer. These sensors are typically found on mobile devices, so don't expect this demo to work on a desktop PC.Language: GDScriptRenderer: Mobile
Simple debugger for multitouch input. Shows colored dots everywhere you press.Language: GDScriptRenderer: Compatibility
Demo of multitouch input and different gestures using the touch API. This demo is meant to be used with a touch-enabled device such as a phone or tablet.Language: GDScriptRenderer: Compatibility
This demo shows how to make in-app payments in Android.NOTE: Running the demo requires exporting and uploading the game to Google Play.Language: GDScriptRenderer: Compatibility
