godotengine/godot-docs
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs.git synced 2026-01-04 14:11:02 +03:00
Code Issues Packages Projects Releases Wiki Activity

Remove documentation specific to 3.2.4 (now 3.3, in its own branch)

Browse Source
This commit is contained in:
Rémi Verschelde
2021-03-19 14:18:14 +01:00
parent 9eba7649e1
commit e0e14e9435
9 changed files with 20 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
about/list_of_features.rst
View File

@@ -370,7 +370,6 @@ Import
- WAV with optional IMA-ADPCM compression.
- Ogg Vorbis.
- MP3 (only in Godot 3.2.4 and later).
- *3D scenes:*

5
about/troubleshooting.rst
View File

@@ -5,11 +5,6 @@ Troubleshooting
This page lists common issues encountered when using Godot and possible solutions.
.. seealso::
See :ref:`doc_using_the_web_editor` for caveats specific to the HTML5 version
of the Godot editor.
Everything I do in the editor or project manager appears delayed by one frame.
------------------------------------------------------------------------------

1
getting_started/editor/index.rst
View File

@@ -6,7 +6,6 @@ Editor manual
:maxdepth: 1
:name: toc-learn-editor
using_the_web_editor
command_line_tutorial
external_editor
default_key_mapping

121
getting_started/editor/using_the_web_editor.rst
View File

@@ -1,121 +0,0 @@
.. _doc_using_the_web_editor:
Using the Web editor
====================
Since Godot 3.2.4, there is a `Web editor <https://editor.godotengine.org/>`__
you can use to work on new or existing projects.
.. note::
The web editor is in a preliminary stage. While its feature set may be
sufficient for educational purposes, it is currently **not recommended for
production work**. See :ref:`doc_using_the_web_editor_limitations` below.
Browser support
---------------
The Web editor requires support for WebAssembly's SharedArrayBuffer. This
is in turn required to support threading in the browser. The following desktop
browsers support WebAssembly threading and can therefore run the web editor:
- Chrome 68 or later
- Firefox 79 or later
- Edge 79 or later
Opera and Safari are not supported yet. Safari may work in the future once
proper threading support is added.
**Mobile browsers are currently not supported.**
The web editor supports both the GLES3 and GLES2 renderers, although GLES2 is
recommended for better performance and compatibility with old/low-end hardware.
.. note::
If you use Linux, due to
`poor Firefox WebGL performance <https://bugzilla.mozilla.org/show_bug.cgi?id=1010527>`__,
it's recommended to use a Chromium-based browser instead of Firefox.
.. _doc_using_the_web_editor_limitations:
Limitations
-----------
Due to limitations on the Godot or Web platform side, the following features
are currently missing:
- No C#/Mono support.
- No GDNative support.
- No project exporting. As a workaround, you can download the project source
using **Project > Tools > Download Project Source** and export it using a
`native version of the Godot editor <https://godotengine.org/download>`__.
- The editor won't warn you when closing the tab with unsaved changes.
- No lightmap baking support. You can still use existing lightmaps if they were
baked with a native version of the Godot editor
(e.g. by importing an existing project).
The following features are unlikely to be supported due to inherent limitations
of the Web platform:
- No support for external script editors.
- No support for Android one-click deploy.
.. seealso::
See the
`list of open issues on GitHub related to the web editor <https://github.com/godotengine/godot/issues?q=is%3Aopen+is%3Aissue+label%3Aplatform%3Ahtml5+label%3Atopic%3Aeditor>`__ for a list of known bugs.
Importing a project
-------------------
To import an existing project, the current process is as follows:
- Specify a ZIP file to preload on the HTML5 filesystem using the
**Preload project ZIP** input.
- Run the editor by clicking **Start Godot editor**.
The Godot project manager should appear after 10-20 seconds.
On slower machines or connections, loading may take up to a minute.
- In the dialog that appears at the middle of the window, specify a name for
the folder to create then click the **Create Folder** button
(it doesn't have to match the ZIP archive's name).
- Click **Install & Edit** and the project will open in the editor.
.. attention::
It's important to place the project folder somewhere in ``/home/web_user/``.
If your project folder is placed outside ``/home/web_user/``, you will
lose your project when closing the editor!
When you follow the steps described above, the project folder will always be
located in ``/home/web_user/projects``, keeping it safe.
Editing and running a project
-----------------------------
Unlike the native version of Godot, the web editor is constrained to a single
window. Therefore, it cannot open a new window when running the project.
Instead, when you run the project by clicking the Run button or pressing
:kbd:`F5`, it will appear to "replace" the editor window.
The web editor offers an alternative way to deal with the editor and game
windows (which are now "tabs"). You can switch between the **Editor** and
**Game** tabs using the buttons on the top. You can also close the running game
or editor by clicking the **×** button next to those tabs.
Where are my project files?
---------------------------
Due to browser security limitations, the editor will save the project files to
the browser's IndexedDB storage. This storage isn't accessible as a regular folder
on your machine, but is abstracted away in a database.
You can download the project files as a ZIP archive by using
**Project > Tools > Download Project Source**. This can be used to export the
project using a `native Godot editor <https://godotengine.org/download>`__,
since exporting from the web editor isn't supported yet.
In the future, it may be possible to use the
`HTML5 FileSystem API <https://developer.mozilla.org/en-US/docs/Web/API/FileSystem>`__
to store the project files on the user's filesystem as the native editor would do.
However, this isn't implemented yet.

