Relintai/pandemonium_engine_docs
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine_docs.git synced 2025-01-19 14:57:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

Mass renamed godot to pandemonium.

Browse Source
This commit is contained in:
Relintai 2024-03-16 20:56:52 +01:00
parent 4439456d7b
commit 0de9f653b9
307 changed files with 2384 additions and 2384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
README.md
View File

@ -1,18 +1,18 @@
# Godot Engine documentation # Pandemonium Engine documentation
This repository contains the source files of [Godot Engine](https://godotengine.org)'s documentation, in reStructuredText markup language (reST). This repository contains the source files of [Pandemonium Engine](https://pandemoniumengine.org)'s documentation, in reStructuredText markup language (reST).
They are meant to be parsed with the [Sphinx](https://www.sphinx-doc.org/) documentation builder to build the HTML documentation on [Godot's website](https://docs.godotengine.org). They are meant to be parsed with the [Sphinx](https://www.sphinx-doc.org/) documentation builder to build the HTML documentation on [Pandemonium's website](https://docs.pandemoniumengine.org).
## Download for offline use ## Download for offline use
You can [download an HTML copy](https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-stable.zip) You can [download an HTML copy](https://nightly.link/pandemoniumengine/pandemonium-docs/workflows/build_offline_docs/master/pandemonium-docs-html-stable.zip)
for offline reading (updated every Monday). Extract the ZIP archive then open for offline reading (updated every Monday). Extract the ZIP archive then open
the top-level `index.html` in a web browser. the top-level `index.html` in a web browser.
## Theming ## Theming
The Godot documentation uses the default `sphinx_rtd_theme` with many The Pandemonium documentation uses the default `sphinx_rtd_theme` with many
[customizations](_static/) applied on top. It will automatically switch between [customizations](_static/) applied on top. It will automatically switch between
the light and dark theme depending on your browser/OS' theming preference. the light and dark theme depending on your browser/OS' theming preference.
@ -23,15 +23,15 @@ add-on.
## Contributing changes ## Contributing changes
**Pull Requests should use the `master` branch by default. Only make Pull Requests against other branches (e.g. `2.1` or `3.0`) if your changes only apply to that specific version of Godot.** **Pull Requests should use the `master` branch by default. Only make Pull Requests against other branches (e.g. `2.1` or `3.0`) if your changes only apply to that specific version of Pandemonium.**
Though arguably less convenient to edit than a wiki, this Git repository is meant to receive pull requests to always improve the documentation, add new pages, etc. Having direct access to the source files in a revision control system is a big plus to ensure the quality of our documentation. Though arguably less convenient to edit than a wiki, this Git repository is meant to receive pull requests to always improve the documentation, add new pages, etc. Having direct access to the source files in a revision control system is a big plus to ensure the quality of our documentation.
### Editing existing pages ### Editing existing pages
To edit an existing page, locate its .rst source file and open it in your favorite text editor. You can then commit the changes, push them to your fork and make a pull request. To edit an existing page, locate its .rst source file and open it in your favorite text editor. You can then commit the changes, push them to your fork and make a pull request.
**Note that the pages in `classes/` should not be edited here, they are automatically generated from Godot's [XML class references](https://github.com/godotengine/godot/tree/master/doc/classes).** **Note that the pages in `classes/` should not be edited here, they are automatically generated from Pandemonium's [XML class references](https://github.com/pandemoniumengine/pandemonium/tree/master/doc/classes).**
See [Contribute to the Class Reference](https://docs.godotengine.org/en/latest/community/contributing/updating_the_class_reference.html) for details. See [Contribute to the Class Reference](https://docs.pandemoniumengine.org/en/latest/community/contributing/updating_the_class_reference.html) for details.
### Adding new pages ### Adding new pages
@ -92,7 +92,7 @@ set SPHINXOPTS=-j2 && make html
The compilation might take some time as the `classes/` folder contains many files to parse. The compilation might take some time as the `classes/` folder contains many files to parse.
In case of a `MemoryError` or `EOFError`, you can remove the `classes/` folder and run `make` again. This will drop the class references from the final HTML documentation but will keep the rest intact. Make sure to avoid using `git add .` in this case when working on a pull request, or the whole `classes/` folder will be removed when you make a commit. See [#3157](https://github.com/godotengine/godot-docs/issues/3157) for more details. In case of a `MemoryError` or `EOFError`, you can remove the `classes/` folder and run `make` again. This will drop the class references from the final HTML documentation but will keep the rest intact. Make sure to avoid using `git add .` in this case when working on a pull request, or the whole `classes/` folder will be removed when you make a commit. See [#3157](https://github.com/pandemoniumengine/pandemonium-docs/issues/3157) for more details.
You can then test the changes live by opening `build/html/index.html` in your favorite browser. You can then test the changes live by opening `build/html/index.html` in your favorite browser.
@ -133,7 +133,7 @@ Then do `make html` like above.
## License ## License
At the exception of the `classes/` folder, all the content of this repository is licensed under the Creative Commons Attribution 3.0 Unported license ([CC BY 3.0](https://creativecommons.org/licenses/by/3.0/)) and is to be attributed to "Juan Linietsky, Ariel Manzur and the Godot community". At the exception of the `classes/` folder, all the content of this repository is licensed under the Creative Commons Attribution 3.0 Unported license ([CC BY 3.0](https://creativecommons.org/licenses/by/3.0/)) and is to be attributed to "Juan Linietsky, Ariel Manzur and the Pandemonium community".
See [LICENSE.txt](/LICENSE.txt) for details. See [LICENSE.txt](/LICENSE.txt) for details.
The files in the `classes/` folder are derived from [Godot's main source repository](https://github.com/godotengine/godot) and are distributed under the MIT license, with the same authors as above. The files in the `classes/` folder are derived from [Pandemonium's main source repository](https://github.com/pandemoniumengine/pandemonium) and are distributed under the MIT license, with the same authors as above.

28
about/complying_with_licenses.md
View File

@ -6,7 +6,7 @@ Complying with licenses
What are licenses? What are licenses?
------------------ ------------------
Godot is created and distributed under the `MIT License ( https://opensource.org/licenses/MIT )`. Pandemonium is created and distributed under the `MIT License ( https://opensource.org/licenses/MIT )`.
It doesn't have a sole owner either, as every contributor that submits code to It doesn't have a sole owner either, as every contributor that submits code to
the project does it under this same license and keeps ownership of the the project does it under this same license and keeps ownership of the
contribution. contribution.
@ -33,10 +33,10 @@ text somewhere in your game or derivative project.
This text reads as follows: This text reads as follows:
This game uses Godot Engine, available under the following license: This game uses Pandemonium Engine, available under the following license:
Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.
Copyright (c) 2014-2022 Godot Engine contributors. Copyright (c) 2014-2022 Pandemonium Engine contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
@ -48,7 +48,7 @@ Note:
Your games do not need to be under the same license. You are free to release Your games do not need to be under the same license. You are free to release
your Godot projects under any license and to create commercial games with your Pandemonium projects under any license and to create commercial games with
the engine. the engine.
Inclusion Inclusion
@ -91,17 +91,17 @@ If the game includes printed manuals, license text can be included there.
Link to the license Link to the license
^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
The Godot Engine developers consider that a link to `godotengine.org/license` The Pandemonium Engine developers consider that a link to `pandemoniumengine.org/license`
in your game documentation or credits would be an acceptable way to satisfy in your game documentation or credits would be an acceptable way to satisfy
the license terms. the license terms.
Third-party licenses Third-party licenses
-------------------- --------------------
Godot itself contains software written by Pandemonium itself contains software written by
`third parties ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )`. `third parties ( https://github.com/pandemoniumengine/pandemonium/blob/master/COPYRIGHT.txt )`.
Most of it does not require license inclusion, but some do. Most of it does not require license inclusion, but some do.
Make sure to do it if these are compiled in your Godot export template. If Make sure to do it if these are compiled in your Pandemonium export template. If
you're using the official export templates, all libraries are enabled. This you're using the official export templates, all libraries are enabled. This
means you need to provide attribution for all the libraries listed below. means you need to provide attribution for all the libraries listed below.
@ -110,9 +110,9 @@ Here's a list of libraries requiring attribution:
FreeType FreeType
^^^^^^^^ ^^^^^^^^
Godot uses `FreeType ( https://www.freetype.org/ )` to render fonts. Its license Pandemonium uses `FreeType ( https://www.freetype.org/ )` to render fonts. Its license
requires attribution, so the following text must be included together with the requires attribution, so the following text must be included together with the
Godot license: Pandemonium license:
Portions of this software are copyright © ( year> The FreeType Project (www.freetype.org). All rights reserved. Portions of this software are copyright © ( year> The FreeType Project (www.freetype.org). All rights reserved.
@ -127,8 +127,8 @@ Note:
ENet ENet
^^^^ ^^^^
Godot includes the `ENet ( http://enet.bespin.org/ )` library to handle Pandemonium includes the `ENet ( http://enet.bespin.org/ )` library to handle
high-level multiplayer. ENet has similar licensing terms as Godot: high-level multiplayer. ENet has similar licensing terms as Pandemonium:
Copyright (c) 2002-2020 Lee Salzman Copyright (c) 2002-2020 Lee Salzman
@ -142,7 +142,7 @@ high-level multiplayer. ENet has similar licensing terms as Godot:
mbed TLS mbed TLS
^^^^^^^^ ^^^^^^^^
If the project is exported with Godot 3.1 or later, it includes `mbed TLS ( https://tls.mbed.org )`. If the project is exported with Pandemonium 3.1 or later, it includes `mbed TLS ( https://tls.mbed.org )`.
The Apache license needs to be complied to by including the following text: The Apache license needs to be complied to by including the following text:
Copyright The Mbed TLS Contributors Copyright The Mbed TLS Contributors
@ -159,7 +159,7 @@ The Apache license needs to be complied to by including the following text:
See the License for the specific language governing permissions and See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
Keep in mind that Godot 2.x and 3.0 use `OpenSSL ( https://www.openssl.org )` 1.x Keep in mind that Pandemonium 2.x and 3.0 use `OpenSSL ( https://www.openssl.org )` 1.x
instead. This old OpenSSL version used the OpenSSL license, not the Apache 2 license instead. This old OpenSSL version used the OpenSSL license, not the Apache 2 license
as the latest version of OpenSSL currently uses (as of April 2022). as the latest version of OpenSSL currently uses (as of April 2022).

8
about/docs_changelog.md
View File

@ -121,13 +121,13 @@ Project workflow
Best Practices: Best Practices:
- `doc_introduction_best_practices` - `doc_introduction_best_practices`
- `doc_what_are_godot_classes` - `doc_what_are_pandemonium_classes`
- `doc_scene_organization` - `doc_scene_organization`
- `doc_scenes_versus_scripts` - `doc_scenes_versus_scripts`
- `doc_autoloads_versus_internal_nodes` - `doc_autoloads_versus_internal_nodes`
- `doc_node_alternatives` - `doc_node_alternatives`
- `doc_godot_interfaces` - `doc_pandemonium_interfaces`
- `doc_godot_notifications` - `doc_pandemonium_notifications`
- `doc_data_preferences` - `doc_data_preferences`
- `doc_logic_preferences` - `doc_logic_preferences`
@ -170,7 +170,7 @@ Viewports
Shading Shading
^^^^^^^ ^^^^^^^
- `doc_converting_glsl_to_godot_shaders` - `doc_converting_glsl_to_pandemonium_shaders`
- `doc_advanced_postprocessing` - `doc_advanced_postprocessing`
Shading Reference: Shading Reference:

250
about/faq.md
View File

@ -2,31 +2,31 @@
Frequently asked questions Frequently asked questions
========================== ==========================
What can I do with Godot? How much does it cost? What are the license terms? What can I do with Pandemonium? How much does it cost? What are the license terms?
---------------------------------------------------------------------------- ----------------------------------------------------------------------------
Godot is `Free and Open-Source Software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )` available under the `OSI-approved ( https://opensource.org/licenses/MIT )` MIT license. This means it is free as in "free speech" as well as in "free beer." Pandemonium is `Free and Open-Source Software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )` available under the `OSI-approved ( https://opensource.org/licenses/MIT )` MIT license. This means it is free as in "free speech" as well as in "free beer."
In short: In short:
* You are free to download and use Godot for any purpose: personal, non-profit, commercial, or otherwise. * You are free to download and use Pandemonium for any purpose: personal, non-profit, commercial, or otherwise.
* You are free to modify, distribute, redistribute, and remix Godot to your heart's content, for any reason, both non-commercially and commercially. * You are free to modify, distribute, redistribute, and remix Pandemonium to your heart's content, for any reason, both non-commercially and commercially.
All the contents of this accompanying documentation are published under All the contents of this accompanying documentation are published under
the permissive Creative Commons Attribution 3.0 (`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`) license, with attribution the permissive Creative Commons Attribution 3.0 (`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`) license, with attribution
to "Juan Linietsky, Ariel Manzur and the Godot Engine community." to "Juan Linietsky, Ariel Manzur and the Pandemonium Engine community."
Logos and icons are generally under the same Creative Commons license. Note Logos and icons are generally under the same Creative Commons license. Note
that some third-party libraries included with Godot's source code may have that some third-party libraries included with Pandemonium's source code may have
different licenses. different licenses.
For full details, look at the `COPYRIGHT.txt ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )` as well For full details, look at the `COPYRIGHT.txt ( https://github.com/pandemoniumengine/pandemonium/blob/master/COPYRIGHT.txt )` as well
as the `LICENSE.txt ( https://github.com/godotengine/godot/blob/master/LICENSE.txt )` and `LOGO_LICENSE.txt ( https://github.com/godotengine/godot/blob/master/LOGO_LICENSE.md )` files as the `LICENSE.txt ( https://github.com/pandemoniumengine/pandemonium/blob/master/LICENSE.txt )` and `LOGO_LICENSE.txt ( https://github.com/pandemoniumengine/pandemonium/blob/master/LOGO_LICENSE.md )` files
in the Godot repository. in the Pandemonium repository.
Also, see `the license page on the Godot website ( https://godotengine.org/license )`. Also, see `the license page on the Pandemonium website ( https://pandemoniumengine.org/license )`.
Which platforms are supported by Godot? Which platforms are supported by Pandemonium?
--------------------------------------- ---------------------------------------
**For the editor:** **For the editor:**
@ -49,7 +49,7 @@ Which platforms are supported by Godot?
Both 32- and 64-bit binaries are supported where it makes sense, with 64 Both 32- and 64-bit binaries are supported where it makes sense, with 64
being the default. being the default.
Some users also report building and using Godot successfully on ARM-based Some users also report building and using Pandemonium successfully on ARM-based
systems with Linux, like the Raspberry Pi. systems with Linux, like the Raspberry Pi.
Additionally, there is some unofficial third-party work being done on building Additionally, there is some unofficial third-party work being done on building
@ -57,17 +57,17 @@ for some consoles. However, none of this is included in the default build
scripts or export templates at this time. scripts or export templates at this time.
For more on this, see the sections on `exporting ( toc-learn-workflow-export )` For more on this, see the sections on `exporting ( toc-learn-workflow-export )`
and `compiling Godot yourself ( toc-devel-compiling )`. and `compiling Pandemonium yourself ( toc-devel-compiling )`.
Which programming languages are supported in Godot? Which programming languages are supported in Pandemonium?
--------------------------------------------------- ---------------------------------------------------
The officially supported languages for Godot are GDScript, Visual Scripting, The officially supported languages for Pandemonium are GDScript, Visual Scripting,
C#, and C++. See the subcategories for each language in the C#, and C++. See the subcategories for each language in the
`scripting ( toc-learn-scripting )` section. `scripting ( toc-learn-scripting )` section.
If you are just starting out with either Godot or game development in general, If you are just starting out with either Pandemonium or game development in general,
GDScript is the recommended language to learn and use since it is native to Godot. GDScript is the recommended language to learn and use since it is native to Pandemonium.
While scripting languages tend to be less performant than lower-level languages in While scripting languages tend to be less performant than lower-level languages in
the long run, for prototyping, developing Minimum Viable Products (MVPs), and the long run, for prototyping, developing Minimum Viable Products (MVPs), and
focusing on Time-To-Market (TTM), GDScript will provide a fast, friendly, and capable focusing on Time-To-Market (TTM), GDScript will provide a fast, friendly, and capable
@ -77,22 +77,22 @@ Note that C# support is still relatively new, and as such, you may encounter som
issues along the way. Our friendly and hard-working development community is always issues along the way. Our friendly and hard-working development community is always
ready to tackle new problems as they arise, but since this is an open-source project, ready to tackle new problems as they arise, but since this is an open-source project,
we recommend that you first do some due diligence yourself. Searching through we recommend that you first do some due diligence yourself. Searching through
discussions on `open issues ( https://github.com/godotengine/godot/issues )` is a discussions on `open issues ( https://github.com/pandemoniumengine/pandemonium/issues )` is a
great way to start your troubleshooting. great way to start your troubleshooting.
As for new languages, support is possible via third parties using the GDNative / As for new languages, support is possible via third parties using the GDNative /
NativeScript / PluginScript facilities. (See the question about plugins below.) NativeScript / PluginScript facilities. (See the question about plugins below.)
Work is currently underway, for example, on unofficial bindings for Godot Work is currently underway, for example, on unofficial bindings for Pandemonium
to `Python ( https://github.com/touilleMan/godot-python )` and `Nim ( https://github.com/pragmagic/godot-nim )`. to `Python ( https://github.com/touilleMan/pandemonium-python )` and `Nim ( https://github.com/pragmagic/pandemonium-nim )`.
What is GDScript and why should I use it? What is GDScript and why should I use it?
----------------------------------------- -----------------------------------------
GDScript is Godot's integrated scripting language. It was built from the ground GDScript is Pandemonium's integrated scripting language. It was built from the ground
up to maximize Godot's potential in the least amount of code, affording both novice up to maximize Pandemonium's potential in the least amount of code, affording both novice
and expert developers alike to capitalize on Godot's strengths as fast as possible. and expert developers alike to capitalize on Pandemonium's strengths as fast as possible.
If you've ever written anything in a language like Python before then you'll feel If you've ever written anything in a language like Python before then you'll feel
right at home. For examples, history, and a complete overview of the power GDScript right at home. For examples, history, and a complete overview of the power GDScript
offers you, check out the `GDScript scripting guide ( doc_gdscript )`. offers you, check out the `GDScript scripting guide ( doc_gdscript )`.
@ -102,19 +102,19 @@ alpha/beta stages of your project, or are not creating the next AAA title--but t
most salient reason is the overall **reduction of complexity**. most salient reason is the overall **reduction of complexity**.
The original intent of creating a tightly integrated, custom scripting language for The original intent of creating a tightly integrated, custom scripting language for
Godot was two-fold: first, it reduces the amount of time necessary to get up and running Pandemonium was two-fold: first, it reduces the amount of time necessary to get up and running
with Godot, giving developers a rapid way of exposing themselves to the engine with a with Pandemonium, giving developers a rapid way of exposing themselves to the engine with a
focus on productivity; second, it reduces the overall burden of maintenance, attenuates focus on productivity; second, it reduces the overall burden of maintenance, attenuates
the dimensionality of issues, and allows the developers of the engine to focus on squashing the dimensionality of issues, and allows the developers of the engine to focus on squashing
bugs and improving features related to the engine core--rather than spending a lot of time bugs and improving features related to the engine core--rather than spending a lot of time
trying to get a small set of incremental features working across a large set of languages. trying to get a small set of incremental features working across a large set of languages.
Since Godot is an open-source project, it was imperative from the start to prioritize a Since Pandemonium is an open-source project, it was imperative from the start to prioritize a
more integrated and seamless experience over attracting additional users by supporting more integrated and seamless experience over attracting additional users by supporting
more familiar programming languages--especially when supporting those more familiar more familiar programming languages--especially when supporting those more familiar
languages would result in a worse experience. We understand if you would rather use languages would result in a worse experience. We understand if you would rather use
another language in Godot (see the list of supported options above). That being said, if another language in Pandemonium (see the list of supported options above). That being said, if
you haven't given GDScript a try, try it for **three days**. Just like Godot, you haven't given GDScript a try, try it for **three days**. Just like Pandemonium,
once you see how powerful it is and rapid your development becomes, we think GDScript once you see how powerful it is and rapid your development becomes, we think GDScript
will grow on you. will grow on you.
@ -130,12 +130,12 @@ oriented system (by using fallbacks) was complex and slow and took an
enormous amount of code. After some experiments with enormous amount of code. After some experiments with
`Python ( https://www.python.org )`, it also proved difficult to embed. `Python ( https://www.python.org )`, it also proved difficult to embed.
The main reasons for creating a custom scripting language for Godot were: The main reasons for creating a custom scripting language for Pandemonium were:
1. Poor threading support in most script VMs, and Godot uses threads 1. Poor threading support in most script VMs, and Pandemonium uses threads
(Lua, Python, Squirrel, JavaScript, ActionScript, etc.). (Lua, Python, Squirrel, JavaScript, ActionScript, etc.).
2. Poor class-extending support in most script VMs, and adapting to 2. Poor class-extending support in most script VMs, and adapting to
the way Godot works is highly inefficient (Lua, Python, JavaScript). the way Pandemonium works is highly inefficient (Lua, Python, JavaScript).
3. Many existing languages have horrible interfaces for binding to C++, resulting in large amount of 3. Many existing languages have horrible interfaces for binding to C++, resulting in large amount of
code, bugs, bottlenecks, and general inefficiency (Lua, Python, code, bugs, bottlenecks, and general inefficiency (Lua, Python,
Squirrel, JavaScript, etc.) We wanted to focus on a great engine, not a great amount of integrations. Squirrel, JavaScript, etc.) We wanted to focus on a great engine, not a great amount of integrations.
@ -150,46 +150,46 @@ The main reasons for creating a custom scripting language for Godot were:
GDScript was designed to curtail the issues above, and more. GDScript was designed to curtail the issues above, and more.
What type of 3D model formats does Godot support? What type of 3D model formats does Pandemonium support?
------------------------------------------------- -------------------------------------------------
Godot supports Collada via the `OpenCollada ( https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools )` exporter (Maya, 3DSMax). Pandemonium supports Collada via the `OpenCollada ( https://github.com/KhronosGroup/OpenCOLLADA/wiki/OpenCOLLADA-Tools )` exporter (Maya, 3DSMax).
If you are using Blender, take a look at our own `Better Collada Exporter ( https://godotengine.org/download )`. If you are using Blender, take a look at our own `Better Collada Exporter ( https://pandemoniumengine.org/download )`.
As of Godot 3.0, glTF is supported. As of Pandemonium 3.0, glTF is supported.
FBX is supported via the Open Asset Import library. However, FBX is proprietary FBX is supported via the Open Asset Import library. However, FBX is proprietary
so we recommend using other formats listed above, if suitable for your workflow. so we recommend using other formats listed above, if suitable for your workflow.
Will [insert closed SDK such as FMOD, GameWorks, etc.] be supported in Godot? Will [insert closed SDK such as FMOD, GameWorks, etc.] be supported in Pandemonium?
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
The aim of Godot is to create a free and open-source MIT-licensed engine that The aim of Pandemonium is to create a free and open-source MIT-licensed engine that
is modular and extendable. There are no plans for the core engine development is modular and extendable. There are no plans for the core engine development
community to support any third-party, closed-source/proprietary SDKs, as integrating community to support any third-party, closed-source/proprietary SDKs, as integrating
with these would go against Godot's ethos. with these would go against Pandemonium's ethos.
That said, because Godot is open-source and modular, nothing prevents you or That said, because Pandemonium is open-source and modular, nothing prevents you or
anyone else interested in adding those libraries as a module and shipping your anyone else interested in adding those libraries as a module and shipping your
game with them--as either open- or closed-source. game with them--as either open- or closed-source.
To see how support for your SDK of choice could still be provided, look at the To see how support for your SDK of choice could still be provided, look at the
Plugins question below. Plugins question below.
If you know of a third-party SDK that is not supported by Godot but that offers If you know of a third-party SDK that is not supported by Pandemonium but that offers
free and open-source integration, consider starting the integration work yourself. free and open-source integration, consider starting the integration work yourself.
Godot is not owned by one person; it belongs to the community, and it grows along Pandemonium is not owned by one person; it belongs to the community, and it grows along
with ambitious community contributors like you. with ambitious community contributors like you.
How do I install the Godot editor on my system (for desktop integration)? How do I install the Pandemonium editor on my system (for desktop integration)?
------------------------------------------------------------------------- -------------------------------------------------------------------------
Since you don't need to actually install Godot on your system to run it, Since you don't need to actually install Pandemonium on your system to run it,
this means desktop integration is not performed automatically. this means desktop integration is not performed automatically.
There are two ways to overcome this. You can install Godot from There are two ways to overcome this. You can install Pandemonium from
`Steam ( https://store.steampowered.com/app/404790/Godot_Engine/ )` (all platforms), `Steam ( https://store.steampowered.com/app/404790/Pandemonium_Engine/ )` (all platforms),
`Scoop ( https://scoop.sh/ )` (Windows), `Homebrew ( https://brew.sh/ )` (macOS) `Scoop ( https://scoop.sh/ )` (Windows), `Homebrew ( https://brew.sh/ )` (macOS)
or `Flathub ( https://flathub.org/apps/details/org.godotengine.Godot )` (Linux). or `Flathub ( https://flathub.org/apps/details/org.pandemoniumengine.Pandemonium )` (Linux).
This will automatically perform the required steps for desktop integration. This will automatically perform the required steps for desktop integration.
Alternatively, you can manually perform the steps that an installer would do for you: Alternatively, you can manually perform the steps that an installer would do for you:
@ -197,86 +197,86 @@ Alternatively, you can manually perform the steps that an installer would do for
Windows Windows
^^^^^^^ ^^^^^^^
- Move the Godot executable to a stable location (i.e. outside of your Downloads folder), - Move the Pandemonium executable to a stable location (i.e. outside of your Downloads folder),
so you don't accidentally move it and break the shortcut in the future. so you don't accidentally move it and break the shortcut in the future.
- Right-click the Godot executable and choose **Create Shortcut**. - Right-click the Pandemonium executable and choose **Create Shortcut**.
- Move the created shortcut to `%LOCALAPPDATA%\Microsoft\Windows\Start Menu\Programs`. - Move the created shortcut to `%LOCALAPPDATA%\Microsoft\Windows\Start Menu\Programs`.
This is the user-wide location for shortcuts that will appear in the Start menu. This is the user-wide location for shortcuts that will appear in the Start menu.
You can also pin Godot in the task bar by right-clicking the executable and choosing You can also pin Pandemonium in the task bar by right-clicking the executable and choosing
**Pin to Task Bar**. **Pin to Task Bar**.
macOS macOS
^^^^^ ^^^^^
Drag the extracted Godot application to `/Applications/Godot.app`, then drag it Drag the extracted Pandemonium application to `/Applications/Pandemonium.app`, then drag it
to the Dock if desired. Spotlight will be able to find Godot as long as it's in to the Dock if desired. Spotlight will be able to find Pandemonium as long as it's in
`/Applications` or `~/Applications`. `/Applications` or `~/Applications`.
Linux Linux
^^^^^ ^^^^^
- Move the Godot binary to a stable location (i.e. outside of your Downloads folder), - Move the Pandemonium binary to a stable location (i.e. outside of your Downloads folder),
so you don't accidentally move it and break the shortcut in the future. so you don't accidentally move it and break the shortcut in the future.
- Rename and move the Godot binary to a location present in your `PATH` environment variable. - Rename and move the Pandemonium binary to a location present in your `PATH` environment variable.
This is typically `/usr/local/bin/godot` or `/usr/bin/godot`. This is typically `/usr/local/bin/pandemonium` or `/usr/bin/pandemonium`.
Doing this requires administrator privileges, Doing this requires administrator privileges,
but this also allows you to but this also allows you to
`run the Godot editor from a terminal ( doc_command_line_tutorial )` by entering `godot`. `run the Pandemonium editor from a terminal ( doc_command_line_tutorial )` by entering `pandemonium`.
- If you cannot move the Godot editor binary to a protected location, you can - If you cannot move the Pandemonium editor binary to a protected location, you can
keep the binary somewhere in your home directory, and modify the `Path=` keep the binary somewhere in your home directory, and modify the `Path=`
line in the `.desktop` file linked below to contain the full *absolute* path line in the `.desktop` file linked below to contain the full *absolute* path
to the Godot binary. to the Pandemonium binary.
- Save `this .desktop file ( https://raw.githubusercontent.com/godotengine/godot/3.x/misc/dist/linux/org.godotengine.Godot.desktop )` - Save `this .desktop file ( https://raw.githubusercontent.com/pandemoniumengine/pandemonium/3.x/misc/dist/linux/org.pandemoniumengine.Pandemonium.desktop )`
to `$HOME/.local/share/applications/`. If you have administrator privileges, to `$HOME/.local/share/applications/`. If you have administrator privileges,
you can also save the `.desktop` file to `/usr/local/share/applications` you can also save the `.desktop` file to `/usr/local/share/applications`
to make the shortcut available for all users. to make the shortcut available for all users.
Is the Godot editor a portable application? Is the Pandemonium editor a portable application?
------------------------------------------- -------------------------------------------
In its default configuration, Godot is *semi-portable*. Its executable can run In its default configuration, Pandemonium is *semi-portable*. Its executable can run
from any location (including non-writable locations) and never requires from any location (including non-writable locations) and never requires
administrator privileges. administrator privileges.
However, configuration files will be written to the user-wide configuration or However, configuration files will be written to the user-wide configuration or
data directory. This is usually a good approach, but this means configuration files data directory. This is usually a good approach, but this means configuration files
will not carry across machines if you copy the folder containing the Godot executable. will not carry across machines if you copy the folder containing the Pandemonium executable.
See `doc_data_paths` for more information. See `doc_data_paths` for more information.
If *true* portable operation is desired (e.g. for use on an USB stick), If *true* portable operation is desired (e.g. for use on an USB stick),
follow the steps in `doc_data_paths_self_contained_mode`. follow the steps in `doc_data_paths_self_contained_mode`.
Why does Godot use Vulkan or OpenGL instead of Direct3D? Why does Pandemonium use Vulkan or OpenGL instead of Direct3D?
-------------------------------------------------------- --------------------------------------------------------
Godot aims for cross-platform compatibility and open standards first and Pandemonium aims for cross-platform compatibility and open standards first and
foremost. OpenGL and Vulkan are the technologies that are both open and foremost. OpenGL and Vulkan are the technologies that are both open and
available (nearly) on all platforms. Thanks to this design decision, a project available (nearly) on all platforms. Thanks to this design decision, a project
developed with Godot on Windows will run out of the box on Linux, macOS, and developed with Pandemonium on Windows will run out of the box on Linux, macOS, and
more. more.
Since Godot only has a few people working on its renderer, we would prefer Since Pandemonium only has a few people working on its renderer, we would prefer
having fewer rendering backends to maintain. On top of that, using a single API having fewer rendering backends to maintain. On top of that, using a single API
on all platforms allows for greater consistency with fewer platform-specific on all platforms allows for greater consistency with fewer platform-specific
issues. issues.
In the long term, we may develop a Direct3D 12 renderer for Godot (mainly for In the long term, we may develop a Direct3D 12 renderer for Pandemonium (mainly for
the Xbox's purposes), but Vulkan and OpenGL will remain the default rendering the Xbox's purposes), but Vulkan and OpenGL will remain the default rendering
backends on all platforms, including Windows. backends on all platforms, including Windows.
Why does Godot aim to keep its core feature set small? Why does Pandemonium aim to keep its core feature set small?
------------------------------------------------------ ------------------------------------------------------
Godot intentionally does not include features that can be implemented by add-ons Pandemonium intentionally does not include features that can be implemented by add-ons
unless they are used very often. One example of this would be advanced unless they are used very often. One example of this would be advanced
artificial intelligence functionality. artificial intelligence functionality.
There are several reasons for this: There are several reasons for this:
- **Code maintenance and surface for bugs.** Every time we accept new code in - **Code maintenance and surface for bugs.** Every time we accept new code in
the Godot repository, existing contributors often take the reponsibility of the Pandemonium repository, existing contributors often take the reponsibility of
maintaining it. Some contributors don't always stick around after getting maintaining it. Some contributors don't always stick around after getting
their code merged, which can make it difficult for us to maintain the code in their code merged, which can make it difficult for us to maintain the code in
question. This can lead to poorly maintained features with bugs that are never question. This can lead to poorly maintained features with bugs that are never
@ -285,24 +285,24 @@ There are several reasons for this:
- **Ease of contribution.** By keeping the codebase small and tidy, it can remain - **Ease of contribution.** By keeping the codebase small and tidy, it can remain
fast and easy to compile from source. This makes it easier for new fast and easy to compile from source. This makes it easier for new
contributors to get started with Godot, without requiring them to purchase contributors to get started with Pandemonium, without requiring them to purchase
high-end hardware. high-end hardware.
- **Keeping the binary size small for the editor.** Not everyone has a fast Internet - **Keeping the binary size small for the editor.** Not everyone has a fast Internet
connection. Ensuring that everyone can download the Godot editor, extract it connection. Ensuring that everyone can download the Pandemonium editor, extract it
and run it in less than 5 minutes makes Godot more accessible to developers in and run it in less than 5 minutes makes Pandemonium more accessible to developers in
all countries. all countries.
- **Keeping the binary size small for export templates.** This directly impacts the - **Keeping the binary size small for export templates.** This directly impacts the
size of projects exported with Godot. On mobile and web platforms, keeping size of projects exported with Pandemonium. On mobile and web platforms, keeping
file sizes low is primordial to ensure fast installation and loading on file sizes low is primordial to ensure fast installation and loading on
underpowered devices. Again, there are many countries where high-speed underpowered devices. Again, there are many countries where high-speed
Internet is not readily available. To add to this, strict data usage caps are Internet is not readily available. To add to this, strict data usage caps are
often in effect in those countries. often in effect in those countries.
For all the reasons above, we have to be selective of what we can accept as core For all the reasons above, we have to be selective of what we can accept as core
functionality in Godot. This is why we are aiming to move some core functionality in Pandemonium. This is why we are aiming to move some core
functionality to officially supported add-ons in future versions of Godot. In functionality to officially supported add-ons in future versions of Pandemonium. In
terms of binary size, this also has the advantage of making you pay only for what terms of binary size, this also has the advantage of making you pay only for what
you actually use in your project. (In the meantime, you can you actually use in your project. (In the meantime, you can
`compile custom export templates with unused features disabled ( doc_optimizing_for_size )` `compile custom export templates with unused features disabled ( doc_optimizing_for_size )`
@ -331,7 +331,7 @@ This is mostly needed for 2D, as in 3D it's just a matter of Camera XFov or YFov
resolution, the larger your assets, the more memory they will take resolution, the larger your assets, the more memory they will take
and the longer the time it will take for loading. and the longer the time it will take for loading.
2. Use the stretch options in Godot; 2D stretching while keeping aspect 2. Use the stretch options in Pandemonium; 2D stretching while keeping aspect
ratios works best. Check the `doc_multiple_resolutions` tutorial ratios works best. Check the `doc_multiple_resolutions` tutorial
on how to achieve this. on how to achieve this.
@ -351,24 +351,24 @@ devices with tiny screens (fewer than 300 pixels in width), you can use
the export option to shrink images, and set that build to be used for the export option to shrink images, and set that build to be used for
certain screen sizes in the App Store or Google Play. certain screen sizes in the App Store or Google Play.
How can I extend Godot? How can I extend Pandemonium?
----------------------- -----------------------
For extending Godot, like creating Godot Editor plugins or adding support For extending Pandemonium, like creating Pandemonium Editor plugins or adding support
for additional languages, take a look at `EditorPlugins ( doc_making_plugins )` for additional languages, take a look at `EditorPlugins ( doc_making_plugins )`
and tool scripts. and tool scripts.
Also, see the official blog posts on these topics: Also, see the official blog posts on these topics:
* `A look at the GDNative architecture ( https://godotengine.org/article/look-gdnative-architecture )` * `A look at the GDNative architecture ( https://pandemoniumengine.org/article/look-gdnative-architecture )`
* `GDNative is here! ( https://godotengine.org/article/dlscript-here )` * `GDNative is here! ( https://pandemoniumengine.org/article/dlscript-here )`
You can also take a look at the GDScript implementation, the Godot modules, You can also take a look at the GDScript implementation, the Pandemonium modules,
as well as the `unofficial Python support ( https://github.com/touilleMan/godot-python )` for Godot. as well as the `unofficial Python support ( https://github.com/touilleMan/pandemonium-python )` for Pandemonium.
This would be a good starting point to see how another third-party library This would be a good starting point to see how another third-party library
integrates with Godot. integrates with Pandemonium.
When is the next release of Godot out? When is the next release of Pandemonium out?
-------------------------------------- --------------------------------------
When it's ready! See `doc_release_policy_when_is_next_release_out` for more When it's ready! See `doc_release_policy_when_is_next_release_out` for more
@ -377,26 +377,26 @@ information.
I would like to contribute! How can I get started? I would like to contribute! How can I get started?
-------------------------------------------------- --------------------------------------------------
Awesome! As an open-source project, Godot thrives off of the innovation and Awesome! As an open-source project, Pandemonium thrives off of the innovation and
ambition of developers like you. ambition of developers like you.
The first place to get started is in the `issues ( https://github.com/godotengine/godot/issues )`. The first place to get started is in the `issues ( https://github.com/pandemoniumengine/pandemonium/issues )`.
Find an issue that resonates with you, then proceed to the `How to Contribute ( https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#contributing-pull-requests )` Find an issue that resonates with you, then proceed to the `How to Contribute ( https://github.com/pandemoniumengine/pandemonium/blob/master/CONTRIBUTING.md#contributing-pull-requests )`
guide to learn how to fork, modify, and submit a Pull Request (PR) with your changes. guide to learn how to fork, modify, and submit a Pull Request (PR) with your changes.
I have a great idea for Godot. How can I share it? I have a great idea for Pandemonium. How can I share it?
-------------------------------------------------- --------------------------------------------------
It might be tempting to want to bring ideas to Godot, like ones that It might be tempting to want to bring ideas to Pandemonium, like ones that
result in massive core changes, some sort of mimicry of what another result in massive core changes, some sort of mimicry of what another
game engine does, or alternative workflows that you'd like built into game engine does, or alternative workflows that you'd like built into
the editor. These are great, and we are thankful to have such motivated the editor. These are great, and we are thankful to have such motivated
people want to contribute, but Godot's focus is and always will be the people want to contribute, but Pandemonium's focus is and always will be the
core functionality as outlined in the `Roadmap ( https://github.com/godotengine/godot-roadmap/blob/master/ROADMAP.md )`, core functionality as outlined in the `Roadmap ( https://github.com/pandemoniumengine/pandemonium-roadmap/blob/master/ROADMAP.md )`,
`squashing bugs and addressing issues ( https://github.com/godotengine/godot/issues )`, `squashing bugs and addressing issues ( https://github.com/pandemoniumengine/pandemonium/issues )`,
and conversations between Godot community members. and conversations between Pandemonium community members.
Most developers in the Godot community will be more interested to learn Most developers in the Pandemonium community will be more interested to learn
about things like: about things like:
- Your experience using the software and the problems you have (we - Your experience using the software and the problems you have (we
@ -407,7 +407,7 @@ about things like:
- The parts of your workflow you would like to see optimized. - The parts of your workflow you would like to see optimized.
- Parts where you missed clear tutorials or where the documentation wasn't clear. - Parts where you missed clear tutorials or where the documentation wasn't clear.
Please don't feel like your ideas for Godot are unwelcome. Instead, Please don't feel like your ideas for Pandemonium are unwelcome. Instead,
try to reformulate them as a problem first, so developers and the community try to reformulate them as a problem first, so developers and the community
have a functional foundation to ground your ideas on. have a functional foundation to ground your ideas on.
@ -422,66 +422,66 @@ projects (if applicable).
Is it possible to use Godot to create non-game applications? Is it possible to use Pandemonium to create non-game applications?
------------------------------------------------------------ ------------------------------------------------------------
Yes! Godot features an extensive built-in UI system, and its small distribution Yes! Pandemonium features an extensive built-in UI system, and its small distribution
size can make it a suitable alternative to frameworks like Electron or Qt. size can make it a suitable alternative to frameworks like Electron or Qt.
When creating a non-game application, make sure to enable When creating a non-game application, make sure to enable
`low-processor mode` `low-processor mode`
in the Project Settings to decrease CPU and GPU usage. in the Project Settings to decrease CPU and GPU usage.
That said, we wouldn't recommend using Godot to create a *mobile* application That said, we wouldn't recommend using Pandemonium to create a *mobile* application
since low-processor mode isn't supported on mobile platforms yet. since low-processor mode isn't supported on mobile platforms yet.
Check out `Material Maker ( https://github.com/RodZill4/material-maker )` and Check out `Material Maker ( https://github.com/RodZill4/material-maker )` and
`Pixelorama ( https://github.com/Orama-Interactive/Pixelorama )` for examples of `Pixelorama ( https://github.com/Orama-Interactive/Pixelorama )` for examples of
open source applications made with Godot. open source applications made with Pandemonium.
Is it possible to use Godot as a library? Is it possible to use Pandemonium as a library?
----------------------------------------- -----------------------------------------
Godot is meant to be used with its editor. We recommend you give it a try, as it Pandemonium is meant to be used with its editor. We recommend you give it a try, as it
will most likely save you time in the long term. There are no plans to make will most likely save you time in the long term. There are no plans to make
Godot usable as a library, as it would make the rest of the engine more Pandemonium usable as a library, as it would make the rest of the engine more
convoluted and difficult to use for casual users. convoluted and difficult to use for casual users.
If you want to use a rendering library, look into using an established rendering If you want to use a rendering library, look into using an established rendering
engine instead. Keep in mind rendering engines usually have smaller communities engine instead. Keep in mind rendering engines usually have smaller communities
compared to Godot. This will make it more difficult to find answers to your compared to Pandemonium. This will make it more difficult to find answers to your
questions. questions.
What user interface toolkit does Godot use? What user interface toolkit does Pandemonium use?
------------------------------------------- -------------------------------------------
Godot does not use a standard :abbr:`GUI (Graphical User Interface)` toolkit Pandemonium does not use a standard :abbr:`GUI (Graphical User Interface)` toolkit
like GTK, Qt or wxWidgets. Instead, Godot uses its own user interface toolkit, like GTK, Qt or wxWidgets. Instead, Pandemonium uses its own user interface toolkit,
rendered using OpenGL ES or Vulkan. This toolkit is exposed in the form of rendered using OpenGL ES or Vulkan. This toolkit is exposed in the form of
Control nodes, which are used to render the editor (which is written in C++). Control nodes, which are used to render the editor (which is written in C++).
These Control nodes can also be used in projects from any scripting language These Control nodes can also be used in projects from any scripting language
supported by Godot. supported by Pandemonium.
This custom toolkit makes it possible to benefit from hardware acceleration and This custom toolkit makes it possible to benefit from hardware acceleration and
have a consistent appearance across all platforms. On top of that, it doesn't have a consistent appearance across all platforms. On top of that, it doesn't
have to deal with the LGPL licensing caveats that come with GTK or Qt. Lastly, have to deal with the LGPL licensing caveats that come with GTK or Qt. Lastly,
this means Godot is "eating its own dog food" since the editor itself is one of this means Pandemonium is "eating its own dog food" since the editor itself is one of
the most complex users of Godot's UI system. the most complex users of Pandemonium's UI system.
This custom UI toolkit `can't be used as a library ( doc_faq_use_godot_as_library )`, This custom UI toolkit `can't be used as a library ( doc_faq_use_pandemonium_as_library )`,
but you can still but you can still
`use Godot to create non-game applications by using the editor ( doc_faq_non_game_applications )`. `use Pandemonium to create non-game applications by using the editor ( doc_faq_non_game_applications )`.
Why does Godot not use STL (Standard Template Library)? Why does Pandemonium not use STL (Standard Template Library)?
------------------------------------------------------- -------------------------------------------------------
Like many other libraries (Qt as an example), Godot does not make use of Like many other libraries (Qt as an example), Pandemonium does not make use of
STL. We believe STL is a great general purpose library, but we had special STL. We believe STL is a great general purpose library, but we had special
requirements for Godot. requirements for Pandemonium.
* STL templates create very large symbols, which results in huge debug binaries. We use few templates with very short names instead. * STL templates create very large symbols, which results in huge debug binaries. We use few templates with very short names instead.
* Most of our containers cater to special needs, like Vector, which uses copy on write and we use to pass data around, or the RID system, which requires O(1) access time for performance. Likewise, our hash map implementations are designed to integrate seamlessly with internal engine types. * Most of our containers cater to special needs, like Vector, which uses copy on write and we use to pass data around, or the RID system, which requires O(1) access time for performance. Likewise, our hash map implementations are designed to integrate seamlessly with internal engine types.
@ -489,28 +489,28 @@ requirements for Godot.
* For large arrays, we use pooled memory, which can be mapped to either a preallocated buffer or virtual memory. * For large arrays, we use pooled memory, which can be mapped to either a preallocated buffer or virtual memory.
* We use our custom String type, as the one provided by STL is too basic and lacks proper internationalization support. * We use our custom String type, as the one provided by STL is too basic and lacks proper internationalization support.
Why does Godot not use exceptions? Why does Pandemonium not use exceptions?
---------------------------------- ----------------------------------
We believe games should not crash, no matter what. If an unexpected We believe games should not crash, no matter what. If an unexpected
situation happens, Godot will print an error (which can be traced even to situation happens, Pandemonium will print an error (which can be traced even to
script), but then it will try to recover as gracefully as possible and keep script), but then it will try to recover as gracefully as possible and keep
going. going.
Additionally, exceptions significantly increase binary size for the Additionally, exceptions significantly increase binary size for the
executable. executable.
Why does Godot not enforce RTTI? Why does Pandemonium not enforce RTTI?
-------------------------------- --------------------------------
Godot provides its own type-casting system, which can optionally use RTTI Pandemonium provides its own type-casting system, which can optionally use RTTI
internally. Disabling RTTI in Godot means considerably smaller binary sizes can internally. Disabling RTTI in Pandemonium means considerably smaller binary sizes can
be achieved, at a little performance cost. be achieved, at a little performance cost.
Why does Godot not force users to implement DoD (Data oriented Design)? Why does Pandemonium not force users to implement DoD (Data oriented Design)?
----------------------------------------------------------------------- -----------------------------------------------------------------------
While Godot internally for a lot of the heavy performance tasks attempts While Pandemonium internally for a lot of the heavy performance tasks attempts
to use cache coherency as well as possible, we believe most users don't to use cache coherency as well as possible, we believe most users don't
really need to be forced to use DoD practices. really need to be forced to use DoD practices.
@ -521,19 +521,19 @@ modification). As in, if you are moving a few hundred sprites or enemies
per frame, DoD won't help you, and you should consider a different approach per frame, DoD won't help you, and you should consider a different approach
to optimization. to optimization.
The vast majority of games do not need this and Godot provides handy helpers The vast majority of games do not need this and Pandemonium provides handy helpers
to do the job for most cases when you do. to do the job for most cases when you do.
If a game that really needs to process such large amount of objects is If a game that really needs to process such large amount of objects is
needed, our recommendation is to use C++ and GDNative for the high needed, our recommendation is to use C++ and GDNative for the high
performance parts and GDScript (or C#) for the rest of the game. performance parts and GDScript (or C#) for the rest of the game.
How can I support Godot development or contribute? How can I support Pandemonium development or contribute?
-------------------------------------------------- --------------------------------------------------
See `doc_ways_to_contribute`. See `doc_ways_to_contribute`.
Who is working on Godot? How can I contact you? Who is working on Pandemonium? How can I contact you?
----------------------------------------------- -----------------------------------------------
See the corresponding page on the `Godot website ( https://godotengine.org/contact )`. See the corresponding page on the `Pandemonium website ( https://pandemoniumengine.org/contact )`.

32
about/introduction.md
View File

@ -8,7 +8,7 @@ Introduction
$Label.text = "Hello world!" $Label.text = "Hello world!"
``` ```
Welcome to the official documentation of Godot Engine, the free and open source Welcome to the official documentation of Pandemonium Engine, the free and open source
community-driven 2D and 3D game engine! Behind this mouthful, you will find a community-driven 2D and 3D game engine! Behind this mouthful, you will find a
powerful yet user-friendly tool that you can use to develop any kind of game, powerful yet user-friendly tool that you can use to develop any kind of game,
for any platform and with no usage restriction whatsoever. for any platform and with no usage restriction whatsoever.
@ -26,25 +26,25 @@ those may be worth a look.
In case you have trouble with one of the tutorials or your project, In case you have trouble with one of the tutorials or your project,
you can find help on the various `Community channels ( doc_community_channels )`, you can find help on the various `Community channels ( doc_community_channels )`,
especially the Godot Discord community, Q&A, and IRC. especially the Pandemonium Discord community, Q&A, and IRC.
About Godot Engine About Pandemonium Engine
------------------ ------------------
A game engine is a complex tool, and it is therefore difficult to present Godot A game engine is a complex tool, and it is therefore difficult to present Pandemonium
in a few words. Here's a quick synopsis, which you are free to reuse in a few words. Here's a quick synopsis, which you are free to reuse
if you need a quick writeup about Godot Engine. if you need a quick writeup about Pandemonium Engine.
Godot Engine is a feature-packed, cross-platform game engine to create 2D Pandemonium 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 and 3D games from a unified interface. It provides a comprehensive set of
common tools, so users can focus on making games without having to common tools, so users can focus on making games without having to
reinvent the wheel. Games can be exported in one click to a number of reinvent the wheel. Games can be exported in one click to a number of
platforms, including the major desktop platforms (Linux, macOS, Windows) platforms, including the major desktop platforms (Linux, macOS, Windows)
as well as mobile (Android, iOS) and web-based (HTML5) platforms. as well as mobile (Android, iOS) and web-based (HTML5) platforms.
Godot is completely free and open source under the permissive MIT Pandemonium is completely free and open source under the permissive MIT
license. No strings attached, no royalties, nothing. Users' games are license. No strings attached, no royalties, nothing. Users' games are
theirs, down to the last line of engine code. Godot's development is fully theirs, down to the last line of engine code. Pandemonium's development is fully
independent and community-driven, empowering users to help shape their independent and community-driven, empowering users to help shape their
engine to match their expectations. It is supported by the `Software engine to match their expectations. It is supported by the `Software
Freedom Conservancy ( https://sfconservancy.org )` not-for-profit. Freedom Conservancy ( https://sfconservancy.org )` not-for-profit.
@ -57,22 +57,22 @@ About the documentation
----------------------- -----------------------
This documentation is continuously written, corrected, edited, and revamped by This documentation is continuously written, corrected, edited, and revamped by
members of the Godot Engine community. It is edited via text files in the members of the Pandemonium Engine community. It is edited via text files in the
`reStructuredText ( http://www.sphinx-doc.org/en/stable/rest.html )` markup `reStructuredText ( http://www.sphinx-doc.org/en/stable/rest.html )` markup
language and then compiled into a static website/offline document using the language and then compiled into a static website/offline document using the
open source `Sphinx ( http://www.sphinx-doc.org )` and `ReadTheDocs open source `Sphinx ( http://www.sphinx-doc.org )` and `ReadTheDocs
( https://readthedocs.org/ )` tools. ( https://readthedocs.org/ )` tools.
Note: Note:
You can contribute to Godot's documentation by opening issue tickets You can contribute to Pandemonium's documentation by opening issue tickets
or sending patches via pull requests on its GitHub or sending patches via pull requests on its GitHub
`source repository ( https://github.com/godotengine/godot-docs )`, or `source repository ( https://github.com/pandemoniumengine/pandemonium-docs )`, or
translating it into your language on `Hosted Weblate translating it into your language on `Hosted Weblate
( https://hosted.weblate.org/projects/godot-engine/godot-docs/ )`. ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium-docs/ )`.
All the contents are under the permissive Creative Commons Attribution 3.0 All the contents are under the permissive Creative Commons Attribution 3.0
(`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`) license, with (`CC-BY 3.0 ( https://creativecommons.org/licenses/by/3.0/ )`) license, with
attribution to "Juan Linietsky, Ariel Manzur and the Godot Engine community". attribution to "Juan Linietsky, Ariel Manzur and the Pandemonium Engine community".
Organization of the documentation Organization of the documentation
--------------------------------- ---------------------------------
@ -99,13 +99,13 @@ relatively intuitive:
help with the documentation, etc. It also points to various community channels help with the documentation, etc. It also points to various community channels
like IRC and Discord and contains a list of recommended third-party tutorials like IRC and Discord and contains a list of recommended third-party tutorials
outside of this documentation. outside of this documentation.
- Finally, the `sec-class-ref` is the documentation of the Godot API, - Finally, the `sec-class-ref` is the documentation of the Pandemonium API,
which is also available directly within the engine's script editor. It is which is also available directly within the engine's script editor. It is
generated automatically from a file in the main source repository, therefore generated automatically from a file in the main source repository, therefore
the generated files of the documentation are not meant to be modified. See the generated files of the documentation are not meant to be modified. See
`doc_updating_the_class_reference` for details. `doc_updating_the_class_reference` for details.
In addition to this documentation you may also want to take a look at the In addition to this documentation you may also want to take a look at the
various `Godot demo projects ( https://github.com/godotengine/godot-demo-projects )`. various `Pandemonium demo projects ( https://github.com/pandemoniumengine/pandemonium-demo-projects )`.
Have fun reading and making games with Godot Engine! Have fun reading and making games with Pandemonium Engine!

38
about/list_of_features.md
View File

@ -3,13 +3,13 @@
List of features List of features
================ ================
This page aims to list all features currently supported by Godot. This page aims to list all features currently supported by Pandemonium.
Note: Note:
This page lists features supported by the current stable version of This page lists features supported by the current stable version of
Godot (3.5). `More features ( https://docs.godotengine.org/en/latest/about/list_of_features.html )` Pandemonium (3.5). `More features ( https://docs.pandemoniumengine.org/en/latest/about/list_of_features.html )`
are available in the latest development version (4.0). are available in the latest development version (4.0).
Features Features
@ -37,7 +37,7 @@ Platforms
- `Consoles ( doc_consoles )`. - `Consoles ( doc_consoles )`.
- `Headless Linux and macOS servers ( doc_exporting_for_dedicated_servers )`. - `Headless Linux and macOS servers ( doc_exporting_for_dedicated_servers )`.
Godot aims to be as platform-independent as possible and can be ported to new Pandemonium aims to be as platform-independent as possible and can be ported to new
platforms with relative ease. platforms with relative ease.
Editor Editor
@ -286,7 +286,7 @@ Note:
Most of the effects listed above can be adjusted for better performance or Most of the effects listed above can be adjusted for better performance or
to further improve quality. This can be helpful when using Godot for to further improve quality. This can be helpful when using Pandemonium for
offline rendering. offline rendering.
3D tools 3D tools
@ -384,13 +384,13 @@ Scripting
Warning: Warning:
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )` `Pandemonium 4.0 will remove VisualScript from core entirely. ( https://pandemoniumengine.org/article/pandemonium-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended. As a result, creating new projects using visual scripting in Pandemonium is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension. Future Pandemonium 4.x releases may have VisualScript reimplemented as an extension.
While Godot 3.x will keep VisualScript supported, we recommend While Pandemonium 3.x will keep VisualScript supported, we recommend
`trying out GDScript ( toc-learn-scripting-gdscript )` instead, `trying out GDScript ( toc-learn-scripting-gdscript )` instead,
especially if you intend to migrate your project to Godot 4. especially if you intend to migrate your project to Pandemonium 4.
Audio Audio
^^^^^ ^^^^^
@ -433,7 +433,7 @@ Import
- *3D scenes:* - *3D scenes:*
- glTF 2.0 *(recommended)*. - glTF 2.0 *(recommended)*.
- `ESCN ( https://github.com/godotengine/godot-blender-exporter )` - `ESCN ( https://github.com/pandemoniumengine/pandemonium-blender-exporter )`
(direct export from Blender). (direct export from Blender).
- FBX (experimental, static meshes only). - FBX (experimental, static meshes only).
- Collada (.dae). - Collada (.dae).
@ -499,7 +499,7 @@ Internationalization
or `gettext ( doc_localization_using_gettext )`. or `gettext ( doc_localization_using_gettext )`.
- Use localized strings in your project automatically in GUI elements or by - Use localized strings in your project automatically in GUI elements or by
using the `tr()` function. using the `tr()` function.
- Support for right-to-left typesetting and text shaping planned in Godot 4.0. - Support for right-to-left typesetting and text shaping planned in Pandemonium 4.0.
Windowing and OS integration Windowing and OS integration
^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -544,7 +544,7 @@ XR support (AR and VR)
GUI system GUI system
^^^^^^^^^^ ^^^^^^^^^^
Godot's GUI is built using the same Control nodes used to make games in Godot. Pandemonium's GUI is built using the same Control nodes used to make games in Pandemonium.
The editor UI can easily be extended in many ways using add-ons. The editor UI can easily be extended in many ways using add-ons.
**Nodes:** **Nodes:**
@ -587,7 +587,7 @@ The editor UI can easily be extended in many ways using add-ons.
- Texture-based theming using `StyleBoxTexture`. - Texture-based theming using `StyleBoxTexture`.
Godot's small distribution size can make it a suitable alternative to frameworks Pandemonium's small distribution size can make it a suitable alternative to frameworks
like Electron or Qt. like Electron or Qt.
Animation Animation
@ -615,7 +615,7 @@ File formats
- Read and write `JSON` files. - Read and write `JSON` files.
- Read and write INI-style configuration files using `ConfigFile`. - Read and write INI-style configuration files using `ConfigFile`.
- Can (de)serialize any Godot datatype, including Vector2/3, Color, ... - Can (de)serialize any Pandemonium datatype, including Vector2/3, Color, ...
- Read XML files using `XMLParser`. - Read XML files using `XMLParser`.
- Pack game data into a PCK file (custom format optimized for fast seeking), - Pack game data into a PCK file (custom format optimized for fast seeking),
@ -631,7 +631,7 @@ Miscellaneous
- `Command line interface ( doc_command_line_tutorial )` for automation. - `Command line interface ( doc_command_line_tutorial )` for automation.
- Export and deploy projects using continuous integration platforms. - Export and deploy projects using continuous integration platforms.
- `Shell completion scripts ( https://github.com/godotengine/godot/tree/master/misc/dist/shell )` - `Shell completion scripts ( https://github.com/pandemoniumengine/pandemonium/tree/master/misc/dist/shell )`
are available for Bash, zsh and fish. are available for Bash, zsh and fish.
- Support for `C++ modules ( doc_custom_modules_in_c++ )` statically linked - Support for `C++ modules ( doc_custom_modules_in_c++ )` statically linked
@ -641,9 +641,9 @@ Miscellaneous
- Can be `compiled ( doc_introduction_to_the_buildsystem )` using GCC, - Can be `compiled ( doc_introduction_to_the_buildsystem )` using GCC,
Clang and MSVC. MinGW is also supported. Clang and MSVC. MinGW is also supported.
- Friendly towards packagers. In most cases, system libraries can be used - Friendly towards packagers. In most cases, system libraries can be used
instead of the ones provided by Godot. The build system doesn't download anything. instead of the ones provided by Pandemonium. The build system doesn't download anything.
Builds can be fully reproducible. Builds can be fully reproducible.
- Godot 4.0 will be written in C++17. - Pandemonium 4.0 will be written in C++17.
- Licensed under the permissive MIT license. - Licensed under the permissive MIT license.
@ -652,6 +652,6 @@ Miscellaneous
See also: See also:
The `Godot proposals repository ( https://github.com/godotengine/godot-proposals )` The `Pandemonium proposals repository ( https://github.com/pandemoniumengine/pandemonium-proposals )`
lists features that have been requested by the community and may be implemented lists features that have been requested by the community and may be implemented
in future Godot releases. in future Pandemonium releases.

52
about/release_policy.md
View File

@ -1,17 +1,17 @@
Godot release policy Pandemonium release policy
==================== ====================
Godot's release policy is in constant evolution. What is described below is Pandemonium's release policy is in constant evolution. What is described below is
intended to give a general idea of what to expect, but what will actually intended to give a general idea of what to expect, but what will actually
happen depends on the choices of core contributors, and the needs of the happen depends on the choices of core contributors, and the needs of the
community at a given time. community at a given time.
Godot versioning Pandemonium versioning
---------------- ----------------
Godot loosely follows `Semantic Versioning ( https://semver.org/ )` with a Pandemonium loosely follows `Semantic Versioning ( https://semver.org/ )` with a
`major.minor.patch` versioning system, albeit with an interpretation of each `major.minor.patch` versioning system, albeit with an interpretation of each
term adapted to the complexity of a game engine: term adapted to the complexity of a game engine:
@ -19,7 +19,7 @@ term adapted to the complexity of a game engine:
which imply significant porting work to move projects from one major version which imply significant porting work to move projects from one major version
to another. to another.
For example, porting Godot projects from Godot 2.1 to Godot 3.0 required For example, porting Pandemonium projects from Pandemonium 2.1 to Pandemonium 3.0 required
running the project through a conversion tool, and then performing a number running the project through a conversion tool, and then performing a number
of further adjustments manually for what the tool could not do automatically. of further adjustments manually for what the tool could not do automatically.
@ -28,7 +28,7 @@ term adapted to the complexity of a game engine:
areas *may* happen in minor versions, but the vast majority of projects areas *may* happen in minor versions, but the vast majority of projects
should not be affected or require significant porting work. should not be affected or require significant porting work.
The reason for this is that as a game engine, Godot covers many areas such The reason for this is that as a game engine, Pandemonium covers many areas such
as rendering, physics, scripting, etc., and fixing bugs or implementing new as rendering, physics, scripting, etc., and fixing bugs or implementing new
features in a given area may sometimes require changing the behavior of a features in a given area may sometimes require changing the behavior of a
feature, or modifying the interface of a given class, even if the rest of feature, or modifying the interface of a given class, even if the rest of
@ -64,8 +64,8 @@ further developed for maintenance releases in a Git branch of the same name
Note: Note:
As mentioned in the introduction, Godot's release policy is evolving, and As mentioned in the introduction, Pandemonium's release policy is evolving, and
earlier Godot releases may not have followed the above rules to the letter. earlier Pandemonium releases may not have followed the above rules to the letter.
In particular, the 3.2 stable branch received a number of new features in In particular, the 3.2 stable branch received a number of new features in
3.2.2 which would have warranted a `minor` version increment. 3.2.2 which would have warranted a `minor` version increment.
@ -81,7 +81,7 @@ Whenever a new major version is released, we make the previous stable branch a
long-term supported release, and do our best to provide fixes for issues long-term supported release, and do our best to provide fixes for issues
encountered by users of that branch who cannot port complex projects to the new encountered by users of that branch who cannot port complex projects to the new
major version. This was the case for the 2.1 branch, and will be the case for major version. This was the case for the 2.1 branch, and will be the case for
the latest 3.x stable branch by the time Godot 4.0 is released. the latest 3.x stable branch by the time Pandemonium 4.0 is released.
In a given minor release series, only the latest patch release receives support. In a given minor release series, only the latest patch release receives support.
If you experience an issue using an older patch release, please upgrade to the If you experience an issue using an older patch release, please upgrade to the
@ -91,32 +91,32 @@ on GitHub.
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| **Version** | **Release date** | **Support level** | | **Version** | **Release date** | **Support level** |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 4.0 | Q4 2022 | |unstable| *Alpha.* Current focus of development (unstable). | | Pandemonium 4.0 | Q4 2022 | |unstable| *Alpha.* Current focus of development (unstable). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.6 | Q4 2022 | |supported| *Beta.* Receives new features as well as bug fixes while | | Pandemonium 3.6 | Q4 2022 | |supported| *Beta.* Receives new features as well as bug fixes while |
| | | under development. | | | | under development. |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.5 | August 2022 | |supported| Receives fixes for bugs, security and platform support | | Pandemonium 3.5 | August 2022 | |supported| Receives fixes for bugs, security and platform support |
| | | issues, as well as backwards-compatible usability enhancements. | | | | issues, as well as backwards-compatible usability enhancements. |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.4 | November 2021 | |partial| Receives fixes for security and platform support issues only. | | Pandemonium 3.4 | November 2021 | |partial| Receives fixes for security and platform support issues only. |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.3 | April 2021 | |eol| No longer supported as fully superseded by the compatible 3.4 | | Pandemonium 3.3 | April 2021 | |eol| No longer supported as fully superseded by the compatible 3.4 |
| | | release (last update: 3.3.4). | | | | release (last update: 3.3.4). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.2 | January 2020 | |eol| No longer supported (last update: 3.2.3). | | Pandemonium 3.2 | January 2020 | |eol| No longer supported (last update: 3.2.3). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.1 | March 2019 | |eol| No longer supported (last update: 3.1.2). | | Pandemonium 3.1 | March 2019 | |eol| No longer supported (last update: 3.1.2). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 3.0 | January 2018 | |eol| No longer supported (last update: 3.0.6). | | Pandemonium 3.0 | January 2018 | |eol| No longer supported (last update: 3.0.6). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 2.1 | July 2016 | |eol| No longer supported (last update: 2.1.6). | | Pandemonium 2.1 | July 2016 | |eol| No longer supported (last update: 2.1.6). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 2.0 | February 2016 | |eol| No longer supported (last update: 2.0.4.1). | | Pandemonium 2.0 | February 2016 | |eol| No longer supported (last update: 2.0.4.1). |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 1.1 | May 2015 | |eol| No longer supported. | | Pandemonium 1.1 | May 2015 | |eol| No longer supported. |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
| Godot 1.0 | December 2014 | |eol| No longer supported. | | Pandemonium 1.0 | December 2014 | |eol| No longer supported. |
+-------------+----------------------+--------------------------------------------------------------------------+ +-------------+----------------------+--------------------------------------------------------------------------+
.. |supported| image:: img/supported.png) .. |supported| image:: img/supported.png)
@ -130,7 +130,7 @@ on GitHub.
|eol| No support (end of life) – |eol| No support (end of life) –
|unstable| Development version |unstable| Development version
Pre-release Godot versions aren't intended to be used in production and are Pre-release Pandemonium versions aren't intended to be used in production and are
provided for testing purposes only. provided for testing purposes only.
@ -138,15 +138,15 @@ provided for testing purposes only.
When is the next release out? When is the next release out?
----------------------------- -----------------------------
While Godot contributors aren't working under any deadlines, we strive to While Pandemonium contributors aren't working under any deadlines, we strive to
publish minor releases relatively frequently, with an average of two 3.x minor publish minor releases relatively frequently, with an average of two 3.x minor
releases per year since Godot 3.3. releases per year since Pandemonium 3.3.
Maintenance (patch) releases are released as needed with potentially very Maintenance (patch) releases are released as needed with potentially very
short development cycles, to provide users of the current stable branch with short development cycles, to provide users of the current stable branch with
the latest bug fixes for their production needs. the latest bug fixes for their production needs.
As for the upcoming Godot 4.0, as of August 2022, we are aiming for a *beta* As for the upcoming Pandemonium 4.0, as of August 2022, we are aiming for a *beta*
release in Q3 2022, and possibly a stable release by Q4 2022 (but experience release in Q3 2022, and possibly a stable release by Q4 2022 (but experience
has shown time and time again that such estimates tend to be overly optimistic). has shown time and time again that such estimates tend to be overly optimistic).
`Follow the Godot blog ( https://godotengine.org/news )` for the latest updates. `Follow the Pandemonium blog ( https://pandemoniumengine.org/news )` for the latest updates.

26
about/troubleshooting.md
View File

@ -3,18 +3,18 @@
Troubleshooting Troubleshooting
=============== ===============
This page lists common issues encountered when using Godot and possible solutions. This page lists common issues encountered when using Pandemonium and possible solutions.
See also: See also:
See `doc_using_the_web_editor` for caveats specific to the HTML5 version See `doc_using_the_web_editor` for caveats specific to the HTML5 version
of the Godot editor. of the Pandemonium editor.
Everything I do in the editor or project manager appears delayed by one frame. Everything I do in the editor or project manager appears delayed by one frame.
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
This is a `known bug ( https://github.com/godotengine/godot/issues/23069 )` on This is a `known bug ( https://github.com/pandemoniumengine/pandemonium/issues/23069 )` on
Intel graphics drivers on Windows. Updating to the latest graphics driver Intel graphics drivers on Windows. Updating to the latest graphics driver
version *provided by Intel* should fix the issue. version *provided by Intel* should fix the issue.
@ -25,19 +25,19 @@ outdated.
The grid disappears and meshes turn black when I rotate the 3D camera in the editor. The grid disappears and meshes turn black when I rotate the 3D camera in the editor.
------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------
This is a `known bug ( https://github.com/godotengine/godot/issues/30330 )` on This is a `known bug ( https://github.com/pandemoniumengine/pandemonium/issues/30330 )` on
Intel graphics drivers on Windows. Intel graphics drivers on Windows.
The only workaround, for now, is to switch to the GLES2 renderer. You can switch The only workaround, for now, is to switch to the GLES2 renderer. You can switch
the renderer in the top-right corner of the editor or the Project Settings. the renderer in the top-right corner of the editor or the Project Settings.
If you use a computer allowing you to switch your graphics card, like NVIDIA If you use a computer allowing you to switch your graphics card, like NVIDIA
Optimus, you can use the dedicated graphics card to run Godot. Optimus, you can use the dedicated graphics card to run Pandemonium.
The editor or project takes a very long time to start. The editor or project takes a very long time to start.
------------------------------------------------------ ------------------------------------------------------
This is a `known bug ( https://github.com/godotengine/godot/issues/20566 )` on This is a `known bug ( https://github.com/pandemoniumengine/pandemonium/issues/20566 )` on
Windows when you have specific USB peripherals connected. In particular, Windows when you have specific USB peripherals connected. In particular,
Corsair's iCUE software seems to cause the bug. Try updating your USB Corsair's iCUE software seems to cause the bug. Try updating your USB
peripherals' drivers to their latest version. If the bug persists, you need to peripherals' drivers to their latest version. If the bug persists, you need to
@ -47,17 +47,17 @@ connect the peripheral again.
Editor tooltips in the Inspector and Node docks blink when they're displayed. Editor tooltips in the Inspector and Node docks blink when they're displayed.
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
This is a `known issue ( https://github.com/godotengine/godot/issues/32990 )` This is a `known issue ( https://github.com/pandemoniumengine/pandemonium/issues/32990 )`
caused by the third-party Stardock Fences application on Windows. caused by the third-party Stardock Fences application on Windows.
The only known workaround is to disable Stardock Fences while using Godot. The only known workaround is to disable Stardock Fences while using Pandemonium.
The Godot editor appears frozen after clicking the system console. The Pandemonium editor appears frozen after clicking the system console.
------------------------------------------------------------------ ------------------------------------------------------------------
When running Godot on Windows with the system console enabled, you can When running Pandemonium on Windows with the system console enabled, you can
accidentally enable *selection mode* by clicking inside the command window. This accidentally enable *selection mode* by clicking inside the command window. This
Windows-specific behavior pauses the application to let you select text inside Windows-specific behavior pauses the application to let you select text inside
the system console. Godot cannot override this system-specific behavior. the system console. Pandemonium cannot override this system-specific behavior.
To solve this, select the system console window and press Enter to leave To solve this, select the system console window and press Enter to leave
selection mode. selection mode.
@ -87,7 +87,7 @@ configured to support `multiple resolutions ( doc_multiple_resolutions )`.
The project window doesn't appear centered when I run the project. The project window doesn't appear centered when I run the project.
------------------------------------------------------------------ ------------------------------------------------------------------
This is a `known bug ( https://github.com/godotengine/godot/issues/13017 )`. To This is a `known bug ( https://github.com/pandemoniumengine/pandemonium/issues/13017 )`. To
resolve this, open **Project > Project Settings** and enable **Display > Window resolve this, open **Project > Project Settings** and enable **Display > Window
> Dpi > Allow Hidpi**. On top of that, make sure your project is configured to > Dpi > Allow Hidpi**. On top of that, make sure your project is configured to
support `multiple resolutions ( doc_multiple_resolutions )`. support `multiple resolutions ( doc_multiple_resolutions )`.
@ -96,7 +96,7 @@ The project works when run from the editor, but fails to load some files when ru
------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------
This is usually caused by forgetting to specify a filter for non-resource files This is usually caused by forgetting to specify a filter for non-resource files
in the Export dialog. By default, Godot will only include actual *resources* in the Export dialog. By default, Pandemonium will only include actual *resources*
into the PCK file. Some files commonly used, such as JSON files, are not into the PCK file. Some files commonly used, such as JSON files, are not
considered resources. For example, if you load `test.json` in the exported considered resources. For example, if you load `test.json` in the exported
project, you need to specify `*.json` in the non-resource export filter. See project, you need to specify `*.json` in the non-resource export filter. See

12
community/contributing/best_practices_for_engine_contributors.md
View File

@ -6,7 +6,7 @@ Best practices for engine contributors
Introduction Introduction
------------ ------------
Godot has a large amount of users who have the ability to contribute, given the Pandemonium has a large amount of users who have the ability to contribute, given the
project itself is aimed mainly at users with the ability to do programming. project itself is aimed mainly at users with the ability to do programming.
Despite this, not all of them have the same level of experience working in large Despite this, not all of them have the same level of experience working in large
projects or in software engineering, which can lead to common misunderstandings projects or in software engineering, which can lead to common misunderstandings
@ -76,7 +76,7 @@ than it needs to be.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Software is designed to solve problems, but we can't expect it to solve *every Software is designed to solve problems, but we can't expect it to solve *every
problem that exists under the sun*. As a game engine, Godot will solve problems problem that exists under the sun*. As a game engine, Pandemonium will solve problems
for you, so it helps you to make games better and faster, but it won't make the for you, so it helps you to make games better and faster, but it won't make the
*entire game* for you. A line must be drawn somewhere. *entire game* for you. A line must be drawn somewhere.
@ -128,7 +128,7 @@ The only exception, in this case, is when an area of code has a clear owner
(agreed by the other contributors), who talks to users directly and has the most (agreed by the other contributors), who talks to users directly and has the most
knowledge to implement a solution directly. knowledge to implement a solution directly.
Also, Godot's philosophy is to favor ease of use and maintenance over absolute Also, Pandemonium's philosophy is to favor ease of use and maintenance over absolute
performance. Performance optimizations will be considered, but they may not performance. Performance optimizations will be considered, but they may not
be accepted if they make something too difficult to use or if they add too much be accepted if they make something too difficult to use or if they add too much
complexity to the codebase. complexity to the codebase.
@ -225,7 +225,7 @@ but this path is always the advised one.
Not every problem has a simple solution and, many times, the right choice is to Not every problem has a simple solution and, many times, the right choice is to
use a third party library to solve the problem. use a third party library to solve the problem.
As Godot requires to be shipped in a large amount of platforms, we can't As Pandemonium requires to be shipped in a large amount of platforms, we can't
link libraries dynamically. Instead, we bundle them in our source tree. link libraries dynamically. Instead, we bundle them in our source tree.
![](img/best_practices8.png) ![](img/best_practices8.png)
@ -234,11 +234,11 @@ As a result, we are very picky with what goes in, and we tend to prefer smaller
libraries (in fact, single header ones are our favorite). Only in cases where libraries (in fact, single header ones are our favorite). Only in cases where
there is no other choice we end up bundling something larger. there is no other choice we end up bundling something larger.
Also, libraries must use a permissive enough license to be included into Godot. Also, libraries must use a permissive enough license to be included into Pandemonium.
Some examples of acceptable licenses are Apache 2.0, BSD, MIT, ISC, and MPL 2.0. Some examples of acceptable licenses are Apache 2.0, BSD, MIT, ISC, and MPL 2.0.
In particular, we cannot accept libraries licensed under the GPL or LGPL since In particular, we cannot accept libraries licensed under the GPL or LGPL since
these licenses effectively disallow static linking in proprietary software these licenses effectively disallow static linking in proprietary software
(which Godot is distributed as in most exported projects). This requirement also (which Pandemonium is distributed as in most exported projects). This requirement also
applies to the editor, since we may want to run it on iOS in the long term. applies to the editor, since we may want to run it on iOS in the long term.
Since iOS doesn't support dynamic linking, static linking the only option on Since iOS doesn't support dynamic linking, static linking the only option on
that platform. that platform.

44
community/contributing/bisecting_regressions.md
View File

@ -5,7 +5,7 @@ Bisecting regressions
Bisecting is a way to find regressions in software. After reporting a bug on the Bisecting is a way to find regressions in software. After reporting a bug on the
`Godot repository on GitHub ( https://github.com/godotengine/godot )`, you may `Pandemonium repository on GitHub ( https://github.com/pandemoniumengine/pandemonium )`, you may
be asked by a contributor to *bisect* the issue. Bisecting makes it possible for be asked by a contributor to *bisect* the issue. Bisecting makes it possible for
contributors to fix bugs faster, as they can know in advance which commit caused contributors to fix bugs faster, as they can know in advance which commit caused
the regression. Your effort will be widely appreciated :) the regression. Your effort will be widely appreciated :)
@ -15,7 +15,7 @@ The guide below explains how to find a regression by bisecting.
What is bisecting? What is bisecting?
------------------ ------------------
Godot developers use the `Git ( https://git-scm.com/ )` version control system. Pandemonium developers use the `Git ( https://git-scm.com/ )` version control system.
In the context of Git, bisecting is the process of performing a manual In the context of Git, bisecting is the process of performing a manual
`binary search ( https://en.wikipedia.org/wiki/Binary_search_algorithm )` `binary search ( https://en.wikipedia.org/wiki/Binary_search_algorithm )`
to determine when a regression appeared. While it's typically used for bugs, to determine when a regression appeared. While it's typically used for bugs,
@ -29,22 +29,22 @@ Before using Git's `bisect` command, we strongly recommend trying to reproduce
the bug with an older (or newer) official release. This greatly reduces the the bug with an older (or newer) official release. This greatly reduces the
range of commits that potentially need to be built from source and tested. range of commits that potentially need to be built from source and tested.
You can find binaries of official releases, as well as alphas, betas, You can find binaries of official releases, as well as alphas, betas,
and release candidates `here ( https://downloads.tuxfamily.org/godotengine/ )`. and release candidates `here ( https://downloads.tuxfamily.org/pandemoniumengine/ )`.
For example, if you've reported a bug against Godot 3.2, you should first try to For example, if you've reported a bug against Pandemonium 3.2, you should first try to
reproduce the bug in Godot 3.1 (not a patch release, see below for the reason). reproduce the bug in Pandemonium 3.1 (not a patch release, see below for the reason).
If the bug doesn't occur there, try to reproduce it in Godot 3.2 *beta 1* (which If the bug doesn't occur there, try to reproduce it in Pandemonium 3.2 *beta 1* (which
is roughly in the middle of all test builds available). If you can't reproduce is roughly in the middle of all test builds available). If you can't reproduce
the bug with Godot 3.2 beta 1, then try newer betas and RC builds. If you do the bug with Pandemonium 3.2 beta 1, then try newer betas and RC builds. If you do
manage to reproduce the bug with Godot 3.2 beta 1, then try older alpha builds. manage to reproduce the bug with Pandemonium 3.2 beta 1, then try older alpha builds.
Warning: Warning:
For bisecting regressions, don't use patch releases such as Godot 3.1.2. For bisecting regressions, don't use patch releases such as Pandemonium 3.1.2.
Instead, use the minor version's first release like Godot 3.1. This is Instead, use the minor version's first release like Pandemonium 3.1. This is
because patch releases are built from a separate *stable branch*. This kind because patch releases are built from a separate *stable branch*. This kind
of branch doesn't follow the rest of Godot's development, which is done in of branch doesn't follow the rest of Pandemonium's development, which is done in
the `master` branch. the `master` branch.
The Git bisect command The Git bisect command
@ -60,11 +60,11 @@ Note:
Before bisecting a regression, you need to set up a build environment to Before bisecting a regression, you need to set up a build environment to
compile Godot from source. To do so, read the compile Pandemonium from source. To do so, read the
`Compiling ( toc-devel-compiling )` page for your target platform. `Compiling ( toc-devel-compiling )` page for your target platform.
(Compiling Godot from source doesn't require C++ programming knowledge.) (Compiling Pandemonium from source doesn't require C++ programming knowledge.)
Note that compiling Godot can take a while on slow hardware (up an hour for Note that compiling Pandemonium can take a while on slow hardware (up an hour for
each full rebuild on a slow dual-core CPU). This means the full process can each full rebuild on a slow dual-core CPU). This means the full process can
take up to several hours. If your hardware is too slow, you may want to stop take up to several hours. If your hardware is too slow, you may want to stop
there and report the results of your "pre-bisecting" on the GitHub issue so there and report the results of your "pre-bisecting" on the GitHub issue so
@ -74,7 +74,7 @@ To start bisecting, you must first determine the commit hashes (identifiers) of
the "bad" and "good" build. "bad" refers to the build that exhibits the bug, the "bad" and "good" build. "bad" refers to the build that exhibits the bug,
whereas "good" refers to the version that doesn't exhibit the bug. If you're whereas "good" refers to the version that doesn't exhibit the bug. If you're
using a pre-release build as the "good" or "bad" build, browse the `download using a pre-release build as the "good" or "bad" build, browse the `download
mirror ( https://downloads.tuxfamily.org/godotengine/ )`, go to the folder that mirror ( https://downloads.tuxfamily.org/pandemoniumengine/ )`, go to the folder that
contains the pre-release you downloaded and look for the `README.txt` file. contains the pre-release you downloaded and look for the `README.txt` file.
The commit hash is written inside that file. The commit hash is written inside that file.
@ -90,8 +90,8 @@ following commit hashes depending on the version:
To refer to the latest state of the master branch, you can use `master` To refer to the latest state of the master branch, you can use `master`
instead of a commit hash. instead of a commit hash.
`Get Godot's source code using Git ( doc_getting_source )`. Once this `Get Pandemonium's source code using Git ( doc_getting_source )`. Once this
is done, in the terminal window, use `cd` to reach the Godot repository is done, in the terminal window, use `cd` to reach the Pandemonium repository
folder and enter the following command: folder and enter the following command:
``` ```
@ -102,7 +102,7 @@ folder and enter the following command:
$ git bisect bad <bad commit hash> $ git bisect bad <bad commit hash>
``` ```
Compile Godot. This assumes you've set up a build environment: Compile Pandemonium. This assumes you've set up a build environment:
``` ```
# <platform> is the platform you're targeting for regression testing, # <platform> is the platform you're targeting for regression testing,
@ -110,9 +110,9 @@ Compile Godot. This assumes you've set up a build environment:
$ scons platform=<platform> -j4 $ scons platform=<platform> -j4
``` ```
Since building Godot takes a while, you want to dedicate as many CPU threads as Since building Pandemonium takes a while, you want to dedicate as many CPU threads as
possible to the task. This is what the `-j` parameter does. Here, the command possible to the task. This is what the `-j` parameter does. Here, the command
assigns 4 CPU threads to compiling Godot. assigns 4 CPU threads to compiling Pandemonium.
Run the binary located in the `bin/` folder and try to reproduce the bug. Run the binary located in the `bin/` folder and try to reproduce the bug.
@ -129,7 +129,7 @@ If the build **does not** exhibit the bug, run the following command:
``` ```
After entering one of the commands above, Git will switch to a different commit. After entering one of the commands above, Git will switch to a different commit.
You should now build Godot again, try to reproduce the bug, then enter `git You should now build Pandemonium again, try to reproduce the bug, then enter `git
bisect good` or `git bisect bad` depending on the result. You'll have to bisect good` or `git bisect bad` depending on the result. You'll have to
repeat this several times. The longer the commit range, the more steps will be repeat this several times. The longer the commit range, the more steps will be
required. 5 to 10 steps are usually sufficient to find most regressions; Git required. 5 to 10 steps are usually sufficient to find most regressions; Git
@ -138,7 +138,7 @@ will remind you of the number of steps remaining (in the worst case scenario).
Once you've completed enough steps, Git will display the commit hash where the Once you've completed enough steps, Git will display the commit hash where the
regression appeared. Write this commit hash as a comment to the GitHub issue regression appeared. Write this commit hash as a comment to the GitHub issue
you've bisected. This will help in solving the issue. Thanks again for you've bisected. This will help in solving the issue. Thanks again for
contributing to Godot :) contributing to Pandemonium :)
Note: Note:

32
community/contributing/bug_triage_guidelines.md
View File

@ -4,8 +4,8 @@ Bug triage guidelines
===================== =====================
This page describes the typical workflow of the bug triage team aka This page describes the typical workflow of the bug triage team aka
bugsquad when handling issues and pull requests on Godot's bugsquad when handling issues and pull requests on Pandemonium's
`GitHub repository ( https://github.com/godotengine/godot )`. `GitHub repository ( https://github.com/pandemoniumengine/pandemonium )`.
It is bound to evolve together with the bugsquad, so do not It is bound to evolve together with the bugsquad, so do not
hesitate to propose modifications to the following guidelines. hesitate to propose modifications to the following guidelines.
@ -17,10 +17,10 @@ GitHub proposes various features to manage issues:
- Set one or several labels from a predefined list - Set one or several labels from a predefined list
- Set one milestone from a predefined list - Set one milestone from a predefined list
- Keep track of the issue in the project dashboard - Keep track of the issue in the project dashboard
- Define one contributor as "assignee" among the Godot engine - Define one contributor as "assignee" among the Pandemonium engine
organization members organization members
As the Godot engine organization on GitHub currently has a restricted As the Pandemonium engine organization on GitHub currently has a restricted
number of contributors, we do not use assignees extensively for now. All number of contributors, we do not use assignees extensively for now. All
contributors are welcome to take on any issue, if relevant after mentioning contributors are welcome to take on any issue, if relevant after mentioning
it on the issue ticket and/or discussing the best way to resolve it with it on the issue ticket and/or discussing the best way to resolve it with
@ -34,7 +34,7 @@ to both issues and pull requests.
Labels Labels
~~~~~~ ~~~~~~
The following labels are currently defined in the Godot repository: The following labels are currently defined in the Pandemonium repository:
**Categories:** **Categories:**
@ -52,7 +52,7 @@ The following labels are currently defined in the Godot repository:
The purpose of this label is to let developers know which issues are The purpose of this label is to let developers know which issues are
still reproducible when they want to select what to work on. It is still reproducible when they want to select what to work on. It is
therefore a good practice to add in a comment on what platform and therefore a good practice to add in a comment on what platform and
what version or commit of Godot the issue could be reproduced; if a what version or commit of Pandemonium the issue could be reproduced; if a
developer looks at the issue one year later, the *Confirmed* label developer looks at the issue one year later, the *Confirmed* label
may not be relevant anymore. may not be relevant anymore.
- *Discussion*: the issue is not consensual and needs further - *Discussion*: the issue is not consensual and needs further
@ -61,15 +61,15 @@ The following labels are currently defined in the Godot repository:
- *Documentation*: issue related to the documentation. Mainly to request - *Documentation*: issue related to the documentation. Mainly to request
enhancements in the API documentation. Issues related to the ReadTheDocs enhancements in the API documentation. Issues related to the ReadTheDocs
documentation should be filed on the documentation should be filed on the
`godot-docs ( https://github.com/godotengine/godot-docs )` repository. `pandemonium-docs ( https://github.com/pandemoniumengine/pandemonium-docs )` repository.
- *Enhancement*: describes a proposed enhancement to an existing - *Enhancement*: describes a proposed enhancement to an existing
functionality. functionality.
- *Feature proposal*: describes a wish for a new feature to be - *Feature proposal*: describes a wish for a new feature to be
implemented. Note that the main Godot repository no longer accepts implemented. Note that the main Pandemonium repository no longer accepts
feature requests. Please use feature requests. Please use
`godot-proposals ( https://github.com/godotengine/godot-proposals )` instead. `pandemonium-proposals ( https://github.com/pandemoniumengine/pandemonium-proposals )` instead.
- *For PR meeting*: the issue needs to be discussed in a pull request meeting. - *For PR meeting*: the issue needs to be discussed in a pull request meeting.
These meetings are public and are held on the `Godot Contributors Chat ( https://chat.godotengine.org/ )`. These meetings are public and are held on the `Pandemonium Contributors Chat ( https://chat.pandemoniumengine.org/ )`.
- *Good first issue*: the issue is *assumed* to be an easy one to fix, which makes - *Good first issue*: the issue is *assumed* to be an easy one to fix, which makes
it a great fit for new contributors who need to become familiar with it a great fit for new contributors who need to become familiar with
the code base. the code base.
@ -126,9 +126,9 @@ feature request, or one that is not precise enough to be worked on.
- *Plugin*: relates to problems encountered while writing plugins. - *Plugin*: relates to problems encountered while writing plugins.
- *Porting*: relates to some specific platforms or exporting projects. - *Porting*: relates to some specific platforms or exporting projects.
- *Rendering*: relates to the 2D and 3D rendering engines. - *Rendering*: relates to the 2D and 3D rendering engines.
- *Shaders*: relates to the Godot shader language or visual shaders. - *Shaders*: relates to the Pandemonium shader language or visual shaders.
- *Tests*: relates to unit tests. - *Tests*: relates to unit tests.
- *Thirdparty*: relates to third-party libraries used in Godot. - *Thirdparty*: relates to third-party libraries used in Pandemonium.
- *VisualScript*: relates to issues with the visual scripting language (*not* visual shaders). - *VisualScript*: relates to issues with the visual scripting language (*not* visual shaders).
- *XR*: relates to Augmented Reality or Virtual Reality. - *XR*: relates to Augmented Reality or Virtual Reality.
@ -149,7 +149,7 @@ Android and Linux exclusively, select those two platforms).
Documentation labels Documentation labels
~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~
In the `documentation repository ( https://github.com/godotengine/godot-docs )`, we In the `documentation repository ( https://github.com/pandemoniumengine/pandemonium-docs )`, we
use the following labels: use the following labels:
- *Bug*: Incorrect information in an existing page. Not to be used for - *Bug*: Incorrect information in an existing page. Not to be used for
@ -170,15 +170,15 @@ use the following labels:
merge conflicts and its author is not active anymore. However, it can still merge conflicts and its author is not active anymore. However, it can still
be picked up by an external contributor to bring it to a mergeable state. be picked up by an external contributor to bring it to a mergeable state.
To do so, you need to open a new pull request based on the original pull request. To do so, you need to open a new pull request based on the original pull request.
- *Topic:Mono*: the issue is about C# support in Godot. - *Topic:Mono*: the issue is about C# support in Pandemonium.
- *Topic:Website*: the issue relates to the Sphinx/Read the Docs frontend or backend, - *Topic:Website*: the issue relates to the Sphinx/Read the Docs frontend or backend,
not the documentation contents. not the documentation contents.
Milestones Milestones
~~~~~~~~~~ ~~~~~~~~~~
`Milestones ( https://github.com/godotengine/godot/milestones )` correspond to `Milestones ( https://github.com/pandemoniumengine/pandemonium/milestones )` correspond to
planned future versions of Godot for which there is an existing roadmap. Issues planned future versions of Pandemonium for which there is an existing roadmap. Issues
that fit in the said roadmap should be filed under the corresponding milestone; that fit in the said roadmap should be filed under the corresponding milestone;
if they don't correspond to any current roadmap, they should be left without if they don't correspond to any current roadmap, they should be left without
milestone. As a rule of thumb, an issue corresponds to a given milestone if it milestone. As a rule of thumb, an issue corresponds to a given milestone if it

12
community/contributing/building_the_manual.md
View File

@ -3,18 +3,18 @@
Building the manual with Sphinx Building the manual with Sphinx
=============================== ===============================
This page explains how to build a local copy of the Godot manual using the This page explains how to build a local copy of the Pandemonium manual using the
Sphinx docs engine. This allows you to have local HTML files and build the Sphinx docs engine. This allows you to have local HTML files and build the
documentation as a PDF, EPUB, or LaTeX file, for example. documentation as a PDF, EPUB, or LaTeX file, for example.
To get started, you need to: To get started, you need to:
1. Clone the `godot-docs repository ( https://github.com/godotengine/godot-docs/ )`. 1. Clone the `pandemonium-docs repository ( https://github.com/pandemoniumengine/pandemonium-docs/ )`.
2. Install `Sphinx ( https://www.sphinx-doc.org/ )` 2. Install `Sphinx ( https://www.sphinx-doc.org/ )`
3. To build the docs as HTML files, install the `readthedocs.org theme 3. To build the docs as HTML files, install the `readthedocs.org theme
( https://github.com/snide/sphinx_rtd_theme )`. ( https://github.com/snide/sphinx_rtd_theme )`.
4. Install the Sphinx extensions defined in the `godot-docs repository 4. Install the Sphinx extensions defined in the `pandemonium-docs repository
( https://github.com/godotengine/godot-docs/ )` `requirements.txt` file. ( https://github.com/pandemoniumengine/pandemonium-docs/ )` `requirements.txt` file.
We recommend using `pip ( https://pip.pypa.io )`, Python’s package manager to We recommend using `pip ( https://pip.pypa.io )`, Python’s package manager to
install all these tools. It comes pre-installed with `Python install all these tools. It comes pre-installed with `Python
@ -26,7 +26,7 @@ Note:
If both approaches fail, `check that you have pip3 installed ( https://pip.pypa.io/en/stable/installation/ )`. If both approaches fail, `check that you have pip3 installed ( https://pip.pypa.io/en/stable/installation/ )`.
``` ```
git clone https://github.com/godotengine/godot-docs.git git clone https://github.com/pandemoniumengine/pandemonium-docs.git
pip3 install -r requirements.txt pip3 install -r requirements.txt
``` ```
@ -73,7 +73,7 @@ Note:
If you delete the `classes/` folder, do not use `git add .` when If you delete the `classes/` folder, do not use `git add .` when
working on a pull request or the whole `classes/` folder will be working on a pull request or the whole `classes/` folder will be
removed when you commit. See `#3157 removed when you commit. See `#3157
( https://github.com/godotengine/godot-docs/issues/3157 )` for more ( https://github.com/pandemoniumengine/pandemonium-docs/issues/3157 )` for more
detail. detail.
Alternatively, you can build the documentation by running the sphinx-build Alternatively, you can build the documentation by running the sphinx-build

20
community/contributing/class_reference_writing_guidelines.md
View File

@ -4,13 +4,13 @@ Class reference writing guidelines
================================== ==================================
This page explains how to write the class reference. You will learn where to This page explains how to write the class reference. You will learn where to
write new descriptions for the classes, methods, and properties for Godot's write new descriptions for the classes, methods, and properties for Pandemonium's
built-in node types. built-in node types.
See also: See also:
To learn to submit your changes to the Godot project using the Git version To learn to submit your changes to the Pandemonium project using the Git version
control system, see `doc_updating_the_class_reference`. control system, see `doc_updating_the_class_reference`.
The reference for each class is contained in an XML file like the one below: The reference for each class is contained in an XML file like the one below:
@ -24,8 +24,8 @@ The reference for each class is contained in an XML file like the one below:
A 2D game object, with a transform (position, rotation, and scale). All 2D nodes, including physics objects and sprites, inherit from Node2D. Use Node2D as a parent node to move, scale and rotate children in a 2D project. Also gives control of the node's render order. A 2D game object, with a transform (position, rotation, and scale). All 2D nodes, including physics objects and sprites, inherit from Node2D. Use Node2D as a parent node to move, scale and rotate children in a 2D project. Also gives control of the node's render order.
</description> </description>
<tutorials> <tutorials>
<link title="Custom drawing in 2D">https://docs.godotengine.org/en/latest/tutorials/2d/custom_drawing_in_2d.html</link> <link title="Custom drawing in 2D">https://docs.pandemoniumengine.org/en/latest/tutorials/2d/custom_drawing_in_2d.html</link>
<link title="All 2D Demos">https://github.com/godotengine/godot-demo-projects/tree/master/2d</link> <link title="All 2D Demos">https://github.com/pandemoniumengine/pandemonium-demo-projects/tree/master/2d</link>
</tutorials> </tutorials>
<methods> <methods>
<method name="apply_scale"> <method name="apply_scale">
@ -67,7 +67,7 @@ description is always at the top of the page, while the long description lies
below the list of methods, variables, and constants. You can find methods, below the list of methods, variables, and constants. You can find methods,
member variables, constants, and signals in separate XML nodes. member variables, constants, and signals in separate XML nodes.
For each, you want to learn how they work in Godot's source code. Then, fill For each, you want to learn how they work in Pandemonium's source code. Then, fill
their documentation by completing or improving the text in these tags: their documentation by completing or improving the text in these tags:
- `<brief_description>` - `<brief_description>`
@ -91,7 +91,7 @@ How to edit class XML
Edit the file for your chosen class in `doc/classes/` to update the class Edit the file for your chosen class in `doc/classes/` to update the class
reference. The folder contains an XML file for each class. The XML lists the reference. The folder contains an XML file for each class. The XML lists the
constants and methods you will find in the class reference. Godot generates and constants and methods you will find in the class reference. Pandemonium generates and
updates the XML automatically. updates the XML automatically.
Note: Note:
@ -107,7 +107,7 @@ documentation, navigate to the `doc/` folder and run the command `make rst`.
This will convert the XML files to the online documentation's format and output This will convert the XML files to the online documentation's format and output
errors if anything's wrong. errors if anything's wrong.
Alternatively, you can build Godot and open the modified page in the built-in Alternatively, you can build Pandemonium and open the modified page in the built-in
code reference. To learn how to compile the engine, read the `compilation code reference. To learn how to compile the engine, read the `compilation
guide ( toc-devel-compiling )`. guide ( toc-devel-compiling )`.
@ -120,7 +120,7 @@ search feature to find classes and properties quickly.
Improve formatting with BBCode style tags Improve formatting with BBCode style tags
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Godot's class reference supports BBCode-like tags. They add nice formatting to Pandemonium's class reference supports BBCode-like tags. They add nice formatting to
the text. Here's the list of available tags: the text. Here's the list of available tags:
+----------------------------+--------------------------------------+-----------------------------------+---------------------------------------------------+ +----------------------------+--------------------------------------+-----------------------------------+---------------------------------------------------+
@ -242,6 +242,6 @@ I don't know what this method does!
No problem. Leave it behind, and list the methods you skipped when you request a No problem. Leave it behind, and list the methods you skipped when you request a
pull of your changes. Another writer will take care of it. pull of your changes. Another writer will take care of it.
You can still look at the methods' implementation in Godot's source code on You can still look at the methods' implementation in Pandemonium's source code on
GitHub. If you have doubts, feel free to ask on the `Q&A website GitHub. If you have doubts, feel free to ask on the `Q&A website
( https://godotengine.org/qa/ )` and `Godot Contributors Chat ( https://chat.godotengine.org/ )`. ( https://pandemoniumengine.org/qa/ )` and `Pandemonium Contributors Chat ( https://chat.pandemoniumengine.org/ )`.

44
community/contributing/code_style_guidelines.md
View File

@ -4,7 +4,7 @@ Code style guidelines
===================== =====================
When contributing to Godot's source code, you will be expected to follow the When contributing to Pandemonium's source code, you will be expected to follow the
style guidelines outlined below. Some of them are checked via the Continuous style guidelines outlined below. Some of them are checked via the Continuous
Integration process and reviewers will ask you to fix potential issues, so Integration process and reviewers will ask you to fix potential issues, so
best setup your system as outlined below to ensure all your commits follow the best setup your system as outlined below to ensure all your commits follow the
@ -25,8 +25,8 @@ To name a few:
- See further down regarding header includes - See further down regarding header includes
The rules used by clang-format are outlined in the The rules used by clang-format are outlined in the
`.clang-format ( https://github.com/godotengine/godot/blob/master/.clang-format )` `.clang-format ( https://github.com/pandemoniumengine/pandemonium/blob/master/.clang-format )`
file of the Godot repository. file of the Pandemonium repository.
As long as you ensure that your style matches the surrounding code and that you As long as you ensure that your style matches the surrounding code and that you
not introducing trailing whitespace or space-based indentation, you should be not introducing trailing whitespace or space-based indentation, you should be
@ -34,8 +34,8 @@ fine. If you plan to contribute regularly however, we strongly advise that you
setup clang-format locally to check and automatically fix all your commits. setup clang-format locally to check and automatically fix all your commits.
Warning: Warning:
Godot's code style should *not* be applied to third-party code, Pandemonium's code style should *not* be applied to third-party code,
i.e. that is included in Godot's source tree but was not written i.e. that is included in Pandemonium's source tree but was not written
specifically for our project. Such code usually come from specifically for our project. Such code usually come from
different upstream projects with their own style guides (or lack different upstream projects with their own style guides (or lack
thereof), and don't want to introduce differences that would make thereof), and don't want to introduce differences that would make
@ -44,7 +44,7 @@ Warning:
Third-party code is usually included in the `thirdparty/` folder Third-party code is usually included in the `thirdparty/` folder
and can thus easily be excluded from formatting scripts. For the and can thus easily be excluded from formatting scripts. For the
rare cases where a third-party code snippet needs to be included rare cases where a third-party code snippet needs to be included
directly within a Godot file, you can use directly within a Pandemonium file, you can use
`/* clang-format off */` and `/* clang-format on */` to tell `/* clang-format off */` and `/* clang-format on */` to tell
clang-format to ignore a chunk of code. clang-format to ignore a chunk of code.
@ -58,7 +58,7 @@ Using clang-format locally
~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~
First of all, you will need to install clang-format. As of now, you need to use First of all, you will need to install clang-format. As of now, you need to use
**clang-format 13** to be compatible with Godot's format. Later versions might **clang-format 13** to be compatible with Pandemonium's format. Later versions might
be suitable, but previous versions may not support all used options, or format be suitable, but previous versions may not support all used options, or format
some things differently, leading to style issues in pull requests. some things differently, leading to style issues in pull requests.
@ -94,7 +94,7 @@ command:
- The path can point to several files, either one after the other or using - The path can point to several files, either one after the other or using
wildcards like in a typical Unix shell. Be careful when globbing so that wildcards like in a typical Unix shell. Be careful when globbing so that
you don't run clang-format on compiled objects (.o and .a files) that are you don't run clang-format on compiled objects (.o and .a files) that are
in Godot's tree. So better use `core/*.{cpp,h}` than `core/*`. in Pandemonium's tree. So better use `core/*.{cpp,h}` than `core/*`.
Pre-commit hook Pre-commit hook
^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
@ -136,7 +136,7 @@ Header includes
When adding new C++ or Objective-C files or including new headers in existing When adding new C++ or Objective-C files or including new headers in existing
ones, the following rules should be followed: ones, the following rules should be followed:
- The first lines in the file should be Godot's copyright header and MIT - The first lines in the file should be Pandemonium's copyright header and MIT
license, copy-pasted from another file. Make sure to adjust the filename. license, copy-pasted from another file. Make sure to adjust the filename.
- In a `.h` header, include guards should be used with the form - In a `.h` header, include guards should be used with the form
`FILENAME_H`. `FILENAME_H`.
@ -144,16 +144,16 @@ ones, the following rules should be followed:
- In a `.cpp` file (e.g. `filename.cpp`), the first include should be the - In a `.cpp` file (e.g. `filename.cpp`), the first include should be the
one where the class is declared (e.g. `#include "filename.h"`), followed by one where the class is declared (e.g. `#include "filename.h"`), followed by
an empty line for separation. an empty line for separation.
- Then come headers from Godot's own code base, included in alphabetical order - Then come headers from Pandemonium's own code base, included in alphabetical order
(enforced by `clang-format`) with paths relative to the root folder. Those (enforced by `clang-format`) with paths relative to the root folder. Those
includes should be done with quotes, e.g. `#include "core/object.h"`. The includes should be done with quotes, e.g. `#include "core/object.h"`. The
block of Godot header includes should then be followed by an empty line for block of Pandemonium header includes should then be followed by an empty line for
separation. separation.
- Finally, third-party headers (either from `thirdparty` or from the system's - Finally, third-party headers (either from `thirdparty` or from the system's
include paths) come next and should be included with the < and > symbols, e.g. include paths) come next and should be included with the < and > symbols, e.g.
`#include <png.h>`. The block of third-party headers should also be followed `#include <png.h>`. The block of third-party headers should also be followed
by an empty line for separation. by an empty line for separation.
- Godot and third-party headers should be included in the file that requires - Pandemonium and third-party headers should be included in the file that requires
them, i.e. in the `.h` header if used in the declarative code or in the `.cpp` them, i.e. in the `.h` header if used in the declarative code or in the `.cpp`
if used only in the imperative code. if used only in the imperative code.
@ -164,11 +164,11 @@ Example:
/* my_new_file.h */ /* my_new_file.h */
/*************************************************************************/ /*************************************************************************/
/* This file is part of: */ /* This file is part of: */
/* GODOT ENGINE */ /* PANDEMONIUM ENGINE */
/* https://godotengine.org */ /* https://pandemoniumengine.org */
/*************************************************************************/ /*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */ /* Copyright (c) 2014-2021 Pandemonium Engine contributors (cf. AUTHORS.md). */
/* */ /* */
/* Permission is hereby granted, free of charge, to any person obtaining */ /* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */ /* a copy of this software and associated documentation files (the */
@ -209,11 +209,11 @@ Example:
/* my_new_file.cpp */ /* my_new_file.cpp */
/*************************************************************************/ /*************************************************************************/
/* This file is part of: */ /* This file is part of: */
/* GODOT ENGINE */ /* PANDEMONIUM ENGINE */
/* https://godotengine.org */ /* https://pandemoniumengine.org */
/*************************************************************************/ /*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */ /* Copyright (c) 2014-2021 Pandemonium Engine contributors (cf. AUTHORS.md). */
/* */ /* */
/* Permission is hereby granted, free of charge, to any person obtaining */ /* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */ /* a copy of this software and associated documentation files (the */
@ -247,15 +247,15 @@ Example:
Java Java
---- ----
Godot's Java code (mostly in `platform/android`) is also enforced via Pandemonium's Java code (mostly in `platform/android`) is also enforced via
`clang-format`, so see the instructions above to set it up. Keep in mind that `clang-format`, so see the instructions above to set it up. Keep in mind that
this style guide only applies to code written and maintained by Godot, not this style guide only applies to code written and maintained by Pandemonium, not
third-party code such as the `java/src/com/google` subfolder. third-party code such as the `java/src/com/google` subfolder.
Python Python
------ ------
Godot's SCons buildsystem is written in Python, and various scripts included Pandemonium's SCons buildsystem is written in Python, and various scripts included
in the source tree are also using Python. in the source tree are also using Python.
For those, we follow the `Black style guide ( https://github.com/psf/black#the-black-code-style )`. For those, we follow the `Black style guide ( https://github.com/psf/black#the-black-code-style )`.
@ -315,7 +315,7 @@ Comment style guide
------------------- -------------------
This comment style guide applies to all programming languages used within This comment style guide applies to all programming languages used within
Godot's codebase. Pandemonium's codebase.
- Begin comments with a space character to distinguish them from disabled code. - Begin comments with a space character to distinguish them from disabled code.
- Use sentence case for comments. Begin comments with an uppercase character and - Use sentence case for comments. Begin comments with an uppercase character and

10
community/contributing/content_guidelines.md
View File

@ -13,7 +13,7 @@ We want to achieve two goals:
them to learn from the docs. them to learn from the docs.
2. **Write a complete reference manual**. Our goal here is not to teach 2. **Write a complete reference manual**. Our goal here is not to teach
programming foundations. Instead, we should provide a reference for how programming foundations. Instead, we should provide a reference for how
Godot's features work. Pandemonium's features work.
Guidelines and principles Guidelines and principles
------------------------- -------------------------
@ -27,13 +27,13 @@ Writing complete and accessible documentation
**A feature doesn't exist unless it is documented**. If a user can't find **A feature doesn't exist unless it is documented**. If a user can't find
information about a feature and how it works, it doesn't exist to them. We information about a feature and how it works, it doesn't exist to them. We
should ensure that we cover everything Godot does. should ensure that we cover everything Pandemonium does.
Note: Note:
When adding or updating an engine feature, the documentation team needs to When adding or updating an engine feature, the documentation team needs to
know about it. Contributors should open an issue on the `godot-docs` repository know about it. Contributors should open an issue on the `pandemonium-docs` repository
when their work gets merged and requires documentation. when their work gets merged and requires documentation.
Do your best to keep documents **under 1000 words in length**. If a page goes Do your best to keep documents **under 1000 words in length**. If a page goes
@ -53,7 +53,7 @@ Note:
Long section titles lead to long entries in the side menu, which can make Long section titles lead to long entries in the side menu, which can make
navigation cumbersome. Try to keep headings five words long or less. navigation cumbersome. Try to keep headings five words long or less.
If the page assumes specific knowledge of other Godot features, mention it and If the page assumes specific knowledge of other Pandemonium features, mention it and
link it to the corresponding documentation. For instance, a page about physics link it to the corresponding documentation. For instance, a page about physics
may use signals, in which case we could note that the page that introduces may use signals, in which case we could note that the page that introduces
signals is a pre-requisite. signals is a pre-requisite.
@ -89,7 +89,7 @@ Note:
Having programming foundations is a pre-requisite to use a complex engine Having programming foundations is a pre-requisite to use a complex engine
like Godot. Talking about variables, functions, or classes is acceptable. like Pandemonium. Talking about variables, functions, or classes is acceptable.
But we should favor plain language over specific terminology like But we should favor plain language over specific terminology like
"metaprogramming". If you need to use precise terms, be sure to define them. "metaprogramming". If you need to use precise terms, be sure to define them.

36
community/contributing/contributing_to_the_documentation.md
View File

@ -3,7 +3,7 @@
Contributing to the documentation Contributing to the documentation
================================= =================================
This guide explains how to contribute to Godot's documentation, be it by This guide explains how to contribute to Pandemonium's documentation, be it by
writing or reviewing pages. writing or reviewing pages.
See also: See also:
@ -16,29 +16,29 @@ Getting started
--------------- ---------------
To modify or create pages in the reference manual, you need to edit `.rst` To modify or create pages in the reference manual, you need to edit `.rst`
files in the `godot-docs GitHub repository files in the `pandemonium-docs GitHub repository
( https://github.com/godotengine/godot-docs )`. Modifying those pages in a pull ( https://github.com/pandemoniumengine/pandemonium-docs )`. Modifying those pages in a pull
request triggers a rebuild of the online documentation upon merging. request triggers a rebuild of the online documentation upon merging.
See also: See also:
For details on Git usage and the pull request workflow, please For details on Git usage and the pull request workflow, please
refer to the `doc_pr_workflow` page. Most of what it describes refer to the `doc_pr_workflow` page. Most of what it describes
regarding the main godotengine/godot repository is also valid for regarding the main pandemoniumengine/pandemonium repository is also valid for
the docs repository. the docs repository.
Warning: Warning:
The class reference's source files are in the `Godot engine The class reference's source files are in the `Pandemonium engine
repository ( https://github.com/godotengine/godot )`. We generate repository ( https://github.com/pandemoniumengine/pandemonium )`. We generate
the `Godot API ( toc-class-ref )` section of this documentation the `Pandemonium API ( toc-class-ref )` section of this documentation
from them. If you want to update the description of a class, its from them. If you want to update the description of a class, its
methods, or properties, read methods, or properties, read
`doc_updating_the_class_reference`. `doc_updating_the_class_reference`.
What is the Godot documentation What is the Pandemonium documentation
------------------------------- -------------------------------
The Godot documentation is intended as a comprehensive reference manual for the The Pandemonium documentation is intended as a comprehensive reference manual for the
Godot game engine. It is not meant to contain step-by-step tutorials, except for Pandemonium game engine. It is not meant to contain step-by-step tutorials, except for
two game creation tutorials in the Getting Started section. two game creation tutorials in the Getting Started section.
We strive to write factual content in an accessible and well-written language. To We strive to write factual content in an accessible and well-written language. To
@ -54,7 +54,7 @@ Contributing changes
**Pull Requests should use the** `master` **branch by default.** Only make Pull **Pull Requests should use the** `master` **branch by default.** Only make Pull
Requests against other branches (e.g. `2.1` or `3.0`) if your changes only Requests against other branches (e.g. `2.1` or `3.0`) if your changes only
apply to that specific version of Godot. apply to that specific version of Pandemonium.
Though less convenient to edit than a wiki, this Git repository is where we Though less convenient to edit than a wiki, this Git repository is where we
write the documentation. Having direct access to the source files in a revision write the documentation. Having direct access to the source files in a revision
@ -66,8 +66,8 @@ Editing existing pages
To edit an existing page, locate its `.rst` source file and open it in your To edit an existing page, locate its `.rst` source file and open it in your
favorite text editor. You can then commit the changes, push them to your fork, favorite text editor. You can then commit the changes, push them to your fork,
and make a pull request. **Note that the pages in** `classes/` **should not be and make a pull request. **Note that the pages in** `classes/` **should not be
edited here.** They are automatically generated from Godot’s `XML class edited here.** They are automatically generated from Pandemonium’s `XML class
reference ( https://github.com/godotengine/godot/tree/master/doc/classes )`. reference ( https://github.com/pandemoniumengine/pandemonium/tree/master/doc/classes )`.
See `doc_updating_the_class_reference` for details. See `doc_updating_the_class_reference` for details.
See also: See also:
@ -96,7 +96,7 @@ and to log in to use it. Once logged in, you can propose change like so:
by a short but clear one-line description, as this is the commit title. by a short but clear one-line description, as this is the commit title.
5. On the following screens, click the **Create pull request** button until you 5. On the following screens, click the **Create pull request** button until you
see a message like *Username wants to merge 1 commit into godotengine:master see a message like *Username wants to merge 1 commit into pandemoniumengine:master
from Username:patch-1*. from Username:patch-1*.
Another contributor will review your changes and merge them into the docs if Another contributor will review your changes and merge them into the docs if
@ -108,7 +108,7 @@ Adding new pages
Before adding a new page, please ensure that it fits in the documentation: Before adding a new page, please ensure that it fits in the documentation:
1. Look for `existing issues 1. Look for `existing issues
( https://github.com/godotengine/godot-docs/issues )` or open a new one to see ( https://github.com/pandemoniumengine/pandemonium-docs/issues )` or open a new one to see
if the page is necessary. if the page is necessary.
2. Ensure there isn't a page that already covers the topic. 2. Ensure there isn't a page that already covers the topic.
3. Read our `doc_content_guidelines`. 3. Read our `doc_content_guidelines`.
@ -138,8 +138,8 @@ the lack of leading underscore in the reference).
Write your titles like plain sentences, without capitalizing each word: Write your titles like plain sentences, without capitalizing each word:
- **Good:** Understanding signals in Godot - **Good:** Understanding signals in Pandemonium
- **Bad:** Understanding Signals In Godot - **Bad:** Understanding Signals In Pandemonium
Only propers nouns, projects, people, and node class names should have their Only propers nouns, projects, people, and node class names should have their
first letter capitalized. first letter capitalized.
@ -185,7 +185,7 @@ License
This documentation and every page it contains is published under the terms of This documentation and every page it contains is published under the terms of
the `Creative Commons Attribution 3.0 license (CC-BY-3.0) the `Creative Commons Attribution 3.0 license (CC-BY-3.0)
( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`, with ( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`, with
attribution to "Juan Linietsky, Ariel Manzur and the Godot community". attribution to "Juan Linietsky, Ariel Manzur and the Pandemonium community".
By contributing to the documentation on the GitHub repository, you agree that By contributing to the documentation on the GitHub repository, you agree that
your changes are distributed under this license. your changes are distributed under this license.

12
community/contributing/cpp_usage_guidelines.md
View File

@ -6,7 +6,7 @@ C++ usage guidelines
Rationale Rationale
--------- ---------
Since Godot 4.0, the C++ standard used throughout the codebase is a subset of Since Pandemonium 4.0, the C++ standard used throughout the codebase is a subset of
**C++17**. While modern C++ brings a lot of opportunities to write faster, more **C++17**. While modern C++ brings a lot of opportunities to write faster, more
readable code, we chose to restrict our usage of C++ to a subset for a few readable code, we chose to restrict our usage of C++ to a subset for a few
reasons: reasons:
@ -15,7 +15,7 @@ reasons:
contributors don't always have access to a full-featured IDE while reviewing contributors don't always have access to a full-featured IDE while reviewing
code. code.
- It makes the code easier to grasp for beginner contributors (who may not be - It makes the code easier to grasp for beginner contributors (who may not be
professional C++ programmers). Godot's codebase is known to be easy to learn professional C++ programmers). Pandemonium's codebase is known to be easy to learn
from, and we'd like to keep it that way. from, and we'd like to keep it that way.
To get your pull request merged, it needs to follow the C++ usage guidelines To get your pull request merged, it needs to follow the C++ usage guidelines
@ -25,7 +25,7 @@ modules or GDNative scripts.
Note: Note:
Prior to Godot 4.0, the C++ standard used throughout the codebase was C++03, Prior to Pandemonium 4.0, the C++ standard used throughout the codebase was C++03,
with a handful of C++14 extensions. If you are contributing a pull request with a handful of C++14 extensions. If you are contributing a pull request
to the `3.x` branch rather than `master`, your code can't use C++17 features. to the `3.x` branch rather than `master`, your code can't use C++17 features.
Instead, your code must be able to be built with a C++14 compiler. Instead, your code must be able to be built with a C++14 compiler.
@ -51,11 +51,11 @@ Standard Template Library
^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
We don't allow using the `STL ( https://en.wikipedia.org/wiki/Standard_Template_Library )` We don't allow using the `STL ( https://en.wikipedia.org/wiki/Standard_Template_Library )`
as Godot provides its own data types (among other things). as Pandemonium provides its own data types (among other things).
See `doc_faq_why_not_stl` for more information. See `doc_faq_why_not_stl` for more information.
This means that pull requests should **not** use `std::string`, This means that pull requests should **not** use `std::string`,
`std::vector` and the like. Instead, use Godot's datatypes as described below: `std::vector` and the like. Instead, use Pandemonium's datatypes as described below:
- Use `String` instead of `std::string`. - Use `String` instead of `std::string`.
- Use `Vector` instead of `std::vector`. In some cases, `LocalVector` - Use `Vector` instead of `std::vector`. In some cases, `LocalVector`
@ -65,7 +65,7 @@ This means that pull requests should **not** use `std::string`,
Note: Note:
Godot also has a List datatype (which is a linked list). While List is already used Pandemonium also has a List datatype (which is a linked list). While List is already used
in the codebase, it typically performs worse than other datatypes like Vector in the codebase, it typically performs worse than other datatypes like Vector
and Array. Therefore, List should be avoided in new code unless necessary. and Array. Therefore, List should be avoided in new code unless necessary.

8
community/contributing/docs_writing_guidelines.md
View File

@ -3,7 +3,7 @@
Docs writing guidelines Docs writing guidelines
======================= =======================
The Godot community is rich and international. Users come from all The Pandemonium community is rich and international. Users come from all
around the world. Some of them are young, and many aren't native English around the world. Some of them are young, and many aren't native English
speakers. That's why we must all write using a clear and a common speakers. That's why we must all write using a clear and a common
language. For the class reference, the goal is to make it easy to read language. For the class reference, the goal is to make it easy to read
@ -444,12 +444,12 @@ Use `[code]` around arguments
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In the class reference, always surround arguments with `[code][/code]`. In the In the class reference, always surround arguments with `[code][/code]`. In the
documentation and in Godot, it will display like `this`. When you edit XML documentation and in Pandemonium, it will display like `this`. When you edit XML
files in the Godot repository, replace existing arguments written like 'this' or files in the Pandemonium repository, replace existing arguments written like 'this' or
\`this\` with `[code]this[/code]`. \`this\` with `[code]this[/code]`.
Common vocabulary to use in Godot's documentation Common vocabulary to use in Pandemonium's documentation
------------------------------------------------- -------------------------------------------------
The developers chose some specific words to refer to areas of the The developers chose some specific words to refer to areas of the

34
community/contributing/documentation_guidelines.md
View File

@ -3,18 +3,18 @@
Documentation guidelines Documentation guidelines
======================== ========================
This page describes the rules to follow if you want to contribute to Godot This page describes the rules to follow if you want to contribute to Pandemonium
Engine by writing or reviewing documentation, or by translating existing Engine by writing or reviewing documentation, or by translating existing
documentation. Also, have a look at README of the documentation. Also, have a look at README of the
`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )` `pandemonium-docs GitHub repository ( https://github.com/pandemoniumengine/pandemonium-docs )`
and the `docs front page ( https://docs.godotengine.org )` and the `docs front page ( https://docs.pandemoniumengine.org )`
on what steps to follow and how to contact the docs team. on what steps to follow and how to contact the docs team.
How to contribute How to contribute
----------------- -----------------
Creating or modifying documentation pages is mainly done via the Creating or modifying documentation pages is mainly done via the
`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )`. `pandemonium-docs GitHub repository ( https://github.com/pandemoniumengine/pandemonium-docs )`.
The HTML (or PDF and EPUB) documentation is generated from the .rst files The HTML (or PDF and EPUB) documentation is generated from the .rst files
(reStructuredText markup language) in that repository. Modifying those pages (reStructuredText markup language) in that repository. Modifying those pages
in a pull request and getting it merged will trigger a rebuild of the online in a pull request and getting it merged will trigger a rebuild of the online
@ -23,20 +23,20 @@ documentation.
See also: See also:
For details on Git usage and the pull request workflow, please For details on Git usage and the pull request workflow, please
refer to the `doc_pr_workflow` page. Most of what it refer to the `doc_pr_workflow` page. Most of what it
describes regarding the main godotengine/godot repository is describes regarding the main pandemoniumengine/pandemonium repository is
also valid for the docs repository. also valid for the docs repository.
Warning: Warning:
The class reference's source files are in the `Godot engine repository The class reference's source files are in the `Pandemonium engine repository
( https://github.com/godotengine/godot )`. We generate the `Godot API ( https://github.com/pandemoniumengine/pandemonium )`. We generate the `Pandemonium API
( toc-class-ref )` section of this documentation from them. If you want to update the ( toc-class-ref )` section of this documentation from them. If you want to update the
description of a class, its methods, or properties, read description of a class, its methods, or properties, read
`doc_updating_the_class_reference`. `doc_updating_the_class_reference`.
Warning: Warning:
If you want to edit the **API reference**, please note that it If you want to edit the **API reference**, please note that it
should *not* be done in the godot-docs repository. Instead, you should *not* be done in the pandemonium-docs repository. Instead, you
should edit the `doc/classes/*` XML files of Godot's should edit the `doc/classes/*` XML files of Pandemonium's
main repository. These files are then later used to generate the main repository. These files are then later used to generate the
in-editor documentation as well as the API reference of the in-editor documentation as well as the API reference of the
online docs. Read more here: `doc_updating_the_class_reference`. online docs. Read more here: `doc_updating_the_class_reference`.
@ -44,7 +44,7 @@ Warning:
The 'Edit on GitHub' link The 'Edit on GitHub' link
------------------------- -------------------------
If you're reading documentation on `docs.godotengine.org ( https://docs.godotengine.org )`, If you're reading documentation on `docs.pandemoniumengine.org ( https://docs.pandemoniumengine.org )`,
you'll see an **Edit on GitHub** hyperlink at the top right of the page. you'll see an **Edit on GitHub** hyperlink at the top right of the page.
Once you've created a GitHub account, you can propose changes to a page you're Once you've created a GitHub account, you can propose changes to a page you're
reading as follows: reading as follows:
@ -62,7 +62,7 @@ reading as follows:
5. On the following screens, click the **Create pull request** button until you 5. On the following screens, click the **Create pull request** button until you
see a message like *Username wants to merge 1 commit into see a message like *Username wants to merge 1 commit into
godotengine:master from Username:patch-6*. pandemoniumengine:master from Username:patch-6*.
6. A reviewer will evaluate your changes and incorporate them into the docs if 6. A reviewer will evaluate your changes and incorporate them into the docs if
they're acceptable. You might also be asked to make they're acceptable. You might also be asked to make
@ -84,7 +84,7 @@ definitions:
object"). object").
- Documentation: a page describing precisely one and only one concept at a - Documentation: a page describing precisely one and only one concept at a
time, if possible exhaustively (e.g. the list of methods of the time, if possible exhaustively (e.g. the list of methods of the
Sprite class, or an overview of the input management in Godot). Sprite class, or an overview of the input management in Pandemonium).
You are free to write the kind of documentation you wish, as long as you You are free to write the kind of documentation you wish, as long as you
respect the following rules (and the ones on the repo). respect the following rules (and the ones on the repo).
@ -119,24 +119,24 @@ letter.
Translating existing pages Translating existing pages
-------------------------- --------------------------
You can help to translate the official Godot documentation on our `Hosted Weblate ( https://hosted.weblate.org/engage/godot-engine/ )`. You can help to translate the official Pandemonium documentation on our `Hosted Weblate ( https://hosted.weblate.org/engage/pandemonium-engine/ )`.
![](https://hosted.weblate.org/widgets/godot-engine/-/godot-docs/287x66-white.png) ![](https://hosted.weblate.org/widgets/pandemonium-engine/-/pandemonium-docs/287x66-white.png)
:alt: Translation state :alt: Translation state
:align: center :align: center
:target: https://hosted.weblate.org/engage/godot-engine/?utm_source=widget :target: https://hosted.weblate.org/engage/pandemonium-engine/?utm_source=widget
:width: 287 :width: 287
:height: 66 :height: 66
There also is the official There also is the official
`Godot i18n repository ( https://github.com/godotengine/godot-docs-l10n )` `Pandemonium i18n repository ( https://github.com/pandemoniumengine/pandemonium-docs-l10n )`
where you can see when the data was last synchronized. where you can see when the data was last synchronized.
License License
------- -------
This documentation and every page it contains is published under the terms of This documentation and every page it contains is published under the terms of
the `Creative Commons Attribution 3.0 license (CC-BY-3.0) ( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`, with attribution to "Juan Linietsky, Ariel Manzur and the Godot community". the `Creative Commons Attribution 3.0 license (CC-BY-3.0) ( https://tldrlegal.com/license/creative-commons-attribution-(cc) )`, with attribution to "Juan Linietsky, Ariel Manzur and the Pandemonium community".
By contributing to the documentation on the GitHub repository, you agree that By contributing to the documentation on the GitHub repository, you agree that
your changes are distributed under this license. your changes are distributed under this license.

54
community/contributing/editor_and_docs_localization.md
View File

@ -3,18 +3,18 @@
Editor and docs localization Editor and docs localization
============================ ============================
Godot aims to make game development available to everyone, including people who Pandemonium aims to make game development available to everyone, including people who
may not know or be comfortable with English. Therefore, we do our best to make may not know or be comfortable with English. Therefore, we do our best to make
the most important resources available in many languages, thanks to the the most important resources available in many languages, thanks to the
translation effort of the community. translation effort of the community.
These resources include: These resources include:
1. The `Godot editor's interface ( https://hosted.weblate.org/projects/godot-engine/godot/ )` 1. The `Pandemonium editor's interface ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium/ )`
(ca. 15,000 words). (ca. 15,000 words).
2. The `online documentation ( https://hosted.weblate.org/projects/godot-engine/godot-docs/ )` 2. The `online documentation ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium-docs/ )`
(editor manual and tutorials, ca. 300,000 words). (editor manual and tutorials, ca. 300,000 words).
3. The `class reference ( https://hosted.weblate.org/projects/godot-engine/godot-class-reference/ )`, 3. The `class reference ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium-class-reference/ )`,
available both online and in the editor (ca. 200,000 words). available both online and in the editor (ca. 200,000 words).
To manage translations, we use the GNU gettext file format (`PO` files), and To manage translations, we use the GNU gettext file format (`PO` files), and
@ -30,7 +30,7 @@ localization of images.
Tip: Tip:
Translating all the official Godot content is a massive undertaking, so we Translating all the official Pandemonium content is a massive undertaking, so we
advise prioritizing the resources as they are listed above: first the editor advise prioritizing the resources as they are listed above: first the editor
interface, then the online documentation, and eventually the class reference interface, then the online documentation, and eventually the class reference
if there are enough translators to keep up with updates. if there are enough translators to keep up with updates.
@ -38,17 +38,17 @@ Tip:
Using Weblate for translations Using Weblate for translations
------------------------------ ------------------------------
While our translations eventually reside in the Git repositories of the Godot While our translations eventually reside in the Git repositories of the Pandemonium
engine and its documentation, all translation updates are handled through engine and its documentation, all translation updates are handled through
Weblate, and thus direct pull requests to the Git repositories are not accepted. Weblate, and thus direct pull requests to the Git repositories are not accepted.
Translations are synced manually between Weblate and the Godot repositories by Translations are synced manually between Weblate and the Pandemonium repositories by
maintainers. maintainers.
You should therefore `register on Weblate ( https://hosted.weblate.org/accounts/register/ )` You should therefore `register on Weblate ( https://hosted.weblate.org/accounts/register/ )`
to contribute to Godot's translations. to contribute to Pandemonium's translations.
Once signed in, browse to the Godot resource which you want to contribute to (in Once signed in, browse to the Pandemonium resource which you want to contribute to (in
this page we will use the `editor translation ( https://hosted.weblate.org/projects/godot-engine/godot/ )` this page we will use the `editor translation ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium/ )`
as an example) to find the list of all languages: as an example) to find the list of all languages:
![](img/l10n_01_language_list.png) ![](img/l10n_01_language_list.png)
@ -79,7 +79,7 @@ to translate to:
for French) instead of a regional variant (e.g. `fr_FR` for French for French) instead of a regional variant (e.g. `fr_FR` for French
(France), `fr_CA` for French (Canada), or `fr_DZ` for French (Algeria)). (France), `fr_CA` for French (Canada), or `fr_DZ` for French (Algeria)).
Godot has a huge amount of content to translate, so duplicating the work for Pandemonium has a huge amount of content to translate, so duplicating the work for
regional variants should only be done if the language variations are regional variants should only be done if the language variations are
significant enough. Additionally, if a translation is done with for a significant enough. Additionally, if a translation is done with for a
regional variant, it will only be available automatically for users located regional variant, it will only be available automatically for users located
@ -132,7 +132,7 @@ On that page, you have:
- On the top right, the glossary shows terms for which an entry has been added - On the top right, the glossary shows terms for which an entry has been added
previously, and which are included in the current string. For example, if previously, and which are included in the current string. For example, if
you decided with fellow translators to use a specific translation for the you decided with fellow translators to use a specific translation for the
"node" term in Godot, you can add it to the glossary to ensure that other "node" term in Pandemonium, you can add it to the glossary to ensure that other
translators use the same convention. translators use the same convention.
- The bottom right panel includes information on the source string. The most - The bottom right panel includes information on the source string. The most
relevant item is the "source string location", which links you to the relevant item is the "source string location", which links you to the
@ -163,7 +163,7 @@ translating.
given file will be grouped together. For example, if the "source string given file will be grouped together. For example, if the "source string
location" indicates `editor/code_editor.cpp`, the current string (and the location" indicates `editor/code_editor.cpp`, the current string (and the
nearby ones) is defined in the `editor/code_editor.cpp` code file, and is nearby ones) is defined in the `editor/code_editor.cpp` code file, and is
thereby related to the code editors in Godot (GDScript, shaders). thereby related to the code editors in Pandemonium (GDScript, shaders).
- The online documentation's translation template is generated from the source - The online documentation's translation template is generated from the source
RST files in the same order as seen in the **table of contents**, so for RST files in the same order as seen in the **table of contents**, so for
example the first strings are from the front page of the documentation. example the first strings are from the front page of the documentation.
@ -258,14 +258,14 @@ external links, etc. Here are some examples:
``` ```
# "development" is styled bold. # "development" is styled bold.
# "Have a look here" is a link pointing to https://docs.godotengine.org/en/latest. # "Have a look here" is a link pointing to https://docs.pandemoniumengine.org/en/latest.
# You should translate "Have a look here", but not the URL, unless there is # You should translate "Have a look here", but not the URL, unless there is
# a matching URL for the same content in your language. # a matching URL for the same content in your language.
# Note: The `, ( , >, and _ characters all have a meaning in the hyperlink # Note: The `, ( , >, and _ characters all have a meaning in the hyperlink
# syntax and should be preserved. # syntax and should be preserved.
Looking for the documentation of the current **development** branch? Looking for the documentation of the current **development** branch?
`Have a look here ( https://docs.godotengine.org/en/latest )`. `Have a look here ( https://docs.pandemoniumengine.org/en/latest )`.
# "|supported|" is an inline reference to an image and should stay unchanged. # "|supported|" is an inline reference to an image and should stay unchanged.
# "master" uses the markup for inline code, and will be styled as such. # "master" uses the markup for inline code, and will be styled as such.
@ -305,11 +305,11 @@ See also:
Class reference (BBCode) Class reference (BBCode)
^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
The class reference is documented in the main Godot repository using XML files, The class reference is documented in the main Pandemonium repository using XML files,
and with BBCode-like markup for styling and internal references. and with BBCode-like markup for styling and internal references.
Some of the tags used are from the original BBCode (e.g. `[b]Bold[/b]` and Some of the tags used are from the original BBCode (e.g. `[b]Bold[/b]` and
`[i]Italics[/i]`), while others are Godot-specific and used for advanced `[i]Italics[/i]`), while others are Pandemonium-specific and used for advanced
features such as inline code (e.g. `[code]true[/code]`), linking to another features such as inline code (e.g. `[code]true[/code]`), linking to another
class (e.g. `[Node2D]`) or to a property in a given class (e.g. class (e.g. `[Node2D]`) or to a property in a given class (e.g.
`[member Node2D.position]`), or for multiline code blocks. Example: `[member Node2D.position]`), or for multiline code blocks. Example:
@ -324,9 +324,9 @@ class (e.g. `[Node2D]`) or to a property in a given class (e.g.
In the above example, `[code]name[/code]`, `[code]alpha[/code]`, and In the above example, `[code]name[/code]`, `[code]alpha[/code]`, and
`[Color]` should *not* be translated, as they refer respectively to argument `[Color]` should *not* be translated, as they refer respectively to argument
names and a class of the Godot API. Similarly, the contents of the names and a class of the Pandemonium API. Similarly, the contents of the
`[codeblock]` should not be translated, as `ColorN` is a function of the `[codeblock]` should not be translated, as `ColorN` is a function of the
Godot API and `"red"` is one of the named colors it supports. At most, you can Pandemonium API and `"red"` is one of the named colors it supports. At most, you can
translate the name of the variable which holds the result (`red = ...`). translate the name of the variable which holds the result (`red = ...`).
Note also that in the XML, each line is a paragraph, so you should not add line Note also that in the XML, each line is a paragraph, so you should not add line
@ -366,25 +366,25 @@ Note:
version. version.
If you want to test changes locally (especially for the editor translation), you If you want to test changes locally (especially for the editor translation), you
can use the downloaded PO file and `compile Godot from source ( toc-devel-compiling )`. can use the downloaded PO file and `compile Pandemonium from source ( toc-devel-compiling )`.
Rename the editor translation PO file to `( lang>.po` (e.g. `eo.po` for Rename the editor translation PO file to `( lang>.po` (e.g. `eo.po` for
Esperanto) and place it in the `editor/translations/` folder Esperanto) and place it in the `editor/translations/` folder
(`GitHub ( https://github.com/godotengine/godot/tree/master/editor/translations )`). (`GitHub ( https://github.com/pandemoniumengine/pandemonium/tree/master/editor/translations )`).
You can also test class reference changes the same way by renaming the PO file You can also test class reference changes the same way by renaming the PO file
similarly and placing it in the `doc/translations/` folder similarly and placing it in the `doc/translations/` folder
(`GitHub ( https://github.com/godotengine/godot/tree/master/doc/translations )`). (`GitHub ( https://github.com/pandemoniumengine/pandemonium/tree/master/doc/translations )`).
Localizing documentation images Localizing documentation images
------------------------------- -------------------------------
The online documentation includes many images, which can be screenshots of the The online documentation includes many images, which can be screenshots of the
Godot editor, custom-made graphs, of any other kind of visual content. Some of Pandemonium editor, custom-made graphs, of any other kind of visual content. Some of
it includes text and might thus be relevant to localize in your language. it includes text and might thus be relevant to localize in your language.
This part is not handled via Weblate, but directly on the `godot-docs-l10n This part is not handled via Weblate, but directly on the `pandemonium-docs-l10n
( https://github.com/godotengine/godot-docs-l10n )` Git repository where the ( https://github.com/pandemoniumengine/pandemonium-docs-l10n )` Git repository where the
documentation translations are synced from Weblate. documentation translations are synced from Weblate.
Note: Note:
@ -417,9 +417,9 @@ Name your localized image like the original one, but with the language code
added before the extension, e.g. `project_manager_first_open.png)` would become added before the extension, e.g. `project_manager_first_open.png)` would become
`project_manager_first_open.fr.png)` for the French localization. `project_manager_first_open.fr.png)` for the French localization.
Finally, on godot-docs-l10n_, recreate the same folder structure as for the Finally, on pandemonium-docs-l10n_, recreate the same folder structure as for the
original image in the `images` subfolder original image in the `images` subfolder
(`GitHub ( https://github.com/godotengine/godot-docs-l10n/tree/master/images )`), (`GitHub ( https://github.com/pandemoniumengine/pandemonium-docs-l10n/tree/master/images )`),
and place your translated image there. In our example, the end result should be and place your translated image there. In our example, the end result should be
`images/getting_started/step_by_step/img/project_manager_first_open.fr.png)`. `images/getting_started/step_by_step/img/project_manager_first_open.fr.png)`.

10
community/contributing/index.md
View File

@ -1,7 +1,7 @@
Contributing Contributing
============ ============
Everyone is most welcome to contribute to Godot. Here are some ways in which you Everyone is most welcome to contribute to Pandemonium. Here are some ways in which you
can contribute to the project: can contribute to the project:
- Improving the engine by fixing bugs, coding new features, or refining existing ones. - Improving the engine by fixing bugs, coding new features, or refining existing ones.
@ -9,7 +9,7 @@ can contribute to the project:
reference manual or the code reference. reference manual or the code reference.
- Translating the editor or documentation from English to other languages. - Translating the editor or documentation from English to other languages.
- Reporting issues or `writing detailed proposals - Reporting issues or `writing detailed proposals
( https://github.com/godotengine/godot-proposals/ )`. ( https://github.com/pandemoniumengine/pandemonium-proposals/ )`.
Getting started Getting started
--------------- ---------------
@ -81,8 +81,8 @@ Class reference guides
The pages below focus on the class reference. The pages below focus on the class reference.
As the reference is included in the Godot editor, its source files are part of As the reference is included in the Pandemonium editor, its source files are part of
the `godot repository ( https://github.com/godotengine/godot )`. We use XML files the `pandemonium repository ( https://github.com/pandemoniumengine/pandemonium )`. We use XML files
to write it, so the process to contribute to the class reference differs from to write it, so the process to contribute to the class reference differs from
writing the online manual. writing the online manual.
@ -98,7 +98,7 @@ writing the online manual.
Translating the documentation Translating the documentation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The community is always working hard on making Godot and its documentation The community is always working hard on making Pandemonium and its documentation
available to more people. Localizing the documentation is a colossal and ongoing available to more people. Localizing the documentation is a colossal and ongoing
effort you can be part of. effort you can be part of.

44
community/contributing/pr_workflow.md
View File

@ -4,7 +4,7 @@ Pull request workflow
===================== =====================
The so-called "PR workflow" used by Godot is common to many projects using The so-called "PR workflow" used by Pandemonium is common to many projects using
Git, and should be familiar to veteran free software contributors. The idea Git, and should be familiar to veteran free software contributors. The idea
is that only a small number (if any) commit directly to the *master* branch. is that only a small number (if any) commit directly to the *master* branch.
Instead, contributors *fork* the project (i.e. create a copy of it, which Instead, contributors *fork* the project (i.e. create a copy of it, which
@ -20,21 +20,21 @@ the *master* branch).
We will go together through an example to show the typical workflow and We will go together through an example to show the typical workflow and
associated Git commands. But first, let's have a quick look at the associated Git commands. But first, let's have a quick look at the
organization of Godot's Git repository. organization of Pandemonium's Git repository.
Git source repository Git source repository
--------------------- ---------------------
The `repository on GitHub ( https://github.com/godotengine/godot )` is a The `repository on GitHub ( https://github.com/pandemoniumengine/pandemonium )` is a
`Git ( https://git-scm.com )` code repository together with an embedded `Git ( https://git-scm.com )` code repository together with an embedded
issue tracker and PR system. issue tracker and PR system.
Note: Note:
If you are contributing to the documentation, its repository can If you are contributing to the documentation, its repository can
be found `here ( https://github.com/godotengine/godot-docs )`. be found `here ( https://github.com/pandemoniumengine/pandemonium-docs )`.
The Git version control system is the tool used to keep track of successive The Git version control system is the tool used to keep track of successive
edits to the source code - to contribute efficiently to Godot, learning the edits to the source code - to contribute efficiently to Pandemonium, learning the
basics of the Git command line is *highly* recommended. There exist some basics of the Git command line is *highly* recommended. There exist some
graphical interfaces for Git, but they usually encourage users to take bad graphical interfaces for Git, but they usually encourage users to take bad
habits regarding the Git and PR workflow, and we therefore recommend not to habits regarding the Git and PR workflow, and we therefore recommend not to
@ -61,7 +61,7 @@ The branches on the Git repository are organized as follows:
branch to the currently maintained stable release (e.g. 3.1.2 or 2.1.6). branch to the currently maintained stable release (e.g. 3.1.2 or 2.1.6).
As a rule of thumb, the last stable branch is maintained until the next As a rule of thumb, the last stable branch is maintained until the next
minor version (e.g. the `3.0` branch was maintained until the release of minor version (e.g. the `3.0` branch was maintained until the release of
Godot 3.1). Pandemonium 3.1).
If you want to make PRs against a maintained stable branch, please check If you want to make PRs against a maintained stable branch, please check
first if your changes are also relevant for the `master` branch, and if so first if your changes are also relevant for the `master` branch, and if so
make the PR for the `master` branch in priority. Release managers can then make the PR for the `master` branch in priority. Release managers can then
@ -72,7 +72,7 @@ The branches on the Git repository are organized as follows:
Forking and cloning Forking and cloning
------------------- -------------------
The first step is to *fork* the `godotengine/godot ( https://github.com/godotengine/godot )` The first step is to *fork* the `pandemoniumengine/pandemonium ( https://github.com/pandemoniumengine/pandemonium )`
repository on GitHub. To do so, you will need to have a GitHub account and to repository on GitHub. To do so, you will need to have a GitHub account and to
be logged in. In the top right corner of the repository's GitHub page, you be logged in. In the top right corner of the repository's GitHub page, you
should see the "Fork" button as shown below: should see the "Fork" button as shown below:
@ -80,7 +80,7 @@ should see the "Fork" button as shown below:
![](img/github_fork_button.png) ![](img/github_fork_button.png)
Click it, and after a while you should be redirected to your own fork of the Click it, and after a while you should be redirected to your own fork of the
Godot repo, with your GitHub username as namespace: Pandemonium repo, with your GitHub username as namespace:
![](img/github_fork_url.png) ![](img/github_fork_url.png)
@ -96,7 +96,7 @@ Note:
To clone your fork from GitHub, use the following command: To clone your fork from GitHub, use the following command:
``` ```
$ git clone https://github.com/USERNAME/godot $ git clone https://github.com/USERNAME/pandemonium
``` ```
Note: Note:
@ -104,27 +104,27 @@ Note:
on typical UNIX shells. It is not part of the command and should on typical UNIX shells. It is not part of the command and should
not be typed. not be typed.
After a little while, you should have a `godot` directory in your current After a little while, you should have a `pandemonium` directory in your current
working directory. Move into it using the `cd` command: working directory. Move into it using the `cd` command:
``` ```
$ cd godot $ cd pandemonium
``` ```
We will start by setting up a reference to the original repository that we forked: We will start by setting up a reference to the original repository that we forked:
``` ```
$ git remote add upstream https://github.com/godotengine/godot $ git remote add upstream https://github.com/pandemoniumengine/pandemonium
$ git fetch upstream $ git fetch upstream
``` ```
This will create a reference named `upstream` pointing to the original This will create a reference named `upstream` pointing to the original
`godotengine/godot` repository. This will be useful when you want to pull new `pandemoniumengine/pandemonium` repository. This will be useful when you want to pull new
commits from its `master` branch to update your fork. You have another commits from its `master` branch to update your fork. You have another
remote reference named `origin`, which points to your fork (`USERNAME/godot`). remote reference named `origin`, which points to your fork (`USERNAME/pandemonium`).
You only need to do the above steps once, as long as you keep that local You only need to do the above steps once, as long as you keep that local
`godot` folder (which you can move around if you want, the relevant `pandemonium` folder (which you can move around if you want, the relevant
metadata is hidden in its `.git` subfolder). metadata is hidden in its `.git` subfolder).
Note: Note:
@ -140,7 +140,7 @@ Note:
working in Git. working in Git.
In the following, we will assume as an example that you want to implement a feature in In the following, we will assume as an example that you want to implement a feature in
Godot's project manager, which is coded in the `editor/project_manager.cpp` Pandemonium's project manager, which is coded in the `editor/project_manager.cpp`
file. file.
Branching Branching
@ -361,18 +361,18 @@ Issuing a pull request
---------------------- ----------------------
When you load your fork's branch on GitHub, you should see a line saying When you load your fork's branch on GitHub, you should see a line saying
*"This branch is 2 commits ahead of godotengine:master."* (and potentially some *"This branch is 2 commits ahead of pandemoniumengine:master."* (and potentially some
commits behind, if your `master` branch was out of sync with the upstream commits behind, if your `master` branch was out of sync with the upstream
`master` branch). `master` branch).
![](img/github_fork_make_pr.png) ![](img/github_fork_make_pr.png)
On that line, there is a "Pull request" link. Clicking it will open a form On that line, there is a "Pull request" link. Clicking it will open a form
that will let you issue a pull request on the `godotengine/godot` upstream that will let you issue a pull request on the `pandemoniumengine/pandemonium` upstream
repository. It should show you your two commits, and state "Able to merge". repository. It should show you your two commits, and state "Able to merge".
If not (e.g. it has way more commits, or says there are merge conflicts), If not (e.g. it has way more commits, or says there are merge conflicts),
don't create the PR yet, something went wrong. Go to our don't create the PR yet, something went wrong. Go to our
`Godot Contributors Chat ( https://chat.godotengine.org/ )` and ask for support :) `Pandemonium Contributors Chat ( https://chat.pandemoniumengine.org/ )` and ask for support :)
Use an explicit title for the PR and put the necessary details in the comment Use an explicit title for the PR and put the necessary details in the comment
area. You can drag and drop screenshots, GIFs or zipped projects if relevant, area. You can drag and drop screenshots, GIFs or zipped projects if relevant,
@ -440,7 +440,7 @@ aware of our workflow and Git usage tips, reviewers might request of your to
Indeed, if some commits have been made following reviews to fix bugs, typos, etc. Indeed, if some commits have been made following reviews to fix bugs, typos, etc.
in the original commit, they are not relevant to a future changelog reader who in the original commit, they are not relevant to a future changelog reader who
would want to know what happened in the Godot codebase, or when and how a given would want to know what happened in the Pandemonium codebase, or when and how a given
file was last modified. file was last modified.
To squash those extraneous commits into the main one, we will have to *rewrite To squash those extraneous commits into the main one, we will have to *rewrite
@ -511,9 +511,9 @@ will raise an error:
``` ```
$ git push origin better-project-manager $ git push origin better-project-manager
To https://github.com/akien-mga/godot To https://github.com/akien-mga/pandemonium
! [rejected] better-project-manager -> better-project-manager (non-fast-forward) ! [rejected] better-project-manager -> better-project-manager (non-fast-forward)
error: failed to push some refs to 'https://akien-mga@github.com/akien-mga/godot' error: failed to push some refs to 'https://akien-mga@github.com/akien-mga/pandemonium'
hint: Updates were rejected because the tip of your current branch is behind hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. hint: its remote counterpart.
``` ```

6
community/contributing/testing_pull_requests.md
View File

@ -5,9 +5,9 @@ Testing pull requests
Many people are developing new features or fixing bugs on GitHub. Many people are developing new features or fixing bugs on GitHub.
To help with engine development, you may be asked to test those pull requests To help with engine development, you may be asked to test those pull requests
with a Godot build that includes code from the pull request in question. with a Pandemonium build that includes code from the pull request in question.
Thanks to GitHub Actions, all `pull requests ( https://github.com/godotengine/godot/pulls )` Thanks to GitHub Actions, all `pull requests ( https://github.com/pandemoniumengine/pandemonium/pulls )`
have continuous builds available. These builds let you try out pull requests have continuous builds available. These builds let you try out pull requests
without having to compile anything from source. without having to compile anything from source.
@ -90,7 +90,7 @@ Compiling a pull request branch from source
This approach may be needed for pull requests that were last updated more than This approach may be needed for pull requests that were last updated more than
90 days ago, or to test on platforms and configurations that are not supported 90 days ago, or to test on platforms and configurations that are not supported
by Godot's GitHub Actions setup. by Pandemonium's GitHub Actions setup.
- Open the pull request page. Click the *fork*'s branch name near the top of the page: - Open the pull request page. Click the *fork*'s branch name near the top of the page:

24
community/contributing/updating_the_class_reference.md
View File

@ -5,15 +5,15 @@ Contributing to the class reference
The class reference is available online in the `classes ( toc-class-ref )` The class reference is available online in the `classes ( toc-class-ref )`
section of the documentation and in the Godot editor, from the help menu. section of the documentation and in the Pandemonium editor, from the help menu.
In the class reference, some methods, variables, and signals lack descriptions. In the class reference, some methods, variables, and signals lack descriptions.
Others changed with recent releases and need updates. The developers can't write Others changed with recent releases and need updates. The developers can't write
the entire reference on their own. Godot needs you, and all of us, to the entire reference on their own. Pandemonium needs you, and all of us, to
contribute. contribute.
**Important:** If you plan to make large changes, you should create an issue on **Important:** If you plan to make large changes, you should create an issue on
the `godot-docs repository ( https://github.com/godotengine/godot-docs/ )` the `pandemonium-docs repository ( https://github.com/pandemoniumengine/pandemonium-docs/ )`
or comment on an existing issue. Doing so lets others know you're already or comment on an existing issue. Doing so lets others know you're already
taking care of a given class. taking care of a given class.
@ -35,11 +35,11 @@ See also:
Not sure which class to contribute to? Take a look at the class reference's Not sure which class to contribute to? Take a look at the class reference's
completion status `here ( https://godotengine.github.io/doc-status/ )`. completion status `here ( https://pandemoniumengine.github.io/doc-status/ )`.
You can find the source files for the class reference in Godot's GitHub You can find the source files for the class reference in Pandemonium's GitHub
repository: `doc/classes/ repository: `doc/classes/
( https://github.com/godotengine/godot/tree/master/doc/classes )`. ( https://github.com/pandemoniumengine/pandemonium/tree/master/doc/classes )`.
Note: Note:
For some modules in the engine's source code, you'll find the XML For some modules in the engine's source code, you'll find the XML
@ -48,8 +48,8 @@ Note:
Warning: Warning:
Always edit the API reference through these source XML files. Do Always edit the API reference through these source XML files. Do
not edit the generated `.rst` files `in the online documentation not edit the generated `.rst` files `in the online documentation
( toc-class-ref )`, hosted in the `godot-docs ( toc-class-ref )`, hosted in the `pandemonium-docs
( https://github.com/godotengine/godot-docs )` repository. ( https://github.com/pandemoniumengine/pandemonium-docs )` repository.
Warning: Warning:
@ -67,16 +67,16 @@ Updating the documentation template
When you create a new class or modify the engine's API, you need to re-generate the XML files in `doc/classes/`. When you create a new class or modify the engine's API, you need to re-generate the XML files in `doc/classes/`.
To do so, you first need to compile Godot. See the To do so, you first need to compile Pandemonium. See the
`doc_introduction_to_the_buildsystem` page to learn how. Then, execute the `doc_introduction_to_the_buildsystem` page to learn how. Then, execute the
compiled Godot binary from the Godot root directory with the `--doctool` option. compiled Pandemonium binary from the Pandemonium root directory with the `--doctool` option.
For example, if you're on 64-bit Linux, the command is: For example, if you're on 64-bit Linux, the command is:
``` ```
./bin/godot.linuxbsd.tools.64 --doctool ./bin/pandemonium.linuxbsd.tools.64 --doctool
``` ```
The XML files in doc/classes should then be up-to-date with current Godot Engine The XML files in doc/classes should then be up-to-date with current Pandemonium Engine
features. You can then check what changed using the `git diff` command. Please features. You can then check what changed using the `git diff` command. Please
only include changes that are relevant to your work on the API in your commits. only include changes that are relevant to your work on the API in your commits.
You can discard changes in other XML files using `git checkout`. You can discard changes in other XML files using `git checkout`.

52
community/contributing/ways_to_contribute.md
View File

@ -3,17 +3,17 @@
Ways to contribute Ways to contribute
================== ==================
Godot Engine is a non-profit, community-driven free and open source project. Pandemonium Engine is a non-profit, community-driven free and open source project.
Almost all (but our lead dev Juan, more on that below) developers are working Almost all (but our lead dev Juan, more on that below) developers are working
*pro bono* on their free time, out of personal interest and for the love of *pro bono* on their free time, out of personal interest and for the love of
creating a libre engine of exceptional quality. creating a libre engine of exceptional quality.
This means that to thrive, Godot needs as many users as possible to get This means that to thrive, Pandemonium needs as many users as possible to get
involved by contributing to the engine. There are many ways to contribute to involved by contributing to the engine. There are many ways to contribute to
such a big project, making it possible for everybody to bring something such a big project, making it possible for everybody to bring something
positive to the engine, regardless of their skill set: positive to the engine, regardless of their skill set:
- **Be part of the community.** The best way to contribute to Godot and help - **Be part of the community.** The best way to contribute to Pandemonium and help
it become ever better is simply to use the engine and promote it by it become ever better is simply to use the engine and promote it by
word-of-mouth, in the credits or splash screen of your games, blog posts, tutorials, word-of-mouth, in the credits or splash screen of your games, blog posts, tutorials,
videos, demos, gamedev or free software events, support on the Q&A, forums, videos, demos, gamedev or free software events, support on the Q&A, forums,
@ -23,10 +23,10 @@ positive to the engine, regardless of their skill set:
to become more mainstream. to become more mainstream.
- **Make games.** It's no secret that, to convince new users and especially the - **Make games.** It's no secret that, to convince new users and especially the
industry at large that Godot is a relevant market player, we need great games industry at large that Pandemonium is a relevant market player, we need great games
made with Godot. We know that the engine has a lot of potential, both for 2D made with Pandemonium. We know that the engine has a lot of potential, both for 2D
and 3D games, but given its young age we still lack big releases that will and 3D games, but given its young age we still lack big releases that will
draw attention to Godot. So keep working on your awesome projects, each new draw attention to Pandemonium. So keep working on your awesome projects, each new
game increases our credibility on the gamedev market! game increases our credibility on the gamedev market!
- **Get involved in the engine's development.** This can be by contributing - **Get involved in the engine's development.** This can be by contributing
@ -37,7 +37,7 @@ positive to the engine, regardless of their skill set:
The following sections will cover each of those "direct" ways The following sections will cover each of those "direct" ways
of contributing to the engine. of contributing to the engine.
- **Donate.** Godot is a non-profit project, but it can still benefit from - **Donate.** Pandemonium is a non-profit project, but it can still benefit from
user donations for many things. Apart from usual expenses such as hosting user donations for many things. Apart from usual expenses such as hosting
costs or promotional material on events, we also use donation money to costs or promotional material on events, we also use donation money to
acquire hardware when necessary (e.g. we used donation money to buy a acquire hardware when necessary (e.g. we used donation money to buy a
@ -47,7 +47,7 @@ positive to the engine, regardless of their skill set:
can work full-time on the engine. Even with a low can work full-time on the engine. Even with a low
monthly wage, we need a steady donation income to continue doing this, which monthly wage, we need a steady donation income to continue doing this, which
has been very beneficial to the project so far. So if you want to donate has been very beneficial to the project so far. So if you want to donate
some money to the project, check `our website ( https://godotengine.org/donate )` some money to the project, check `our website ( https://pandemoniumengine.org/donate )`
for details. for details.
Contributing code Contributing code
@ -55,11 +55,11 @@ Contributing code
The possibility to study, use, modify and redistribute modifications of the The possibility to study, use, modify and redistribute modifications of the
engine's source code are the fundamental rights that engine's source code are the fundamental rights that
Godot's `MIT ( https://tldrlegal.com/license/mit-license )` license grants you, Pandemonium's `MIT ( https://tldrlegal.com/license/mit-license )` license grants you,
making it `free and open source software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )`. making it `free and open source software ( https://en.wikipedia.org/wiki/Free_and_open-source_software )`.
As such, everyone is entitled to modify As such, everyone is entitled to modify
`Godot's source code ( https://github.com/godotengine/godot )`, and send those `Pandemonium's source code ( https://github.com/pandemoniumengine/pandemonium )`, and send those
modifications back to the upstream project in the form of a patch (a text file modifications back to the upstream project in the form of a patch (a text file
describing the changes in a ready-to-apply manner) or - in the modern workflow describing the changes in a ready-to-apply manner) or - in the modern workflow
that we use - via a so-called "pull request" (PR), i.e. a proposal to directly that we use - via a so-called "pull request" (PR), i.e. a proposal to directly
@ -80,12 +80,12 @@ Contributing code changes upstream has two big advantages:
the time of this writing, more than 1000 developers have contributed code the time of this writing, more than 1000 developers have contributed code
changes to the engine! changes to the engine!
To ensure good collaboration and overall quality, the Godot developers To ensure good collaboration and overall quality, the Pandemonium developers
enforce some rules for code contributions, for example regarding the style to enforce some rules for code contributions, for example regarding the style to
use in the C++ code (indentation, brackets, etc.) or the Git and PR workflow. use in the C++ code (indentation, brackets, etc.) or the Git and PR workflow.
A good place to start is by searching for issues tagged as A good place to start is by searching for issues tagged as
`good first issue ( https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22 )` `good first issue ( https://github.com/pandemoniumengine/pandemonium/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22 )`
on GitHub. on GitHub.
See also: See also:
@ -100,14 +100,14 @@ All pull requests must go through a review process before being accepted.
Depending on the scope of the changes, it may take some time for a maintainer Depending on the scope of the changes, it may take some time for a maintainer
responsible for the modified part of the engine to provide their review. responsible for the modified part of the engine to provide their review.
We value all of our contributors and ask them to be patient in the meantime, We value all of our contributors and ask them to be patient in the meantime,
as it is expected that in an open source project like Godot, there is going to be as it is expected that in an open source project like Pandemonium, there is going to be
way more contributions than people validating them. way more contributions than people validating them.
To make sure that your time and efforts aren't wasted, it is recommended to vet the idea To make sure that your time and efforts aren't wasted, it is recommended to vet the idea
first before implementing it and putting it for a review as a PR. To that end, Godot first before implementing it and putting it for a review as a PR. To that end, Pandemonium
has a `proposal system ( https://github.com/godotengine/godot-proposals )`. Its has a `proposal system ( https://github.com/pandemoniumengine/pandemonium-proposals )`. Its
usage is encouraged to plan changes and discuss them with the community. Implementation usage is encouraged to plan changes and discuss them with the community. Implementation
details can also be discussed with other contributors on the `Godot Contributors Chat ( https://chat.godotengine.org/ )`. details can also be discussed with other contributors on the `Pandemonium Contributors Chat ( https://chat.pandemoniumengine.org/ )`.
Note: Note:
Proposals are only required when working on an enhancement or a new feature. Proposals are only required when working on an enhancement or a new feature.
@ -145,7 +145,7 @@ the developers.
Filing an issue on GitHub Filing an issue on GitHub
~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~
Godot uses `GitHub's issue tracker ( https://github.com/godotengine/godot/issues )` Pandemonium uses `GitHub's issue tracker ( https://github.com/pandemoniumengine/pandemonium/issues )`
for bug reports and enhancement suggestions. You will need a GitHub account to for bug reports and enhancement suggestions. You will need a GitHub account to
be able to open a new issue there, and click on the **New issue** button. be able to open a new issue there, and click on the **New issue** button.
@ -157,7 +157,7 @@ then help make the diagnosis of the issue you met, so that the actual cause of
the bug can be identified and addressed. the bug can be identified and addressed.
You should therefore always ask yourself: what is relevant information to You should therefore always ask yourself: what is relevant information to
give so that other Godot contributors can understand the bug, identify it and give so that other Pandemonium contributors can understand the bug, identify it and
hopefully fix it. Here are some of the most important infos that you should hopefully fix it. Here are some of the most important infos that you should
always provide: always provide:
@ -170,9 +170,9 @@ always provide:
only on certain processors, graphic cards, etc. If you are able to, only on certain processors, graphic cards, etc. If you are able to,
it can be helpful to include information on your hardware. it can be helpful to include information on your hardware.
- **Godot version.** This is a must-have. Some issues might be relevant in the - **Pandemonium version.** This is a must-have. Some issues might be relevant in the
current stable release, but fixed in the development branch, or the other current stable release, but fixed in the development branch, or the other
way around. You might also be using an obsolete version of Godot and way around. You might also be using an obsolete version of Pandemonium and
experiencing a known issue fixed in a later version, so knowing this from experiencing a known issue fixed in a later version, so knowing this from
the start helps to speed up the diagnosis. the start helps to speed up the diagnosis.
@ -194,11 +194,11 @@ are consistent and provide the required information.
Contributing to the documentation Contributing to the documentation
--------------------------------- ---------------------------------
There are two separate resources referred to as "documentation" in Godot: There are two separate resources referred to as "documentation" in Pandemonium:
- **The class reference.** This is the documentation for the complete Godot API - **The class reference.** This is the documentation for the complete Pandemonium API
as exposed to GDScript and the other scripting languages. It can be consulted as exposed to GDScript and the other scripting languages. It can be consulted
offline, directly in Godot's code editor, or online at `Godot API offline, directly in Pandemonium's code editor, or online at `Pandemonium API
( toc-class-ref )`. To contribute to the class reference, you have to edit the ( toc-class-ref )`. To contribute to the class reference, you have to edit the
XML file corresponding to the class and make a pull request. XML file corresponding to the class and make a pull request.
See `doc_updating_the_class_reference` and See `doc_updating_the_class_reference` and
@ -208,14 +208,14 @@ There are two separate resources referred to as "documentation" in Godot:
This is the part you are reading now, which is distributed in the HTML format. This is the part you are reading now, which is distributed in the HTML format.
Its contents are generated from plain text files in the reStructured Text Its contents are generated from plain text files in the reStructured Text
(rst) format, to which you can contribute via pull requests on the (rst) format, to which you can contribute via pull requests on the
`godot-docs ( https://github.com/godotengine/godot-docs )` GitHub repository. `pandemonium-docs ( https://github.com/pandemoniumengine/pandemonium-docs )` GitHub repository.
See `doc_contributing_to_the_documentation` for more details. See `doc_contributing_to_the_documentation` for more details.
Contributing translations Contributing translations
------------------------- -------------------------
To make Godot accessible to everyone, including users who may prefer resources To make Pandemonium accessible to everyone, including users who may prefer resources
in their native language instead of English, our community helps translate both in their native language instead of English, our community helps translate both
the Godot editor and its documentation in many languages. the Pandemonium editor and its documentation in many languages.
See `doc_editor_and_docs_localization` for more details. See `doc_editor_and_docs_localization` for more details.

18
community/tutorials.md
View File

@ -3,27 +3,27 @@
Tutorials and resources Tutorials and resources
======================= =======================
This is a list of third-party tutorials and resources created by the Godot community. For resources, remember that there is the official `Godot Asset Library ( https://godotengine.org/asset-library/asset )` full of official and community resources too! Also, have a look at this `huge list over at Reddit ( https://www.reddit.com/r/godot/comments/an0iq5/godot_tutorials_list_of_video_and_written/ )`. This is a list of third-party tutorials and resources created by the Pandemonium community. For resources, remember that there is the official `Pandemonium Asset Library ( https://pandemoniumengine.org/asset-library/asset )` full of official and community resources too! Also, have a look at this `huge list over at Reddit ( https://www.reddit.com/r/pandemonium/comments/an0iq5/pandemonium_tutorials_list_of_video_and_written/ )`.
Think there is something missing here? Feel free to submit a `Pull Request ( https://github.com/godotengine/godot-docs/blob/master/community/tutorials.rst )` as always. Think there is something missing here? Feel free to submit a `Pull Request ( https://github.com/pandemoniumengine/pandemonium-docs/blob/master/community/tutorials.rst )` as always.
Where to start Where to start
-------------- --------------
The Godot video tutorials by `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )`, `Game from Scratch ( https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d )` and `KidsCanCode ( https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists )` are well-regarded in the community and often recommended as a gentle introduction to beginners. The Pandemonium video tutorials by `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )`, `Game from Scratch ( https://www.youtube.com/watch?v=iDEcP8Mc-7s&list=PLS9MbmO_ssyDk79j9ewONxV88fD5e_o5d )` and `KidsCanCode ( https://www.youtube.com/channel/UCNaPQ5uLX5iIEHUCLmfAgKg/playlists )` are well-regarded in the community and often recommended as a gentle introduction to beginners.
If you're interested in Visual Scripting, `Emilio's tutorials ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )` may be worth a look. If you're interested in Visual Scripting, `Emilio's tutorials ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )` may be worth a look.
If you're interested in a complete introduction to programming using Godot and GDScript, the unofficial `Godot Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )` YouTube channel is a good place to start. If you're interested in a complete introduction to programming using Pandemonium and GDScript, the unofficial `Pandemonium Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )` YouTube channel is a good place to start.
GDQuest's *Learn GDScript From Zero* is a free and open source interactive tutorial for absolute beginners to learn to program with Godot's GDScript language. It is available as a `desktop application ( https://gdquest.itch.io/learn-godot-gdscript )` or `in the browser ( https://gdquest.github.io/learn-gdscript )`. GDQuest's *Learn GDScript From Zero* is a free and open source interactive tutorial for absolute beginners to learn to program with Pandemonium's GDScript language. It is available as a `desktop application ( https://gdquest.itch.io/learn-pandemonium-gdscript )` or `in the browser ( https://gdquest.github.io/learn-gdscript )`.
Some tutorials mentioned below provide more advanced tutorials, e.g. on 3D or shaders. Some tutorials mentioned below provide more advanced tutorials, e.g. on 3D or shaders.
Video tutorials Video tutorials
--------------- ---------------
- `Godot Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )` (2D, GDScript, Programming Basics). - `Pandemonium Tutorials ( https://www.youtube.com/channel/UCnr9ojBEQGgwbcKsZC-2rIg )` (2D, GDScript, Programming Basics).
- `Emilio ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )` (2D, GDScript and VisualScript). - `Emilio ( https://www.youtube.com/channel/UC9DR22-qohBDtZ74R3FxOZg )` (2D, GDScript and VisualScript).
- `FinePointCGI ( https://www.youtube.com/channel/UCSojAWUnEUTUcdA9iJ6bryQ )` (2D, 3D, GDScript and C#). - `FinePointCGI ( https://www.youtube.com/channel/UCSojAWUnEUTUcdA9iJ6bryQ )` (2D, 3D, GDScript and C#).
- `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )` (2D and 3D, GDScript, VisualScript and C#). - `GDQuest ( https://www.youtube.com/channel/UCxboW7x0jZqFdvMdCFKTMsQ/playlists )` (2D and 3D, GDScript, VisualScript and C#).
@ -51,7 +51,7 @@ Text tutorials
- `FinepointCGI website by Mitch ( http://finepointcgi.io/ )` - `FinepointCGI website by Mitch ( http://finepointcgi.io/ )`
- `GDScript website by Andrew Wilkes ( https://gdscript.com )` - `GDScript website by Andrew Wilkes ( https://gdscript.com )`
- `Godot Recipes by KidsCanCode ( http://godotrecipes.com/ )` - `Pandemonium Recipes by KidsCanCode ( http://pandemoniumrecipes.com/ )`
- `Steincodes ( https://steincodes.tumblr.com )` - `Steincodes ( https://steincodes.tumblr.com )`
Devlogs Devlogs
@ -63,5 +63,5 @@ Devlogs
Resources Resources
--------- ---------
- `awesome-godot: A curated list of free/libre plugins, scripts and add-ons ( https://github.com/godotengine/awesome-godot )` - `awesome-pandemonium: A curated list of free/libre plugins, scripts and add-ons ( https://github.com/pandemoniumengine/awesome-pandemonium )`
- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz ( https://godot-engine.zeef.com/andre.antonio.schmitz )` - `Zeef Pandemonium Engine: A curated directory of resources by Andre Schmitz ( https://pandemonium-engine.zeef.com/andre.antonio.schmitz )`

44
engine_development/compiling/compiling_for_android.md
View File

@ -33,9 +33,9 @@ For compiling under Windows, Linux or macOS, the following is required:
- You can download a build from `ojdkbuild ( https://github.com/ojdkbuild/ojdkbuild )`. - You can download a build from `ojdkbuild ( https://github.com/ojdkbuild/ojdkbuild )`.
To get the Godot source code for compiling, see `doc_getting_source`. To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`. For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## Setting up the buildsystem ## Setting up the buildsystem
@ -67,13 +67,13 @@ points to the root of the SDK directories.
## Building the export templates ## Building the export templates
Godot needs two export templates for Android: the optimized "release" Pandemonium needs two export templates for Android: the optimized "release"
template (`android_release.apk`) and the debug template (`android_debug.apk`). template (`android_release.apk`) and the debug template (`android_debug.apk`).
As Google will require all APKs to include ARMv8 (64-bit) libraries starting As Google will require all APKs to include ARMv8 (64-bit) libraries starting
from August 2019, the commands below will build an APK containing both from August 2019, the commands below will build an APK containing both
ARMv7 and ARMv8 libraries. ARMv7 and ARMv8 libraries.
Compiling the standard export templates is done by calling SCons from the Godot Compiling the standard export templates is done by calling SCons from the Pandemonium
root directory with the following arguments: root directory with the following arguments:
- Release template (used when exporting with **Debugging Enabled** unchecked) - Release template (used when exporting with **Debugging Enabled** unchecked)
@ -83,9 +83,9 @@ root directory with the following arguments:
scons platform=android target=release android_arch=arm64v8 scons platform=android target=release android_arch=arm64v8
cd platform/android/java cd platform/android/java
# On Windows # On Windows
.\gradlew generateGodotTemplates .\gradlew generatePandemoniumTemplates
# On Linux and macOS # On Linux and macOS
./gradlew generateGodotTemplates ./gradlew generatePandemoniumTemplates
``` ```
The resulting APK will be located at `bin/android_release.apk`. The resulting APK will be located at `bin/android_release.apk`.
@ -97,9 +97,9 @@ The resulting APK will be located at `bin/android_release.apk`.
scons platform=android target=release_debug android_arch=arm64v8 scons platform=android target=release_debug android_arch=arm64v8
cd platform/android/java cd platform/android/java
# On Windows # On Windows
.\gradlew generateGodotTemplates .\gradlew generatePandemoniumTemplates
# On Linux and macOS # On Linux and macOS
./gradlew generateGodotTemplates ./gradlew generatePandemoniumTemplates
``` ```
The resulting APK will be located at `bin/android_debug.apk`. The resulting APK will be located at `bin/android_debug.apk`.
@ -118,9 +118,9 @@ example, for the release template:
scons platform=android target=release android_arch=x86_64 scons platform=android target=release android_arch=x86_64
cd platform/android/java cd platform/android/java
# On Windows # On Windows
.\gradlew generateGodotTemplates .\gradlew generatePandemoniumTemplates
# On Linux and macOS # On Linux and macOS
./gradlew generateGodotTemplates ./gradlew generatePandemoniumTemplates
``` ```
This will create a fat binary that works on all platforms. This will create a fat binary that works on all platforms.
@ -135,33 +135,33 @@ You can use the following commands to remove the generated export templates:
``` ```
cd platform/android/java cd platform/android/java
# On Windows # On Windows
.\gradlew cleanGodotTemplates .\gradlew cleanPandemoniumTemplates
# On Linux and macOS # On Linux and macOS
./gradlew cleanGodotTemplates ./gradlew cleanPandemoniumTemplates
``` ```
## Using the export templates ## Using the export templates
Godot needs release and debug APKs that were compiled against the same Pandemonium needs release and debug APKs that were compiled against the same
version/commit as the editor. If you are using official binaries version/commit as the editor. If you are using official binaries
for the editor, make sure to install the matching export templates, for the editor, make sure to install the matching export templates,
or build your own from the same version. or build your own from the same version.
When exporting your game, Godot opens the APK, changes a few things inside and When exporting your game, Pandemonium opens the APK, changes a few things inside and
adds your files. adds your files.
Installing the templates Installing the templates
The newly-compiled templates (`android_debug.apk` The newly-compiled templates (`android_debug.apk`
and `android_release.apk`) must be copied to Godot's templates folder and `android_release.apk`) must be copied to Pandemonium's templates folder
with their respective names. The templates folder can be located in: with their respective names. The templates folder can be located in:
- Windows: `%APPDATA%\Godot\templates\( version>\` - Windows: `%APPDATA%\Pandemonium\templates\( version>\`
- Linux: `$HOME/.local/share/godot/templates/( version>/` - Linux: `$HOME/.local/share/pandemonium/templates/( version>/`
- macOS: `$HOME/Library/Application Support/Godot/templates/( version>/` - macOS: `$HOME/Library/Application Support/Pandemonium/templates/( version>/`
`( version )` is of the form `major.minor[.patch].status` using values from `( version )` is of the form `major.minor[.patch].status` using values from
`version.py` in your Godot source repository (e.g. `3.0.5.stable` or `3.1.dev`). `version.py` in your Pandemonium source repository (e.g. `3.0.5.stable` or `3.1.dev`).
You also need to write this same version string to a `version.txt` file located You also need to write this same version string to a `version.txt` file located
next to your export templates. next to your export templates.
@ -172,7 +172,7 @@ here:
![](img/andtemplates.png) ![](img/andtemplates.png)
You don't even need to copy them, you can just reference the resulting You don't even need to copy them, you can just reference the resulting
file in the `bin\` directory of your Godot source folder, so that the file in the `bin\` directory of your Pandemonium source folder, so that the
next time you build you will automatically have the custom templates next time you build you will automatically have the custom templates
referenced. referenced.
@ -211,8 +211,8 @@ If the application runs but exits immediately, this might be due to
one of the following reasons: one of the following reasons:
- Make sure to use export templates that match your editor version; if - Make sure to use export templates that match your editor version; if
you use a new Godot version, you *have* to update the templates too. you use a new Pandemonium version, you *have* to update the templates too.
- `libgodot_android.so` is not in `libs/( android_arch>/` - `libpandemonium_android.so` is not in `libs/( android_arch>/`
where `( android_arch )` is the device's architecture. where `( android_arch )` is the device's architecture.
- The device's architecture does not match the exported one(s). - The device's architecture does not match the exported one(s).
Make sure your templates were built for that device's architecture, Make sure your templates were built for that device's architecture,

16
engine_development/compiling/compiling_for_ios.md
View File

@ -11,8 +11,8 @@ project to iOS instead, read `doc_exporting_for_ios`.
to run `scons` in a terminal when installed). to run `scons` in a terminal when installed).
- Xcode 10.0 (or later) with the iOS (10.0) SDK and the command line tools. - Xcode 10.0 (or later) with the iOS (10.0) SDK and the command line tools.
To get the Godot source code for compiling, see `doc_getting_source`. To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`. For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## Compiling ## Compiling
@ -48,9 +48,9 @@ All those steps can be performed with following commands:
``` ```
$ scons p=iphone tools=no target=release arch=arm $ scons p=iphone tools=no target=release arch=arm
$ scons p=iphone tools=no target=release arch=arm64 $ scons p=iphone tools=no target=release arch=arm64
$ lipo -create bin/libgodot.iphone.opt.arm.a bin/libgodot.iphone.opt.arm64.a -output bin/libgodot.iphone.release.fat.a $ lipo -create bin/libpandemonium.iphone.opt.arm.a bin/libpandemonium.iphone.opt.arm64.a -output bin/libpandemonium.iphone.release.fat.a
$ lipo -create bin/libgodot_camera_module.iphone.opt.arm.a bin/libgodot_camera_module.iphone.opt.arm64.a -output bin/libgodot_camera_module.iphone.release.fat.a $ lipo -create bin/libpandemonium_camera_module.iphone.opt.arm.a bin/libpandemonium_camera_module.iphone.opt.arm64.a -output bin/libpandemonium_camera_module.iphone.release.fat.a
$ lipo -create bin/libgodot_arkit_module.iphone.opt.arm.a bin/libgodot_arkit_module.iphone.opt.arm64.a -output bin/libgodot_arkit_module.iphone.release.fat.a $ lipo -create bin/libpandemonium_arkit_module.iphone.opt.arm.a bin/libpandemonium_arkit_module.iphone.opt.arm64.a -output bin/libpandemonium_arkit_module.iphone.release.fat.a
``` ```
If you also want to provide a simulator build (reduces the chance of any linker errors with dependencies), you'll need to build and lipo the `x86_64` architecture as well. If you also want to provide a simulator build (reduces the chance of any linker errors with dependencies), you'll need to build and lipo the `x86_64` architecture as well.
@ -59,9 +59,9 @@ If you also want to provide a simulator build (reduces the chance of any linker
$ scons p=iphone tools=no target=release arch=arm $ scons p=iphone tools=no target=release arch=arm
$ scons p=iphone tools=no target=release arch=arm64 $ scons p=iphone tools=no target=release arch=arm64
$ scons p=iphone tools=no target=release arch=x86_64 $ scons p=iphone tools=no target=release arch=x86_64
$ lipo -create bin/libgodot.iphone.opt.arm.a bin/libgodot.iphone.opt.arm64.a bin/libgodot.iphone.opt.x86_64.a -output bin/libgodot.iphone.release.fat.a $ lipo -create bin/libpandemonium.iphone.opt.arm.a bin/libpandemonium.iphone.opt.arm64.a bin/libpandemonium.iphone.opt.x86_64.a -output bin/libpandemonium.iphone.release.fat.a
$ lipo -create bin/libgodot_camera_module.iphone.opt.arm.a bin/libgodot_camera_module.iphone.opt.arm64.a bin/libgodot_camera_module.iphone.opt.x86_64.a -output bin/libgodot_camera_module.iphone.release.fat.a $ lipo -create bin/libpandemonium_camera_module.iphone.opt.arm.a bin/libpandemonium_camera_module.iphone.opt.arm64.a bin/libpandemonium_camera_module.iphone.opt.x86_64.a -output bin/libpandemonium_camera_module.iphone.release.fat.a
$ lipo -create bin/libgodot_arkit_module.iphone.opt.arm.a bin/libgodot_arkit_module.iphone.opt.arm64.a bin/libgodot_arkit_module.iphone.opt.x86_64.a -output bin/libgodot_arkit_module.iphone.release.fat.a $ lipo -create bin/libpandemonium_arkit_module.iphone.opt.arm.a bin/libpandemonium_arkit_module.iphone.opt.arm64.a bin/libpandemonium_arkit_module.iphone.opt.x86_64.a -output bin/libpandemonium_arkit_module.iphone.release.fat.a
``` ```
## Run ## Run

30
engine_development/compiling/compiling_for_osx.md
View File

@ -31,9 +31,9 @@ SCons and yasm using the following command:
sudo port install scons yasm sudo port install scons yasm
``` ```
To get the Godot source code for compiling, see `doc_getting_source`. To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`. For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## Compiling ## Compiling
@ -54,13 +54,13 @@ To compile for Apple Silicon (ARM64) powered Macs, use:
To support both architectures in a single "Universal 2" binary, run the above two commands and then use `lipo` to bundle them together: To support both architectures in a single "Universal 2" binary, run the above two commands and then use `lipo` to bundle them together:
``` ```
lipo -create bin/godot.osx.tools.x86_64 bin/godot.osx.tools.arm64 -output bin/godot.osx.tools.universal lipo -create bin/pandemonium.osx.tools.x86_64 bin/pandemonium.osx.tools.arm64 -output bin/pandemonium.osx.tools.universal
``` ```
If all goes well, the resulting binary executable will be placed in the `bin/` subdirectory. This executable If all goes well, the resulting binary executable will be placed in the `bin/` subdirectory. This executable
file contains the whole engine and runs without any dependencies. Executing it will bring up the project manager. file contains the whole engine and runs without any dependencies. Executing it will bring up the project manager.
If you want to use separate editor settings for your own Godot builds and official releases, you can enable If you want to use separate editor settings for your own Pandemonium builds and official releases, you can enable
`doc_data_paths_self_contained_mode` by creating a file called `._sc_` or `sc_` in the `bin/` folder. `doc_data_paths_self_contained_mode` by creating a file called `._sc_` or `sc_` in the `bin/` folder.
To create an `.app` bundle like in the official builds, you need to use the To create an `.app` bundle like in the official builds, you need to use the
@ -68,10 +68,10 @@ template located in `misc/dist/osx_tools.app`. Typically, for an optimized
editor binary built with `target=release_debug`: editor binary built with `target=release_debug`:
``` ```
cp -r misc/dist/osx_tools.app ./Godot.app cp -r misc/dist/osx_tools.app ./Pandemonium.app
mkdir -p Godot.app/Contents/MacOS mkdir -p Pandemonium.app/Contents/MacOS
cp bin/godot.osx.opt.tools.universal Godot.app/Contents/MacOS/Godot cp bin/pandemonium.osx.opt.tools.universal Pandemonium.app/Contents/MacOS/Pandemonium
chmod +x Godot.app/Contents/MacOS/Godot chmod +x Pandemonium.app/Contents/MacOS/Pandemonium
``` ```
## Compiling a headless/server build ## Compiling a headless/server build
@ -125,27 +125,27 @@ To support both architectures in a single "Universal 2" binary, run the above
two commands blocks and then use `lipo` to bundle them together: two commands blocks and then use `lipo` to bundle them together:
``` ```
lipo -create bin/godot.osx.opt.x86_64 bin/godot.osx.opt.arm64 -output bin/godot.osx.opt.universal lipo -create bin/pandemonium.osx.opt.x86_64 bin/pandemonium.osx.opt.arm64 -output bin/pandemonium.osx.opt.universal
lipo -create bin/godot.osx.opt.debug.x86_64 bin/godot.osx.opt.debug.arm64 -output bin/godot.osx.opt.debug.universal lipo -create bin/pandemonium.osx.opt.debug.x86_64 bin/pandemonium.osx.opt.debug.arm64 -output bin/pandemonium.osx.opt.debug.universal
``` ```
To create an `.app` bundle like in the official builds, you need to use the To create an `.app` bundle like in the official builds, you need to use the
template located in `misc/dist/osx_template.app`. The release and debug template located in `misc/dist/osx_template.app`. The release and debug
builds should be placed in `osx_template.app/Contents/MacOS` with the names builds should be placed in `osx_template.app/Contents/MacOS` with the names
`godot_osx_release.64` and `godot_osx_debug.64` respectively. You can do so `pandemonium_osx_release.64` and `pandemonium_osx_debug.64` respectively. You can do so
with the following commands (assuming a universal build, otherwise replace the with the following commands (assuming a universal build, otherwise replace the
`.universal` extension with the one of your arch-specific binaries): `.universal` extension with the one of your arch-specific binaries):
``` ```
cp -r misc/dist/osx_template.app . cp -r misc/dist/osx_template.app .
mkdir -p osx_template.app/Contents/MacOS mkdir -p osx_template.app/Contents/MacOS
cp bin/godot.osx.opt.universal osx_template.app/Contents/MacOS/godot_osx_release.64 cp bin/pandemonium.osx.opt.universal osx_template.app/Contents/MacOS/pandemonium_osx_release.64
cp bin/godot.osx.opt.debug.universal osx_template.app/Contents/MacOS/godot_osx_debug.64 cp bin/pandemonium.osx.opt.debug.universal osx_template.app/Contents/MacOS/pandemonium_osx_debug.64
chmod +x osx_template.app/Contents/MacOS/godot_osx* chmod +x osx_template.app/Contents/MacOS/pandemonium_osx*
``` ```
You can then zip the `osx_template.app` folder to reproduce the `osx.zip` You can then zip the `osx_template.app` folder to reproduce the `osx.zip`
template from the official Godot distribution: template from the official Pandemonium distribution:
``` ```
zip -q -9 -r osx.zip osx_template.app zip -q -9 -r osx.zip osx_template.app

34
engine_development/compiling/compiling_for_uwp.md
View File

@ -31,10 +31,10 @@ Note:
the new build instructions. the new build instructions.
See also: See also:
To get the Godot source code for compiling, see To get the Pandemonium source code for compiling, see
`doc_getting_source`. `doc_getting_source`.
For a general overview of SCons usage for Godot, see For a general overview of SCons usage for Pandemonium, see
`doc_introduction_to_the_buildsystem`. `doc_introduction_to_the_buildsystem`.
Compiling Compiling
@ -55,7 +55,7 @@ required DLLs for the selected architecture.
Once you're set, run the SCons command similarly to the other platforms: Once you're set, run the SCons command similarly to the other platforms:
``` ```
C:\godot>scons platform=uwp C:\pandemonium>scons platform=uwp
``` ```
Creating UWP export templates Creating UWP export templates
@ -69,18 +69,18 @@ Open the command prompt for one architecture and run SCons twice (once for
each target): each target):
``` ```
C:\godot>scons platform=uwp target=release_debug C:\pandemonium>scons platform=uwp target=release_debug
C:\godot>scons platform=uwp target=release C:\pandemonium>scons platform=uwp target=release
``` ```
Repeat for the other architectures. Repeat for the other architectures.
In the end your `bin` folder will have the `.exe` binaries with a name In the end your `bin` folder will have the `.exe` binaries with a name
like `godot.uwp.opt.debug.32.x86.exe` (with variations for each like `pandemonium.uwp.opt.debug.32.x86.exe` (with variations for each
target/arch). target/arch).
Copy one of these to `misc/dist/uwp_template` inside the Godot source Copy one of these to `misc/dist/uwp_template` inside the Pandemonium source
folder and rename the binary to `godot.uwp.exe`. From the ANGLE source, folder and rename the binary to `pandemonium.uwp.exe`. From the ANGLE source,
under `winrt/10/src/Release_%arch%` (where `%arch%` can be `Win32`, under `winrt/10/src/Release_%arch%` (where `%arch%` can be `Win32`,
`x64` or `ARM`), get the `libEGL.dll` and the `libGLESv2.dll`, `x64` or `ARM`), get the `libEGL.dll` and the `libGLESv2.dll`,
putting them along with the executable. putting them along with the executable.
@ -97,9 +97,9 @@ Zip according to the target/architecture of the template:
uwp_arm_release.zip uwp_arm_release.zip
``` ```
Move those templates to the `[versionstring]\templates` folder in Godot Move those templates to the `[versionstring]\templates` folder in Pandemonium
settings path, where `versionstring` is the version of Godot you have compiled settings path, where `versionstring` is the version of Pandemonium you have compiled
the export templates for - e.g. `3.0.alpha` for the alpha version of Godot 3. the export templates for - e.g. `3.0.alpha` for the alpha version of Pandemonium 3.
If you don't want to replace the templates, you can set the "Custom Package" If you don't want to replace the templates, you can set the "Custom Package"
property in the export window. property in the export window.
@ -115,7 +115,7 @@ Within the ANGLE source folder, open `templates` and double-click the
`install.bat` script file. This will install the Visual Studio project `install.bat` script file. This will install the Visual Studio project
templates for ANGLE apps. templates for ANGLE apps.
If you have not built Godot yet, open the `winrt/10/src/angle.sln` solution If you have not built Pandemonium yet, open the `winrt/10/src/angle.sln` solution
from the ANGLE source and build it to Release/Win32 target. You may also need from the ANGLE source and build it to Release/Win32 target. You may also need
to build it for ARM if you plan to run on a device. You can also use MSBuild if to build it for ARM if you plan to run on a device. You can also use MSBuild if
you're comfortable with the command line. you're comfortable with the command line.
@ -131,18 +131,18 @@ and in the "Properties" window and change the relative path from
`Debug_Win32` to `Release_Win32` (or `Release_ARM` for devices). `Debug_Win32` to `Release_Win32` (or `Release_ARM` for devices).
In the same "Binaries" filter, select "Add > Existing Item" and point to the In the same "Binaries" filter, select "Add > Existing Item" and point to the
Godot executable for UWP you have. In the "Properties" window, set "Content" Pandemonium executable for UWP you have. In the "Properties" window, set "Content"
to `True` so it's included in the project. to `True` so it's included in the project.
Right-click the `Package.appxmanifest` file and select "Open With... > XML Right-click the `Package.appxmanifest` file and select "Open With... > XML
(Text) Editor". In the `Package/Applications/Application` element, replace (Text) Editor". In the `Package/Applications/Application` element, replace
the `Executable` attribute from `$targetnametoken$.exe` to the `Executable` attribute from `$targetnametoken$.exe` to
`godot.uwp.exe` (or whatever your Godot executable is called). Also change `pandemonium.uwp.exe` (or whatever your Pandemonium executable is called). Also change
the `EntryPoint` attribute to `GodotUWP.App`. This will ensure that the `EntryPoint` attribute to `PandemoniumUWP.App`. This will ensure that
the Godot executable is correctly called when the app starts. the Pandemonium executable is correctly called when the app starts.
Create a folder (*not* a filter) called `game` in your Visual Studio project Create a folder (*not* a filter) called `game` in your Visual Studio project
folder and there you can put either a `data.pck` file or your Godot project folder and there you can put either a `data.pck` file or your Pandemonium project
files. After that, make sure to include it all with the "Add > Existing Item" files. After that, make sure to include it all with the "Add > Existing Item"
command and set their "Content" property to `True` so they're copied to the command and set their "Content" property to `True` so they're copied to the
app. app.

18
engine_development/compiling/compiling_for_web.md
View File

@ -14,8 +14,8 @@ To compile export templates for the Web, the following is required:
- `SCons 3.0+ ( https://www.scons.org )` build system. - `SCons 3.0+ ( https://www.scons.org )` build system.
To get the Godot source code for compiling, see `doc_getting_source`. To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`. For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## Building export templates ## Building export templates
@ -44,20 +44,20 @@ enabled. Since `eval()` calls can be a security concern, the
The engine will now be compiled to WebAssembly by Emscripten. Once finished, The engine will now be compiled to WebAssembly by Emscripten. Once finished,
the resulting file will be placed in the `bin` subdirectory. Its name is the resulting file will be placed in the `bin` subdirectory. Its name is
`godot.javascript.opt.zip` for release or `godot.javascript.opt.debug.zip` `pandemonium.javascript.opt.zip` for release or `pandemonium.javascript.opt.debug.zip`
for debug. for debug.
Finally, rename the zip archive to `webassembly_release.zip` for the Finally, rename the zip archive to `webassembly_release.zip` for the
release template: release template:
``` ```
mv bin/godot.javascript.opt.zip bin/webassembly_release.zip mv bin/pandemonium.javascript.opt.zip bin/webassembly_release.zip
``` ```
And `webassembly_debug.zip` for the debug template: And `webassembly_debug.zip` for the debug template:
``` ```
mv bin/godot.javascript.opt.debug.zip bin/webassembly_debug.zip mv bin/pandemonium.javascript.opt.debug.zip bin/webassembly_debug.zip
``` ```
## Threads ## Threads
@ -79,19 +79,19 @@ Its name will have the `.threads` suffix.
Finally, rename the zip archives to `webassembly_release_threads.zip` for the release template: Finally, rename the zip archives to `webassembly_release_threads.zip` for the release template:
``` ```
mv bin/godot.javascript.opt.threads.zip bin/webassembly_threads_release.zip mv bin/pandemonium.javascript.opt.threads.zip bin/webassembly_threads_release.zip
``` ```
And `webassembly_debug_threads.zip` for the debug template: And `webassembly_debug_threads.zip` for the debug template:
``` ```
mv bin/godot.javascript.opt.debug.threads.zip bin/webassembly_threads_debug.zip mv bin/pandemonium.javascript.opt.debug.threads.zip bin/webassembly_threads_debug.zip
``` ```
## Building the Editor ## Building the Editor
It is also possible to build a version of the Godot editor that can run in the It is also possible to build a version of the Pandemonium editor that can run in the
browser. The editor version requires threads support and is not recommended browser. The editor version requires threads support and is not recommended
over the native build. You can build the editor with: over the native build. You can build the editor with:
@ -100,7 +100,7 @@ over the native build. You can build the editor with:
``` ```
Once finished, the resulting file will be placed in the `bin` subdirectory. Once finished, the resulting file will be placed in the `bin` subdirectory.
Its name will be `godot.javascript.opt.tools.threads.zip`. You can upload the Its name will be `pandemonium.javascript.opt.tools.threads.zip`. You can upload the
zip content to your web server and visit it with your browser to use the editor. zip content to your web server and visit it with your browser to use the editor.
Refer to the `export page ( doc_javascript_export_options )` for the web Refer to the `export page ( doc_javascript_export_options )` for the web

54
engine_development/compiling/compiling_for_windows.md
View File

@ -40,9 +40,9 @@ For each MSYS2 MinGW subsystem, you should then run `pip3 install scons` in its
### See also: ### See also:
To get the Godot source code for compiling, see `doc_getting_source`. To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`. For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## Setting up SCons ## Setting up SCons
@ -85,21 +85,21 @@ C++ support, run the installer again; it should present you a **Modify** button.
Running the installer from *Add/Remove Programs* will only give you Running the installer from *Add/Remove Programs* will only give you
a **Repair** option, which won't let you install C++ tools. a **Repair** option, which won't let you install C++ tools.
## Downloading Godot's source ## Downloading Pandemonium's source
Refer to `doc_getting_source` for detailed instructions. Refer to `doc_getting_source` for detailed instructions.
The tutorial will assume from now on that you placed the source code in `C:\godot`. The tutorial will assume from now on that you placed the source code in `C:\pandemonium`.
### Warning: ### Warning:
To prevent slowdowns caused by continuous virus scanning during compilation, add the Godot source To prevent slowdowns caused by continuous virus scanning during compilation, add the Pandemonium source
folder to the list of exceptions in your antivirus software. folder to the list of exceptions in your antivirus software.
For Windows Defender, hit the :kbd:`Windows` key, type "Windows Defender Settings" then hit :kbd:`Enter`. For Windows Defender, hit the :kbd:`Windows` key, type "Windows Defender Settings" then hit :kbd:`Enter`.
Under **Virus & threat protection**, go to **Virus & threat protection setting** and scroll Under **Virus & threat protection**, go to **Virus & threat protection setting** and scroll
down to **Exclusions**. Click **Add or remove exclusions** then add the Godot source folder. down to **Exclusions**. Click **Add or remove exclusions** then add the Pandemonium source folder.
## Compiling ## Compiling
@ -113,7 +113,7 @@ builds cannot be performed from the MSYS2 or MinGW shells. Use either
`cmd.exe` or PowerShell instead. `cmd.exe` or PowerShell instead.
During development, using the Visual Studio compiler is usually a better idea, During development, using the Visual Studio compiler is usually a better idea,
as it links the Godot binary much faster than MinGW. However, MinGW can as it links the Pandemonium binary much faster than MinGW. However, MinGW can
produce more optimized binaries using link-time optimization (see below), produce more optimized binaries using link-time optimization (see below),
making it a better choice for production use. making it a better choice for production use.
@ -123,24 +123,24 @@ After opening a command prompt, change to the root directory of
the engine source code (using `cd`) and type: the engine source code (using `cd`) and type:
``` ```
C:\godot> scons platform=windows C:\pandemonium> scons platform=windows
``` ```
You can specify a number of CPU threads to use to speed up the build: You can specify a number of CPU threads to use to speed up the build:
``` ```
C:\godot> scons -j6 platform=windows C:\pandemonium> scons -j6 platform=windows
``` ```
In general, it is OK to have at least as many threads compiling Godot as you In general, it is OK to have at least as many threads compiling Pandemonium as you
have cores in your CPU, if not one or two more. Feel free to add the `-j` have cores in your CPU, if not one or two more. Feel free to add the `-j`
option to any SCons command you see below. option to any SCons command you see below.
Note: When compiling with multiple CPU threads, SCons may warn about pywin32 being missing. You can safely ignore this warning. Note: When compiling with multiple CPU threads, SCons may warn about pywin32 being missing. You can safely ignore this warning.
If all goes well, the resulting binary executable will be placed in If all goes well, the resulting binary executable will be placed in
`C:\godot\bin\` with the name `godot.windows.tools.32.exe` or `C:\pandemonium\bin\` with the name `pandemonium.windows.tools.32.exe` or
`godot.windows.tools.64.exe`. By default, SCons will build a binary matching `pandemonium.windows.tools.64.exe`. By default, SCons will build a binary matching
your CPU architecture, but this can be overridden using `bits=64` or your CPU architecture, but this can be overridden using `bits=64` or
`bits=32`. `bits=32`.
@ -149,25 +149,25 @@ dependencies. Running it will bring up the Project Manager.
Note: Note:
If you are compiling Godot for production use, then you can make the final executable smaller and faster by adding the If you are compiling Pandemonium for production use, then you can make the final executable smaller and faster by adding the
SCons option `target=release_debug`. SCons option `target=release_debug`.
If you are compiling Godot with MinGW, you can make the binary even smaller and faster by adding the SCons If you are compiling Pandemonium with MinGW, you can make the binary even smaller and faster by adding the SCons
option `use_lto=yes`. As link-time optimization is a memory-intensive process, this will require about option `use_lto=yes`. As link-time optimization is a memory-intensive process, this will require about
7 GB of available RAM while compiling. 7 GB of available RAM while compiling.
Note: Note:
If you want to use separate editor settings for your own Godot builds and official releases, you can enable If you want to use separate editor settings for your own Pandemonium builds and official releases, you can enable
`doc_data_paths_self_contained_mode` by creating a file called `._sc_` or `sc_` in the `bin/` folder. `doc_data_paths_self_contained_mode` by creating a file called `._sc_` or `sc_` in the `bin/` folder.
## Development in Visual Studio ## Development in Visual Studio
Using an IDE is not required to compile Godot, as SCons takes care of everything. Using an IDE is not required to compile Pandemonium, as SCons takes care of everything.
But if you intend to do engine development or debugging of the engine's C++ code, But if you intend to do engine development or debugging of the engine's C++ code,
you may be interested in configuring a code editor or an IDE. you may be interested in configuring a code editor or an IDE.
Folder-based editors don't require any particular setup to start working with Godot's Folder-based editors don't require any particular setup to start working with Pandemonium's
codebase. To edit projects with Visual Studio they need to be set up as a solution. codebase. To edit projects with Visual Studio they need to be set up as a solution.
You can create a Visual Studio solution via SCons by running SCons with You can create a Visual Studio solution via SCons by running SCons with
@ -177,8 +177,8 @@ the `vsproj=yes` parameter, like this:
scons p=windows vsproj=yes scons p=windows vsproj=yes
``` ```
You will be able to open Godot's source in a Visual Studio solution now, You will be able to open Pandemonium's source in a Visual Studio solution now,
and able to build Godot using Visual Studio's **Build** button. and able to build Pandemonium using Visual Studio's **Build** button.
See also: See also:
See `doc_configuring_an_ide_vs` for further details. See `doc_configuring_an_ide_vs` for further details.
@ -247,7 +247,7 @@ differ based on your system):
### Troubleshooting ### Troubleshooting
Cross-compiling from some Ubuntu versions may lead to Cross-compiling from some Ubuntu versions may lead to
`this bug ( https://github.com/godotengine/godot/issues/9258 )`, `this bug ( https://github.com/pandemoniumengine/pandemonium/issues/9258 )`,
due to a default configuration lacking support for POSIX threading. due to a default configuration lacking support for POSIX threading.
You can change that configuration following those instructions, You can change that configuration following those instructions,
@ -271,14 +271,14 @@ And for 32-bit:
### Creating Windows export templates ### Creating Windows export templates
Windows export templates are created by compiling Godot without the editor, Windows export templates are created by compiling Pandemonium without the editor,
with the following flags: with the following flags:
``` ```
C:\godot> scons platform=windows tools=no target=release_debug bits=32 C:\pandemonium> scons platform=windows tools=no target=release_debug bits=32
C:\godot> scons platform=windows tools=no target=release bits=32 C:\pandemonium> scons platform=windows tools=no target=release bits=32
C:\godot> scons platform=windows tools=no target=release_debug bits=64 C:\pandemonium> scons platform=windows tools=no target=release_debug bits=64
C:\godot> scons platform=windows tools=no target=release bits=64 C:\pandemonium> scons platform=windows tools=no target=release bits=64
``` ```
If you plan on replacing the standard export templates, copy these to the If you plan on replacing the standard export templates, copy these to the
@ -286,7 +286,7 @@ following location, replacing `( version )` with the version identifier
(such as `3.1.1.stable` or `3.2.dev`): (such as `3.1.1.stable` or `3.2.dev`):
``` ```
%USERPROFILE%\AppData\Roaming\Godot\templates\<version>\ %USERPROFILE%\AppData\Roaming\Pandemonium\templates\<version>\
``` ```
With the following names: With the following names:
@ -305,5 +305,5 @@ here:
![](img/wintemplates.png) ![](img/wintemplates.png)
You don't need to copy them in this case, just reference the resulting You don't need to copy them in this case, just reference the resulting
files in the `bin\` directory of your Godot source folder, so the next files in the `bin\` directory of your Pandemonium source folder, so the next
time you build, you will automatically have the custom templates referenced. time you build, you will automatically have the custom templates referenced.

24
engine_development/compiling/compiling_for_x11.md
View File

@ -24,8 +24,8 @@ For compiling under Linux or other Unix variants, the following is required:
- *Optional* - libudev (build with `udev=yes`). - *Optional* - libudev (build with `udev=yes`).
- *Optional* - yasm (for WebM SIMD optimizations). - *Optional* - yasm (for WebM SIMD optimizations).
To get the Godot source code for compiling, see `doc_getting_source`. To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`. For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
### Distro-specific one-liners ### Distro-specific one-liners
@ -118,7 +118,7 @@ Start a terminal, go to the root dir of the engine source code and type:
``` ```
A good rule of thumb for the `-j` (*jobs*) flag, is to have at least as many A good rule of thumb for the `-j` (*jobs*) flag, is to have at least as many
threads compiling Godot as you have cores in your CPU, if not one or two more. threads compiling Pandemonium as you have cores in your CPU, if not one or two more.
Feel free to add the `-j` option to any SCons command you see below. Feel free to add the `-j` option to any SCons command you see below.
If all goes well, the resulting binary executable will be placed in the If all goes well, the resulting binary executable will be placed in the
@ -136,16 +136,16 @@ Using Clang appears to be a requirement for OpenBSD, otherwise fonts would not b
Note: Note:
If you are compiling Godot for production use, then you can make the final executable smaller If you are compiling Pandemonium for production use, then you can make the final executable smaller
and faster by adding the SCons option `target=release_debug`. and faster by adding the SCons option `target=release_debug`.
If you are compiling Godot with GCC, you can make the binary even smaller and faster by adding the SCons If you are compiling Pandemonium with GCC, you can make the binary even smaller and faster by adding the SCons
option `use_lto=yes`. As link-time optimization is a memory-intensive process, this will require about option `use_lto=yes`. As link-time optimization is a memory-intensive process, this will require about
7 GB of available RAM while compiling. 7 GB of available RAM while compiling.
Note: Note:
If you want to use separate editor settings for your own Godot builds and official releases, If you want to use separate editor settings for your own Pandemonium builds and official releases,
you can enable `doc_data_paths_self_contained_mode` by creating a file called `._sc_` or `sc_` in the `bin/` folder. you can enable `doc_data_paths_self_contained_mode` by creating a file called `._sc_` or `sc_` in the `bin/` folder.
## Compiling a headless/server build ## Compiling a headless/server build
@ -199,10 +199,10 @@ platform is not always straight-forward and might need a chroot environment.
To create standard export templates, the resulting files must be copied to: To create standard export templates, the resulting files must be copied to:
``` ```
$HOME/.local/share/godot/templates/[gd-version]/ $HOME/.local/share/pandemonium/templates/[gd-version]/
``` ```
and named like this (even for \*BSD which is seen as "Linux X11" by Godot): and named like this (even for \*BSD which is seen as "Linux X11" by Pandemonium):
``` ```
linux_x11_32_debug linux_x11_32_debug
@ -217,13 +217,13 @@ binaries as custom export templates here:
![](img/lintemplates.png) ![](img/lintemplates.png)
You don't even need to copy them, you can just reference the resulting files in the `bin/` directory of your You don't even need to copy them, you can just reference the resulting files in the `bin/` directory of your
Godot source folder, so the next time you build, you automatically have the custom templates referenced. Pandemonium source folder, so the next time you build, you automatically have the custom templates referenced.
## Using Clang and LLD for faster development ## Using Clang and LLD for faster development
You can also use Clang and LLD to build Godot. This has two upsides compared to the default GCC + GNU ld setup: You can also use Clang and LLD to build Pandemonium. This has two upsides compared to the default GCC + GNU ld setup:
- LLD links Godot significantly faster compared to GNU ld or gold. This leads to faster iteration times. - LLD links Pandemonium significantly faster compared to GNU ld or gold. This leads to faster iteration times.
- Clang tends to give more useful error messages compared to GCC. - Clang tends to give more useful error messages compared to GCC.
To do so, install Clang and the `lld` package from your distribution's package manager To do so, install Clang and the `lld` package from your distribution's package manager
@ -259,7 +259,7 @@ to get even faster builds.
``` ```
- Instead of running `scons ( build arguments )`, run `pyston-scons ( build arguments )` - Instead of running `scons ( build arguments )`, run `pyston-scons ( build arguments )`
to compile Godot. to compile Pandemonium.
If you can't run `pyston-scons` after creating the symbolic link, If you can't run `pyston-scons` after creating the symbolic link,
make sure `$HOME/.local/bin/` is part of your user's `PATH` environment variable. make sure `$HOME/.local/bin/` is part of your user's `PATH` environment variable.

10
engine_development/compiling/compiling_with_script_encryption_key.md
View File

@ -28,10 +28,10 @@ PCK encryption.
`OpenSSL ( https://www.openssl.org/ )` command-line tools: `OpenSSL ( https://www.openssl.org/ )` command-line tools:
``` ```
openssl rand -hex 32 > godot.gdkey openssl rand -hex 32 > pandemonium.gdkey
``` ```
The output in `godot.gdkey` should be similar to: The output in `pandemonium.gdkey` should be similar to:
``` ```
# NOTE: Do not use the key below! Generate your own key instead. # NOTE: Do not use the key below! Generate your own key instead.
@ -42,7 +42,7 @@ PCK encryption.
that way you can minimize the risk of exposing the key. that way you can minimize the risk of exposing the key.
2. Set this key as environment variable in the console that you will use to 2. Set this key as environment variable in the console that you will use to
compile Godot, like this: compile Pandemonium, like this:
bash Linux/macOS bash Linux/macOS
@ -57,7 +57,7 @@ bat Windows (PowerShell)
``` $env:SCRIPT_AES256_ENCRYPTION_KEY="your_generated_key" ``` ``` $env:SCRIPT_AES256_ENCRYPTION_KEY="your_generated_key" ```
3. Compile Godot export templates and set them as custom export templates 3. Compile Pandemonium export templates and set them as custom export templates
in the export preset options. in the export preset options.
4. Set the encryption key in the **Script** tab of the export preset: 4. Set the encryption key in the **Script** tab of the export preset:
@ -69,7 +69,7 @@ bat Windows (PowerShell)
## Troubleshooting ## Troubleshooting
If you get an error like below, it means the key wasn't properly included in If you get an error like below, it means the key wasn't properly included in
your Godot build. Godot is encrypting the scripts during export, but can't read your Pandemonium build. Pandemonium is encrypting the scripts during export, but can't read
them at runtime. them at runtime.
``` ```

14
engine_development/compiling/cross-compiling_for_ios_on_linux.md
View File

@ -4,7 +4,7 @@
The procedure for this is somewhat complex and requires a lot of steps, The procedure for this is somewhat complex and requires a lot of steps,
but once you have the environment properly configured it will be easy to but once you have the environment properly configured it will be easy to
compile Godot for iOS anytime you want. compile Pandemonium for iOS anytime you want.
## Disclaimer ## Disclaimer
@ -112,7 +112,7 @@ to the following commands:
Now you should have the iOS toolchain binaries in Now you should have the iOS toolchain binaries in
`/home/user/iostoolchain/usr/bin`. `/home/user/iostoolchain/usr/bin`.
## Compiling Godot for iPhone ## Compiling Pandemonium for iPhone
Once you've done the above steps, you should keep two things in your Once you've done the above steps, you should keep two things in your
environment: the built toolchain and the iPhoneOS SDK directory. Those environment: the built toolchain and the iPhoneOS SDK directory. Those
@ -126,7 +126,7 @@ environment variable defined to anything.
$ export OSXCROSS_IOS=anything $ export OSXCROSS_IOS=anything
``` ```
Now you can compile for iPhone using SCons like the standard Godot Now you can compile for iPhone using SCons like the standard Pandemonium
way, with some additional arguments to provide the correct paths: way, with some additional arguments to provide the correct paths:
``` ```
@ -139,12 +139,12 @@ way, with some additional arguments to provide the correct paths:
Apple requires a fat binary with both architectures (`armv7` and Apple requires a fat binary with both architectures (`armv7` and
`arm64`) in a single file. To do this, use the `arm64`) in a single file. To do this, use the
`arm-apple-darwin11-lipo` executable. The following example assumes `arm-apple-darwin11-lipo` executable. The following example assumes
you are in the root Godot source directory: you are in the root Pandemonium source directory:
``` ```
$ /path/to/iostoolchain/usr/bin/arm-apple-darwin11-lipo -create bin/libgodot.iphone.opt.debug.arm.a bin/libgodot.iphone.opt.debug.arm64.a -output bin/libgodot.iphone.debug.fat.a $ /path/to/iostoolchain/usr/bin/arm-apple-darwin11-lipo -create bin/libpandemonium.iphone.opt.debug.arm.a bin/libpandemonium.iphone.opt.debug.arm64.a -output bin/libpandemonium.iphone.debug.fat.a
$ /path/to/iostoolchain/usr/bin/arm-apple-darwin11-lipo -create bin/libgodot_camera_module.iphone.opt.debug.arm.a bin/libgodot_camera_module.iphone.opt.debug.arm64.a -output bin/libgodot_camera_module.iphone.debug.fat.a $ /path/to/iostoolchain/usr/bin/arm-apple-darwin11-lipo -create bin/libpandemonium_camera_module.iphone.opt.debug.arm.a bin/libpandemonium_camera_module.iphone.opt.debug.arm64.a -output bin/libpandemonium_camera_module.iphone.debug.fat.a
$ /path/to/iostoolchain/usr/bin/arm-apple-darwin11-lipo -create bin/libgodot_arkit_module.iphone.opt.debug.arm.a bin/libgodot_arkit_module.iphone.opt.debug.arm64.a -output bin/libgodot_arkit_module.iphone.debug.fat.a $ /path/to/iostoolchain/usr/bin/arm-apple-darwin11-lipo -create bin/libpandemonium_arkit_module.iphone.opt.debug.arm.a bin/libpandemonium_arkit_module.iphone.opt.debug.arm64.a -output bin/libpandemonium_arkit_module.iphone.debug.fat.a
``` ```
Then you will have iOS fat binaries in `bin` directory. Then you will have iOS fat binaries in `bin` directory.

20
engine_development/compiling/getting_source.md
View File

@ -1,12 +1,12 @@
# Getting the source # Getting the source
## Downloading the Godot source code ## Downloading the Pandemonium source code
Before `getting into the SCons build system ( doc_introduction_to_the_buildsystem )` Before `getting into the SCons build system ( doc_introduction_to_the_buildsystem )`
and compiling Godot, you need to actually download the Godot source code. and compiling Pandemonium, you need to actually download the Pandemonium source code.
The source code is available on `GitHub ( https://github.com/godotengine/godot )` The source code is available on `GitHub ( https://github.com/pandemoniumengine/pandemonium )`
and while you can manually download it via the website, in general you want to and while you can manually download it via the website, in general you want to
do it via the `git` version control system. do it via the `git` version control system.
@ -18,19 +18,19 @@ If you don't know much about `git` yet, there are a great number of
In general, you need to install `git` and/or one of the various GUI clients. In general, you need to install `git` and/or one of the various GUI clients.
Afterwards, to get the latest development version of the Godot source code Afterwards, to get the latest development version of the Pandemonium source code
(the unstable `master` branch), you can use `git clone`. (the unstable `master` branch), you can use `git clone`.
If you are using the `git` command line client, this is done by entering If you are using the `git` command line client, this is done by entering
the following in a terminal: the following in a terminal:
``` ```
git clone https://github.com/godotengine/godot.git git clone https://github.com/pandemoniumengine/pandemonium.git
# You can add the --depth 1 argument to omit the commit history. # You can add the --depth 1 argument to omit the commit history.
# Faster, but not all Git operations (like blame) will work. # Faster, but not all Git operations (like blame) will work.
``` ```
For any stable release, visit the `release page ( https://github.com/godotengine/godot/releases )` For any stable release, visit the `release page ( https://github.com/pandemoniumengine/pandemonium/releases )`
and click on the link for the release you want. and click on the link for the release you want.
You can then download and extract the source from the download link on the page. You can then download and extract the source from the download link on the page.
@ -39,13 +39,13 @@ after the `--branch` (or just `-b`) argument:
``` ```
# Clone the continuously maintained stable branch (`3.x` as of writing). # Clone the continuously maintained stable branch (`3.x` as of writing).
git clone https://github.com/godotengine/godot.git -b 3.x git clone https://github.com/pandemoniumengine/pandemonium.git -b 3.x
# Clone the `3.2.3-stable` tag. This is a fixed revision that will never change. # Clone the `3.2.3-stable` tag. This is a fixed revision that will never change.
git clone https://github.com/godotengine/godot.git -b 3.2.3-stable git clone https://github.com/pandemoniumengine/pandemonium.git -b 3.2.3-stable
``` ```
There are also generally branches besides `master` for each major version. There are also generally branches besides `master` for each major version.
After downloading the Godot source code, After downloading the Pandemonium source code,
you can `continue to compiling Godot ( doc_introduction_to_the_buildsystem )`. you can `continue to compiling Pandemonium ( doc_introduction_to_the_buildsystem )`.

52
engine_development/compiling/introduction_to_the_buildsystem.md
View File

@ -3,14 +3,14 @@
## SCons ## SCons
Godot uses `SCons ( https://www.scons.org/ )` to build. We love it, we are Pandemonium uses `SCons ( https://www.scons.org/ )` to build. We love it, we are
not changing it for anything else. We are not even sure other build not changing it for anything else. We are not even sure other build
systems are up to the task of building Godot. We constantly get requests systems are up to the task of building Pandemonium. We constantly get requests
to move the build system to CMake, or Visual Studio, but this is not to move the build system to CMake, or Visual Studio, but this is not
going to happen. There are many reasons why we have chosen SCons over going to happen. There are many reasons why we have chosen SCons over
other alternatives, for example: other alternatives, for example:
- Godot can be compiled for a dozen different platforms: all PC - Pandemonium can be compiled for a dozen different platforms: all PC
platforms, all mobile platforms, many consoles, and WebAssembly. platforms, all mobile platforms, many consoles, and WebAssembly.
- Developers often need to compile for several of the platforms **at - Developers often need to compile for several of the platforms **at
the same time**, or even different targets of the same platform. They the same time**, or even different targets of the same platform. They
@ -19,17 +19,17 @@ other alternatives, for example:
- SCons will *never* break a build no matter how many changes, - SCons will *never* break a build no matter how many changes,
configurations, additions, removals etc. You have more chances to die configurations, additions, removals etc. You have more chances to die
struck by lightning than needing to clean and rebuild in SCons. struck by lightning than needing to clean and rebuild in SCons.
- Godot build process is not simple. Several files are generated by - Pandemonium build process is not simple. Several files are generated by
code (binders), others are parsed (shaders), and others need to offer code (binders), others are parsed (shaders), and others need to offer
customization (plugins). This requires complex logic which is easier customization (plugins). This requires complex logic which is easier
to write in an actual programming language (like Python) rather than to write in an actual programming language (like Python) rather than
using a mostly macro-based language only meant for building. using a mostly macro-based language only meant for building.
- Godot build process makes heavy use of cross-compiling tools. Each - Pandemonium build process makes heavy use of cross-compiling tools. Each
platform has a specific detection process, and all these must be platform has a specific detection process, and all these must be
handled as specific cases with special code written for each. handled as specific cases with special code written for each.
So, please try to keep an open mind and get at least a little familiar with it So, please try to keep an open mind and get at least a little familiar with it
if you are planning to build Godot yourself. if you are planning to build Pandemonium yourself.
## Setup ## Setup
@ -44,7 +44,7 @@ the standard Windows command prompt to enter the commands below.
## Platform selection ## Platform selection
Godot's build system will begin by detecting the platforms it can build Pandemonium's build system will begin by detecting the platforms it can build
for. If not detected, the platform will simply not appear on the list of for. If not detected, the platform will simply not appear on the list of
available platforms. The build requirements for each platform are available platforms. The build requirements for each platform are
described in the rest of this tutorial section. described in the rest of this tutorial section.
@ -94,14 +94,14 @@ The resulting binaries will be placed in the `bin/` subdirectory,
generally with this naming convention: generally with this naming convention:
``` ```
godot.<platform>.[opt].[tools/debug].<architecture>[extension] pandemonium.<platform>.[opt].[tools/debug].<architecture>[extension]
``` ```
For the previous build attempt, the result would look like this: For the previous build attempt, the result would look like this:
``` ```
ls bin ls bin
bin/godot.x11.tools.64 bin/pandemonium.x11.tools.64
``` ```
This means that the binary is for X11, is not optimized, has tools (the This means that the binary is for X11, is not optimized, has tools (the
@ -110,14 +110,14 @@ whole editor) compiled in, and is meant for 64 bits.
A Windows binary with the same configuration will look like this: A Windows binary with the same configuration will look like this:
``` ```
C:\godot> dir bin/ C:\pandemonium> dir bin/
godot.windows.tools.64.exe pandemonium.windows.tools.64.exe
``` ```
Copy that binary to any location you like, as it contains the project manager, Copy that binary to any location you like, as it contains the project manager,
editor and all means to execute the game. However, it lacks the data to export editor and all means to execute the game. However, it lacks the data to export
it to the different platforms. For that the export templates are needed (which it to the different platforms. For that the export templates are needed (which
can be either downloaded from `godotengine.org ( https://godotengine.org/ )`, or can be either downloaded from `pandemoniumengine.org ( https://pandemoniumengine.org/ )`, or
you can build them yourself). you can build them yourself).
Aside from that, there are a few standard options that can be set in all Aside from that, there are a few standard options that can be set in all
@ -177,7 +177,7 @@ architecture.
## Custom modules ## Custom modules
It's possible to compile modules residing outside of Godot's directory It's possible to compile modules residing outside of Pandemonium's directory
tree, along with the built-in modules. tree, along with the built-in modules.
A `custom_modules` build option can be passed to the command line before A `custom_modules` build option can be passed to the command line before
@ -189,7 +189,7 @@ For instance, it's possible to provide both relative, absolute, and user
directory paths containing such modules: directory paths containing such modules:
``` ```
scons custom_modules="../modules,/abs/path/to/modules,~/src/godot_modules" scons custom_modules="../modules,/abs/path/to/modules,~/src/pandemonium_modules"
``` ```
Note: Note:
@ -208,7 +208,7 @@ See also:
Sometimes, you may encounter an error due to generated files being present. You Sometimes, you may encounter an error due to generated files being present. You
can remove them by using `scons --clean <options )`, where `<options )` is the can remove them by using `scons --clean <options )`, where `<options )` is the
list of build options you've used to build Godot previously. list of build options you've used to build Pandemonium previously.
Alternatively, you can use `git clean -fixd` which will clean build artifacts Alternatively, you can use `git clean -fixd` which will clean build artifacts
for all platforms and configurations. Beware, as this will remove all untracked for all platforms and configurations. Beware, as this will remove all untracked
@ -218,7 +218,7 @@ uncommitted work!
## Other build options ## Other build options
There are several other build options that you can use to configure the There are several other build options that you can use to configure the
way Godot should be built (compiler, debug options, etc.) as well as the way Pandemonium should be built (compiler, debug options, etc.) as well as the
features to include/disable. features to include/disable.
Check the output of `scons --help` for details about each option for Check the output of `scons --help` for details about each option for
@ -228,7 +228,7 @@ the version you are willing to compile.
#### Using a file #### Using a file
The default `custom.py` file can be created at the root of the Godot Engine The default `custom.py` file can be created at the root of the Pandemonium Engine
source to initialize any SCons build options passed via the command line: source to initialize any SCons build options passed via the command line:
``` ```
@ -245,9 +245,9 @@ time it takes to build the engine. See `doc_optimizing_for_size` page for more d
See also: See also:
You can use the online `Godot build options generator ( https://godot-build-options-generator.github.io/ )` You can use the online `Pandemonium build options generator ( https://pandemonium-build-options-generator.github.io/ )`
to generate a `custom.py` file containing SCons options. You can then save this file and place it at the root to generate a `custom.py` file containing SCons options. You can then save this file and place it at the root
of your Godot source directory. of your Pandemonium source directory.
Another custom file can be specified explicitly with the `profile` command Another custom file can be specified explicitly with the `profile` command
line option, both overriding the default build configuration: line option, both overriding the default build configuration:
@ -265,7 +265,7 @@ It's also possible to override the options conditionally:
import version import version
# Override options specific for Godot 3.x and 4.x versions. # Override options specific for Pandemonium 3.x and 4.x versions.
if version.major == 3: if version.major == 3:
pass pass
elif version.major == 4: elif version.major == 4:
@ -277,7 +277,7 @@ It's also possible to override the options conditionally:
`SCONSFLAGS` is an environment variable which is used by the SCons to set the `SCONSFLAGS` is an environment variable which is used by the SCons to set the
options automatically without having to supply them via the command line. options automatically without having to supply them via the command line.
For instance, you may want to build Godot in parallel with the aforementioned For instance, you may want to build Pandemonium in parallel with the aforementioned
`-j` option for all the future builds: `-j` option for all the future builds:
bash Linux/macOS bash Linux/macOS
@ -294,8 +294,8 @@ powershell Windows (powershell)
## Export templates ## Export templates
Official export templates are downloaded from the Godot Engine site: Official export templates are downloaded from the Pandemonium Engine site:
`godotengine.org ( https://godotengine.org/ )`. However, you might want `pandemoniumengine.org ( https://pandemoniumengine.org/ )`. However, you might want
to build them yourself (in case you want newer ones, you are using custom to build them yourself (in case you want newer ones, you are using custom
modules, or simply don't trust your own shadow). modules, or simply don't trust your own shadow).
@ -326,13 +326,13 @@ To create those yourself, follow the instructions detailed for each
platform in this same tutorial section. Each platform explains how to platform in this same tutorial section. Each platform explains how to
create its own template. create its own template.
The `version.txt` file should contain the corresponding Godot version The `version.txt` file should contain the corresponding Pandemonium version
identifier. This file is used to install export templates in a version-specific identifier. This file is used to install export templates in a version-specific
directory to avoid conflicts. For instance, if you are building export templates directory to avoid conflicts. For instance, if you are building export templates
for Godot 3.1.1, `version.txt` should contain `3.1.1.stable` on the first for Pandemonium 3.1.1, `version.txt` should contain `3.1.1.stable` on the first
line (and nothing else). This version identifier is based on the `major`, line (and nothing else). This version identifier is based on the `major`,
`minor`, `patch` (if present) and `status` lines of the `minor`, `patch` (if present) and `status` lines of the
`version.py file in the Godot Git repository ( https://github.com/godotengine/godot/blob/master/version.py )`. `version.py file in the Pandemonium Git repository ( https://github.com/pandemoniumengine/pandemonium/blob/master/version.py )`.
If you are developing for multiple platforms, macOS is definitely the most If you are developing for multiple platforms, macOS is definitely the most
convenient host platform for cross-compilation, since you can cross-compile for convenient host platform for cross-compilation, since you can cross-compile for

8
engine_development/compiling/optimizing_for_size.md
View File

@ -11,7 +11,7 @@ Common situations include creating builds for mobile and Web platforms.
This tutorial aims to give an overview on different methods to create This tutorial aims to give an overview on different methods to create
a smaller binary. Before continuing, it is recommended to read the previous tutorials a smaller binary. Before continuing, it is recommended to read the previous tutorials
on compiling Godot for each platform. on compiling Pandemonium for each platform.
The options below are listed from the most important (greatest size savings) The options below are listed from the most important (greatest size savings)
to the least important (lowest size savings). to the least important (lowest size savings).
@ -27,7 +27,7 @@ strip debug symbols from binaries by installing the `strip` package from your
distribution then running: distribution then running:
``` ```
strip path/to/godot.binary strip path/to/pandemonium.binary
``` ```
On Windows, `strip.exe` is included in most MinGW toolchain setups. On Windows, `strip.exe` is included in most MinGW toolchain setups.
@ -51,7 +51,7 @@ Note:
- **Difficulty:** Easy - **Difficulty:** Easy
- **Performed in official builds:** Yes, but only for HTML5 - **Performed in official builds:** Yes, but only for HTML5
Godot 3.1 onwards allows compiling using size optimizations (instead of speed). Pandemonium 3.1 onwards allows compiling using size optimizations (instead of speed).
To enable this, set the `optimize` flag to `size`: To enable this, set the `optimize` flag to `size`:
``` ```
@ -143,7 +143,7 @@ This is everything that will be disabled:
- **Difficulty:** Medium to hard depending on modules - **Difficulty:** Medium to hard depending on modules
- **Performed in official builds:** No - **Performed in official builds:** No
A lot of Godot's functions are offered as modules. A lot of Pandemonium's functions are offered as modules.
You can see a list of modules with the following command: You can see a list of modules with the following command:
``` ```

46
engine_development/cpp/binding_to_external_libraries.md
View File

@ -14,7 +14,7 @@ a speech synthesis (text-to-speech) library written in C++.
To bind to an external library, set up a module directory similar to the Summator example: To bind to an external library, set up a module directory similar to the Summator example:
``` ```
godot/modules/tts/ pandemonium/modules/tts/
``` ```
Next, you will create a header file with a simple TTS class: Next, you will create a header file with a simple TTS class:
@ -22,8 +22,8 @@ Next, you will create a header file with a simple TTS class:
``` ```
/* tts.h */ /* tts.h */
#ifndef GODOT_TTS_H #ifndef PANDEMONIUM_TTS_H
#define GODOT_TTS_H #define PANDEMONIUM_TTS_H
#include "core/reference.h" #include "core/reference.h"
@ -39,7 +39,7 @@ Next, you will create a header file with a simple TTS class:
TTS(); TTS();
}; };
#endif // GODOT_TTS_H #endif // PANDEMONIUM_TTS_H
``` ```
And then you'll add the cpp file. And then you'll add the cpp file.
@ -53,7 +53,7 @@ And then you'll add the cpp file.
bool TTS::say_text(String p_txt) { bool TTS::say_text(String p_txt) {
//convert Godot String to Godot CharString to C string //convert Pandemonium String to Pandemonium CharString to C string
return festival_say_text(p_txt.ascii().get_data()); return festival_say_text(p_txt.ascii().get_data());
} }
@ -131,7 +131,7 @@ installation commands for Linux below, for reference.
.. important:: .. important::
The voices that Festival uses (and any other potential external/3rd-party The voices that Festival uses (and any other potential external/3rd-party
resource) all have varying licenses and terms of use; some (if not most) of them may be resource) all have varying licenses and terms of use; some (if not most) of them may be
be problematic with Godot, even if the Festival Library itself is MIT License compatible. be problematic with Pandemonium, even if the Festival Library itself is MIT License compatible.
Please be sure to check the licenses and terms of use. Please be sure to check the licenses and terms of use.
The external library will also need to be installed inside your module to make the source The external library will also need to be installed inside your module to make the source
@ -153,8 +153,8 @@ can link to them instead by adding them as submodules (from within the modules/t
``` ```
.. important:: .. important::
Please note that Git submodules are not used in the Godot repository. If Please note that Git submodules are not used in the Pandemonium repository. If
you are developing a module to be merged into the main Godot repository, you should not you are developing a module to be merged into the main Pandemonium repository, you should not
use submodules. If your module doesn't get merged in, you can always try to implement use submodules. If your module doesn't get merged in, you can always try to implement
the external library as a GDNative C++ plugin. the external library as a GDNative C++ plugin.
@ -166,10 +166,10 @@ environment's paths:
env_tts.Append(CPPPATH=["speech_tools/include", "festival/src/include"]) env_tts.Append(CPPPATH=["speech_tools/include", "festival/src/include"])
# LIBPATH and LIBS need to be set on the real "env" (not the clone) # LIBPATH and LIBS need to be set on the real "env" (not the clone)
# to link the specified libraries to the Godot executable. # to link the specified libraries to the Pandemonium executable.
# This is a path relative to /modules/tts/ where your .a libraries reside. # This is a path relative to /modules/tts/ where your .a libraries reside.
# If you are compiling the module externally (not in the godot source tree), # If you are compiling the module externally (not in the pandemonium source tree),
# these will need to be full paths. # these will need to be full paths.
env.Append(LIBPATH=['libpath']) env.Append(LIBPATH=['libpath'])
@ -179,7 +179,7 @@ environment's paths:
``` ```
If you want to add custom compiler flags when building your module, you need to clone If you want to add custom compiler flags when building your module, you need to clone
`env` first, so it won't add those flags to whole Godot build (which can cause errors). `env` first, so it won't add those flags to whole Pandemonium build (which can cause errors).
Example `SCsub` with custom flags: Example `SCsub` with custom flags:
``` ```
@ -199,18 +199,18 @@ Example `SCsub` with custom flags:
The final module should look like this: The final module should look like this:
``` ```
godot/modules/tts/festival/ pandemonium/modules/tts/festival/
godot/modules/tts/libpath/libestbase.a pandemonium/modules/tts/libpath/libestbase.a
godot/modules/tts/libpath/libestools.a pandemonium/modules/tts/libpath/libestools.a
godot/modules/tts/libpath/libeststring.a pandemonium/modules/tts/libpath/libeststring.a
godot/modules/tts/libpath/libFestival.a pandemonium/modules/tts/libpath/libFestival.a
godot/modules/tts/speech_tools/ pandemonium/modules/tts/speech_tools/
godot/modules/tts/config.py pandemonium/modules/tts/config.py
godot/modules/tts/tts.h pandemonium/modules/tts/tts.h
godot/modules/tts/tts.cpp pandemonium/modules/tts/tts.cpp
godot/modules/tts/register_types.h pandemonium/modules/tts/register_types.h
godot/modules/tts/register_types.cpp pandemonium/modules/tts/register_types.cpp
godot/modules/tts/SCsub pandemonium/modules/tts/SCsub
``` ```
Using the module Using the module

16
engine_development/cpp/common_engine_methods_and_macros.md
View File

@ -3,7 +3,7 @@
Common engine methods and macros Common engine methods and macros
================================ ================================
Godot's C++ codebase makes use of dozens of custom methods and macros which are Pandemonium's C++ codebase makes use of dozens of custom methods and macros which are
used in almost every file. This page is geared towards beginner contributors, used in almost every file. This page is geared towards beginner contributors,
but it can also be useful for those writing custom C++ modules. but it can also be useful for those writing custom C++ modules.
@ -67,7 +67,7 @@ This is mainly useful when printing numbers directly.
Internationalize a string Internationalize a string
------------------------- -------------------------
There are two types of internationalization in Godot's codebase: There are two types of internationalization in Pandemonium's codebase:
- `TTR()`: **Editor ("tools") translations** will only be processed in the - `TTR()`: **Editor ("tools") translations** will only be processed in the
editor. If a user uses the same text in one of their projects, it won't be editor. If a user uses the same text in one of their projects, it won't be
@ -103,7 +103,7 @@ Note:
Clamp a value Clamp a value
------------- -------------
Godot provides macros for clamping a value with a lower bound (`MAX`), an Pandemonium provides macros for clamping a value with a lower bound (`MAX`), an
upper bound (`MIN`) or both (`CLAMP`): upper bound (`MIN`) or both (`CLAMP`):
``` ```
@ -175,7 +175,7 @@ use `GLOBAL_GET`/`EDITOR_GET` in all other places where it's referenced.
Error macros Error macros
------------ ------------
Godot features many error macros to make error reporting more convenient. Pandemonium features many error macros to make error reporting more convenient.
Warning: Warning:
@ -233,7 +233,7 @@ Note:
} }
// Crashes the engine. This should generally never be used // Crashes the engine. This should generally never be used
// except for testing crash handling code. Godot's philosophy // except for testing crash handling code. Pandemonium's philosophy
// is to never crash, both in the editor and in exported projects. // is to never crash, both in the editor and in exported projects.
CRASH_NOW_MSG("Can't predict the future! Aborting."); CRASH_NOW_MSG("Can't predict the future! Aborting.");
``` ```
@ -241,10 +241,10 @@ Note:
See also: See also:
See `core/error_macros.h ( https://github.com/godotengine/godot/blob/3.x/core/error_macros.h )` See `core/error_macros.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/error_macros.h )`
in Godot's codebase for more information about each error macro. in Pandemonium's codebase for more information about each error macro.
Some functions return an error code (materialized by a return type of Some functions return an error code (materialized by a return type of
`Error`). This value can be returned directly from an error macro. `Error`). This value can be returned directly from an error macro.
See the list of available error codes in See the list of available error codes in
`core/error_list.h ( https://github.com/godotengine/godot/blob/3.x/core/error_list.h )`. `core/error_list.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/error_list.h )`.

6
engine_development/cpp/configuring_an_ide/android_studio.md
View File

@ -6,7 +6,7 @@ Android Studio
`Android Studio ( https://developer.android.com/studio )` is a free `Android Studio ( https://developer.android.com/studio )` is a free
`JetBrains ( https://www.jetbrains.com/ )` IDE for Android development. `JetBrains ( https://www.jetbrains.com/ )` IDE for Android development.
It has a feature-rich editor which supports Java and C/C++. It can be used to It has a feature-rich editor which supports Java and C/C++. It can be used to
work on Godot's core engine as well as the Android platform codebase. work on Pandemonium's core engine as well as the Android platform codebase.
Importing the project Importing the project
--------------------- ---------------------
@ -20,9 +20,9 @@ Importing the project
Android Studio's welcome window. Android Studio's welcome window.
- Navigate to `<Godot root directory>/platform/android/java` and select the `settings.gradle` file. - Navigate to `<Pandemonium root directory>/platform/android/java` and select the `settings.gradle` file.
- Android Studio will import and index the project. - Android Studio will import and index the project.
- To build the project, follow the `compiling instructions <toc-devel-compiling )`. - To build the project, follow the `compiling instructions <toc-devel-compiling )`.
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

20
engine_development/cpp/configuring_an_ide/clion.md
View File

@ -10,14 +10,14 @@ Importing the project
--------------------- ---------------------
CLion requires a `CMakeLists.txt` file as a project file, which is problematic CLion requires a `CMakeLists.txt` file as a project file, which is problematic
for Godot because it uses the SCons buildsystem instead of CMake. However, for Pandemonium because it uses the SCons buildsystem instead of CMake. However,
there is a `CMakeLists.txt` configuration for `Android Studio ( doc_configuring_an_ide_android_studio )` there is a `CMakeLists.txt` configuration for `Android Studio ( doc_configuring_an_ide_android_studio )`
which can also be used by CLion. which can also be used by CLion.
- From the CLion's welcome window choose the option to import an existing - From the CLion's welcome window choose the option to import an existing
project. If you've already opened another project, choose **File > Open** project. If you've already opened another project, choose **File > Open**
from the top menu. from the top menu.
- Navigate to `<Godot root directory>/platform/android/java/nativeSrcsConfigs` (the - Navigate to `<Pandemonium root directory>/platform/android/java/nativeSrcsConfigs` (the
`CMakeLists.txt` file is located there) and select it (but *not* the `CMakeLists.txt` file is located there) and select it (but *not* the
`CMakeLists.txt` file itself), then click **OK**. `CMakeLists.txt` file itself), then click **OK**.
@ -32,7 +32,7 @@ which can also be used by CLion.
:align: center :align: center
- Choose **Tools > CMake > Change Project Root** from the top menu and select - Choose **Tools > CMake > Change Project Root** from the top menu and select
the Godot root folder. the Pandemonium root folder.
.. figure:: img/clion_3_change_project_root.png) .. figure:: img/clion_3_change_project_root.png)
:align: center :align: center
@ -41,26 +41,26 @@ which can also be used by CLion.
work once the project has finished indexing. work once the project has finished indexing.
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.
Debugging the project Debugging the project
--------------------- ---------------------
Since CLion does not support SCons, you won't be able to compile, launch, and debug Godot from CLion in one step. Since CLion does not support SCons, you won't be able to compile, launch, and debug Pandemonium from CLion in one step.
You will first need to `compile godot yourself ( https://docs.godotengine.org/en/stable/development/compiling/index.html )` and run the binary without CLion. You will then be able to debug Godot by using the `Attach to process ( https://www.jetbrains.com/help/clion/attaching-to-local-process.html )` feature. You will first need to `compile pandemonium yourself ( https://docs.pandemoniumengine.org/en/stable/development/compiling/index.html )` and run the binary without CLion. You will then be able to debug Pandemonium by using the `Attach to process ( https://www.jetbrains.com/help/clion/attaching-to-local-process.html )` feature.
- Run the compilation in debug mode by entering `scons`. - Run the compilation in debug mode by entering `scons`.
- Run the binary you have created (in the bin directory). If you want to debug a specific project, run the binary with the following arguments : `--editor --path path/to/your/godot/project`. To run the project instead of editing it, remove the `--editor` argument. - Run the binary you have created (in the bin directory). If you want to debug a specific project, run the binary with the following arguments : `--editor --path path/to/your/pandemonium/project`. To run the project instead of editing it, remove the `--editor` argument.
- In CLion, go to **Run > Attach to Process...** - In CLion, go to **Run > Attach to Process...**
.. figure:: img/clion_4_select_attach_to_process.png) .. figure:: img/clion_4_select_attach_to_process.png)
:align: center :align: center
- Find and Select godot in the list (or type the binary name/Process ID) - Find and Select pandemonium in the list (or type the binary name/Process ID)
.. figure:: img/clion_5_select_godot_process.png) .. figure:: img/clion_5_select_pandemonium_process.png)
:align: center :align: center
You can now use the debugging tools from CLion. You can now use the debugging tools from CLion.
@ -69,4 +69,4 @@ Note:
If you run the binary without any arguments, you will only debug the project manager window. If you run the binary without any arguments, you will only debug the project manager window.
Don't forget to add the `--path path/to/your/godot/project` argument to debug a project. Don't forget to add the `--path path/to/your/pandemonium/project` argument to debug a project.

16
engine_development/cpp/configuring_an_ide/code_blocks.md
View File

@ -26,9 +26,9 @@ Click Next, to pass the welcome to the new empty project wizard.
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
The project file should be created in the root of the cloned project folder. To achieve this, first, ensure that the **Project title** is the same as the folder name that Godot was cloned into. Unless you cloned the project into a folder with a different name, this will be `godot`. The project file should be created in the root of the cloned project folder. To achieve this, first, ensure that the **Project title** is the same as the folder name that Pandemonium was cloned into. Unless you cloned the project into a folder with a different name, this will be `pandemonium`.
Second, ensure that the **Folder to create project in** is the folder you ran the Git clone command from, not the `godot` project folder. Confirm that the **Resulting filename** field will create the project file in the root of the cloned project folder. Second, ensure that the **Folder to create project in** is the folder you ran the Git clone command from, not the `pandemonium` project folder. Confirm that the **Resulting filename** field will create the project file in the root of the cloned project folder.
.. figure:: img/code_blocks_project_title_and_location.png) .. figure:: img/code_blocks_project_title_and_location.png)
:figclass: figure-w480 :figclass: figure-w480
@ -79,7 +79,7 @@ Windows example:
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
Code::Blocks should now be configured to build Godot; so either select **Build > Build**, click the gear button, or press :kbd:`Ctrl + F9`. Code::Blocks should now be configured to build Pandemonium; so either select **Build > Build**, click the gear button, or press :kbd:`Ctrl + F9`.
Configuring the run Configuring the run
------------------- -------------------
@ -92,14 +92,14 @@ Deselect the **Auto-generate filename prefix** and **Auto-generate filename exte
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
Code::Blocks should now be configured to run your compiled Godot executable; so either select **Build > Run**, click the green arrow button, or press :kbd:`Ctrl + F10`. Code::Blocks should now be configured to run your compiled Pandemonium executable; so either select **Build > Run**, click the green arrow button, or press :kbd:`Ctrl + F10`.
There are two additional points worth noting. First, if required, the **Execution working dir** field can be used to test specific projects, by setting it to the folder containing the `project.godot` file. Second, the **Build targets** tab can be used to add and remove build targets for working with and creating different builds. There are two additional points worth noting. First, if required, the **Execution working dir** field can be used to test specific projects, by setting it to the folder containing the `project.pandemonium` file. Second, the **Build targets** tab can be used to add and remove build targets for working with and creating different builds.
Adding files to the project Adding files to the project
--------------------------- ---------------------------
To add all the Godot code files to the project, right-click on the new project and select **Add files recursively...**. To add all the Pandemonium code files to the project, right-click on the new project and select **Add files recursively...**.
.. figure:: img/code_blocks_add_files_recursively.png) .. figure:: img/code_blocks_add_files_recursively.png)
:figclass: figure-w480 :figclass: figure-w480
@ -114,7 +114,7 @@ It should automatically select the project folder; so simply click **Open**. By
Code style configuration Code style configuration
------------------------ ------------------------
Before editing any files, remember that all code needs to comply with the `doc_code_style_guidelines`. One important difference with Godot is the use of tabs for indents. Therefore, the key default editor setting that needs to be changed in Code::Blocks is to enable tabs for indents. This setting can be found by selecting **Settings > Editor**. Before editing any files, remember that all code needs to comply with the `doc_code_style_guidelines`. One important difference with Pandemonium is the use of tabs for indents. Therefore, the key default editor setting that needs to be changed in Code::Blocks is to enable tabs for indents. This setting can be found by selecting **Settings > Editor**.
.. figure:: img/code_blocks_update_editor_settings.png) .. figure:: img/code_blocks_update_editor_settings.png)
:figclass: figure-w480 :figclass: figure-w480
@ -126,4 +126,4 @@ Under **General Settings**, on the **Editor Settings** tab, under **Tab Options*
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
That's it. You're ready to start contributing to Godot using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Godot's community channels ( https://godotengine.org/community )`. That's it. You're ready to start contributing to Pandemonium using the Code::Blocks IDE. Remember to save the project file and the **Workspace**. If you run into any issues, ask for help in one of `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

6
engine_development/cpp/configuring_an_ide/index.md
View File

@ -1,10 +1,10 @@
Configuring an IDE Configuring an IDE
================== ==================
We assume that you have already `cloned ( https://github.com/godotengine/godot )` We assume that you have already `cloned ( https://github.com/pandemoniumengine/pandemonium )`
and `compiled <toc-devel-compiling )` Godot. and `compiled <toc-devel-compiling )` Pandemonium.
You can easily develop Godot with any text editor and by invoking `scons` You can easily develop Pandemonium with any text editor and by invoking `scons`
on the command line, but if you want to work with an IDE (Integrated on the command line, but if you want to work with an IDE (Integrated
Development Environment), here are setup instructions for some popular ones: Development Environment), here are setup instructions for some popular ones:

10
engine_development/cpp/configuring_an_ide/kdevelop.md
View File

@ -16,7 +16,7 @@ Importing the project
KDevelop's main screen. KDevelop's main screen.
- Navigate to the Godot root folder and select it. - Navigate to the Pandemonium root folder and select it.
- On the next screen, choose **Custom Build System** for the **Project Manager**. - On the next screen, choose **Custom Build System** for the **Project Manager**.
.. figure:: img/kdevelop_custombuild.png) .. figure:: img/kdevelop_custombuild.png)
@ -33,7 +33,7 @@ Importing the project
- Under **Language Support** open the **Includes/Imports** tab and add the following paths: - Under **Language Support** open the **Includes/Imports** tab and add the following paths:
``` ```
. // A dot, to indicate the root of the Godot project . // A dot, to indicate the root of the Pandemonium project
core/ core/
core/os/ core/os/
core/math/ core/math/
@ -76,12 +76,12 @@ Debugging the project
- Click **Add** to create a new launch configuration. - Click **Add** to create a new launch configuration.
- Select **Executable** option and specify the path to your executable located in - Select **Executable** option and specify the path to your executable located in
the `<Godot root directory>/bin` folder. The name depends on your build configuration, the `<Pandemonium root directory>/bin` folder. The name depends on your build configuration,
e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled. e.g. `pandemonium.x11.tools.64` for 64-bit X11 platform with `tools` enabled.
.. figure:: img/kdevelop_configlaunches2.png) .. figure:: img/kdevelop_configlaunches2.png)
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

14
engine_development/cpp/configuring_an_ide/qt_creator.md
View File

@ -14,7 +14,7 @@ Importing the project
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
- Under **Location** select the Godot root folder. - Under **Location** select the Pandemonium root folder.
.. figure:: img/qtcreator-set-project-path.png) .. figure:: img/qtcreator-set-project-path.png)
:figclass: figure-w480 :figclass: figure-w480
@ -76,9 +76,9 @@ Debugging the project
- From the left-side menu select **Projects** and open the **Run** tab. - From the left-side menu select **Projects** and open the **Run** tab.
- Under **Executable** specify the path to your executable located in - Under **Executable** specify the path to your executable located in
the `<Godot root directory>/bin` folder. The name depends on your build configuration, the `<Pandemonium root directory>/bin` folder. The name depends on your build configuration,
e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled. e.g. `pandemonium.x11.tools.64` for 64-bit X11 platform with `tools` enabled.
You can use `%{buildDir}` to reference the project root, e.g: `%{buildDir}/bin/godot.x11.opt.tools.64`. You can use `%{buildDir}` to reference the project root, e.g: `%{buildDir}/bin/pandemonium.x11.opt.tools.64`.
- If you want to run a specific project, specify its root folder under **Working directory**. - If you want to run a specific project, specify its root folder under **Working directory**.
- If you want to run the editor, add `-e` to the **Command line arguments** field. - If you want to run the editor, add `-e` to the **Command line arguments** field.
@ -94,7 +94,7 @@ Code style configuration
Developers must follow the project's `code style ( doc_code_style_guidelines )` Developers must follow the project's `code style ( doc_code_style_guidelines )`
and the IDE should help them follow it. By default, Qt Creator uses spaces and the IDE should help them follow it. By default, Qt Creator uses spaces
for indentation which doesn't match the Godot code style guidelines. You can for indentation which doesn't match the Pandemonium code style guidelines. You can
change this behavior by changing the **Code Style** in **Tools > Options > C++**. change this behavior by changing the **Code Style** in **Tools > Options > C++**.
.. figure:: img/qtcreator-options-cpp.png) .. figure:: img/qtcreator-options-cpp.png)
@ -103,11 +103,11 @@ change this behavior by changing the **Code Style** in **Tools > Options > C++**
Click on **Edit** to change the current settings, then click on Click on **Edit** to change the current settings, then click on
**Copy Built-in Code Style** button to set a new code style. Set a name for it **Copy Built-in Code Style** button to set a new code style. Set a name for it
(e.g. Godot) and change the Tab policy to be **Tabs Only**. (e.g. Pandemonium) and change the Tab policy to be **Tabs Only**.
.. figure:: img/qtcreator-edit-codestyle.png) .. figure:: img/qtcreator-edit-codestyle.png)
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

14
engine_development/cpp/configuring_an_ide/visual_studio.md
View File

@ -11,12 +11,12 @@ control and more.
Importing the project Importing the project
--------------------- ---------------------
Visual Studio requires a solution file to work on a project. While Godot does not come Visual Studio requires a solution file to work on a project. While Pandemonium does not come
with the solution file, it can be generated using SCons. with the solution file, it can be generated using SCons.
- Navigate to the Godot root folder and open a Command Prompt or PowerShell window. - Navigate to the Pandemonium root folder and open a Command Prompt or PowerShell window.
- Run `scons platform=windows vsproj=yes` to generate the solution. - Run `scons platform=windows vsproj=yes` to generate the solution.
- You can now open the project by double-clicking on the `godot.sln` in the project root - You can now open the project by double-clicking on the `pandemonium.sln` in the project root
or by using the **Open a project or solution** option inside of the Visual Studio. or by using the **Open a project or solution** option inside of the Visual Studio.
- Use the **Build** top menu to build the project. - Use the **Build** top menu to build the project.
@ -30,13 +30,13 @@ Warning:
Debugging the project Debugging the project
--------------------- ---------------------
Visual Studio features a powerful debugger. This allows the user to examine Godot's Visual Studio features a powerful debugger. This allows the user to examine Pandemonium's
source code, stop at specific points in the code, inspect the current execution context, source code, stop at specific points in the code, inspect the current execution context,
and make live changes to the codebase. and make live changes to the codebase.
You can launch the project with the debugger attached using the **Debug > Start Debugging** You can launch the project with the debugger attached using the **Debug > Start Debugging**
option from the top menu. However, unless you want to debug the project manager specifically, option from the top menu. However, unless you want to debug the project manager specifically,
you'd need to configure debugging options first. This is due to the fact that when the Godot you'd need to configure debugging options first. This is due to the fact that when the Pandemonium
project manager opens a project, the initial process is terminated and the debugger gets detached. project manager opens a project, the initial process is terminated and the debugger gets detached.
- To configure the launch options to use with the debugger use **Project > Properties** - To configure the launch options to use with the debugger use **Project > Properties**
@ -48,7 +48,7 @@ project manager opens a project, the initial process is terminated and the debug
- Open the **Debugging** section and under **Command Arguments** add two new arguments: - Open the **Debugging** section and under **Command Arguments** add two new arguments:
the `-e` flag opens the editor instead of the project manager, and the `--path` argument the `-e` flag opens the editor instead of the project manager, and the `--path` argument
tells the executable to open the specified project (must be provided as an *absolute* path tells the executable to open the specified project (must be provided as an *absolute* path
to the project root, not the `project.godot` file). to the project root, not the `project.pandemonium` file).
.. figure:: img/vs_3_debug_command_line.png) .. figure:: img/vs_3_debug_command_line.png)
:align: center :align: center
@ -66,4 +66,4 @@ start debugging.
:align: center :align: center
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

24
engine_development/cpp/configuring_an_ide/visual_studio_code.md
View File

@ -14,7 +14,7 @@ Importing the project
Alternatively, `clangd ( https://open-vsx.org/extension/llvm-vs-code-extensions/vscode-clangd )` Alternatively, `clangd ( https://open-vsx.org/extension/llvm-vs-code-extensions/vscode-clangd )`
can be used instead. can be used instead.
- When using the clangd extension, run `scons compiledb=yes`. - When using the clangd extension, run `scons compiledb=yes`.
- From the Visual Studio Code's main screen open the Godot root folder with - From the Visual Studio Code's main screen open the Pandemonium root folder with
**File > Open Folder...**. **File > Open Folder...**.
- Press :kbd:`Ctrl + Shift + P` to open the command prompt window and enter *Configure Task*. - Press :kbd:`Ctrl + Shift + P` to open the command prompt window and enter *Configure Task*.
@ -97,11 +97,11 @@ js X11
"name": "Launch Project", "name": "Launch Project",
"type": "lldb", "type": "lldb",
"request": "launch", "request": "launch",
// Change to godot.x11.tools.64.llvm for llvm-based builds. // Change to pandemonium.x11.tools.64.llvm for llvm-based builds.
"program": "${workspaceFolder}/bin/godot.x11.tools.64", "program": "${workspaceFolder}/bin/pandemonium.x11.tools.64",
// Change the arguments below for the project you want to test with. // Change the arguments below for the project you want to test with.
// To run the project instead of editing it, remove the "--editor" argument. // To run the project instead of editing it, remove the "--editor" argument.
"args": [ "--editor", "--path", "path-to-your-godot-project-folder" ], "args": [ "--editor", "--path", "path-to-your-pandemonium-project-folder" ],
"stopAtEntry": false, "stopAtEntry": false,
"cwd": "${workspaceFolder}", "cwd": "${workspaceFolder}",
"environment": [], "environment": [],
@ -118,11 +118,11 @@ js X11_gdb
"name": "Launch Project", "name": "Launch Project",
"type": "cppdbg", "type": "cppdbg",
"request": "launch", "request": "launch",
// Change to godot.x11.tools.64.llvm for llvm-based builds. // Change to pandemonium.x11.tools.64.llvm for llvm-based builds.
"program": "${workspaceFolder}/bin/godot.x11.tools.64", "program": "${workspaceFolder}/bin/pandemonium.x11.tools.64",
// Change the arguments below for the project you want to test with. // Change the arguments below for the project you want to test with.
// To run the project instead of editing it, remove the "--editor" argument. // To run the project instead of editing it, remove the "--editor" argument.
"args": [ "--editor", "--path", "path-to-your-godot-project-folder" ], "args": [ "--editor", "--path", "path-to-your-pandemonium-project-folder" ],
"stopAtEntry": false, "stopAtEntry": false,
"cwd": "${workspaceFolder}", "cwd": "${workspaceFolder}",
"environment": [], "environment": [],
@ -146,15 +146,15 @@ js Windows
"name": "Launch Project", "name": "Launch Project",
"type": "cppvsdbg", "type": "cppvsdbg",
"request": "launch", "request": "launch",
"program": "${workspaceFolder}/bin/godot.windows.tools.64.exe", "program": "${workspaceFolder}/bin/pandemonium.windows.tools.64.exe",
// Change the arguments below for the project you want to test with. // Change the arguments below for the project you want to test with.
// To run the project instead of editing it, remove the "--editor" argument. // To run the project instead of editing it, remove the "--editor" argument.
"args": [ "--editor", "--path", "path-to-your-godot-project-folder" ], "args": [ "--editor", "--path", "path-to-your-pandemonium-project-folder" ],
"stopAtEntry": false, "stopAtEntry": false,
"cwd": "${workspaceFolder}", "cwd": "${workspaceFolder}",
"environment": [], "environment": [],
"console": "internalConsole", "console": "internalConsole",
"visualizerFile": "${workspaceFolder}/platform/windows/godot.natvis", "visualizerFile": "${workspaceFolder}/platform/windows/pandemonium.natvis",
"preLaunchTask": "build" "preLaunchTask": "build"
} }
``` ```
@ -178,7 +178,7 @@ Note:
Do note that lldb may work better with llvm-based builds. See `doc_compiling_for_x11` for further information. Do note that lldb may work better with llvm-based builds. See `doc_compiling_for_x11` for further information.
The name under `program` depends on your build configuration, The name under `program` depends on your build configuration,
e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled. e.g. `pandemonium.x11.tools.64` for 64-bit X11 platform with `tools` enabled.
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

22
engine_development/cpp/configuring_an_ide/xcode.md
View File

@ -23,7 +23,7 @@ Importing the project
+------------+------------------------------------------------------------------------------+ +------------+------------------------------------------------------------------------------+
| Arguments | See `doc_introduction_to_the_buildsystem` for a full list of arguments. | | Arguments | See `doc_introduction_to_the_buildsystem` for a full list of arguments. |
+------------+------------------------------------------------------------------------------+ +------------+------------------------------------------------------------------------------+
| Directory | A full path to the Godot root folder | | Directory | A full path to the Pandemonium root folder |
+------------+------------------------------------------------------------------------------+ +------------+------------------------------------------------------------------------------+
.. figure:: img/xcode_2_configure_scons.png) .. figure:: img/xcode_2_configure_scons.png)
@ -44,24 +44,24 @@ Importing the project
:align: center :align: center
Note: Note:
Name it something so you know not to compile with this target (e.g. `GodotXcodeIndex`). Name it something so you know not to compile with this target (e.g. `PandemoniumXcodeIndex`).
- For this target open the **Build Settings** tab and look for **Header Search Paths**. - For this target open the **Build Settings** tab and look for **Header Search Paths**.
- Set **Header Search Paths** to the absolute path to the Godot root folder. You need to - Set **Header Search Paths** to the absolute path to the Pandemonium root folder. You need to
include subdirectories as well. To achieve that, add two two asterisks (`**`) to the include subdirectories as well. To achieve that, add two two asterisks (`**`) to the
end of the path, e.g. `/Users/me/repos/godot-source/**`. end of the path, e.g. `/Users/me/repos/pandemonium-source/**`.
- Add the Godot source to the project by dragging and dropping it into the project file browser. - Add the Pandemonium source to the project by dragging and dropping it into the project file browser.
- Uncheck **Create external build system project**. - Uncheck **Create external build system project**.
.. figure:: img/xcode_5_after_add_godot_source_to_project.png) .. figure:: img/xcode_5_after_add_pandemonium_source_to_project.png)
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
- Next select **Create groups** for the **Added folders** option and check *only* - Next select **Create groups** for the **Added folders** option and check *only*
your command line indexing target in the **Add to targets** section. your command line indexing target in the **Add to targets** section.
.. figure:: img/xcode_6_after_add_godot_source_to_project_2.png) .. figure:: img/xcode_6_after_add_pandemonium_source_to_project_2.png)
:figclass: figure-w480 :figclass: figure-w480
:align: center :align: center
@ -82,7 +82,7 @@ To enable debugging support you need to edit the external build target's build a
- Create a script that will give the binary a name that Xcode can recognize, e.g.: - Create a script that will give the binary a name that Xcode can recognize, e.g.:
``` ```
ln -f ${PROJECT_DIR}/godot/bin/godot.osx.tools.64 ${PROJECT_DIR}/godot/bin/godot ln -f ${PROJECT_DIR}/pandemonium/bin/pandemonium.osx.tools.64 ${PROJECT_DIR}/pandemonium/bin/pandemonium
``` ```
.. figure:: img/xcode_7_setup_build_post_action.png) .. figure:: img/xcode_7_setup_build_post_action.png)
@ -102,10 +102,10 @@ To enable debugging support you need to edit the external build target's build a
- You can add two arguments on the **Arguments** tab: - You can add two arguments on the **Arguments** tab:
the `-e` flag opens the editor instead of the project manager, and the `--path` argument the `-e` flag opens the editor instead of the project manager, and the `--path` argument
tells the executable to open the specified project (must be provided as an *absolute* path tells the executable to open the specified project (must be provided as an *absolute* path
to the project root, not the `project.godot` file). to the project root, not the `project.pandemonium` file).
To check that everything is working, put a breakpoint in `platform/osx/godot_main_osx.mm` and To check that everything is working, put a breakpoint in `platform/osx/pandemonium_main_osx.mm` and
run the project. run the project.
If you run into any issues, ask for help in one of If you run into any issues, ask for help in one of
`Godot's community channels ( https://godotengine.org/community )`. `Pandemonium's community channels ( https://pandemoniumengine.org/community )`.

40
engine_development/cpp/core_types.md
View File

@ -3,7 +3,7 @@
Core types Core types
========== ==========
Godot has a rich set of classes and templates that compose its core, Pandemonium has a rich set of classes and templates that compose its core,
and everything is built upon them. and everything is built upon them.
This reference will try to list them in order for their better This reference will try to list them in order for their better
@ -12,7 +12,7 @@ understanding.
Definitions Definitions
----------- -----------
Godot uses the standard C99 datatypes, such as `uint8_t`, Pandemonium uses the standard C99 datatypes, such as `uint8_t`,
`uint32_t`, `int64_t`, etc. which are nowadays supported by every `uint32_t`, `int64_t`, etc. which are nowadays supported by every
compiler. Reinventing the wheel for those is not fun, as it makes code compiler. Reinventing the wheel for those is not fun, as it makes code
more difficult to read. more difficult to read.
@ -34,7 +34,7 @@ directly to wchar_t.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/typedefs.h ( https://github.com/godotengine/godot/blob/3.x/core/typedefs.h )` - `core/typedefs.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/typedefs.h )`
Memory model Memory model
------------ ------------
@ -62,10 +62,10 @@ be unused, segmentation will not be a problem over time as it will
remain constant. In other words, leave 10-20% of your memory free remain constant. In other words, leave 10-20% of your memory free
and perform all small allocations and you are fine. and perform all small allocations and you are fine.
Godot ensures that all objects that can be allocated dynamically are Pandemonium ensures that all objects that can be allocated dynamically are
small (less than a few kb at most). But what happens if an allocation is small (less than a few kb at most). But what happens if an allocation is
too large (like an image or mesh geometry or large array)? In this case too large (like an image or mesh geometry or large array)? In this case
Godot has the option to use a dynamic memory pool. This memory needs to Pandemonium has the option to use a dynamic memory pool. This memory needs to
be locked to be accessed, and if an allocation runs out of memory, the be locked to be accessed, and if an allocation runs out of memory, the
pool will be rearranged and compacted on demand. Depending on the need pool will be rearranged and compacted on demand. Depending on the need
of the game, the programmer can configure the dynamic memory pool size. of the game, the programmer can configure the dynamic memory pool size.
@ -73,11 +73,11 @@ of the game, the programmer can configure the dynamic memory pool size.
Allocating memory Allocating memory
----------------- -----------------
Godot has many tools for tracking memory usage in a game, especially Pandemonium has many tools for tracking memory usage in a game, especially
during debug. Because of this, the regular C and C++ library calls during debug. Because of this, the regular C and C++ library calls
should not be used. Instead, a few other ones are provided. should not be used. Instead, a few other ones are provided.
For C-style allocation, Godot provides a few macros: For C-style allocation, Pandemonium provides a few macros:
``` ```
memalloc() memalloc()
@ -131,13 +131,13 @@ large amount of accesses.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/os/memory.h ( https://github.com/godotengine/godot/blob/3.x/core/os/memory.h )` - `core/os/memory.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/os/memory.h )`
- `core/pool_vector.h ( https://github.com/godotengine/godot/blob/3.x/core/pool_vector.cpp )` - `core/pool_vector.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/pool_vector.cpp )`
Containers Containers
---------- ----------
Godot provides also a set of common containers: Pandemonium provides also a set of common containers:
- Vector - Vector
- List - List
@ -165,15 +165,15 @@ The Vector<> class also has a few nice features:
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/vector.h ( https://github.com/godotengine/godot/blob/3.x/core/vector.h )` - `core/vector.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/vector.h )`
- `core/list.h ( https://github.com/godotengine/godot/blob/3.x/core/list.h )` - `core/list.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/list.h )`
- `core/set.h ( https://github.com/godotengine/godot/blob/3.x/core/set.h )` - `core/set.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/set.h )`
- `core/map.h ( https://github.com/godotengine/godot/blob/3.x/core/map.h )` - `core/map.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/map.h )`
String String
------ ------
Godot also provides a String class. This class has a huge amount of Pandemonium also provides a String class. This class has a huge amount of
features, full Unicode support in all the functions (like case features, full Unicode support in all the functions (like case
operations) and utf8 parsing/extracting, as well as helpers for operations) and utf8 parsing/extracting, as well as helpers for
conversion and visualization. conversion and visualization.
@ -181,7 +181,7 @@ conversion and visualization.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/ustring.h ( https://github.com/godotengine/godot/blob/3.x/core/ustring.h )` - `core/ustring.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/ustring.h )`
StringName StringName
---------- ----------
@ -197,7 +197,7 @@ is fast.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/string_name.h ( https://github.com/godotengine/godot/blob/3.x/core/string_name.h )` - `core/string_name.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/string_name.h )`
Math types Math types
---------- ----------
@ -208,7 +208,7 @@ directory.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/math ( https://github.com/godotengine/godot/tree/3.x/core/math )` - `core/math ( https://github.com/pandemoniumengine/pandemonium/tree/3.x/core/math )`
NodePath NodePath
-------- --------
@ -219,7 +219,7 @@ referencing them fast.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/node_path.h ( https://github.com/godotengine/godot/blob/3.x/core/node_path.h )` - `core/node_path.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/node_path.h )`
RID RID
--- ---
@ -232,4 +232,4 @@ referenced data.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/rid.h ( https://github.com/godotengine/godot/blob/3.x/core/rid.h )` - `core/rid.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/rid.h )`

16
engine_development/cpp/custom_audiostreams.md
View File

@ -22,8 +22,8 @@ This guide assumes the reader knows how to create C++ modules. If not, refer to
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )` - `servers/audio/audio_stream.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )` - `scene/audio/audioplayer.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/scene/audio/audio_player.cpp )`
What for? What for?
--------- ---------
@ -116,7 +116,7 @@ Therefore, playback state must be self-contained in AudioStreamPlayback.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )` - `servers/audio/audio_stream.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/servers/audio/audio_stream.h )`
Create an AudioStreamPlayback Create an AudioStreamPlayback
@ -231,9 +231,9 @@ Since AudioStreamPlayback is controlled by the audio thread, i/o and dynamic mem
Resampling Resampling
~~~~~~~~~~ ~~~~~~~~~~
Godot's AudioServer currently uses 44100 Hz sample rate. When other sample rates are Pandemonium's AudioServer currently uses 44100 Hz sample rate. When other sample rates are
needed such as 48000, either provide one or use AudioStreamPlaybackResampled. needed such as 48000, either provide one or use AudioStreamPlaybackResampled.
Godot provides cubic interpolation for audio resampling. Pandemonium provides cubic interpolation for audio resampling.
Instead of overloading `mix`, AudioStreamPlaybackResampled uses `mix_internal` to Instead of overloading `mix`, AudioStreamPlaybackResampled uses `mix_internal` to
query AudioFrames and `get_stream_sampling_rate` to query current mix rate. query AudioFrames and `get_stream_sampling_rate` to query current mix rate.
@ -345,6 +345,6 @@ query AudioFrames and `get_stream_sampling_rate` to query current mix rate.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/math/audio_frame.h ( https://github.com/godotengine/godot/blob/master/core/math/audio_frame.h )` - `core/math/audio_frame.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/core/math/audio_frame.h )`
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )` - `servers/audio/audio_stream.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )` - `scene/audio/audioplayer.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/scene/audio/audio_player.cpp )`

26
engine_development/cpp/custom_godot_servers.md
View File

@ -1,24 +1,24 @@
Custom Godot servers Custom Pandemonium servers
==================== ====================
Introduction Introduction
------------ ------------
Godot implements multi-threading as servers. Servers are daemons which Pandemonium implements multi-threading as servers. Servers are daemons which
manage data, process it, and push the result. Servers implement the manage data, process it, and push the result. Servers implement the
mediator pattern which interprets resource ID and process data for the mediator pattern which interprets resource ID and process data for the
engine and other modules. In addition, the server claims ownership for engine and other modules. In addition, the server claims ownership for
its RID allocations. its RID allocations.
This guide assumes the reader knows how to create C++ modules and Godot This guide assumes the reader knows how to create C++ modules and Pandemonium
data types. If not, refer to `doc_custom_modules_in_c++`. data types. If not, refer to `doc_custom_modules_in_c++`.
References References
~~~~~~~~~~~ ~~~~~~~~~~~
- `Why does Godot use servers and RIDs? ( https://godotengine.org/article/why-does-godot-use-servers-and-rids )` - `Why does Pandemonium use servers and RIDs? ( https://pandemoniumengine.org/article/why-does-pandemonium-use-servers-and-rids )`
- `Singleton pattern ( https://en.wikipedia.org/wiki/Singleton_pattern )` - `Singleton pattern ( https://en.wikipedia.org/wiki/Singleton_pattern )`
- `Mediator pattern ( https://en.wikipedia.org/wiki/Mediator_pattern )` - `Mediator pattern ( https://en.wikipedia.org/wiki/Mediator_pattern )`
@ -32,7 +32,7 @@ What for?
- Adding a custom VoIP protocol. - Adding a custom VoIP protocol.
- And more... - And more...
Creating a Godot server Creating a Pandemonium server
----------------------- -----------------------
At minimum, a server must have a static instance, a sleep timer, a thread loop, At minimum, a server must have a static instance, a sleep timer, a thread loop,
@ -75,7 +75,7 @@ an initialization state and a cleanup procedure.
private: private:
uint64_t counter; uint64_t counter;
RID_Owner<InfiniteBus> bus_owner; RID_Owner<InfiniteBus> bus_owner;
// https://github.com/godotengine/godot/blob/3.x/core/rid.h#L196 // https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/rid.h#L196
Set<RID> buses; Set<RID> buses;
void _emit_occupy_room(uint64_t room, RID rid); void _emit_occupy_room(uint64_t room, RID rid);
@ -203,7 +203,7 @@ an initialization state and a cleanup procedure.
return ret; return ret;
} }
// https://github.com/godotengine/godot/blob/3.x/core/rid.h#L187 // https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/rid.h#L187
bool HilbertHotel::delete_bus(RID id) { bool HilbertHotel::delete_bus(RID id) {
if (bus_owner.owns(id)) { if (bus_owner.owns(id)) {
lock(); lock();
@ -273,7 +273,7 @@ an initialization state and a cleanup procedure.
Custom managed resource data Custom managed resource data
---------------------------- ----------------------------
Godot servers implement a mediator pattern. All data types inherit `RID_Data`. Pandemonium servers implement a mediator pattern. All data types inherit `RID_Data`.
`RID_Owner<MyRID_Data )` owns the object when `make_rid` is called. During debug mode only, `RID_Owner<MyRID_Data )` owns the object when `make_rid` is called. During debug mode only,
RID_Owner maintains a list of RIDs. In practice, RIDs are similar to writing RID_Owner maintains a list of RIDs. In practice, RIDs are similar to writing
object-oriented C code. object-oriented C code.
@ -316,7 +316,7 @@ References
~~~~~~~~~~~ ~~~~~~~~~~~
- `RID( rid )` - `RID( rid )`
- `core/rid.h ( https://github.com/godotengine/godot/blob/3.x/core/rid.h )` - `core/rid.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/rid.h )`
Registering the class in GDScript Registering the class in GDScript
--------------------------------- ---------------------------------
@ -325,9 +325,9 @@ Servers are allocated in `register_types.cpp`. The constructor sets the static
instance and `init()` creates the managed thread; `unregister_types.cpp` instance and `init()` creates the managed thread; `unregister_types.cpp`
cleans up the server. cleans up the server.
Since a Godot server class creates an instance and binds it to a static singleton, Since a Pandemonium server class creates an instance and binds it to a static singleton,
binding the class might not reference the correct instance. Therefore, a dummy binding the class might not reference the correct instance. Therefore, a dummy
class must be created to reference the proper Godot server. class must be created to reference the proper Pandemonium server.
In `register_server_types()`, `Engine::get_singleton()->add_singleton` In `register_server_types()`, `Engine::get_singleton()->add_singleton`
is used to register the dummy class in GDScript. is used to register the dummy class in GDScript.
@ -373,7 +373,7 @@ is used to register the dummy class in GDScript.
void unregister_hilbert_hotel_types(); void unregister_hilbert_hotel_types();
``` ```
- `servers/register_server_types.cpp ( https://github.com/godotengine/godot/blob/master/servers/register_server_types.cpp )` - `servers/register_server_types.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/servers/register_server_types.cpp )`
Bind methods Bind methods
~~~~~~~~~~~~ ~~~~~~~~~~~~
@ -474,7 +474,7 @@ to execute the desired behavior. The queue will be flushed whenever either
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/message_queue.cpp ( https://github.com/godotengine/godot/blob/3.x/core/message_queue.cpp )` - `core/message_queue.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/message_queue.cpp )`
Summing it up Summing it up
------------- -------------

52
engine_development/cpp/custom_modules_in_cpp.md
View File

@ -6,7 +6,7 @@ Custom modules in C++
Modules Modules
------- -------
Godot allows extending the engine in a modular way. New modules can be Pandemonium allows extending the engine in a modular way. New modules can be
created and then enabled/disabled. This allows for adding new engine created and then enabled/disabled. This allows for adding new engine
functionality at every level without modifying the core, which can be functionality at every level without modifying the core, which can be
split for use and reuse in different modules. split for use and reuse in different modules.
@ -25,7 +25,7 @@ While it's recommended that most of a game be written in scripting (as
it is an enormous time saver), it's perfectly possible to use C++ it is an enormous time saver), it's perfectly possible to use C++
instead. Adding C++ modules can be useful in the following scenarios: instead. Adding C++ modules can be useful in the following scenarios:
- Binding an external library to Godot (like PhysX, FMOD, etc). - Binding an external library to Pandemonium (like PhysX, FMOD, etc).
- Optimize critical parts of a game. - Optimize critical parts of a game.
- Adding new functionality to the engine and/or editor. - Adding new functionality to the engine and/or editor.
- Porting an existing game. - Porting an existing game.
@ -34,14 +34,14 @@ instead. Adding C++ modules can be useful in the following scenarios:
Creating a new module Creating a new module
--------------------- ---------------------
Before creating a module, make sure to `download the source code of Godot Before creating a module, make sure to `download the source code of Pandemonium
and compile it <toc-devel-compiling )`. and compile it <toc-devel-compiling )`.
To create a new module, the first step is creating a directory inside To create a new module, the first step is creating a directory inside
`modules/`. If you want to maintain the module separately, you can checkout `modules/`. If you want to maintain the module separately, you can checkout
a different VCS into modules and use it. a different VCS into modules and use it.
The example module will be called "summator" (`godot/modules/summator`). The example module will be called "summator" (`pandemonium/modules/summator`).
Inside we will create a simple summator class: Inside we will create a simple summator class:
``` ```
@ -159,7 +159,7 @@ string list:
``` ```
This allows for powerful possibilities using Python to construct the file list This allows for powerful possibilities using Python to construct the file list
using loops and logic statements. Look at some modules that ship with Godot by using loops and logic statements. Look at some modules that ship with Pandemonium by
default for examples. default for examples.
To add include directories for the compiler to look at you can append it to the To add include directories for the compiler to look at you can append it to the
@ -171,7 +171,7 @@ environment's paths:
``` ```
If you want to add custom compiler flags when building your module, you need to clone If you want to add custom compiler flags when building your module, you need to clone
`env` first, so it won't add those flags to whole Godot build (which can cause errors). `env` first, so it won't add those flags to whole Pandemonium build (which can cause errors).
Example `SCsub` with custom flags: Example `SCsub` with custom flags:
``` ```
@ -208,12 +208,12 @@ And that's it. Hope it was not too complex! Your module should look like
this: this:
``` ```
godot/modules/summator/config.py pandemonium/modules/summator/config.py
godot/modules/summator/summator.h pandemonium/modules/summator/summator.h
godot/modules/summator/summator.cpp pandemonium/modules/summator/summator.cpp
godot/modules/summator/register_types.h pandemonium/modules/summator/register_types.h
godot/modules/summator/register_types.cpp pandemonium/modules/summator/register_types.cpp
godot/modules/summator/SCsub pandemonium/modules/summator/SCsub
``` ```
You can then zip it and share the module with everyone else. When You can then zip it and share the module with everyone else. When
@ -320,7 +320,7 @@ Warning:
`GDNative ( doc_what_is_gdnative )` instead. `GDNative ( doc_what_is_gdnative )` instead.
So far, we defined a clean SCsub that allows us to add the sources So far, we defined a clean SCsub that allows us to add the sources
of our new module as part of the Godot binary. of our new module as part of the Pandemonium binary.
This static approach is fine when we want to build a release version of our This static approach is fine when we want to build a release version of our
game, given we want all the modules in a single binary. game, given we want all the modules in a single binary.
@ -348,19 +348,19 @@ library that will be dynamically loaded when starting our game's binary.
# Position-independent code is required for a shared library. # Position-independent code is required for a shared library.
module_env.Append(CCFLAGS=['-fPIC']) module_env.Append(CCFLAGS=['-fPIC'])
# Don't inject Godot's dependencies into our shared library. # Don't inject Pandemonium's dependencies into our shared library.
module_env['LIBS'] = [] module_env['LIBS'] = []
# Define the shared library. By default, it would be built in the module's # Define the shared library. By default, it would be built in the module's
# folder, however it's better to output it into `bin` next to the # folder, however it's better to output it into `bin` next to the
# Godot binary. # Pandemonium binary.
shared_lib = module_env.SharedLibrary(target='#bin/summator', source=sources) shared_lib = module_env.SharedLibrary(target='#bin/summator', source=sources)
# Finally, notify the main build environment it now has our shared library # Finally, notify the main build environment it now has our shared library
# as a new dependency. # as a new dependency.
# LIBPATH and LIBS need to be set on the real "env" (not the clone) # LIBPATH and LIBS need to be set on the real "env" (not the clone)
# to link the specified libraries to the Godot executable. # to link the specified libraries to the Pandemonium executable.
env.Append(LIBPATH=['#bin']) env.Append(LIBPATH=['#bin'])
@ -371,13 +371,13 @@ library that will be dynamically loaded when starting our game's binary.
``` ```
Once compiled, we should end up with a `bin` directory containing both the Once compiled, we should end up with a `bin` directory containing both the
`godot*` binary and our `libsummator*.so`. However given the .so is not in `pandemonium*` binary and our `libsummator*.so`. However given the .so is not in
a standard directory (like `/usr/lib`), we have to help our binary find it a standard directory (like `/usr/lib`), we have to help our binary find it
during runtime with the `LD_LIBRARY_PATH` environment variable: during runtime with the `LD_LIBRARY_PATH` environment variable:
``` ```
export LD_LIBRARY_PATH="$PWD/bin/" export LD_LIBRARY_PATH="$PWD/bin/"
./bin/godot* ./bin/pandemonium*
``` ```
Note: Note:
@ -386,7 +386,7 @@ Note:
you won't be able to run your project from the editor. you won't be able to run your project from the editor.
On top of that, it would be nice to be able to select whether to compile our On top of that, it would be nice to be able to select whether to compile our
module as shared library (for development) or as a part of the Godot binary module as shared library (for development) or as a part of the Pandemonium binary
(for release). To do that we can define a custom flag to be passed to SCons (for release). To do that we can define a custom flag to be passed to SCons
using the `ARGUMENT` command: using the `ARGUMENT` command:
@ -416,7 +416,7 @@ using the `ARGUMENT` command:
module_env.add_source_files(env.modules_sources, sources) module_env.add_source_files(env.modules_sources, sources)
``` ```
Now by default `scons` command will build our module as part of Godot's binary Now by default `scons` command will build our module as part of Pandemonium's binary
and as a shared library when passing `summator_shared=yes`. and as a shared library when passing `summator_shared=yes`.
Finally, you can even speed up the build further by explicitly specifying your Finally, you can even speed up the build further by explicitly specifying your
@ -470,7 +470,7 @@ Tip:
untracked files with `git status`. For example: untracked files with `git status`. For example:
``` ```
user@host:~/godot$ git status user@host:~/pandemonium$ git status
``` ```
Example output: Example output:
@ -488,7 +488,7 @@ Tip:
3. Now we can generate the documentation: 3. Now we can generate the documentation:
We can do this via running Godot's doctool i.e. `godot --doctool <path )`, We can do this via running Pandemonium's doctool i.e. `pandemonium --doctool <path )`,
which will dump the engine API reference to the given `<path )` in XML format. which will dump the engine API reference to the given `<path )` in XML format.
In our case we'll point it to the root of the cloned repository. You can point it In our case we'll point it to the root of the cloned repository. You can point it
@ -497,10 +497,10 @@ to an another folder, and just copy over the files that you need.
Run command: Run command:
``` ```
user@host:~/godot/bin$ ./bin/<godot_binary> --doctool . user@host:~/pandemonium/bin$ ./bin/<pandemonium_binary> --doctool .
``` ```
Now if you go to the `godot/modules/summator/doc_classes` folder, you will see Now if you go to the `pandemonium/modules/summator/doc_classes` folder, you will see
that it contains a `Summator.xml` file, or any other classes, that you referenced that it contains a `Summator.xml` file, or any other classes, that you referenced
in your `get_doc_classes` function. in your `get_doc_classes` function.
@ -513,7 +513,7 @@ In order to keep documentation up-to-date, all you'll have to do is simply modif
one of the XML files and recompile the engine from now on. one of the XML files and recompile the engine from now on.
If you change your module's API, you can also re-extract the docs, they will contain If you change your module's API, you can also re-extract the docs, they will contain
the things that you previously added. Of course if you point it to your godot the things that you previously added. Of course if you point it to your pandemonium
folder, make sure you don't lose work by extracting older docs from an older engine build folder, make sure you don't lose work by extracting older docs from an older engine build
on top of the newer ones. on top of the newer ones.
@ -559,7 +559,7 @@ Summing up
Remember to: Remember to:
- use `GDCLASS` macro for inheritance, so Godot can wrap it - use `GDCLASS` macro for inheritance, so Pandemonium can wrap it
- use `bind_methods` to bind your functions to scripting, and to - use `bind_methods` to bind your functions to scripting, and to
allow them to work as callbacks for signals. allow them to work as callbacks for signals.

26
engine_development/cpp/custom_resource_format_loaders.md
View File

@ -11,14 +11,14 @@ Resources are primary containers. When load is called on the same file
path again, the previous loaded Resource will be referenced. Naturally, path again, the previous loaded Resource will be referenced. Naturally,
loaded resources must be stateless. loaded resources must be stateless.
This guide assumes the reader knows how to create C++ modules and Godot This guide assumes the reader knows how to create C++ modules and Pandemonium
data types. If not, refer to this guide `doc_custom_modules_in_c++`. data types. If not, refer to this guide `doc_custom_modules_in_c++`.
References References
~~~~~~~~~~ ~~~~~~~~~~
- `ResourceLoader( resourceloader )` - `ResourceLoader( resourceloader )`
- `core/io/resource_loader.cpp ( https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp )` - `core/io/resource_loader.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/core/io/resource_loader.cpp )`
What for? What for?
--------- ---------
@ -38,7 +38,7 @@ ImageFormatLoader should be used to load images.
References References
~~~~~~~~~~ ~~~~~~~~~~
- `core/io/image_loader.h ( https://github.com/godotengine/godot/blob/master/core/io/image_loader.h )` - `core/io/image_loader.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/core/io/image_loader.h )`
Creating a ResourceFormatLoader Creating a ResourceFormatLoader
@ -47,7 +47,7 @@ Creating a ResourceFormatLoader
Each file format consist of a data container and a `ResourceFormatLoader`. Each file format consist of a data container and a `ResourceFormatLoader`.
ResourceFormatLoaders are usually simple classes which return all the ResourceFormatLoaders are usually simple classes which return all the
necessary metadata for supporting new extensions in Godot. The necessary metadata for supporting new extensions in Pandemonium. The
class must return the format name and the extension string. class must return the format name and the extension string.
In addition, ResourceFormatLoaders must convert file paths into In addition, ResourceFormatLoaders must convert file paths into
@ -157,8 +157,8 @@ If you'd like to be able to edit and save a resource, you can implement a
Creating custom data types Creating custom data types
-------------------------- --------------------------
Godot may not have a proper substitute within its `doc_core_types` Pandemonium may not have a proper substitute within its `doc_core_types`
or managed resources. Godot needs a new registered data type to or managed resources. Pandemonium needs a new registered data type to
understand additional binary formats such as machine learning models. understand additional binary formats such as machine learning models.
Here is an example of creating a custom datatype: Here is an example of creating a custom datatype:
@ -262,7 +262,7 @@ Considerations
~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~
Some libraries may not define certain common routines such as IO handling. Some libraries may not define certain common routines such as IO handling.
Therefore, Godot call translations are required. Therefore, Pandemonium call translations are required.
For example, here is the code for translating `FileAccess` For example, here is the code for translating `FileAccess`
calls into `std::istream`. calls into `std::istream`.
@ -273,10 +273,10 @@ calls into `std::istream`.
#include <istream> #include <istream>
#include <streambuf> #include <streambuf>
class GodotFileInStreamBuf : public std::streambuf { class PandemoniumFileInStreamBuf : public std::streambuf {
public: public:
GodotFileInStreamBuf(FileAccess *fa) { PandemoniumFileInStreamBuf(FileAccess *fa) {
_file = fa; _file = fa;
} }
int underflow() { int underflow() {
@ -303,12 +303,12 @@ References
- `istream ( http://www.cplusplus.com/reference/istream/istream/ )` - `istream ( http://www.cplusplus.com/reference/istream/istream/ )`
- `streambuf ( http://www.cplusplus.com/reference/streambuf/streambuf/?kw=streambuf )` - `streambuf ( http://www.cplusplus.com/reference/streambuf/streambuf/?kw=streambuf )`
- `core/io/fileaccess.h ( https://github.com/godotengine/godot/blob/master/core/os/file_access.h )` - `core/io/fileaccess.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/core/os/file_access.h )`
Registering the new file format Registering the new file format
------------------------------- -------------------------------
Godot registers `ResourcesFormatLoader` with a `ResourceLoader` Pandemonium registers `ResourcesFormatLoader` with a `ResourceLoader`
handler. The handler selects the proper loader automatically handler. The handler selects the proper loader automatically
when `load` is called. when `load` is called.
@ -354,7 +354,7 @@ when `load` is called.
References References
~~~~~~~~~~ ~~~~~~~~~~
- `core/io/resource_loader.cpp ( https://github.com/godotengine/godot/blob/master/core/io/resource_loader.cpp )` - `core/io/resource_loader.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/core/io/resource_loader.cpp )`
Loading it on GDScript Loading it on GDScript
---------------------- ----------------------
@ -368,7 +368,7 @@ project's root folder:
"demo": [ "demo": [
"welcome", "welcome",
"to", "to",
"godot", "pandemonium",
"resource", "resource",
"loaders" "loaders"
] ]

12
engine_development/cpp/index.md
View File

@ -4,7 +4,7 @@ Engine development
Setting up a development environment Setting up a development environment
------------------------------------ ------------------------------------
To modify Godot's source code, you need to set up a development environment. Start here. To modify Pandemonium's source code, you need to set up a development environment. Start here.
.. toctree:: .. toctree::
:maxdepth: 1 :maxdepth: 1
@ -12,7 +12,7 @@ To modify Godot's source code, you need to set up a development environment. Sta
configuring_an_ide/index configuring_an_ide/index
Getting started with Godot's source code Getting started with Pandemonium's source code
---------------------------------------- ----------------------------------------
This section covers the basics that you will encounter in (almost) every source file. This section covers the basics that you will encounter in (almost) every source file.
@ -21,17 +21,17 @@ This section covers the basics that you will encounter in (almost) every source
:maxdepth: 1 :maxdepth: 1
:name: toc-devel-cpp-source-beginner :name: toc-devel-cpp-source-beginner
introduction_to_godot_development introduction_to_pandemonium_development
common_engine_methods_and_macros common_engine_methods_and_macros
core_types core_types
variant_class variant_class
object_class object_class
inheritance_class_tree inheritance_class_tree
Extending Godot by modifying its source code Extending Pandemonium by modifying its source code
--------------------------------------------- ---------------------------------------------
This section covers what you can do by modifying Godot's C++ source code. This section covers what you can do by modifying Pandemonium's C++ source code.
.. toctree:: .. toctree::
:maxdepth: 1 :maxdepth: 1
@ -39,7 +39,7 @@ This section covers what you can do by modifying Godot's C++ source code.
custom_modules_in_cpp custom_modules_in_cpp
binding_to_external_libraries binding_to_external_libraries
custom_godot_servers custom_pandemonium_servers
custom_resource_format_loaders custom_resource_format_loaders
custom_audiostreams custom_audiostreams

14
engine_development/cpp/introduction_to_godot_development.md
View File

@ -1,16 +1,16 @@
Introduction to Godot development Introduction to Pandemonium development
================================= =================================
This page is meant to introduce the global organization of Godot Engine's This page is meant to introduce the global organization of Pandemonium Engine's
source code, and give useful tips for extending/fixing the engine on the source code, and give useful tips for extending/fixing the engine on the
C++ side. C++ side.
Architecture diagram Architecture diagram
-------------------- --------------------
The following diagram describes the architecture used by Godot, from the The following diagram describes the architecture used by Pandemonium, from the
core components down to the abstracted drivers, via the scene core components down to the abstracted drivers, via the scene
structure and the servers. structure and the servers.
@ -19,22 +19,22 @@ structure and the servers.
Debugging the editor with gdb Debugging the editor with gdb
----------------------------- -----------------------------
If you are writing or correcting bugs affecting Godot Engine's editor, If you are writing or correcting bugs affecting Pandemonium Engine's editor,
remember that the binary will by default run the project manager first, remember that the binary will by default run the project manager first,
and then only run the editor in another process once you've selected a and then only run the editor in another process once you've selected a
project. To launch a project directly, you need to run the editor by project. To launch a project directly, you need to run the editor by
passing the `-e` argument to Godot Engine's binary from within your passing the `-e` argument to Pandemonium Engine's binary from within your
project's folder. Typically: project's folder. Typically:
``` ```
$ cd ~/myproject $ cd ~/myproject
$ gdb godot $ gdb pandemonium
> run -e > run -e
``` ```
Or: Or:
``` ```
$ gdb godot $ gdb pandemonium
> run -e --path ~/myproject > run -e --path ~/myproject
``` ```

4
engine_development/cpp/macos_debug.md
View File

@ -1,7 +1,7 @@
Debugging on macOS Debugging on macOS
================== ==================
Debugging Godot editor Debugging Pandemonium editor
---------------------- ----------------------
Attaching a debugger to the signed macOS process requires the "com.apple.security.get-task-allow" entitlement, which is not enabled by default, since apps can't be notarized as long as it is enabled. Attaching a debugger to the signed macOS process requires the "com.apple.security.get-task-allow" entitlement, which is not enabled by default, since apps can't be notarized as long as it is enabled.
@ -35,7 +35,7 @@ Create an `editor.entitlements` text file with the following contents:
Then use the following command to re-sign the editor: Then use the following command to re-sign the editor:
``` ```
codesign -s - --deep --force --options=runtime --entitlements ./editor.entitlements ./path/to/Godot.app codesign -s - --deep --force --options=runtime --entitlements ./editor.entitlements ./path/to/Pandemonium.app
``` ```
Debugging exported project Debugging exported project

22
engine_development/cpp/object_class.md
View File

@ -6,13 +6,13 @@ Object class
See also: See also:
This page describes the C++ implementation of objects in Godot. This page describes the C++ implementation of objects in Pandemonium.
Looking for the Object class reference? `Have a look here.` Looking for the Object class reference? `Have a look here.`
General definition General definition
------------------ ------------------
`Object` is the base class for almost everything. Most classes in Godot `Object` is the base class for almost everything. Most classes in Pandemonium
inherit directly or indirectly from it. Objects provide reflection and inherit directly or indirectly from it. Objects provide reflection and
editable properties, and declaring them is a matter of using a single editable properties, and declaring them is a matter of using a single
macro like this. macro like this.
@ -36,7 +36,7 @@ This makes Objects gain a lot of functionality, like for example
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/object.h ( https://github.com/godotengine/godot/blob/3.x/core/object.h )` - `core/object.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/object.h )`
Registering an Object Registering an Object
--------------------- ---------------------
@ -94,7 +94,7 @@ string passing the name can be passed for brevity.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/class_db.h ( https://github.com/godotengine/godot/blob/3.x/core/class_db.h )` - `core/class_db.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/class_db.h )`
Constants Constants
--------- ---------
@ -201,7 +201,7 @@ compared against the desired names in serial order.
Dynamic casting Dynamic casting
--------------- ---------------
Godot provides dynamic casting between Object-derived classes, for Pandemonium provides dynamic casting between Object-derived classes, for
example: example:
``` ```
@ -241,9 +241,9 @@ Adding signals to a class is done in `bind_methods`, using the
Notifications Notifications
------------- -------------
All objects in Godot have a `notification` All objects in Pandemonium have a `notification`
method that allows it to respond to engine level callbacks that may relate to it. method that allows it to respond to engine level callbacks that may relate to it.
More information can be found on the `doc_godot_notifications` page. More information can be found on the `doc_pandemonium_notifications` page.
References References
---------- ----------
@ -266,7 +266,7 @@ templates point to it.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/reference.h ( https://github.com/godotengine/godot/blob/3.x/core/reference.h )` - `core/reference.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/reference.h )`
Resources: Resources:
---------- ----------
@ -282,7 +282,7 @@ Resources without a path are fine too.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/resource.h ( https://github.com/godotengine/godot/blob/3.x/core/resource.h )` - `core/resource.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/resource.h )`
Resource loading Resource loading
---------------- ----------------
@ -303,7 +303,7 @@ the same time.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/io/resource_loader.h ( https://github.com/godotengine/godot/blob/3.x/core/io/resource_loader.h )` - `core/io/resource_loader.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/io/resource_loader.h )`
Resource saving Resource saving
--------------- ---------------
@ -322,4 +322,4 @@ be bundled with the saved resource and assigned sub-IDs, like
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/io/resource_saver.h ( https://github.com/godotengine/godot/blob/3.x/core/io/resource_saver.h )` - `core/io/resource_saver.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/io/resource_saver.h )`

28
engine_development/cpp/using_cpp_profilers.md
View File

@ -3,7 +3,7 @@
Using C++ profilers Using C++ profilers
=================== ===================
To optimize Godot's performance, you need to know what to optimize first. To optimize Pandemonium's performance, you need to know what to optimize first.
To this end, profilers are useful tools. To this end, profilers are useful tools.
Note: Note:
@ -23,10 +23,10 @@ Recommended profilers
These profilers may not be the most powerful or flexible options, but their These profilers may not be the most powerful or flexible options, but their
standalone operation and limited feature set tends to make them easier to use. standalone operation and limited feature set tends to make them easier to use.
Setting up Godot Setting up Pandemonium
---------------- ----------------
To get useful profiling information, it is **absolutely required** to use a Godot To get useful profiling information, it is **absolutely required** to use a Pandemonium
build that includes debugging symbols. Official binaries do not include debugging build that includes debugging symbols. Official binaries do not include debugging
symbols, since these would make the download size significantly larger. symbols, since these would make the download size significantly larger.
@ -51,9 +51,9 @@ Warning:
Benchmarking startup/shutdown times Benchmarking startup/shutdown times
----------------------------------- -----------------------------------
If you're looking into optimizing Godot's startup/shutdown performance, If you're looking into optimizing Pandemonium's startup/shutdown performance,
you can tell the profiler to use the `--quit` command line option on the Godot binary. you can tell the profiler to use the `--quit` command line option on the Pandemonium binary.
This will exit Godot just after it finished starting. This will exit Pandemonium just after it finished starting.
The `--quit` option works with `--editor`, `--project-manager` or The `--quit` option works with `--editor`, `--project-manager` or
`--path <path to project directory )` (which runs a project directly). `--path <path to project directory )` (which runs a project directly).
@ -61,7 +61,7 @@ See also:
See `doc_command_line_tutorial` for more command line arguments See `doc_command_line_tutorial` for more command line arguments
supported by Godot. supported by Pandemonium.
Profiler-specific instructions Profiler-specific instructions
------------------------------ ------------------------------
@ -69,11 +69,11 @@ Profiler-specific instructions
VerySleepy VerySleepy
^^^^^^^^^^ ^^^^^^^^^^
- Start the Godot editor or your project first. - Start the Pandemonium editor or your project first.
If you start the project manager, make sure to edit or run a project first. If you start the project manager, make sure to edit or run a project first.
Otherwise, the profiler will not track the child process since the project manager Otherwise, the profiler will not track the child process since the project manager
will spawn a child process for every project edited or run. will spawn a child process for every project edited or run.
- Open VerySleepy and select the Godot executable in the list of processes on the left: - Open VerySleepy and select the Pandemonium executable in the list of processes on the left:
![](img/cpp_profiler_verysleepy_select_process.png) ![](img/cpp_profiler_verysleepy_select_process.png)
@ -81,9 +81,9 @@ VerySleepy
- Perform the actions you wish to profile in the editor or project. When you're done, click **Stop** (*not* Abort). - Perform the actions you wish to profile in the editor or project. When you're done, click **Stop** (*not* Abort).
- Wait for the results window to appear. - Wait for the results window to appear.
- Once the results window appears, filter the view to remove external modules (such as the graphics driver). - Once the results window appears, filter the view to remove external modules (such as the graphics driver).
You can filter by module by finding a line whose **Module** matches the Godot You can filter by module by finding a line whose **Module** matches the Pandemonium
executable name, right-clicking that line then choosing executable name, right-clicking that line then choosing
**Filter Module to <Godot executable name>** in the dropdown that appears. **Filter Module to <Pandemonium executable name>** in the dropdown that appears.
- Your results window should now look something like this: - Your results window should now look something like this:
![](img/cpp_profiler_verysleepy_results_filtered.png) ![](img/cpp_profiler_verysleepy_results_filtered.png)
@ -95,13 +95,13 @@ HotSpot
![](img/cpp_profiler_hotspot_welcome.png) ![](img/cpp_profiler_hotspot_welcome.png)
- In the next window, specify the path to the Godot binary that includes debug symbols. - In the next window, specify the path to the Pandemonium binary that includes debug symbols.
- Specify command line arguments to run a specific project, with or without the editor. - Specify command line arguments to run a specific project, with or without the editor.
- The path to the working directory can be anything if an absolute path is used - The path to the working directory can be anything if an absolute path is used
for the `--path` command line argument. Otherwise, it must be set to that for the `--path` command line argument. Otherwise, it must be set to that
the relative path to the project is valid. the relative path to the project is valid.
- Make sure **Elevate Privileges** is checked if you have administrative privileges. - Make sure **Elevate Privileges** is checked if you have administrative privileges.
While not essential for profiling Godot, this will ensure all events can be captured. While not essential for profiling Pandemonium, this will ensure all events can be captured.
Otherwise, some events may be missing in the capture. Otherwise, some events may be missing in the capture.
Your settings should now look something like this: Your settings should now look something like this:
@ -145,7 +145,7 @@ Xcode Instruments
![](img/cpp_profiler_xcode_menu.png) ![](img/cpp_profiler_xcode_menu.png)
- In the Time Profiler window, click on the **Target** menu, select **Choose target...** - In the Time Profiler window, click on the **Target** menu, select **Choose target...**
and specify the path to the Godot binary, command line arguments and environment variables and specify the path to the Pandemonium binary, command line arguments and environment variables
in the next window. in the next window.
![](img/cpp_profiler_time_profiler.png) ![](img/cpp_profiler_time_profiler.png)

14
engine_development/cpp/variant_class.md
View File

@ -6,7 +6,7 @@ Variant class
About About
----- -----
Variant is the most important datatype of Godot, it's the most important Variant is the most important datatype of Pandemonium, it's the most important
class in the engine. A Variant takes up only 20 bytes and can store class in the engine. A Variant takes up only 20 bytes and can store
almost any engine datatype inside of it. Variants are rarely used to almost any engine datatype inside of it. Variants are rarely used to
hold information for long periods of time, instead they are used mainly hold information for long periods of time, instead they are used mainly
@ -20,7 +20,7 @@ A Variant can:
its atomic/native datatype). its atomic/native datatype).
- Be hashed, so it can be compared quickly to other variants - Be hashed, so it can be compared quickly to other variants
- Be used to convert safely between datatypes - Be used to convert safely between datatypes
- Be used to abstract calling methods and their arguments (Godot - Be used to abstract calling methods and their arguments (Pandemonium
exports all its functions through variants) exports all its functions through variants)
- Be used to defer calls or move data between threads. - Be used to defer calls or move data between threads.
- Be serialized as binary and stored to disk, or transferred via - Be serialized as binary and stored to disk, or transferred via
@ -30,14 +30,14 @@ A Variant can:
- Work as an exported property, so the editor can edit it universally. - Work as an exported property, so the editor can edit it universally.
- Be used for dictionaries, arrays, parsers, etc. - Be used for dictionaries, arrays, parsers, etc.
Basically, thanks to the Variant class, writing Godot itself was a much, Basically, thanks to the Variant class, writing Pandemonium itself was a much,
much easier task, as it allows for highly dynamic constructs not common much easier task, as it allows for highly dynamic constructs not common
of C++ with little effort. Become a friend of Variant today. of C++ with little effort. Become a friend of Variant today.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/variant.h ( https://github.com/godotengine/godot/blob/3.x/core/variant.h )` - `core/variant.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/variant.h )`
Containers: Dictionary and Array Containers: Dictionary and Array
-------------------------------- --------------------------------
@ -51,10 +51,10 @@ Modifications to a container will modify all references to
it. A Mutex should be created to lock it if multi threaded access is it. A Mutex should be created to lock it if multi threaded access is
desired. desired.
Copy-on-write (COW) mode support for containers was dropped with Godot 3.0. Copy-on-write (COW) mode support for containers was dropped with Pandemonium 3.0.
References: References:
~~~~~~~~~~~ ~~~~~~~~~~~
- `core/dictionary.h ( https://github.com/godotengine/godot/blob/3.x/core/dictionary.h )` - `core/dictionary.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/dictionary.h )`
- `core/array.h ( https://github.com/godotengine/godot/blob/3.x/core/array.h )` - `core/array.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/array.h )`

12
engine_development/editor/creating_icons.md
View File

@ -14,10 +14,10 @@ Creating icons
To create new icons, you first need a vector graphics editor installed. To create new icons, you first need a vector graphics editor installed.
For instance, you can use the open source `Inkscape ( https://inkscape.org/ )` editor. For instance, you can use the open source `Inkscape ( https://inkscape.org/ )` editor.
Clone the `godot` repository containing all the editor icons: Clone the `pandemonium` repository containing all the editor icons:
``` ```
git clone https://github.com/godotengine/godot.git git clone https://github.com/pandemoniumengine/pandemonium.git
``` ```
The icons must be created in a vector graphics editor in SVG format. There are The icons must be created in a vector graphics editor in SVG format. There are
@ -36,9 +36,9 @@ CPUParticles2D, name the file `CPUParticles2D.svg`.
Color conversion for light editor themes Color conversion for light editor themes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the user has configured their editor to use a light theme, Godot will If the user has configured their editor to use a light theme, Pandemonium will
convert the icon's colors based on a convert the icon's colors based on a
`set of predefined color mappings ( https://github.com/godotengine/godot/blob/b9f2e57d6240346f1833fd0390de195c956299e7/editor/editor_themes.cpp#L122-L184 )`. `set of predefined color mappings ( https://github.com/pandemoniumengine/pandemonium/blob/b9f2e57d6240346f1833fd0390de195c956299e7/editor/editor_themes.cpp#L122-L184 )`.
This is to ensure the icon always displays with a sufficient contrast rate. This is to ensure the icon always displays with a sufficient contrast rate.
Try to restrict your icon's color palette to colors found in the list above. Try to restrict your icon's color palette to colors found in the list above.
Otherwise, your icon may become difficult to read on a light background. Otherwise, your icon may become difficult to read on a light background.
@ -82,7 +82,7 @@ add optimized icons to `editor/icons` in the main repository. Recompile the
engine to make it pick up new icons for classes. engine to make it pick up new icons for classes.
It's also possible to create custom icons within a module. If you're creating It's also possible to create custom icons within a module. If you're creating
your own module and don't plan to integrate it with Godot, you don't need to your own module and don't plan to integrate it with Pandemonium, you don't need to
make a separate pull request for your icons to be available within the editor make a separate pull request for your icons to be available within the editor
as they can be self-contained. as they can be self-contained.
@ -102,4 +102,4 @@ If icons don't appear in the editor, make sure that:
References References
~~~~~~~~~~ ~~~~~~~~~~
- `editor/icons ( https://github.com/godotengine/godot/tree/master/editor/icons )` - `editor/icons ( https://github.com/pandemoniumengine/pandemonium/tree/master/editor/icons )`

6
engine_development/editor/editor_style_guide.md
View File

@ -6,9 +6,9 @@ Editor style guide
Introduction Introduction
------------ ------------
Thanks for your interest in contributing to the Godot editor! Thanks for your interest in contributing to the Pandemonium editor!
This page describes the grammar and writing style used throughout the Godot This page describes the grammar and writing style used throughout the Pandemonium
editor. Following this style guide will help your contribution get merged faster editor. Following this style guide will help your contribution get merged faster
since there will be fewer review steps required. since there will be fewer review steps required.
@ -63,7 +63,7 @@ Inspector performance hints
Enum properties that noticeably impact performance should have a performance Enum properties that noticeably impact performance should have a performance
hint associated. The hint should refer to the *absolute* performance impact, hint associated. The hint should refer to the *absolute* performance impact,
rather than being relative to the other options provided in the enum. Here are rather than being relative to the other options provided in the enum. Here are
some examples taken from the Godot editor: some examples taken from the Pandemonium editor:
- **Screen-space antialiasing:** *Disabled (Fastest), FXAA (Fast)* - **Screen-space antialiasing:** *Disabled (Fastest), FXAA (Fast)*
- **MSAA quality:** *Disabled (Fastest), 2x (Fast), 4x (Average), 8x (Slow), 16x - **MSAA quality:** *Disabled (Fastest), 2x (Fast), 4x (Average), 8x (Slow), 16x

38
engine_development/editor/introduction_to_editor_development.md
View File

@ -5,8 +5,8 @@ Introduction to editor development
On this page, you will learn: On this page, you will learn:
- The **design decisions** behind the Godot editor. - The **design decisions** behind the Pandemonium editor.
- How to work efficiently on the Godot editor's C++ code. - How to work efficiently on the Pandemonium editor's C++ code.
This guide is aimed at current or future engine contributors. This guide is aimed at current or future engine contributors.
To create editor plugins in GDScript, see `doc_making_plugins` instead. To create editor plugins in GDScript, see `doc_making_plugins` instead.
@ -14,19 +14,19 @@ To create editor plugins in GDScript, see `doc_making_plugins` instead.
See also: See also:
If you are new to Godot, we recommended you to read If you are new to Pandemonium, we recommended you to read
`doc_godot_design_philosophy` before continuing. Since the Godot editor `doc_pandemonium_design_philosophy` before continuing. Since the Pandemonium editor
is a Godot project written in C++, much of the engine's philosophy applies is a Pandemonium project written in C++, much of the engine's philosophy applies
to the editor. to the editor.
Technical choices Technical choices
----------------- -----------------
The Godot editor is drawn using Godot's renderer and The Pandemonium editor is drawn using Pandemonium's renderer and
`UI system <toc-gui-basics )`. It does *not* rely on a toolkit `UI system <toc-gui-basics )`. It does *not* rely on a toolkit
such as GTK or Qt. This is similar in spirit to software like Blender. such as GTK or Qt. This is similar in spirit to software like Blender.
While using toolkits makes it easier to achieve a "native" appearance, they are While using toolkits makes it easier to achieve a "native" appearance, they are
also quite heavy and their licensing is not compatible with Godot's. also quite heavy and their licensing is not compatible with Pandemonium's.
The editor is fully written in C++. It can't contain any GDScript or C# code. The editor is fully written in C++. It can't contain any GDScript or C# code.
@ -34,26 +34,26 @@ Directory structure
------------------- -------------------
The editor's code is fully self-contained in the The editor's code is fully self-contained in the
`editor/ ( https://github.com/godotengine/godot/tree/master/editor )` folder `editor/ ( https://github.com/pandemoniumengine/pandemonium/tree/master/editor )` folder
of the Godot source repository. of the Pandemonium source repository.
Some editor functionality is also implemented via Some editor functionality is also implemented via
`modules ( doc_custom_modules_in_c++ )`. Some of these are only enabled in `modules ( doc_custom_modules_in_c++ )`. Some of these are only enabled in
editor builds to decrease the binary size of export templates. See the editor builds to decrease the binary size of export templates. See the
`modules/ ( https://github.com/godotengine/godot/tree/master/modules )` folder `modules/ ( https://github.com/pandemoniumengine/pandemonium/tree/master/modules )` folder
in the Godot source repository. in the Pandemonium source repository.
Some important files in the editor are: Some important files in the editor are:
- `editor/editor_node.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/editor_node.cpp )`: - `editor/editor_node.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/editor/editor_node.cpp )`:
Main editor initialization file. Effectively the "main scene" of the editor. Main editor initialization file. Effectively the "main scene" of the editor.
- `editor/project_manager.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/project_manager.cpp )`: - `editor/project_manager.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/editor/project_manager.cpp )`:
Main project manager initialization file. Effectively the "main scene" of the project manager. Main project manager initialization file. Effectively the "main scene" of the project manager.
- `editor/plugins/canvas_item_editor_plugin.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/plugins/canvas_item_editor_plugin.cpp )`: - `editor/plugins/canvas_item_editor_plugin.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/editor/plugins/canvas_item_editor_plugin.cpp )`:
The 2D editor viewport and related functionality (toolbar at the top, editing modes, overlaid helpers/panels, …). The 2D editor viewport and related functionality (toolbar at the top, editing modes, overlaid helpers/panels, …).
- `editor/plugins/spatial_editor_plugin.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/plugins/spatial_editor_plugin.cpp )`: - `editor/plugins/spatial_editor_plugin.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/editor/plugins/spatial_editor_plugin.cpp )`:
The 3D editor viewport and related functionality (toolbar at the top, editing modes, overlaid panels, …). The 3D editor viewport and related functionality (toolbar at the top, editing modes, overlaid panels, …).
- `editor/spatial_editor_gizmos.cpp ( https://github.com/godotengine/godot/blob/3.x/editor/spatial_editor_gizmos.cpp )`: - `editor/spatial_editor_gizmos.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/editor/spatial_editor_gizmos.cpp )`:
Where the 3D editor gizmos are defined and drawn. Where the 3D editor gizmos are defined and drawn.
This file doesn't have a 2D counterpart as 2D gizmos are drawn by the nodes themselves. This file doesn't have a 2D counterpart as 2D gizmos are drawn by the nodes themselves.
@ -61,7 +61,7 @@ Editor dependencies in `scene/` files
--------------------------------------- ---------------------------------------
When working on an editor feature, you may have to modify files in When working on an editor feature, you may have to modify files in
Godot's GUI nodes, which you can find in the `scene/` folder. Pandemonium's GUI nodes, which you can find in the `scene/` folder.
One rule to keep in mind is that you must **not** introduce new dependencies to One rule to keep in mind is that you must **not** introduce new dependencies to
`editor/` includes in other folders such as `scene/`. This applies even if `editor/` includes in other folders such as `scene/`. This applies even if
@ -78,7 +78,7 @@ from `servers/` and `core/`, it cannot depend on includes from `editor/`.
Currently, there are some dependencies to `editor/` includes in `scene/` Currently, there are some dependencies to `editor/` includes in `scene/`
files, but files, but
`they are in the process of being removed ( https://github.com/godotengine/godot/issues/29730 )`. `they are in the process of being removed ( https://github.com/pandemoniumengine/pandemonium/issues/29730 )`.
Development tips Development tips
---------------- ----------------
@ -86,4 +86,4 @@ Development tips
To iterate quickly on the editor, we recommend to set up a test project and To iterate quickly on the editor, we recommend to set up a test project and
`open it from the command line ( doc_command_line_tutorial )` after compiling `open it from the command line ( doc_command_line_tutorial )` after compiling
the editor. This way, you don't have to go through the project manager every the editor. This way, you don't have to go through the project manager every
time you start Godot. time you start Pandemonium.

2
engine_development/file_formats/index.md
View File

@ -1,4 +1,4 @@
Godot file formats Pandemonium file formats
================== ==================
.. toctree:: .. toctree::

20
engine_development/file_formats/tscn.md
View File

@ -4,19 +4,19 @@ TSCN file format
================ ================
The TSCN (text scene) file format represents a single scene tree inside The TSCN (text scene) file format represents a single scene tree inside
Godot. Unlike binary SCN files, TSCN files have the advantage of being mostly Pandemonium. Unlike binary SCN files, TSCN files have the advantage of being mostly
human-readable and easy for version control systems to manage. human-readable and easy for version control systems to manage.
The ESCN (exported scene) file format is identical to the TSCN file format, but The ESCN (exported scene) file format is identical to the TSCN file format, but
is used to indicate to Godot that the file has been exported from another is used to indicate to Pandemonium that the file has been exported from another
program and should not be edited by the user from within Godot. program and should not be edited by the user from within Pandemonium.
Unlike SCN and TSCN files, during import, ESCN files are compiled to binary Unlike SCN and TSCN files, during import, ESCN files are compiled to binary
SCN files stored inside the `.import/` folder. SCN files stored inside the `.import/` folder.
This reduces the data size and speeds up loading, as binary formats are faster This reduces the data size and speeds up loading, as binary formats are faster
to load compared to text-based formats. to load compared to text-based formats.
For those looking for a complete description, the parsing is handled in the file For those looking for a complete description, the parsing is handled in the file
`resource_format_text.cpp ( https://github.com/godotengine/godot/blob/master/scene/resources/resource_format_text.cpp )` `resource_format_text.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/scene/resources/resource_format_text.cpp )`
in the `ResourceFormatLoaderText` class. in the `ResourceFormatLoaderText` class.
File structure File structure
@ -43,7 +43,7 @@ the items in the section. For example, the heading of all external resources
should start with `[ext_resource .....]`. should start with `[ext_resource .....]`.
A TSCN file may contain single-line comments starting with a semicolon (`;`). A TSCN file may contain single-line comments starting with a semicolon (`;`).
However, comments will be discarded when saving the file using the Godot editor. However, comments will be discarded when saving the file using the Pandemonium editor.
Entries inside the file Entries inside the file
~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~
@ -83,7 +83,7 @@ Other valid keywords include:
The first node in the file, which is also the scene root, must not have a The first node in the file, which is also the scene root, must not have a
`parent=Path/To/Node` entry in its heading. All scene files should have `parent=Path/To/Node` entry in its heading. All scene files should have
exactly *one* scene root. If it doesn't, Godot will fail to import the file. exactly *one* scene root. If it doesn't, Pandemonium will fail to import the file.
The parent path of other nodes should be absolute, but shouldn't contain The parent path of other nodes should be absolute, but shouldn't contain
the scene root's name. If the node is a direct child of the scene root, the scene root's name. If the node is a direct child of the scene root,
the path should be `"."`. Here is an example scene tree the path should be `"."`. Here is an example scene tree
@ -136,7 +136,7 @@ save a file with that node in it. Some example nodes are:
NodePath NodePath
~~~~~~~~ ~~~~~~~~
A tree structure is not enough to represent the whole scene. Godot uses a A tree structure is not enough to represent the whole scene. Pandemonium uses a
`NodePath(Path/To/Node)` structure to refer to another node or attribute of `NodePath(Path/To/Node)` structure to refer to another node or attribute of
the node anywhere in the scene tree. For instance, MeshInstance uses the node anywhere in the scene tree. For instance, MeshInstance uses
`NodePath()` to point to its skeleton. Likewise, Animation tracks use `NodePath()` to point to its skeleton. Likewise, Animation tracks use
@ -273,7 +273,7 @@ External resources
External resources are links to resources not contained within the TSCN file External resources are links to resources not contained within the TSCN file
itself. An external resource consists of a path, a type and an ID. itself. An external resource consists of a path, a type and an ID.
Godot always generates absolute paths relative to the resource directory and Pandemonium always generates absolute paths relative to the resource directory and
thus prefixed with `res://`, but paths relative to the TSCN file's location thus prefixed with `res://`, but paths relative to the TSCN file's location
are also valid. are also valid.
@ -286,7 +286,7 @@ Some example external resources are:
Like TSCN files, a TRES file may contain single-line comments starting with a Like TSCN files, a TRES file may contain single-line comments starting with a
semicolon (`;`). However, comments will be discarded when saving the resource semicolon (`;`). However, comments will be discarded when saving the resource
using the Godot editor. using the Pandemonium editor.
Internal resources Internal resources
~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~
@ -311,7 +311,7 @@ internal resources section.
Unfortunately, documentation on the formats for these subresources isn't Unfortunately, documentation on the formats for these subresources isn't
complete. Some examples can be found by inspecting saved resource files, but complete. Some examples can be found by inspecting saved resource files, but
others can only be found by looking through Godot's source. others can only be found by looking through Pandemonium's source.
ArrayMesh ArrayMesh
~~~~~~~~~ ~~~~~~~~~

28
index.md
View File

@ -1,26 +1,26 @@
Godot Docs – *3.5* branch Pandemonium Docs – *3.5* branch
========================= =========================
.. only:: not i18n .. only:: not i18n
Note: Note:
Godot's documentation is available in various languages and versions. Pandemonium's documentation is available in various languages and versions.
Expand the "Read the Docs" panel at the bottom of the sidebar to see Expand the "Read the Docs" panel at the bottom of the sidebar to see
the list. the list.
Tip: Tip:
This is the documentation for the 3.5 branch. This is the documentation for the 3.5 branch.
Looking for the documentation of the current **development** branch? Looking for the documentation of the current **development** branch?
`Have a look here ( https://docs.godotengine.org/en/latest )`. `Have a look here ( https://docs.pandemoniumengine.org/en/latest )`.
You can also browse the documentation for the current stable You can also browse the documentation for the current stable
`3.4 ( https://docs.godotengine.org/en/3.4 )` branch. `3.4 ( https://docs.pandemoniumengine.org/en/3.4 )` branch.
.. only:: i18n .. only:: i18n
Note: Note:
This documentation is translated from the `original English one This documentation is translated from the `original English one
( https://docs.godotengine.org/en/latest )` by community members ( https://docs.pandemoniumengine.org/en/latest )` by community members
on `Weblate ( https://hosted.weblate.org/projects/godot-engine/godot-docs )`. on `Weblate ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium-docs )`.
Depending on the translation effort's completion level, you may Depending on the translation effort's completion level, you may
find paragraphs or whole pages which are still in English. You can find paragraphs or whole pages which are still in English. You can
@ -29,9 +29,9 @@ Godot Docs – *3.5* branch
For the time being, localized translations are only available for For the time being, localized translations are only available for
the "latest" (development) branch, but should be suitable to learn the "latest" (development) branch, but should be suitable to learn
how to use stable Godot releases nevertheless. how to use stable Pandemonium releases nevertheless.
Welcome to the official documentation of `Godot Engine ( https://godotengine.org )`, Welcome to the official documentation of `Pandemonium Engine ( https://pandemoniumengine.org )`,
the free and open source community-driven 2D and 3D game engine! If you are new the free and open source community-driven 2D and 3D game engine! If you are new
to this documentation, we recommend that you read the to this documentation, we recommend that you read the
`introduction page ( doc_about_intro )` to get an overview of what this `introduction page ( doc_about_intro )` to get an overview of what this
@ -41,12 +41,12 @@ The table of contents below and in the sidebar should let you easily access the
documentation for your topic of interest. You can also use the search function documentation for your topic of interest. You can also use the search function
in the top left corner. in the top left corner.
You can also `download an HTML copy ( https://nightly.link/godotengine/godot-docs/workflows/build_offline_docs/master/godot-docs-html-stable.zip )` You can also `download an HTML copy ( https://nightly.link/pandemoniumengine/pandemonium-docs/workflows/build_offline_docs/master/pandemonium-docs-html-stable.zip )`
for offline reading (updated every Monday). Extract the ZIP archive then open for offline reading (updated every Monday). Extract the ZIP archive then open
the top-level `index.html` in a web browser. the top-level `index.html` in a web browser.
Note: Note:
Godot Engine is an open source project developed by a community of Pandemonium Engine is an open source project developed by a community of
volunteers. The documentation team can always use your volunteers. The documentation team can always use your
feedback and help to improve the tutorials and class reference. If feedback and help to improve the tutorials and class reference. If
you don't understand something, or cannot find what you you don't understand something, or cannot find what you
@ -54,12 +54,12 @@ Note:
by letting us know! by letting us know!
Submit an issue or pull request on the `GitHub repository Submit an issue or pull request on the `GitHub repository
( https://github.com/godotengine/godot-docs/issues )`, ( https://github.com/pandemoniumengine/pandemonium-docs/issues )`,
help us `translate the documentation help us `translate the documentation
( https://hosted.weblate.org/engage/godot-engine/ )` into your ( https://hosted.weblate.org/engage/pandemonium-engine/ )` into your
language, or talk to us on the language, or talk to us on the
`#documentation` channel on the `Godot Contributors Chat `#documentation` channel on the `Pandemonium Contributors Chat
( https://chat.godotengine.org/ )`! ( https://chat.pandemoniumengine.org/ )`!
.. centered:: |weblate_widget| .. centered:: |weblate_widget|

26
modules/entity_spell_system.md
View File

@ -1,22 +1,22 @@
# Entity Spell System # Entity Spell System
An entity and spell system for the GODOT Engine, that is usable for both 2d, and 3d games. The main purpose of this An entity and spell system for the PANDEMONIUM Engine, that is usable for both 2d, and 3d games. The main purpose of this
module is to handle spells, auras, and most entity-related things like spawning, items, inventory, containers, module is to handle spells, auras, and most entity-related things like spawning, items, inventory, containers,
vendors, interaction, targeting, equipment (+ visuals), loot, crafting, talents, pets, npcs, etc ... vendors, interaction, targeting, equipment (+ visuals), loot, crafting, talents, pets, npcs, etc ...
The module supports networking. It is designed to be authoritative, so players shouldn't be able to cheat by design. The module supports networking. It is designed to be authoritative, so players shouldn't be able to cheat by design.
It is a c++ engine module, which means you will need to compile it into godot. (See compiling) It is a c++ engine module, which means you will need to compile it into pandemonium. (See compiling)
## Godot Version Support ## Pandemonium Version Support
This module is developed with the 3.x branch of godot, usually at the newest revisions. This module is developed with the 3.x branch of pandemonium, usually at the newest revisions.
3.2 - Will likely work, probably needs changes by now. (TODO check.)\ 3.2 - Will likely work, probably needs changes by now. (TODO check.)\
3.3 - Will more likely work, might need smaller changes by now. (TODO check.)\ 3.3 - Will more likely work, might need smaller changes by now. (TODO check.)\
3.4 - Should work without any issues. (TODO check.)\ 3.4 - Should work without any issues. (TODO check.)\
3.x - Works.\ 3.x - Works.\
4.0 - Have been fixing support from time to time. Currently it won't build on the latest master, and it will take considerable amount of work to get it to work again after the virtual method binding rework. It will be done eventually, but it will take time. [Here](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)'s the last know-to-work commit. 4.0 - Have been fixing support from time to time. Currently it won't build on the latest master, and it will take considerable amount of work to get it to work again after the virtual method binding rework. It will be done eventually, but it will take time. [Here](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)'s the last know-to-work commit.
## Project setup tl;dr ## Project setup tl;dr
@ -133,7 +133,7 @@ and quite a few notification constants.
Open `ProjectSettings`, and then go to `ESS/Enums`. Open `ProjectSettings`, and then go to `ESS/Enums`.
All of the string properties are customizable enums. These require a comma-separated list. All of the string properties are customizable enums. These require a comma-separated list.
They are essentially a godot comma separated property hint enum string. They are essentially a pandemonium comma separated property hint enum string.
They all have defaults. They all have defaults.
@ -568,19 +568,19 @@ https://github.com/Relintai/broken_seals_2d.git
## Compiling ## Compiling
First make sure that you can compile godot. See the official docs: https://docs.godotengine.org/en/3.x/development/compiling/index.html First make sure that you can compile pandemonium. See the official docs: https://docs.pandemoniumengine.org/en/3.x/development/compiling/index.html
1. Clone the engine if you haven't already: 1. Clone the engine if you haven't already:
If you want Godot 3.x: If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot``` ```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory" 2. go into the modules folder inside the engine's directory"
```cd godot``` ```cd pandemonium```
```cd modules``` ```cd modules```
3. clone this repository 3. clone this repository
@ -593,7 +593,7 @@ If you want Godot 4.0:
```cd ..``` ```cd ..```
5. Compile godot. 5. Compile pandemonium.
For example: For example:

2
modules/layered_tile_maps/using_tilemaps.md
View File

@ -33,7 +33,7 @@ Saving the built-in LayeredTileSet resource to an external resource file
## Creating LayeredTileMap layers ## Creating LayeredTileMap layers
As of Godot 4.0, you can place several *layers* in a single LayeredTileMap node. For As of Pandemonium 4.0, you can place several *layers* in a single LayeredTileMap node. For
example, this allows you to distinguish foreground tiles from background tiles example, this allows you to distinguish foreground tiles from background tiles
for better organization. You can place one tile per layer at a given location, for better organization. You can place one tile per layer at a given location,
which allows you to overlap several tiles together if you have more than one layer. which allows you to overlap several tiles together if you have more than one layer.

12
modules/layered_tile_maps/using_tilesets.md
View File

@ -141,7 +141,7 @@ Recreating tiles automatically after changing atlas properties
### Using a collection of scenes ### Using a collection of scenes
Since Godot 4.0, you can place actual *scenes* as tiles. This allows you to use Since Pandemonium 4.0, you can place actual *scenes* as tiles. This allows you to use
any collection of nodes as a tile. For example, you could use scene tiles to any collection of nodes as a tile. For example, you could use scene tiles to
place gameplay elements, such as shops the player may be able to interact with. place gameplay elements, such as shops the player may be able to interact with.
You could also use scene tiles to place AudioStreamPlayer2Ds (for ambient You could also use scene tiles to place AudioStreamPlayer2Ds (for ambient
@ -184,7 +184,7 @@ any other tile.
Using multiple atlases within a single LayeredTileSet resource can sometimes be useful, Using multiple atlases within a single LayeredTileSet resource can sometimes be useful,
but it can also be cumbersome in certain situations (especially if you're using but it can also be cumbersome in certain situations (especially if you're using
one image per tile). Godot allows you to merge several atlases into a single one image per tile). Pandemonium allows you to merge several atlases into a single
atlas for easier organization. atlas for easier organization.
To do so, you must have more than one atlas created in the LayeredTileSet resource. To do so, you must have more than one atlas created in the LayeredTileSet resource.
@ -342,7 +342,7 @@ Assigning custom data in the LayeredTileSet editor using tile property painting
Note: Note:
- This functionality was implemented in a different form as *autotiling* in Godot 3.x. Terrains are essentially a more powerful replacement of autotiles. Unlike autotiles, terrains can support transitions from one terrain to another, as a tile may define several terrains at once. - This functionality was implemented in a different form as *autotiling* in Pandemonium 3.x. Terrains are essentially a more powerful replacement of autotiles. Unlike autotiles, terrains can support transitions from one terrain to another, as a tile may define several terrains at once.
- Unlike before, where autotiles were a specific kind of tiles, terrains are only a set of properties assigned to atlas tiles. These properties are then used by a dedicated LayeredTileMap painting mode that selects tiles featuring terrain data in a smart way. This means any terrain tile can be either painted as terrain or as a single tile, like any other. - Unlike before, where autotiles were a specific kind of tiles, terrains are only a set of properties assigned to atlas tiles. These properties are then used by a dedicated LayeredTileMap painting mode that selects tiles featuring terrain data in a smart way. This means any terrain tile can be either painted as terrain or as a single tile, like any other.
A "polished" tileset generally features variations that you should use on A "polished" tileset generally features variations that you should use on
@ -350,7 +350,7 @@ corners or edges of platforms, floors, etc. While these can be placed manually,
this quickly becomes tedious. Handling this situation with procedurally this quickly becomes tedious. Handling this situation with procedurally
generated levels can also be difficult and require a lot of code. generated levels can also be difficult and require a lot of code.
Godot offers *terrains* to perform this kind of tile connections automatically. Pandemonium offers *terrains* to perform this kind of tile connections automatically.
This allows you to have the "correct" tile variants automatically used. This allows you to have the "correct" tile variants automatically used.
Terrains are grouped into terrain sets. Each terrain set is assigned a mode from Terrains are grouped into terrain sets. Each terrain set is assigned a mode from
@ -359,7 +359,7 @@ terrains are matched to each other in a terrain set.
Note: Note:
- The above modes correspond to the previous bitmask modes autotiles used in Godot 3.x: 2×2, 3×3 or 3×3 minimal. This is also similar to what the [Tiled](https://www.mapeditor.org/) editor features. - The above modes correspond to the previous bitmask modes autotiles used in Pandemonium 3.x: 2×2, 3×3 or 3×3 minimal. This is also similar to what the [Tiled](https://www.mapeditor.org/) editor features.
Select the LayeredTileMap node, go to the inspector and create a new terrain set within the LayeredTileSet *resource*: Select the LayeredTileMap node, go to the inspector and create a new terrain set within the LayeredTileSet *resource*:
@ -469,7 +469,7 @@ can be done using *alternative tiles*.
Tip: Tip:
Since Godot 4.2, you don't have to create alternative tiles to rotate or Since Pandemonium 4.2, you don't have to create alternative tiles to rotate or
flip tiles anymore. You can rotate any tile while placing it in the flip tiles anymore. You can rotate any tile while placing it in the
LayeredTileMap editor by using the rotation/flip buttons in the LayeredTileMap editor LayeredTileMap editor by using the rotation/flip buttons in the LayeredTileMap editor
toolbar. toolbar.

18
modules/mesh_data_resource.md
View File

@ -1,6 +1,6 @@
# Mesh data resource Module # Mesh data resource Module
A c++ Godot engine module, that adds a resource, which contains raw mesh data for merging and collider information. A c++ Pandemonium engine module, that adds a resource, which contains raw mesh data for merging and collider information.
The module also comes with importers (gltf, and collada for now), you can import 3d models as MeshDataResources with these. The module also comes with importers (gltf, and collada for now), you can import 3d models as MeshDataResources with these.
@ -44,18 +44,18 @@ Since MeshDataResource can hold collider information, these importers can create
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
[last tested commit for 4.0](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540) [last tested commit for 4.0](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -64,6 +64,6 @@ cd ./godot/modules/
git clone https://github.com/Relintai/mesh_data_resource mesh_data_resource git clone https://github.com/Relintai/mesh_data_resource mesh_data_resource
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

18
modules/mesh_utils.md
View File

@ -1,8 +1,8 @@
# Mesh Utils Module # Mesh Utils Module
This is a c++ engine module for the Godot engine, containing my mesh merging utilities. This is a c++ engine module for the Pandemonium engine, containing my mesh merging utilities.
It supports both godot 3.2 and 4.0 (master [last tested commit](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only It supports both pandemonium 3.2 and 4.0 (master [last tested commit](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only
check whether it works from time to time. check whether it works from time to time.
# Pre-built binaries # Pre-built binaries
@ -36,17 +36,17 @@ I might just return to using the original FQMS. As if meshes are merged together
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -55,6 +55,6 @@ cd ./godot/modules/
git clone https://github.com/Relintai/mesh_utils mesh_utils git clone https://github.com/Relintai/mesh_utils mesh_utils
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

18
modules/props.md
View File

@ -1,10 +1,10 @@
# Props Module # Props Module
This is a c++ engine module for the Godot Engine. This is a c++ engine module for the Pandemonium Engine.
It gives you props, and editor utilities to convert scenes to props. It gives you props, and editor utilities to convert scenes to props.
It supports both godot 3.2 and 4.0 (master [last tested commit](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only It supports both pandemonium 3.2 and 4.0 (master [last tested commit](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only
check whether it works from time to time. check whether it works from time to time.
# Pre-built binaries # Pre-built binaries
@ -71,17 +71,17 @@ or look into Project->Tools.
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -90,6 +90,6 @@ cd ./godot/modules/
git clone https://github.com/Relintai/props props git clone https://github.com/Relintai/props props
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

18
modules/props_2d.md
View File

@ -1,10 +1,10 @@
# Prop2Ds Module # Prop2Ds Module
This is a c++ engine module for the Godot Engine. This is a c++ engine module for the Pandemonium Engine.
It gives you props, and editor utilities to convert scenes to props. It gives you props, and editor utilities to convert scenes to props.
It supports both godot 3.2 and 4.0 (master [last tested commit](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only It supports both pandemonium 3.2 and 4.0 (master [last tested commit](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only
check whether it works from time to time. check whether it works from time to time.
# Pre-built binaries # Pre-built binaries
@ -71,17 +71,17 @@ or look into Project->Tools.
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -90,6 +90,6 @@ cd ./godot/modules/
git clone https://github.com/Relintai/props props git clone https://github.com/Relintai/props props
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

10
modules/rtile_map.md
View File

@ -1,6 +1,6 @@
# TileMap # TileMap
Godot's TileMap but as an engine module, with a few smaller features added. Pandemonium's TileMap but as an engine module, with a few smaller features added.
The tilemap classes will be prefixed with R, so it compiles cleanly with the built in TileMap class. The tilemap classes will be prefixed with R, so it compiles cleanly with the built in TileMap class.
@ -8,12 +8,12 @@ The tilemap classes will be prefixed with R, so it compiles cleanly with the bui
1. Get the source code for the engine. 1. Get the source code for the engine.
```git clone -b 3.x https://github.com/godotengine/godot.git godot``` ```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -22,4 +22,4 @@ cd ./godot/modules/
git clone https://github.com/Relintai/rtile_map.git rtile_map git clone https://github.com/Relintai/rtile_map.git rtile_map
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

16
modules/skeleton_editor.md
View File

@ -1,22 +1,22 @@
# Skeleton Editor # Skeleton Editor
This is a c++ engine module for the Godot engine that contains a modularized version of TokageItLab's pr's 3.2 version from the godot engine repository, until it gets merged. This is a c++ engine module for the Pandemonium engine that contains a modularized version of TokageItLab's pr's 3.2 version from the pandemonium engine repository, until it gets merged.
The original pr is here: https://github.com/godotengine/godot/pull/45699 The original pr is here: https://github.com/pandemoniumengine/pandemonium/pull/45699
Tht 3.x version (linked in the pr itself) is here (This is the base for this module): https://github.com/TokageItLab/godot/tree/pose-edit-mode Tht 3.x version (linked in the pr itself) is here (This is the base for this module): https://github.com/TokageItLab/pandemonium/tree/pose-edit-mode
I'm developing this for godot 3.x, it will probably work on earlier versions though. 4.0 is not supported. I'm developing this for pandemonium 3.x, it will probably work on earlier versions though. 4.0 is not supported.
# Building # Building
1. Get the source code for the engine. 1. Get the source code for the engine.
```git clone -b 3.x https://github.com/godotengine/godot.git godot``` ```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -25,4 +25,4 @@ cd ./godot/modules/
git clone https://github.com/Relintai/skeleton_editor skeleton_editor git clone https://github.com/Relintai/skeleton_editor skeleton_editor
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

24
modules/terraman.md
View File

@ -1,6 +1,6 @@
# Terraman # Terraman
A terrain engine for godot, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed. A terrain engine for pandemonium, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed.
It is a spinoff of [Voxelman](https://github.com/Relintai/voxelman). I started working on it when I realized that not only a full 3d voxel engine is too hard for me to use properly for an rpg (just think about how hard it is to do smooth zone - zone and dungeon transitions with the proper fidelity for an rpg), it's also unnecessary. It is a spinoff of [Voxelman](https://github.com/Relintai/voxelman). I started working on it when I realized that not only a full 3d voxel engine is too hard for me to use properly for an rpg (just think about how hard it is to do smooth zone - zone and dungeon transitions with the proper fidelity for an rpg), it's also unnecessary.
@ -8,11 +8,11 @@ I could have technically implemented all of this into voxelman, as having only h
So I ended up creating this. Everything works the same as in voxelman, but the apis have been simplified to make UX a bit better. So I ended up creating this. Everything works the same as in voxelman, but the apis have been simplified to make UX a bit better.
This is an engine module! Which means that you will need to compile it into Godot! [See the compiling section here.](#compiling) This is an engine module! Which means that you will need to compile it into Pandemonium! [See the compiling section here.](#compiling)
You can grab pre-built binaries (even editor + export templates) from the [Broken Seals](https://github.com/Relintai/broken_seals/releases) repo. You can grab pre-built binaries (even editor + export templates) from the [Broken Seals](https://github.com/Relintai/broken_seals/releases) repo.
## Godot Version Support ## Pandemonium Version Support
3.2 - Will likely work, probably needs changes by now. (TODO check.)\ 3.2 - Will likely work, probably needs changes by now. (TODO check.)\
3.3 - Will more likely work, might need smaller changes by now. (TODO check.)\ 3.3 - Will more likely work, might need smaller changes by now. (TODO check.)\
@ -55,7 +55,7 @@ This is the basic Minecraft-style lib rary. Use this if you just have one textur
### TerraLibraryMerger ### TerraLibraryMerger
You will only have this if your godot also contains https://github.com/Relintai/texture_packer You will only have this if your pandemonium also contains https://github.com/Relintai/texture_packer
You can assign any texture to your surfaces with this, and it will merge them together. You can assign any texture to your surfaces with this, and it will merge them together.
@ -63,7 +63,7 @@ You can assign any texture to your surfaces with this, and it will merge them to
(PCM = Per Chunk Material) (PCM = Per Chunk Material)
You will only have this if your godot also contains https://github.com/Relintai/texture_packer You will only have this if your pandemonium also contains https://github.com/Relintai/texture_packer
You can assign any texture to your surfaces with this, and it will merge them together, but it will do it for every required chunk/voxel combination. You can assign any texture to your surfaces with this, and it will merge them together, but it will do it for every required chunk/voxel combination.
@ -182,20 +182,20 @@ They won't get reset, so for example if you want all your vertices to have a cer
## Compiling ## Compiling
First make sure that you can compile godot. See the official docs: https://docs.godotengine.org/en/3.x/development/compiling/index.html First make sure that you can compile pandemonium. See the official docs: https://docs.pandemoniumengine.org/en/3.x/development/compiling/index.html
1. Clone the engine if you haven't already: 1. Clone the engine if you haven't already:
If you want Godot 3.x: If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot``` ```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory: 2. go into the modules folder inside the engine's directory:
```cd godot``` \ ```cd pandemonium``` \
```cd modules``` ```cd modules```
3. clone this repository 3. clone this repository
@ -213,7 +213,7 @@ If you want Godot 4.0:
```cd ..``` ```cd ..```
6. Compile godot. 6. Compile pandemonium.
For example: For example:

24
modules/terraman_2d.md
View File

@ -1,6 +1,6 @@
# Terraman # Terraman
A terrain engine for godot, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed. A terrain engine for pandemonium, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed.
It is a spinoff of [Voxelman](https://github.com/Relintai/voxelman). I started working on it when I realized that not only a full 3d voxel engine is too hard for me to use properly for an rpg (just think about how hard it is to do smooth zone - zone and dungeon transitions with the proper fidelity for an rpg), it's also unnecessary. It is a spinoff of [Voxelman](https://github.com/Relintai/voxelman). I started working on it when I realized that not only a full 3d voxel engine is too hard for me to use properly for an rpg (just think about how hard it is to do smooth zone - zone and dungeon transitions with the proper fidelity for an rpg), it's also unnecessary.
@ -8,11 +8,11 @@ I could have technically implemented all of this into voxelman, as having only h
So I ended up creating this. Everything works the same as in voxelman, but the apis have been simplified to make UX a bit better. So I ended up creating this. Everything works the same as in voxelman, but the apis have been simplified to make UX a bit better.
This is an engine module! Which means that you will need to compile it into Godot! [See the compiling section here.](#compiling) This is an engine module! Which means that you will need to compile it into Pandemonium! [See the compiling section here.](#compiling)
You can grab pre-built binaries (even editor + export templates) from the [Broken Seals](https://github.com/Relintai/broken_seals/releases) repo. You can grab pre-built binaries (even editor + export templates) from the [Broken Seals](https://github.com/Relintai/broken_seals/releases) repo.
## Godot Version Support ## Pandemonium Version Support
3.2 - Will likely work, probably needs changes by now. (TODO check.)\ 3.2 - Will likely work, probably needs changes by now. (TODO check.)\
3.3 - Will more likely work, might need smaller changes by now. (TODO check.)\ 3.3 - Will more likely work, might need smaller changes by now. (TODO check.)\
@ -56,7 +56,7 @@ This is the basic Minecraft-style lib rary. Use this if you just have one textur
### TerraLibraryMerger ### TerraLibraryMerger
You will only have this if your godot also contains https://github.com/Relintai/texture_packer You will only have this if your pandemonium also contains https://github.com/Relintai/texture_packer
You can assign any texture to your surfaces with this, and it will merge them together. You can assign any texture to your surfaces with this, and it will merge them together.
@ -64,7 +64,7 @@ You can assign any texture to your surfaces with this, and it will merge them to
(PCM = Per Chunk Material) (PCM = Per Chunk Material)
You will only have this if your godot also contains https://github.com/Relintai/texture_packer You will only have this if your pandemonium also contains https://github.com/Relintai/texture_packer
You can assign any texture to your surfaces with this, and it will merge them together, but it will do it for every required chunk/voxel combination. You can assign any texture to your surfaces with this, and it will merge them together, but it will do it for every required chunk/voxel combination.
@ -184,20 +184,20 @@ They won't get reset, so for example if you want all your vertices to have a cer
## Compiling ## Compiling
First make sure that you can compile godot. See the official docs: https://docs.godotengine.org/en/3.x/development/compiling/index.html First make sure that you can compile pandemonium. See the official docs: https://docs.pandemoniumengine.org/en/3.x/development/compiling/index.html
1. Clone the engine if you haven't already: 1. Clone the engine if you haven't already:
If you want Godot 3.x: If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot``` ```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory: 2. go into the modules folder inside the engine's directory:
```cd godot``` \ ```cd pandemonium``` \
```cd modules``` ```cd modules```
3. clone this repository 3. clone this repository
@ -215,7 +215,7 @@ If you want Godot 4.0:
```cd ..``` ```cd ..```
6. Compile godot. 6. Compile pandemonium.
For example: For example:

20
modules/texture_packer.md
View File

@ -1,6 +1,6 @@
# Texture Packer for the Godot Engine # Texture Packer for the Pandemonium Engine
This is a texture packer engine module, for the Godot Engine. This is a texture packer engine module, for the Pandemonium Engine.
It can create texture atlases for you even in the running game. It can create texture atlases for you even in the running game.
@ -8,7 +8,7 @@ It uses the legacy version of [rectpack2D](https://github.com/TeamHypersomnia/re
It should work on all platforms. It should work on all platforms.
It supports both godot 3.2 and 4.0 (master [last tested commit](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only It supports both pandemonium 3.2 and 4.0 (master [last tested commit](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only
check whether it works from time to time. check whether it works from time to time.
# Pre-built binaries # Pre-built binaries
@ -20,17 +20,17 @@ repo, should you want to. It contains all my modules.
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -39,7 +39,7 @@ cd ./godot/modules/
git clone https://github.com/Relintai/texture_packer texture_packer git clone https://github.com/Relintai/texture_packer texture_packer
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)
# Features and Usage # Features and Usage

18
modules/thread_pool.md
View File

@ -1,6 +1,6 @@
# Thread pool module # Thread pool module
A c++ Godot engine module, that will help you with threading. A c++ Pandemonium engine module, that will help you with threading.
It can also work if threads are not available (like on the javascript backend), in this case it runs jobs on the It can also work if threads are not available (like on the javascript backend), in this case it runs jobs on the
main thread. Jobs themselves can also distribute their work onto multiple frames, and you can set how much time main thread. Jobs themselves can also distribute their work onto multiple frames, and you can set how much time
@ -119,18 +119,18 @@ It's api is still a bit messy, it will be cleaned up (hopefully very soon).
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
[last tested commit](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540) [last tested commit](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -139,6 +139,6 @@ cd ./godot/modules/
git clone https://github.com/Relintai/thread_pool thread_pool git clone https://github.com/Relintai/thread_pool thread_pool
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

20
modules/ui_extensions.md
View File

@ -1,8 +1,8 @@
# UI Extensions # UI Extensions
This is a c++ engine module for the Godot engine, containing smaller utilities. This is a c++ engine module for the Pandemonium engine, containing smaller utilities.
It supports both godot 3.2 and 4.0 (master [last tested commit](https://github.com/godotengine/godot/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only It supports both pandemonium 3.2 and 4.0 (master [last tested commit](https://github.com/pandemoniumengine/pandemonium/commit/b7e10141197fdd9b0dbc4cfa7890329510d36540)). Note that since 4.0 is still in very early stages I only
check whether it works from time to time. check whether it works from time to time.
# Pre-built binaries # Pre-built binaries
@ -18,7 +18,7 @@ A `Control` based button, that handles multitouch properly.
An `inputEventKey` implementation, that matches actions exactly. An `inputEventKey` implementation, that matches actions exactly.
For example with the default godot implementation if you have an action that gets triggered For example with the default pandemonium implementation if you have an action that gets triggered
with the key `E` then `Ctrl-E` will also trigger it. with the key `E` then `Ctrl-E` will also trigger it.
This has the side effect, that if you bind an action to `E`, and an another one to `Ctrl-E`, This has the side effect, that if you bind an action to `E`, and an another one to `Ctrl-E`,
@ -53,17 +53,17 @@ I recommend putting this code into a singleton.
1. Get the source code for the engine. 1. Get the source code for the engine.
If you want Godot 3.2: If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot``` ```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. Go into Godot's modules directory. 2. Go into Pandemonium's modules directory.
``` ```
cd ./godot/modules/ cd ./pandemonium/modules/
``` ```
3. Clone this repository 3. Clone this repository
@ -72,7 +72,7 @@ cd ./godot/modules/
git clone https://github.com/Relintai/ui_extensions ui_extensions git clone https://github.com/Relintai/ui_extensions ui_extensions
``` ```
4. Build Godot. [Tutorial](https://docs.godotengine.org/en/latest/development/compiling/index.html) 4. Build Pandemonium. [Tutorial](https://docs.pandemoniumengine.org/en/latest/development/compiling/index.html)

24
modules/voxelman.md
View File

@ -1,12 +1,12 @@
# Voxelman # Voxelman
A voxel engine for godot, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed. A voxel engine for pandemonium, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed.
This is an engine module! Which means that you will need to compile it into Godot! [See the compiling section here.](#compiling) This is an engine module! Which means that you will need to compile it into Pandemonium! [See the compiling section here.](#compiling)
You can find a demonstration project (with pre-built binaries) here: https://github.com/Relintai/the_tower You can find a demonstration project (with pre-built binaries) here: https://github.com/Relintai/the_tower
## Godot Version Support ## Pandemonium Version Support
I'm currently mostly using [Terraman](https://github.com/Relintai/terraman) instead of this, so it might get temporarily a bit behind.\ I'm currently mostly using [Terraman](https://github.com/Relintai/terraman) instead of this, so it might get temporarily a bit behind.\
If compile breaks, and I don't notice please report. If compile breaks, and I don't notice please report.
@ -52,7 +52,7 @@ This is the basic Minecraft-style lib rary. Use this if you just have one textur
### VoxelLibraryMerger ### VoxelLibraryMerger
You will only have this if your godot also contains https://github.com/Relintai/texture_packer You will only have this if your pandemonium also contains https://github.com/Relintai/texture_packer
You can assign any texture to your surfaces with this, and it will merge them together. You can assign any texture to your surfaces with this, and it will merge them together.
@ -60,7 +60,7 @@ You can assign any texture to your surfaces with this, and it will merge them to
(PCM = Per Chunk Material) (PCM = Per Chunk Material)
You will only have this if your godot also contains https://github.com/Relintai/texture_packer You will only have this if your pandemonium also contains https://github.com/Relintai/texture_packer
You can assign any texture to your surfaces with this, and it will merge them together, but it will do it for every required chunk/voxel combination. You can assign any texture to your surfaces with this, and it will merge them together, but it will do it for every required chunk/voxel combination.
@ -189,20 +189,20 @@ They won't get reset, so for example if you want all your vertices to have a cer
## Compiling ## Compiling
First make sure that you can compile godot. See the official docs: https://docs.godotengine.org/en/3.x/development/compiling/index.html First make sure that you can compile pandemonium. See the official docs: https://docs.pandemoniumengine.org/en/3.x/development/compiling/index.html
1. Clone the engine if you haven't already: 1. Clone the engine if you haven't already:
If you want Godot 3.x: If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot``` ```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0: If you want Pandemonium 4.0:
```git clone https://github.com/godotengine/godot.git godot``` ```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory: 2. go into the modules folder inside the engine's directory:
```cd godot``` \ ```cd pandemonium``` \
```cd modules``` ```cd modules```
3. clone this repository 3. clone this repository
@ -220,7 +220,7 @@ If you want Godot 4.0:
```cd ..``` ```cd ..```
6. Compile godot. 6. Compile pandemonium.
For example: For example:

2
tutorials/first_2d_game/01.project_setup.md
View File

@ -5,7 +5,7 @@ Setting up the project
In this short first part, we'll set up and organize the project. In this short first part, we'll set up and organize the project.
Launch Godot and create a new project. Launch Pandemonium and create a new project.
![](img/new-project-button.png) ![](img/new-project-button.png)

4
tutorials/first_2d_game/02.player_scene.md
View File

@ -20,7 +20,7 @@ what the object *is*. Click the "Other Node" button and add an `Area2D
![](img/add_node.png) ![](img/add_node.png)
Godot will display a warning icon next to the node in the scene tree. You can Pandemonium will display a warning icon next to the node in the scene tree. You can
ignore it for now. We will address it later. ignore it for now. We will address it later.
With `Area2D` we can detect objects that overlap or run into the player. With `Area2D` we can detect objects that overlap or run into the player.
@ -39,7 +39,7 @@ Save the scene. Click Scene -> Save, or press :kbd:`Ctrl + S` on Windows/Linux
or :kbd:`Cmd + S` on macOS. or :kbd:`Cmd + S` on macOS.
Note: Note:
For this project, we will be following the Godot naming conventions. For this project, we will be following the Pandemonium naming conventions.
- **GDScript**: Classes (nodes) use PascalCase, variables and - **GDScript**: Classes (nodes) use PascalCase, variables and
functions use snake_case, and constants use ALL_CAPS (See functions use snake_case, and constants use ALL_CAPS (See

8
tutorials/first_2d_game/03.coding_the_player.md
View File

@ -134,7 +134,7 @@ diagonal movement.
Tip: Tip:
If you've never used vector math before, or need a refresher, you can If you've never used vector math before, or need a refresher, you can
see an explanation of vector usage in Godot at `doc_vector_math`. see an explanation of vector usage in Pandemonium at `doc_vector_math`.
It's good to know but won't be necessary for the rest of this tutorial. It's good to know but won't be necessary for the rest of this tutorial.
We also check whether the player is moving so we can call `play()` or We also check whether the player is moving so we can call `play()` or
@ -242,7 +242,7 @@ Preparing for collisions
~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~
We want `Player` to detect when it's hit by an enemy, but we haven't made any We want `Player` to detect when it's hit by an enemy, but we haven't made any
enemies yet! That's OK, because we're going to use Godot's *signal* enemies yet! That's OK, because we're going to use Pandemonium's *signal*
functionality to make it work. functionality to make it work.
Add the following at the top of the script, after `extends Area2D`: Add the following at the top of the script, after `extends Area2D`:
@ -264,7 +264,7 @@ Notice our custom "hit" signal is there as well! Since our enemies are going to
be `RigidBody2D` nodes, we want the `body_entered(body: Node)` signal. This be `RigidBody2D` nodes, we want the `body_entered(body: Node)` signal. This
signal will be emitted when a body contacts the player. Click "Connect.." and signal will be emitted when a body contacts the player. Click "Connect.." and
the "Connect a Signal" window appears. We don't need to change any of these the "Connect a Signal" window appears. We don't need to change any of these
settings so click "Connect" again. Godot will automatically create a function in settings so click "Connect" again. Pandemonium will automatically create a function in
your player's script. your player's script.
![](img/player_signal_connection.png) ![](img/player_signal_connection.png)
@ -289,7 +289,7 @@ more than once.
Note: Note:
Disabling the area's collision shape can cause an error if it happens Disabling the area's collision shape can cause an error if it happens
in the middle of the engine's collision processing. Using in the middle of the engine's collision processing. Using
`set_deferred()` tells Godot to wait to disable the shape until it's `set_deferred()` tells Pandemonium to wait to disable the shape until it's
safe to do so. safe to do so.
The last piece is to add a function we can call to reset the player when The last piece is to add a function we can call to reset the player when

2
tutorials/first_2d_game/05.the_main_game_scene.md
View File

@ -183,7 +183,7 @@ gdscript GDScript
add_child(mob) add_child(mob)
``` ```
.. important:: Why `PI`? In functions requiring angles, Godot uses *radians*, .. important:: Why `PI`? In functions requiring angles, Pandemonium uses *radians*,
not degrees. Pi represents a half turn in radians, about not degrees. Pi represents a half turn in radians, about
`3.1415` (there is also `TAU` which is equal to `2 * PI`). `3.1415` (there is also `TAU` which is equal to `2 * PI`).
If you're more comfortable working with degrees, you'll need to If you're more comfortable working with degrees, you'll need to

4
tutorials/first_2d_game/07.finishing-up.md
View File

@ -64,7 +64,7 @@ the name `start_game`.
Now when the start button appears, you can either click it or press :kbd:`Enter` Now when the start button appears, you can either click it or press :kbd:`Enter`
to start the game. to start the game.
And with that, you completed your first 2D game in Godot. And with that, you completed your first 2D game in Pandemonium.
![](img/dodge_preview.gif) ![](img/dodge_preview.gif)
@ -76,4 +76,4 @@ There's still much to learn, but you can take a moment to appreciate what you
achieved. achieved.
And when you're ready, you can move on to `doc_your_first_3d_game` to learn And when you're ready, you can move on to `doc_your_first_3d_game` to learn
to create a complete 3D game from scratch, in Godot. to create a complete 3D game from scratch, in Pandemonium.

16
tutorials/first_2d_game/index.md
View File

@ -4,16 +4,16 @@ Your first 2D game
================== ==================
In this step-by-step tutorial series, you will create your first complete 2D In this step-by-step tutorial series, you will create your first complete 2D
game with Godot. By the end of the series, you will have a simple yet complete game with Pandemonium. By the end of the series, you will have a simple yet complete
game of your own, like the image below. game of your own, like the image below.
|image0| |image0|
You will learn how the Godot editor works, how to structure a project, and build You will learn how the Pandemonium editor works, how to structure a project, and build
a 2D game. a 2D game.
Note: Note:
This project is an introduction to the Godot engine. It assumes that This project is an introduction to the Pandemonium engine. It assumes that
you have some programming experience already. If you're new to you have some programming experience already. If you're new to
programming entirely, you should start here: `doc_scripting`. programming entirely, you should start here: `doc_scripting`.
@ -22,7 +22,7 @@ enemies for as long as possible.
You will learn to: You will learn to:
- Create a complete 2D game with the Godot editor. - Create a complete 2D game with the Pandemonium editor.
- Structure a simple game project. - Structure a simple game project.
- Move the player character and change its sprite. - Move the player character and change its sprite.
- Spawn random enemies. - Spawn random enemies.
@ -36,11 +36,11 @@ recommend you to start with this one, though.
**Why start with 2D?** **Why start with 2D?**
3D games are much more complex than 2D ones. It would be best if you stuck to 2D 3D games are much more complex than 2D ones. It would be best if you stuck to 2D
until you understood the game development process and how to use Godot well. until you understood the game development process and how to use Pandemonium well.
You can find a completed version of this project at this location: You can find a completed version of this project at this location:
- https://github.com/godotengine/godot-demo-projects - https://github.com/pandemoniumengine/pandemonium-demo-projects
Prerequisites Prerequisites
------------- -------------
@ -49,8 +49,8 @@ This step-by-step tutorial is intended for beginners who followed the complete
`Getting Started <toc-learn-step_by_step )`. `Getting Started <toc-learn-step_by_step )`.
If you're an experienced programmer, you can find the complete demo's source If you're an experienced programmer, you can find the complete demo's source
code here: `Godot demo projects code here: `Pandemonium demo projects
( https://github.com/godotengine/godot-demo-projects )`. ( https://github.com/pandemoniumengine/pandemonium-demo-projects )`.
We prepared some game assets you'll need to download so we can jump straight to We prepared some game assets you'll need to download so we can jump straight to
the code. the code.

8
tutorials/first_3d_game/01.game_setup.md
View File

@ -6,19 +6,19 @@ Setting up the game area
In this first part, we're going to set up the game area. Let's get started by In this first part, we're going to set up the game area. Let's get started by
importing the start assets and setting up the game scene. importing the start assets and setting up the game scene.
We've prepared a Godot project with the 3D models and sounds we'll use for this We've prepared a Pandemonium project with the 3D models and sounds we'll use for this
tutorial, linked in the index page. If you haven't done so yet, you can download tutorial, linked in the index page. If you haven't done so yet, you can download
the archive here: `Squash the Creeps assets the archive here: `Squash the Creeps assets
( https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.0.0 )`. ( https://github.com/GDQuest/pandemonium-3d-dodge-the-creeps/releases/tag/1.0.0 )`.
Once you downloaded it, extract the .zip archive on your computer. Open the Once you downloaded it, extract the .zip archive on your computer. Open the
Godot project manager and click the *Import* button. Pandemonium project manager and click the *Import* button.
|image1| |image1|
In the import popup, enter the full path to the freshly created directory In the import popup, enter the full path to the freshly created directory
`squash_the_creeps_start/`. You can click the *Browse* button on the right to `squash_the_creeps_start/`. You can click the *Browse* button on the right to
open a file browser and navigate to the `project.godot` file the folder open a file browser and navigate to the `project.pandemonium` file the folder
contains. contains.
|image2| |image2|

6
tutorials/first_3d_game/02.player_input.md
View File

@ -46,7 +46,7 @@ Note:
The `.glb` files contain 3D scene data based on the open-source GLTF 2.0 The `.glb` files contain 3D scene data based on the open-source GLTF 2.0
specification. They're a modern and powerful alternative to a proprietary format specification. They're a modern and powerful alternative to a proprietary format
like FBX, which Godot also supports. To produce these files, we designed the like FBX, which Pandemonium also supports. To produce these files, we designed the
model in `Blender 3D ( https://www.blender.org/ )` and exported it to GLTF. model in `Blender 3D ( https://www.blender.org/ )` and exported it to GLTF.
As with all kinds of physics nodes, we need a collision shape for our character As with all kinds of physics nodes, we need a collision shape for our character
@ -78,7 +78,7 @@ Creating input actions
---------------------- ----------------------
To move the character, we will listen to the player's input, like pressing the To move the character, we will listen to the player's input, like pressing the
arrow keys. In Godot, while we could write all the key bindings in code, there's arrow keys. In Pandemonium, while we could write all the key bindings in code, there's
a powerful system that allows you to assign a label to a set of keys and a powerful system that allows you to assign a label to a set of keys and
buttons. This simplifies our scripts and makes them more readable. buttons. This simplifies our scripts and makes them more readable.
@ -93,7 +93,7 @@ can bind keys to these actions.
|image7| |image7|
Godot projects come with some predefined actions designed for user interface Pandemonium projects come with some predefined actions designed for user interface
design, which we could use here. But we're defining our own to support gamepads. design, which we could use here. But we're defining our own to support gamepads.
We're going to name our actions `move_left`, `move_right`, `move_forward`, We're going to name our actions `move_left`, `move_right`, `move_forward`,

2
tutorials/first_3d_game/04.mob_scene.md
View File

@ -55,7 +55,7 @@ that. Each mob instance has both a memory and a processing cost, and we don't
want to pay for it when the mob's outside the screen. want to pay for it when the mob's outside the screen.
Once a monster leaves the screen, we don't need it anymore, so we can delete it. Once a monster leaves the screen, we don't need it anymore, so we can delete it.
Godot has a node that detects when objects leave the screen, Pandemonium has a node that detects when objects leave the screen,
*VisibilityNotifier*, and we're going to use it to destroy our mobs. *VisibilityNotifier*, and we're going to use it to destroy our mobs.
Note: Note:

4
tutorials/first_3d_game/06.jump_and_squash.md
View File

@ -156,7 +156,7 @@ Let's add the squash mechanic next. We're going to make the character bounce
over monsters and kill them at the same time. over monsters and kill them at the same time.
We need to detect collisions with a monster and to differentiate them from We need to detect collisions with a monster and to differentiate them from
collisions with the floor. To do so, we can use Godot's `group collisions with the floor. To do so, we can use Pandemonium's `group
( doc_groups )` tagging feature. ( doc_groups )` tagging feature.
Open the scene `Mob.tscn` again and select the *Mob* node. Go to the *Node* Open the scene `Mob.tscn` again and select the *Mob* node. Go to the *Node*
@ -195,7 +195,7 @@ gdscript GDScript
``` ```
Then, at the bottom of `physics_process()`, add the following loop. With Then, at the bottom of `physics_process()`, add the following loop. With
`move_and_slide()`, Godot makes the body move sometimes multiple times in a `move_and_slide()`, Pandemonium makes the body move sometimes multiple times in a
row to smooth out the character's motion. So we have to loop over all collisions row to smooth out the character's motion. So we have to loop over all collisions
that may have happened. that may have happened.

8
tutorials/first_3d_game/08.score_and_replay.md
View File

@ -79,7 +79,7 @@ DynamicFont supports the following formats:
- TrueType (`.ttf`) - TrueType (`.ttf`)
- OpenType (`.otf`) - OpenType (`.otf`)
- Web Open Font Format 1 (`.woff`) - Web Open Font Format 1 (`.woff`)
- Web Open Font Format 2 (`.woff2`, since Godot 3.5) - Web Open Font Format 2 (`.woff2`, since Pandemonium 3.5)
In the *FileSystem* dock, expand the `fonts` directory and click and drag the In the *FileSystem* dock, expand the `fonts` directory and click and drag the
`Montserrat-Medium.ttf` file we included in the project onto the *Font Data*. `Montserrat-Medium.ttf` file we included in the project onto the *Font Data*.
@ -148,7 +148,7 @@ gdscript GDScript
``` ```
The second line uses the value of the `score` variable to replace the The second line uses the value of the `score` variable to replace the
placeholder `%s`. When using this feature, Godot automatically converts values placeholder `%s`. When using this feature, Pandemonium automatically converts values
to text, which is convenient to output text in labels or using the `print()` to text, which is convenient to output text in labels or using the `print()`
function. function.
@ -272,14 +272,14 @@ Adding music
------------ ------------
To add music that plays continuously in the background, we're going to use To add music that plays continuously in the background, we're going to use
another feature in Godot: `autoloads ( doc_singletons_autoload )`. another feature in Pandemonium: `autoloads ( doc_singletons_autoload )`.
To play audio, all you need to do is add an *AudioStreamPlayer* node to your To play audio, all you need to do is add an *AudioStreamPlayer* node to your
scene and attach an audio file to it. When you start the scene, it can play scene and attach an audio file to it. When you start the scene, it can play
automatically. However, when you reload the scene, like we do to play again, the automatically. However, when you reload the scene, like we do to play again, the
audio nodes are also reset, and the music starts back from the beginning. audio nodes are also reset, and the music starts back from the beginning.
You can use the autoload feature to have Godot load a node or a scene You can use the autoload feature to have Pandemonium load a node or a scene
automatically at the start of the game, outside the current scene. You can also automatically at the start of the game, outside the current scene. You can also
use it to create globally accessible objects. use it to create globally accessible objects.

4
tutorials/first_3d_game/09.adding_animations.md
View File

@ -3,7 +3,7 @@
Character animation Character animation
=================== ===================
In this final lesson, we'll use Godot's built-in animation tools to make our In this final lesson, we'll use Pandemonium's built-in animation tools to make our
characters float and flap. You'll learn to design animations in the editor and characters float and flap. You'll learn to design animations in the editor and
use code to make your game feel alive. use code to make your game feel alive.
@ -218,7 +218,7 @@ gdscript GDScript
Animating the mobs Animating the mobs
------------------ ------------------
Here's another nice trick with animations in Godot: as long as you use a similar Here's another nice trick with animations in Pandemonium: as long as you use a similar
node structure, you can copy them to different scenes. node structure, you can copy them to different scenes.
For example, both the *Mob* and the *Player* scenes have a *Pivot* and a For example, both the *Mob* and the *Player* scenes have a *Pivot* and a

12
tutorials/first_3d_game/going_further.md
View File

@ -4,27 +4,27 @@ Going further
============= =============
You can pat yourself on the back for having completed your first 3D game with You can pat yourself on the back for having completed your first 3D game with
Godot. Pandemonium.
In this series, we went over a wide range of techniques and editor features. In this series, we went over a wide range of techniques and editor features.
Hopefully, you’ve witnessed how intuitive Godot’s scene system can be and Hopefully, you’ve witnessed how intuitive Pandemonium’s scene system can be and
learned a few tricks you can apply in your projects. learned a few tricks you can apply in your projects.
But we just scratched the surface: Godot has a lot more in store for you to save But we just scratched the surface: Pandemonium has a lot more in store for you to save
time creating games. And you can learn all that by browsing the documentation. time creating games. And you can learn all that by browsing the documentation.
Where should you begin? Below, you’ll find a few pages to start exploring and Where should you begin? Below, you’ll find a few pages to start exploring and
build upon what you’ve learned so far. build upon what you’ve learned so far.
But before that, here’s a link to download a completed version of the project: But before that, here’s a link to download a completed version of the project:
`( https://github.com/GDQuest/godot-3d-dodge-the-creeps )`. `( https://github.com/GDQuest/pandemonium-3d-dodge-the-creeps )`.
Exploring the manual Exploring the manual
-------------------- --------------------
The manual is your ally whenever you have a doubt or you’re curious about a The manual is your ally whenever you have a doubt or you’re curious about a
feature. It does not contain tutorials about specific game genres or mechanics. feature. It does not contain tutorials about specific game genres or mechanics.
Instead, it explains how Godot works in general. In it, you will find Instead, it explains how Pandemonium works in general. In it, you will find
information about 2D, 3D, physics, rendering and performance, and much more. information about 2D, 3D, physics, rendering and performance, and much more.
Here are the sections we recommend you to explore next: Here are the sections we recommend you to explore next:
@ -39,4 +39,4 @@ You can start with these or, if you prefer, look at the sidebar menu on the left
and pick your options. and pick your options.
We hope you enjoyed this tutorial series, and we’re looking forward to seeing We hope you enjoyed this tutorial series, and we’re looking forward to seeing
what you achieve using Godot. what you achieve using Pandemonium.

6
tutorials/first_3d_game/index.md
View File

@ -4,7 +4,7 @@ Your first 3D game
================== ==================
In this step-by-step tutorial series, you will create your first complete 3D In this step-by-step tutorial series, you will create your first complete 3D
game with Godot. By the end of the series, you will have a simple yet finished game with Pandemonium. By the end of the series, you will have a simple yet finished
project of your own like the animated gif below. project of your own like the animated gif below.
|image0| |image0|
@ -31,7 +31,7 @@ This tutorial is for beginners who followed the complete getting started series.
We'll start slow with detailed instructions and shorten them as we do similar We'll start slow with detailed instructions and shorten them as we do similar
steps. If you're an experienced programmer, you can browse the complete demo's steps. If you're an experienced programmer, you can browse the complete demo's
source code here: `Squash the Creep source code source code here: `Squash the Creep source code
( https://github.com/GDQuest/godot-3d-dodge-the-creeps/ )`. ( https://github.com/GDQuest/pandemonium-3d-dodge-the-creeps/ )`.
Note: Note:
@ -43,7 +43,7 @@ Note:
We prepared some game assets so we can jump straight to the code. You can We prepared some game assets so we can jump straight to the code. You can
download them here: `Squash the Creeps assets download them here: `Squash the Creeps assets
( https://github.com/GDQuest/godot-3d-dodge-the-creeps/releases/tag/1.1.0 )`. ( https://github.com/GDQuest/pandemonium-3d-dodge-the-creeps/releases/tag/1.1.0 )`.
We will first work on a basic prototype for the player's movement. We will then We will first work on a basic prototype for the player's movement. We will then
add the monsters that we'll spawn randomly around the screen. After that, we'll add the monsters that we'll spawn randomly around the screen. After that, we'll

10
tutorials/introduction/first_look_at_the_editor.md
View File

@ -6,10 +6,10 @@
First look at Godot's editor First look at Pandemonium's editor
============================ ============================
This page will give you a brief overview of Godot's interface. We're going to This page will give you a brief overview of Pandemonium's interface. We're going to
look at the different main screens and docks to help you situate yourself. look at the different main screens and docks to help you situate yourself.
See also: See also:
@ -19,7 +19,7 @@ See also:
The Project manager The Project manager
------------------- -------------------
When you launch Godot, the first window you see is the Project Manager. In the When you launch Pandemonium, the first window you see is the Project Manager. In the
default tab, "Projects," you can manage existing projects, import or create new default tab, "Projects," you can manage existing projects, import or create new
ones, and more. ones, and more.
@ -37,7 +37,7 @@ English (EN).
![](img/editor_intro_language.png) ![](img/editor_intro_language.png)
First look at Godot's editor First look at Pandemonium's editor
---------------------------- ----------------------------
When you open a new or an existing project, the editor's interface appears. When you open a new or an existing project, the editor's interface appears.
@ -131,7 +131,7 @@ See also:
Integrated class reference Integrated class reference
-------------------------- --------------------------
Godot comes with a built-in class reference. Pandemonium comes with a built-in class reference.
You can search for information about a class, method, property, constant, or You can search for information about a class, method, property, constant, or
signal by any one of the following methods: signal by any one of the following methods:

58
tutorials/introduction/godot_design_philosophy.md
View File

@ -1,33 +1,33 @@
Godot's design philosophy Pandemonium's design philosophy
========================= =========================
Now that you've gotten your feet wet, let's talk about Godot's design. Now that you've gotten your feet wet, let's talk about Pandemonium's design.
**Every game engine is different and fits different needs.** **Every game engine is different and fits different needs.**
Not only do they offer a range of features, but the design of each engine Not only do they offer a range of features, but the design of each engine
is unique. This leads to different workflows and different ways to form is unique. This leads to different workflows and different ways to form
your games' structures. This all stems from their respective design philosophies. your games' structures. This all stems from their respective design philosophies.
This page is here to help you understand how Godot works, starting This page is here to help you understand how Pandemonium works, starting
with some of its core pillars. It is not a list of available features, nor with some of its core pillars. It is not a list of available features, nor
is it an engine comparison. To know if any engine can be a good fit for is it an engine comparison. To know if any engine can be a good fit for
your project, you need to try it out for yourself and your project, you need to try it out for yourself and
understand its design and limitations. understand its design and limitations.
Please watch Please watch
`Godot explained in 5 minutes ( https://www.youtube.com/watch?v=KjX5llYZ5eQ )` `Pandemonium explained in 5 minutes ( https://www.youtube.com/watch?v=KjX5llYZ5eQ )`
if you're looking for an overview of the engine's features. if you're looking for an overview of the engine's features.
Object-oriented design and composition Object-oriented design and composition
-------------------------------------- --------------------------------------
Godot embraces object-oriented design at its core with its flexible Pandemonium embraces object-oriented design at its core with its flexible
scene system and Node hierarchy. It tries to stay away from strict scene system and Node hierarchy. It tries to stay away from strict
programming patterns to offer an intuitive way to structure your game. programming patterns to offer an intuitive way to structure your game.
For one, Godot lets you **compose or aggregate** scenes. For one, Pandemonium lets you **compose or aggregate** scenes.
It's like nested prefabs: you can create a BlinkingLight scene and It's like nested prefabs: you can create a BlinkingLight scene and
a BrokenLantern scene that uses the BlinkingLight. a BrokenLantern scene that uses the BlinkingLight.
Then, create a city filled with BrokenLanterns. Then, create a city filled with BrokenLanterns.
@ -36,7 +36,7 @@ BrokenLanterns in the city will update instantly.
On top of that, you can **inherit** from any scene. On top of that, you can **inherit** from any scene.
A Godot scene could be a Weapon, a Character, an Item, a Door, a Level, A Pandemonium scene could be a Weapon, a Character, an Item, a Door, a Level,
part of a level… anything you'd like. It works like a class in pure code, part of a level… anything you'd like. It works like a class in pure code,
except you're free to design it by using the editor, using only the except you're free to design it by using the editor, using only the
code, or mixing and matching the two. code, or mixing and matching the two.
@ -49,13 +49,13 @@ structure matches the game's design.
|image0| |image0|
Also note that Godot offers many different types of objects called Also note that Pandemonium offers many different types of objects called
nodes, each with a specific purpose. Nodes are part of a tree and always nodes, each with a specific purpose. Nodes are part of a tree and always
inherit from their parents up to the Node class. Although the engine inherit from their parents up to the Node class. Although the engine
does feature some nodes like collision shapes that a parent physics does feature some nodes like collision shapes that a parent physics
body will use, most nodes work independently from one another. body will use, most nodes work independently from one another.
In other words, Godot's nodes do not work like components in some In other words, Pandemonium's nodes do not work like components in some
other game engines. other game engines.
|image1| |image1|
@ -67,7 +67,7 @@ to draw custom shapes and render with a custom shader.
All-inclusive package All-inclusive package
--------------------- ---------------------
Godot tries to provide its own tools to answer most common Pandemonium tries to provide its own tools to answer most common
needs. It has a dedicated scripting workspace, an animation editor, a needs. It has a dedicated scripting workspace, an animation editor, a
tilemap editor, a shader editor, a debugger, a profiler, tilemap editor, a shader editor, a debugger, a profiler,
the ability to hot-reload locally and on remote devices, etc. the ability to hot-reload locally and on remote devices, etc.
@ -77,9 +77,9 @@ the ability to hot-reload locally and on remote devices, etc.
The goal is to offer a full package to create games and a continuous The goal is to offer a full package to create games and a continuous
user experience. You can still work with external programs as long as user experience. You can still work with external programs as long as
there is an import plugin for it. Or you can create one, like the `Tiled there is an import plugin for it. Or you can create one, like the `Tiled
Map Importer ( https://github.com/vnen/godot-tiled-importer )`. Map Importer ( https://github.com/vnen/pandemonium-tiled-importer )`.
That is also partly why Godot offers its own programming languages That is also partly why Pandemonium offers its own programming languages
GDScript and VisualScript, along with C#. They're designed for the needs GDScript and VisualScript, along with C#. They're designed for the needs
of game developers and game designers, and they're tightly integrated in of game developers and game designers, and they're tightly integrated in
the engine and the editor. the engine and the editor.
@ -100,30 +100,30 @@ to create new code blocks.*
Note that the 3D workspace doesn't feature as many tools as the 2D workspace. Note that the 3D workspace doesn't feature as many tools as the 2D workspace.
You'll need external programs or add-ons to edit terrains, animate complex characters, and so on. You'll need external programs or add-ons to edit terrains, animate complex characters, and so on.
Godot provides a complete API to extend the editor's functionality using Pandemonium provides a complete API to extend the editor's functionality using
game code. See `The Godot editor is a Godot game` below. game code. See `The Pandemonium editor is a Pandemonium game` below.
|image4| |image4|
*A State Machine editor plugin in Godot 2 by kubecz3k. It lets you *A State Machine editor plugin in Pandemonium 2 by kubecz3k. It lets you
manage states and transitions visually.* manage states and transitions visually.*
Warning: Warning:
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )` `Pandemonium 4.0 will remove VisualScript from core entirely. ( https://pandemoniumengine.org/article/pandemonium-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended. As a result, creating new projects using visual scripting in Pandemonium is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension. Future Pandemonium 4.x releases may have VisualScript reimplemented as an extension.
While Godot 3.x will keep VisualScript supported, we recommend While Pandemonium 3.x will keep VisualScript supported, we recommend
`trying out GDScript <toc-learn-scripting-gdscript )` instead, `trying out GDScript <toc-learn-scripting-gdscript )` instead,
especially if you intend to migrate your project to Godot 4. especially if you intend to migrate your project to Pandemonium 4.
Open source Open source
----------- -----------
Godot offers a fully open source codebase under the **MIT license**. Pandemonium offers a fully open source codebase under the **MIT license**.
This means all the technologies that ship with it have to be Free This means all the technologies that ship with it have to be Free
(as in freedom) as well. (as in freedom) as well.
For the most part, they're developed from the ground up by contributors. For the most part, they're developed from the ground up by contributors.
@ -135,18 +135,18 @@ third-party plugins instead.
On the other hand, an open codebase means you can **learn from and extend On the other hand, an open codebase means you can **learn from and extend
the engine** to your heart's content. You can also debug games easily, the engine** to your heart's content. You can also debug games easily,
as Godot will print errors with a stack trace, even if they come from the engine itself. as Pandemonium will print errors with a stack trace, even if they come from the engine itself.
Note: Note:
This **does not affect the work you do with Godot** in any way: there's This **does not affect the work you do with Pandemonium** in any way: there's
no strings attached to the engine or anything you make with it. no strings attached to the engine or anything you make with it.
Community-driven Community-driven
---------------- ----------------
**Godot is made by its community, for the community, and for all game **Pandemonium is made by its community, for the community, and for all game
creators out there.** It's the needs of the users and open discussions creators out there.** It's the needs of the users and open discussions
that drive the core updates. New features from the core developers often that drive the core updates. New features from the core developers often
focus on what will benefit the most users first. focus on what will benefit the most users first.
@ -157,10 +157,10 @@ programmers work on features they may need themselves, so you'll see
improvements in all corners of the engine at the same time in every improvements in all corners of the engine at the same time in every
major release. major release.
The Godot editor is a Godot game The Pandemonium editor is a Pandemonium game
-------------------------------- --------------------------------
The Godot editor runs on the game engine. It uses the engine's own UI The Pandemonium editor runs on the game engine. It uses the engine's own UI
system, it can hot-reload code and scenes when you test your projects, system, it can hot-reload code and scenes when you test your projects,
or run game code in the editor. This means you can **use the same code** or run game code in the editor. This means you can **use the same code**
and scenes for your games, or **build plugins and extend the editor.** and scenes for your games, or **build plugins and extend the editor.**
@ -170,7 +170,7 @@ itself. With the `tool` keyword, you can run any game code in the editor.
|image5| |image5|
*RPG in a Box is a voxel RPG editor made with Godot 2. It uses Godot's *RPG in a Box is a voxel RPG editor made with Pandemonium 2. It uses Pandemonium's
UI tools for its node-based programming system and for the rest of the UI tools for its node-based programming system and for the rest of the
interface.* interface.*
@ -184,12 +184,12 @@ Note:
The editor is fully written in C++ and is statically compiled into the The editor is fully written in C++ and is statically compiled into the
binary. This means you can't import it as a typical project that would have a binary. This means you can't import it as a typical project that would have a
`project.godot` file. `project.pandemonium` file.
Separate 2D and 3D engines Separate 2D and 3D engines
-------------------------- --------------------------
Godot offers dedicated 2D and 3D rendering engines. As a result, **the Pandemonium offers dedicated 2D and 3D rendering engines. As a result, **the
base unit for 2D scenes is pixels.** Even though the engines are base unit for 2D scenes is pixels.** Even though the engines are
separate, you can render 2D in 3D, 3D in 2D, and overlay 2D sprites and separate, you can render 2D in 3D, 3D in 2D, and overlay 2D sprites and
interfaces over your 3D world. interfaces over your 3D world.

12
tutorials/introduction/index.md
View File

@ -1,15 +1,15 @@
.. Intention: provide the necessary information to make the most of the getting .. Intention: provide the necessary information to make the most of the getting
started series, answering questions like "do I want to learn Godot?", "how started series, answering questions like "do I want to learn Pandemonium?", "how
does it look and feel?", "how does it work?", and "how do I best learn it?". does it look and feel?", "how does it work?", and "how do I best learn it?".
Introduction Introduction
============ ============
This series will introduce you to Godot and give you an overview of its This series will introduce you to Pandemonium and give you an overview of its
features. features.
In the following pages, you will get answers to questions such as "Is Godot for In the following pages, you will get answers to questions such as "Is Pandemonium for
me?" or "What can I do with Godot?". We will then introduce the engine's most me?" or "What can I do with Pandemonium?". We will then introduce the engine's most
essential concepts, run you through the editor's interface, and give you tips to essential concepts, run you through the editor's interface, and give you tips to
make the most of your time learning it. make the most of your time learning it.
@ -17,8 +17,8 @@ make the most of your time learning it.
:maxdepth: 1 :maxdepth: 1
:name: toc-learn-introduction :name: toc-learn-introduction
introduction_to_godot introduction_to_pandemonium
key_concepts_overview key_concepts_overview
first_look_at_the_editor first_look_at_the_editor
learning_new_features learning_new_features
godot_design_philosophy pandemonium_design_philosophy

34
tutorials/introduction/introduction_to_godot.md
View File

@ -1,9 +1,9 @@
Introduction to Godot Introduction to Pandemonium
===================== =====================
This article is here to help you figure out whether Godot might be a good fit This article is here to help you figure out whether Pandemonium might be a good fit
for you. We will introduce some broad features of the engine to give you a feel for you. We will introduce some broad features of the engine to give you a feel
for what you can achieve with it and answer questions such as "what do I need to for what you can achieve with it and answer questions such as "what do I need to
know to get started?". know to get started?".
@ -11,10 +11,10 @@ know to get started?".
This is by no means an exhaustive overview. We will introduce many more features This is by no means an exhaustive overview. We will introduce many more features
in this getting started series. in this getting started series.
What is Godot? What is Pandemonium?
-------------- --------------
Godot is a general-purpose 2D and 3D game engine designed to support all sorts Pandemonium is a general-purpose 2D and 3D game engine designed to support all sorts
of projects. You can use it to create games or applications you can then release of projects. You can use it to create games or applications you can then release
on desktop or mobile, as well as on the web. on desktop or mobile, as well as on the web.
@ -22,7 +22,7 @@ You can also create console games with it, although you either need strong
programming skills or a developer to port the game for you. programming skills or a developer to port the game for you.
Note: Note:
The Godot team can't provide an open-source console export due to the The Pandemonium team can't provide an open-source console export due to the
licensing terms imposed by console manufacturers. Regardless of the licensing terms imposed by console manufacturers. Regardless of the
engine you use, though, releasing games on consoles is always a lot of engine you use, though, releasing games on consoles is always a lot of
work. You can read more on that here: `doc_consoles`. work. You can read more on that here: `doc_consoles`.
@ -30,18 +30,18 @@ Note:
What can the engine do? What can the engine do?
----------------------- -----------------------
Godot was initially developed in-house by an Argentinan game studio. Its Pandemonium was initially developed in-house by an Argentinan game studio. Its
development started in 2001, and the engine was rewritten and improved development started in 2001, and the engine was rewritten and improved
tremendously since its open-source release in 2014. tremendously since its open-source release in 2014.
Some examples of games created with Godot include Ex-Zodiac and Helms of Fury. Some examples of games created with Pandemonium include Ex-Zodiac and Helms of Fury.
![](img/introduction_ex_zodiac.png) ![](img/introduction_ex_zodiac.png)
![](img/introduction_helms_of_fury.jpg ![](img/introduction_helms_of_fury.jpg
As for applications, the open-source pixel art drawing program Pixelorama is As for applications, the open-source pixel art drawing program Pixelorama is
powered by Godot, and so is the voxel RPG creator RPG in a box. powered by Pandemonium, and so is the voxel RPG creator RPG in a box.
![](img/introduction_rpg_in_a_box.png) ![](img/introduction_rpg_in_a_box.png)
@ -50,7 +50,7 @@ You can find many more examples in the `official showcase videos`.
How does it work and look? How does it work and look?
-------------------------- --------------------------
Godot comes with a fully-fledged game editor with integrated tools to answer the Pandemonium comes with a fully-fledged game editor with integrated tools to answer the
most common needs. It includes a code editor, an animation editor, a tilemap most common needs. It includes a code editor, an animation editor, a tilemap
editor, a shader editor, a debugger, a profiler, and more. editor, a shader editor, a debugger, a profiler, and more.
@ -73,11 +73,11 @@ Programming languages
Let's talk about the available programming languages. Let's talk about the available programming languages.
You can code your games using `GDScript <toc-learn-scripting-gdscript )`, a You can code your games using `GDScript <toc-learn-scripting-gdscript )`, a
Godot-specific and tightly integrated language with a lightweight syntax, or Pandemonium-specific and tightly integrated language with a lightweight syntax, or
`C# <toc-learn-scripting-C# )`, which is popular in the games industry. `C# <toc-learn-scripting-C# )`, which is popular in the games industry.
These are the two main scripting languages we support. These are the two main scripting languages we support.
Godot also supports a node-based visual programming language named Pandemonium also supports a node-based visual programming language named
`VisualScript <toc-learn-scripting-visual_script )`. `VisualScript <toc-learn-scripting-visual_script )`.
With the `GDNative <toc-tutorials-gdnative )` technology, you can also write With the `GDNative <toc-tutorials-gdnative )` technology, you can also write
@ -94,15 +94,15 @@ See also:
see `GDNative third-party bindings see `GDNative third-party bindings
( doc_what_is_gdnative_third_party_bindings )`. ( doc_what_is_gdnative_third_party_bindings )`.
What do I need to know to use Godot? What do I need to know to use Pandemonium?
------------------------------------ ------------------------------------
Godot is a feature-packed game engine. With its thousands of features, there is Pandemonium is a feature-packed game engine. With its thousands of features, there is
a lot to learn. To make the most of it, you need good programming foundations. a lot to learn. To make the most of it, you need good programming foundations.
While we try to make the engine accessible, you will benefit a lot from knowing While we try to make the engine accessible, you will benefit a lot from knowing
how to think like a programmer first. how to think like a programmer first.
Godot relies on the object-oriented programming paradigm. Being comfortable with Pandemonium relies on the object-oriented programming paradigm. Being comfortable with
concepts such as classes and objects will help you code efficiently in it. concepts such as classes and objects will help you code efficiently in it.
If you are entirely new to programming, we recommend following the `CS50 open If you are entirely new to programming, we recommend following the `CS50 open
@ -115,13 +115,13 @@ Note:
afraid of that: programming languages have many similarities. The afraid of that: programming languages have many similarities. The
skills you learn with one language transfer well to others. skills you learn with one language transfer well to others.
We will provide you with more Godot-specific learning resources in We will provide you with more Pandemonium-specific learning resources in
`doc_learning_new_features`. `doc_learning_new_features`.
In the next part, you will get an overview of the engine's essential concepts. In the next part, you will get an overview of the engine's essential concepts.
.. _Blender: https://www.blender.org/ .. _Blender: https://www.blender.org/
.. _VSCode: https://github.com/godotengine/godot-vscode-plugin .. _VSCode: https://github.com/pandemoniumengine/pandemonium-vscode-plugin
.. _Emacs: https://github.com/godotengine/emacs-gdscript-mode .. _Emacs: https://github.com/pandemoniumengine/emacs-gdscript-mode
.. _official showcase videos: https://www.youtube.com/playlist?list=PLeG_dAglpVo6EpaO9A1nkwJZOwrfiLdQ8 .. _official showcase videos: https://www.youtube.com/playlist?list=PLeG_dAglpVo6EpaO9A1nkwJZOwrfiLdQ8
.. _CS50 open courseware: https://cs50.harvard.edu/x .. _CS50 open courseware: https://cs50.harvard.edu/x

14
tutorials/introduction/key_concepts_overview.md
View File

@ -4,11 +4,11 @@
Overview of Godot's key concepts Overview of Pandemonium's key concepts
================================ ================================
Every game engine revolves around abstractions you use to build your Every game engine revolves around abstractions you use to build your
applications. In Godot, a game is a **tree** of **nodes** that you group applications. In Pandemonium, a game is a **tree** of **nodes** that you group
together into **scenes**. You can then wire these nodes so they can communicate together into **scenes**. You can then wire these nodes so they can communicate
using **signals**. using **signals**.
@ -19,9 +19,9 @@ series, you will get to use them in practice.
Scenes Scenes
------ ------
In Godot, you break down your game in reusable scenes. A scene can be a character, In Pandemonium, you break down your game in reusable scenes. A scene can be a character,
a weapon, a menu in the user interface, a single house, an entire level, or a weapon, a menu in the user interface, a single house, an entire level, or
anything you can think of. Godot's scenes are flexible; they fill the role of anything you can think of. Pandemonium's scenes are flexible; they fill the role of
both prefabs and scenes in some other game engines. both prefabs and scenes in some other game engines.
![](img/key_concepts_main_menu.png) ![](img/key_concepts_main_menu.png)
@ -51,7 +51,7 @@ Notice how nodes and scenes look the same in the editor. When you save a tree of
nodes as a scene, it then shows as a single node, with its internal structure nodes as a scene, it then shows as a single node, with its internal structure
hidden in the editor. hidden in the editor.
Godot provides an extensive library of base node types you can combine and Pandemonium provides an extensive library of base node types you can combine and
extend to build more powerful ones. 2D, 3D, or user interface, you will do most extend to build more powerful ones. 2D, 3D, or user interface, you will do most
things with these nodes. things with these nodes.
@ -77,7 +77,7 @@ flexibility in how you structure your scenes.
![](img/key_concepts_signals.png) ![](img/key_concepts_signals.png)
Note: Note:
Signals are Godot's version of the *observer* pattern. You can read Signals are Pandemonium's version of the *observer* pattern. You can read
more about it here: more about it here:
https://gameprogrammingpatterns.com/observer.html https://gameprogrammingpatterns.com/observer.html
@ -91,7 +91,7 @@ tailored to your game.
Summary Summary
------- -------
Nodes, scenes, the scene tree, and signals are four core concepts in Godot that Nodes, scenes, the scene tree, and signals are four core concepts in Pandemonium that
you will manipulate all the time. you will manipulate all the time.
Nodes are your game's smallest building blocks. You combine them to create scenes Nodes are your game's smallest building blocks. You combine them to create scenes

Some files were not shown because too many files have changed in this diff Show More