This flavor of Godot 4.x engine is made to accommodate large open-world 3D games.
This fork is regularly synchronized with 4.x branch.
Available for Windows x86-64, Linux x86-32 and x86-64, Linux ARM32 and ARM64, Android ARM32 and ARM64.
Implemented tweaks:
- Far plane (z-far) upper limit is set to 9e18 meters and tweaked for precision.
- Large World Coordinates are used when compiling (double precision floats).
- Increased editor zoom out distance to galactic scale (depth buffer must be adjusted for such scales, see below).
- Increased editor zoom increment for faster zooming.
- Implemented tweaks to mobile rendering backend to fix possible precision-related issues.
- This 4.x fork build DOES NOT implement hard-coded logarithmic depth buffer. You can implement it in your project shaders (see below).
Suggested:
- Use logarithmic depth in your spatial shaders to achieve rendering at extreme distances without z-fighting. Keep in mind that this may break some depth-related effects and shadow-casting.
// Add this before your vertex shader.
// Edit "Fcoef" to adjust for desirable view distance. Lesser number means further distance limit.
uniform float Fcoef = 0.001;
varying float gl_Position_z;
// Add this to your vertex shader.
void vertex()
{
vec4 gl_Position = MODELVIEW_MATRIX*vec4(VERTEX, 1.0);
gl_Position_z = gl_Position.z;
}
//Add this to your fragment shader.
void fragment()
{
DEPTH = log2(max(1e-6, 1.0 -gl_Position_z)) * Fcoef;
}
- Use spatial shader material dithering for better de-banding on per-material basis when using Vulkan mobile renderer.
// Add this before your vertex shader.
// Edit "dither_darken" to adjust the brightness of dither pattern (optional).
uniform float dither_darken : hint_range(0.5, 1.0, 5e-4) = 0.75;
const float dither_x = 172.7;
const float dither_y = 232.6;
const float dither_r = 105.5;
const float dither_g = 99.0;
const float dither_b = 110.0;
vec3 interleaved_gradient_noise(vec2 frag_coord) {
vec3 dither = vec3(dot(vec2(dither_x, dither_y), frag_coord));
dither.rgb = fract(dither.rgb / vec3(dither_r, dither_g, dither_b));
return (dither.rgb - vec3(dither_darken)) / 255.0;
}
//Add this to your fragment shader.
void fragment()
{
vec2 frag_coord = FRAGCOORD.xy;
ALBEDO += interleaved_gradient_noise(frag_coord);
}
Binaries available for Linux, Windows and Android.
You can download binaries and templates (debug) at releases.
You can build it from source. Refer to rebuild_ scripts in root folder for convenience.
Reminder for cross-compiling for Windows:
To use posix mode for mingw by default:
$ sudo update-alternatives --config x86_64-w64-mingw32-gcc
<choose x86_64-w64-mingw32-gcc-posix from the list>
$ sudo update-alternatives --config x86_64-w64-mingw32-g++
<choose x86_64-w64-mingw32-g++-posix from the list>
Godot Engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so that users can focus on making games without having to reinvent the wheel. Games can be exported with one click to a number of platforms, including the major desktop platforms (Linux, macOS, Windows), mobile platforms (Android, iOS), as well as Web-based platforms and consoles.
Godot is completely free and open source under the very permissive MIT license. No strings attached, no royalties, nothing. The users' games are theirs, down to the last line of engine code. Godot's development is fully independent and community-driven, empowering users to help shape their engine to match their expectations. It is supported by the Godot Foundation not-for-profit.
Before being open sourced in February 2014, Godot had been developed by Juan Linietsky and Ariel Manzur (both still maintaining the project) for several years as an in-house engine, used to publish several work-for-hire titles.
Official binaries for the Godot editor and the export templates can be found on the Godot website.
See the official docs for compilation instructions for every supported platform.
Godot is not only an engine but an ever-growing community of users and engine developers. The main community channels are listed on the homepage.
The best way to get in touch with the core engine developers is to join the Godot Contributors Chat.
To get started contributing to the project, see the contributing guide. This document also includes guidelines for reporting bugs.
The official documentation is hosted on Read the Docs. It is maintained by the Godot community in its own GitHub repository.
The class reference is also accessible from the Godot editor.
We also maintain official demos in their own GitHub repository as well as a list of awesome Godot community resources.
There are also a number of other learning resources provided by the community, such as text and video tutorials, demos, etc. Consult the community channels for more information.