7
getting_started/scripting/c_sharp/c_sharp_basics.rst
View File

@@ -45,7 +45,7 @@ Install the latest stable version of
`.NET Core SDK <https://dotnet.microsoft.com/download/dotnet-core>`__
(3.1 as of writing).
As of Godot 3.2.3, installing Mono SDK is not a requirement anymore,
From Godot 3.2.3 onwards, installing Mono SDK is not a requirement anymore,
except it is required if you are building the engine from source.
Godot bundles the parts of Mono needed to run already compiled games,
@@ -254,9 +254,8 @@ take a look over the official
can use any custom properties or methods without this limitation.
As of Godot 3.2.2, exporting Mono projects is supported for desktop platforms
(Linux, Windows and macOS), Android, HTML5, and iOS. The only platform not
supported yet is UWP.
Exporting Mono projects is supported for desktop platforms (Linux, Windows and
macOS), Android, HTML5, and iOS. The only platform not supported yet is UWP.
Performance of C# in Godot
--------------------------

14
getting_started/workflow/assets/importing_audio_samples.rst
View File

@@ -6,8 +6,7 @@ Importing audio samples
Supported files
---------------
Godot provides three options to import your audio data: WAV, Ogg Vorbis
and MP3.
Godot provides two options to import your audio data: WAV and Ogg Vorbis.
Each has different advantages.
@@ -17,17 +16,10 @@ Each has different advantages.
* Ogg Vorbis files use a stronger compression that results in much
smaller file size, but require significantly more processing power to
play back.
* MP3 files use better compression than WAV with IMA-ADPCM, but worse than
Ogg Vorbis. This means that a MP3 file with roughly equal quality to
Ogg Vorbis will be significantly larger. On the bright side, MP3 requires
less CPU usage to play back compared to Ogg Vorbis. This makes MP3 useful
for mobile and HTML5 projects where CPU resources are limited, especially
when playing multiple compressed sounds at the same time (such as long
ambient sounds).
.. note::
MP3 support is only available in Godot 3.2.4 and later.
MP3 support is available in Godot 3.3 and later.
Here is a comparative chart.
@@ -40,8 +32,6 @@ Here is a comparative chart.
+-----------------------------+-------------------+
| WAV 16-bit, IMA-ADPCM, mono | 22 KB |
+-----------------------------+-------------------+
| MP3 192 Kb/s, stereo | 24 KB |
+-----------------------------+-------------------+
| Ogg Vorbis 128 Kb/s, stereo | 16 KB |
+-----------------------------+-------------------+
| Ogg Vorbis 96 Kb/s, stereo | 12 KB |

7
getting_started/workflow/export/exporting_for_android.rst
View File

@@ -3,13 +3,6 @@
Exporting for Android
=====================
.. seealso::
If you are using Godot 3.2.4 beta/RC, note that
**the Android export process has changed**. Read an
`updated version of this page <https://github.com/m4gr3d/godot-docs/blob/02cfb669f6b4ee77f0cb3e13b4d41054cc020673/getting_started/workflow/export/exporting_for_android.rst>`__
instead of the page you're currently on.
Exporting for Android has fewer requirements than compiling Godot for it.
The following steps detail what is needed to setup the SDK and the engine.

2
tutorials/optimization/optimizing_3d_performance.rst
View File

@@ -31,7 +31,7 @@ prepass* and is enabled by default in Godot when using the GLES3 renderer.
However, unneeded objects are still reducing performance.
One way we can potentially reduce the amount to be rendered is to take advantage
of occlusion. As of Godot 3.2.2, there is no built in support for occlusion in
of occlusion. As of Godot 3.2.3, there is no built in support for occlusion in
Godot. However, with careful design you can still get many of the advantages.
For instance, in our city street scenario, you may be able to work out in advance

28
tutorials/plugins/android/android_plugin.rst
View File

@@ -59,7 +59,7 @@ The instructions below assumes that you're using Android Studio.
- Download the Godot engine library (``godot-lib.<version>.<status>.aar``) from the `Godot download page <https://godotengine.org/download>`_ (e.g: ``godot-lib.3.2.2.stable.aar``).
- Follow `these instructions <https://developer.android.com/studio/projects/android-library#AddDependency>`__ to add
- Follow `these instructions <https://developer.android.com/studio/projects/android-library#AddDependency>`__ to add
the Godot engine library as a dependency for your plugin.
- In the plugin module's ``build.gradle`` file, replace ``implementation`` with ``compileOnly`` for the dependency line for the Godot engine library.
@@ -82,7 +82,7 @@ The instructions below assumes that you're using Android Studio.
Where ``PluginName`` is the name of the plugin, and ``plugin.init.ClassFullName`` is the full name (package + class name) of the plugin loading class.
5. Add the remaining logic for your plugin and run the ``gradlew build`` command to generate the plugin's ``aar`` file.
The build will likely generate both a ``debug`` and ``release`` ``aar`` files.
The build will likely generate both a ``debug`` and ``release`` ``aar`` files.
Depending on your need, pick only one version (usually the ``release`` one) which to provide your users with.
It's recommended that the ``aar`` filename matches the following pattern: ``[PluginName]*.aar`` where ``PluginName`` is the name of the plugin in PascalCase (e.g.: ``GodotPayment.release.aar``).
@@ -90,39 +90,39 @@ The instructions below assumes that you're using Android Studio.
6. Create a Godot Android Plugin configuration file to help the system detect and load your plugin:
- The configuration file extension must be ``gdap`` (e.g.: ``MyPlugin.gdap``).
- The configuration file format is as follow::
[config]
name="MyPlugin"
binary_type="local"
binary="MyPlugin.aar"
[dependencies]
local=["local_dep1.aar", "local_dep2.aar"]
remote=["example.plugin.android:remote-dep1:0.0.1", "example.plugin.android:remote-dep2:0.0.1"]
custom_maven_repos=["http://repo.mycompany.com/maven2"]
The ``config`` section and fields are required and defined as follow:
- **name**: name of the plugin
- **binary_type**: can be either ``local`` or ``remote``. The type affects the **binary** field
- **binary**:
- if **binary_type** is ``local``, then this should be the filepath of the plugin ``aar`` file.
- The filepath can be relative (e.g.: ``MyPlugin.aar``) in which case it's relative to the ``res://android/plugins`` directory.
- The filepath can be absolute: ``res://some_path/MyPlugin.aar``.
- if **binary_type** is ``remote``, then this should be a declaration for a `remote gradle binary <https://developer.android.com/studio/build/dependencies#dependency-types>`_ (e.g.: ``org.godot.example:my-plugin:0.0.0``).
The ``dependencies`` section and fields are optional and defined as follow:
- **local**: contains a list of filepaths to the local ``.aar`` binary files the plugin depends on. Similarly to the ``binary`` field (when the ``binary_type`` is ``local``), the local binaries' filepaths can be relative or absolute.
- **remote**: contains a list of remote binary gradle dependencies for the plugin.