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
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
the top-level `index.html` in a web browser.
## 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
the light and dark theme depending on your browser/OS' theming preference.
@ -23,15 +23,15 @@ add-on.
## 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.
### 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.
**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).**
See [Contribute to the Class Reference](https://docs.godotengine.org/en/latest/community/contributing/updating_the_class_reference.html) for details.
**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.pandemoniumengine.org/en/latest/community/contributing/updating_the_class_reference.html) for details.
### 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.
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.
@ -133,7 +133,7 @@ Then do `make html` like above.
## 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.
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?
------------------
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
the project does it under this same license and keeps ownership of the
contribution.
@ -33,10 +33,10 @@ text somewhere in your game or derivative project.
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) 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:
@ -48,7 +48,7 @@ Note:
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.
Inclusion
@ -91,17 +91,17 @@ If the game includes printed manuals, license text can be included there.
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
the license terms.
Third-party licenses
--------------------
Godot itself contains software written by
`third parties ( https://github.com/godotengine/godot/blob/master/COPYRIGHT.txt )`.
Pandemonium itself contains software written by
`third parties ( https://github.com/pandemoniumengine/pandemonium/blob/master/COPYRIGHT.txt )`.
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
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
^^^^^^^^
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
Godot license:
Pandemonium license:
Portions of this software are copyright © ( year> The FreeType Project (www.freetype.org). All rights reserved.
@ -127,8 +127,8 @@ Note:
ENet
^^^^
Godot includes the `ENet ( http://enet.bespin.org/ )` library to handle
high-level multiplayer. ENet has similar licensing terms as Godot:
Pandemonium includes the `ENet ( http://enet.bespin.org/ )` library to handle
high-level multiplayer. ENet has similar licensing terms as Pandemonium:
Copyright (c) 2002-2020 Lee Salzman
@ -142,7 +142,7 @@ high-level multiplayer. ENet has similar licensing terms as Godot:
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:
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
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
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:
- `doc_introduction_best_practices`
- `doc_what_are_godot_classes`
- `doc_what_are_pandemonium_classes`
- `doc_scene_organization`
- `doc_scenes_versus_scripts`
- `doc_autoloads_versus_internal_nodes`
- `doc_node_alternatives`
- `doc_godot_interfaces`
- `doc_godot_notifications`
- `doc_pandemonium_interfaces`
- `doc_pandemonium_notifications`
- `doc_data_preferences`
- `doc_logic_preferences`
@ -170,7 +170,7 @@ Viewports
Shading
^^^^^^^
- `doc_converting_glsl_to_godot_shaders`
- `doc_converting_glsl_to_pandemonium_shaders`
- `doc_advanced_postprocessing`
Shading Reference:

250
about/faq.md
View File

@ -2,31 +2,31 @@
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:
* You are free to download and use Godot 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 download and use Pandemonium for any purpose: personal, non-profit, commercial, or otherwise.
* 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
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
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.
For full details, look at the `COPYRIGHT.txt ( https://github.com/godotengine/godot/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
in the Godot repository.
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/pandemoniumengine/pandemonium/blob/master/LICENSE.txt )` and `LOGO_LICENSE.txt ( https://github.com/pandemoniumengine/pandemonium/blob/master/LOGO_LICENSE.md )` files
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:**
@ -49,7 +49,7 @@ Which platforms are supported by Godot?
Both 32- and 64-bit binaries are supported where it makes sense, with 64
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.
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.
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
`scripting ( toc-learn-scripting )` section.
If you are just starting out with either Godot or game development in general,
GDScript is the recommended language to learn and use since it is native to Godot.
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 Pandemonium.
While scripting languages tend to be less performant than lower-level languages in
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
@ -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
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
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.
As for new languages, support is possible via third parties using the GDNative /
NativeScript / PluginScript facilities. (See the question about plugins below.)
Work is currently underway, for example, on unofficial bindings for Godot
to `Python ( https://github.com/touilleMan/godot-python )` and `Nim ( https://github.com/pragmagic/godot-nim )`.
Work is currently underway, for example, on unofficial bindings for Pandemonium
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?
-----------------------------------------
GDScript is Godot'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
and expert developers alike to capitalize on Godot's strengths as fast as possible.
GDScript is Pandemonium's integrated scripting language. It was built from the ground
up to maximize Pandemonium's potential in the least amount of code, affording both novice
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
right at home. For examples, history, and a complete overview of the power 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**.
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
with Godot, giving developers a rapid way of exposing themselves to the engine with a
Pandemonium was two-fold: first, it reduces the amount of time necessary to get up and running
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
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
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 familiar programming languages--especially when supporting those more familiar
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
you haven't given GDScript a try, try it for **three days**. Just like Godot,
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 Pandemonium,
once you see how powerful it is and rapid your development becomes, we think GDScript
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
`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.).
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
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.
@ -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.
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).
If you are using Blender, take a look at our own `Better Collada Exporter ( https://godotengine.org/download )`.
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://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
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
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
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
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.
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.
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.
There are two ways to overcome this. You can install Godot from
`Steam ( https://store.steampowered.com/app/404790/Godot_Engine/ )` (all platforms),
There are two ways to overcome this. You can install Pandemonium from
`Steam ( https://store.steampowered.com/app/404790/Pandemonium_Engine/ )` (all platforms),
`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.
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
^^^^^^^
- 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.
- 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`.
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**.
macOS
^^^^^
Drag the extracted Godot application to `/Applications/Godot.app`, then drag it
to the Dock if desired. Spotlight will be able to find Godot as long as it's in
Drag the extracted Pandemonium application to `/Applications/Pandemonium.app`, then drag it
to the Dock if desired. Spotlight will be able to find Pandemonium as long as it's in
`/Applications` or `~/Applications`.
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.
- Rename and move the Godot binary to a location present in your `PATH` environment variable.
This is typically `/usr/local/bin/godot` or `/usr/bin/godot`.
- Rename and move the Pandemonium binary to a location present in your `PATH` environment variable.
This is typically `/usr/local/bin/pandemonium` or `/usr/bin/pandemonium`.
Doing this requires administrator privileges,
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=`
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,
you can also save the `.desktop` file to `/usr/local/share/applications`
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
administrator privileges.
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
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.
If *true* portable operation is desired (e.g. for use on an USB stick),
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
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.
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
on all platforms allows for greater consistency with fewer platform-specific
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
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
artificial intelligence functionality.
There are several reasons for this:
- **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
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
@ -285,24 +285,24 @@ There are several reasons for this:
- **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
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.
- **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
and run it in less than 5 minutes makes Godot more accessible to developers in
connection. Ensuring that everyone can download the Pandemonium editor, extract it
and run it in less than 5 minutes makes Pandemonium more accessible to developers in
all countries.
- **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
underpowered devices. Again, there are many countries where high-speed
Internet is not readily available. To add to this, strict data usage caps are
often in effect in those countries.
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 to officially supported add-ons in future versions of Godot. In
functionality in Pandemonium. This is why we are aiming to move some core
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
you actually use in your project. (In the meantime, you can
`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
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
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
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 )`
and tool scripts.
Also, see the official blog posts on these topics:
* `A look at the GDNative architecture ( https://godotengine.org/article/look-gdnative-architecture )`
* `GDNative is here! ( https://godotengine.org/article/dlscript-here )`
* `A look at the GDNative architecture ( https://pandemoniumengine.org/article/look-gdnative-architecture )`
* `GDNative is here! ( https://pandemoniumengine.org/article/dlscript-here )`
You can also take a look at the GDScript implementation, the Godot modules,
as well as the `unofficial Python support ( https://github.com/touilleMan/godot-python )` for Godot.
You can also take a look at the GDScript implementation, the Pandemonium modules,
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
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
@ -377,26 +377,26 @@ information.
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.
The first place to get started is in the `issues ( https://github.com/godotengine/godot/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 )`
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/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.
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
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
people want to contribute, but Godot'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 )`,
`squashing bugs and addressing issues ( https://github.com/godotengine/godot/issues )`,
and conversations between Godot community members.
people want to contribute, but Pandemonium's focus is and always will be the
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/pandemoniumengine/pandemonium/issues )`,
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:
- 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.
- 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
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.
When creating a non-game application, make sure to enable
`low-processor mode`
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.
Check out `Material Maker ( https://github.com/RodZill4/material-maker )` and
`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
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.
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
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.
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
like GTK, Qt or wxWidgets. Instead, Godot uses its own user interface toolkit,
Pandemonium does not use a standard :abbr:`GUI (Graphical 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
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
supported by Godot.
supported by Pandemonium.
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 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
the most complex users of Godot's UI system.
this means Pandemonium is "eating its own dog food" since the editor itself is one of
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
`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
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.
* 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.
* 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
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
going.
Additionally, exceptions significantly increase binary size for the
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
internally. Disabling RTTI in Godot means considerably smaller binary sizes can
Pandemonium provides its own type-casting system, which can optionally use RTTI
internally. Disabling RTTI in Pandemonium means considerably smaller binary sizes can
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
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
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.
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
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`.
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!"
```
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
powerful yet user-friendly tool that you can use to develop any kind of game,
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,
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
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
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
platforms, including the major desktop platforms (Linux, macOS, Windows)
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
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
engine to match their expectations. It is supported by the `Software
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
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
language and then compiled into a static website/offline document using the
open source `Sphinx ( http://www.sphinx-doc.org )` and `ReadTheDocs
( https://readthedocs.org/ )` tools.
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
`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
( 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
(`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
---------------------------------
@ -99,13 +99,13 @@ relatively intuitive:
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
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
generated automatically from a file in the main source repository, therefore
the generated files of the documentation are not meant to be modified. See
`doc_updating_the_class_reference` for details.
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
================
This page aims to list all features currently supported by Godot.
This page aims to list all features currently supported by Pandemonium.
Note:
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).
Features
@ -37,7 +37,7 @@ Platforms
- `Consoles ( doc_consoles )`.
- `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.
Editor
@ -286,7 +286,7 @@ Note:
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.
3D tools
@ -384,13 +384,13 @@ Scripting
Warning:
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension.
`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 Pandemonium is not recommended.
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,
especially if you intend to migrate your project to Godot 4.
especially if you intend to migrate your project to Pandemonium 4.
Audio
^^^^^
@ -433,7 +433,7 @@ Import
- *3D scenes:*
- glTF 2.0 *(recommended)*.
- `ESCN ( https://github.com/godotengine/godot-blender-exporter )`
- `ESCN ( https://github.com/pandemoniumengine/pandemonium-blender-exporter )`
(direct export from Blender).
- FBX (experimental, static meshes only).
- Collada (.dae).
@ -499,7 +499,7 @@ Internationalization
or `gettext ( doc_localization_using_gettext )`.
- Use localized strings in your project automatically in GUI elements or by
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
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -544,7 +544,7 @@ XR support (AR and VR)
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.
**Nodes:**
@ -587,7 +587,7 @@ The editor UI can easily be extended in many ways using add-ons.
- 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.
Animation
@ -615,7 +615,7 @@ File formats
- Read and write `JSON` files.
- 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`.
- 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.
- 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.
- 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,
Clang and MSVC. MinGW is also supported.
- 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.
- Godot 4.0 will be written in C++17.
- Pandemonium 4.0 will be written in C++17.
- Licensed under the permissive MIT license.
@ -652,6 +652,6 @@ Miscellaneous
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
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
happen depends on the choices of core contributors, and the needs of the
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
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
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
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
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
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
@ -64,8 +64,8 @@ further developed for maintenance releases in a Git branch of the same name
Note:
As mentioned in the introduction, Godot's release policy is evolving, and
earlier Godot releases may not have followed the above rules to the letter.
As mentioned in the introduction, Pandemonium's release policy is evolving, and
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
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
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
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.
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** |
+-------------+----------------------+--------------------------------------------------------------------------+
| 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. |
+-------------+----------------------+--------------------------------------------------------------------------+
| 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. |
+-------------+----------------------+--------------------------------------------------------------------------+
| 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). |
+-------------+----------------------+--------------------------------------------------------------------------+
| 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)
@ -130,7 +130,7 @@ on GitHub.
|eol| No support (end of life) –
|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.
@ -138,15 +138,15 @@ provided for testing purposes only.
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
releases per year since Godot 3.3.
releases per year since Pandemonium 3.3.
Maintenance (patch) releases are released as needed with potentially very
short development cycles, to provide users of the current stable branch with
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
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
===============
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 `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.
------------------------------------------------------------------------------
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
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.
------------------------------------------------------------------------------------
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.
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.
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.
------------------------------------------------------
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,
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
@ -47,17 +47,17 @@ connect the peripheral again.
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.
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
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
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.
------------------------------------------------------------------
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
> Dpi > Allow Hidpi**. On top of that, make sure your project is configured to
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
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
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

12
community/contributing/best_practices_for_engine_contributors.md
View File

@ -6,7 +6,7 @@ Best practices for engine contributors
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.
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
@ -76,7 +76,7 @@ than it needs to be.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
*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
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
be accepted if they make something too difficult to use or if they add too much
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
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.
![](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
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.
In particular, we cannot accept libraries licensed under the GPL or LGPL since
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.
Since iOS doesn't support dynamic linking, static linking the only option on
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
`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
contributors to fix bugs faster, as they can know in advance which commit caused
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?
------------------
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
`binary search ( https://en.wikipedia.org/wiki/Binary_search_algorithm )`
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
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,
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
reproduce the bug in Godot 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
For example, if you've reported a bug against Pandemonium 3.2, you should first try to
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 Pandemonium 3.2 *beta 1* (which
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
manage to reproduce the bug with Godot 3.2 beta 1, then try older alpha builds.
the bug with Pandemonium 3.2 beta 1, then try newer betas and RC builds. If you do
manage to reproduce the bug with Pandemonium 3.2 beta 1, then try older alpha builds.
Warning:
For bisecting regressions, don't use patch releases such as Godot 3.1.2.
Instead, use the minor version's first release like Godot 3.1. This is
For bisecting regressions, don't use patch releases such as Pandemonium 3.1.2.
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
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 Git bisect command
@ -60,11 +60,11 @@ Note:
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 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
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
@ -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,
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
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.
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`
instead of a commit hash.
`Get Godot's source code using Git ( doc_getting_source )`. Once this
is done, in the terminal window, use `cd` to reach the Godot repository
`Get Pandemonium's source code using Git ( doc_getting_source )`. Once this
is done, in the terminal window, use `cd` to reach the Pandemonium repository
folder and enter the following command:
```
@ -102,7 +102,7 @@ folder and enter the following command:
$ 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,
@ -110,9 +110,9 @@ Compile Godot. This assumes you've set up a build environment:
$ 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
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.
@ -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.
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
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
@ -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
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
contributing to Godot :)
contributing to Pandemonium :)
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
bugsquad when handling issues and pull requests on Godot's
`GitHub repository ( https://github.com/godotengine/godot )`.
bugsquad when handling issues and pull requests on Pandemonium's
`GitHub repository ( https://github.com/pandemoniumengine/pandemonium )`.
It is bound to evolve together with the bugsquad, so do not
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 milestone from a predefined list
- 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
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
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
@ -34,7 +34,7 @@ to both issues and pull requests.
Labels
~~~~~~
The following labels are currently defined in the Godot repository:
The following labels are currently defined in the Pandemonium repository:
**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
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
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
may not be relevant anymore.
- *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
enhancements in the API documentation. Issues related to the ReadTheDocs
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
functionality.
- *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
`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.
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
it a great fit for new contributors who need to become familiar with
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.
- *Porting*: relates to some specific platforms or exporting projects.
- *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.
- *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).
- *XR*: relates to Augmented Reality or Virtual Reality.
@ -149,7 +149,7 @@ Android and Linux exclusively, select those two platforms).
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:
- *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
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.
- *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,
not the documentation contents.
Milestones
~~~~~~~~~~
`Milestones ( https://github.com/godotengine/godot/milestones )` correspond to
planned future versions of Godot for which there is an existing roadmap. Issues
`Milestones ( https://github.com/pandemoniumengine/pandemonium/milestones )` correspond to
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;
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

12
community/contributing/building_the_manual.md
View File

@ -3,18 +3,18 @@
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
documentation as a PDF, EPUB, or LaTeX file, for example.
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/ )`
3. To build the docs as HTML files, install the `readthedocs.org theme
( https://github.com/snide/sphinx_rtd_theme )`.
4. Install the Sphinx extensions defined in the `godot-docs repository
( https://github.com/godotengine/godot-docs/ )` `requirements.txt` file.
4. Install the Sphinx extensions defined in the `pandemonium-docs repository
( https://github.com/pandemoniumengine/pandemonium-docs/ )` `requirements.txt` file.
We recommend using `pip ( https://pip.pypa.io )`, Python’s package manager to
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/ )`.
```
git clone https://github.com/godotengine/godot-docs.git
git clone https://github.com/pandemoniumengine/pandemonium-docs.git
pip3 install -r requirements.txt
```
@ -73,7 +73,7 @@ Note:
If you delete the `classes/` folder, do not use `git add .` when
working on a pull request or the whole `classes/` folder will be
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.
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
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.
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`.
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.
</description>
<tutorials>
<link title="Custom drawing in 2D">https://docs.godotengine.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="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/pandemoniumengine/pandemonium-demo-projects/tree/master/2d</link>
</tutorials>
<methods>
<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,
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:
- `<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
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.
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
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
guide ( toc-devel-compiling )`.
@ -120,7 +120,7 @@ search feature to find classes and properties quickly.
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:
+----------------------------+--------------------------------------+-----------------------------------+---------------------------------------------------+
@ -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
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
( 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
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
@ -25,8 +25,8 @@ To name a few:
- See further down regarding header includes
The rules used by clang-format are outlined in the
`.clang-format ( https://github.com/godotengine/godot/blob/master/.clang-format )`
file of the Godot repository.
`.clang-format ( https://github.com/pandemoniumengine/pandemonium/blob/master/.clang-format )`
file of the Pandemonium repository.
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
@ -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.
Warning:
Godot'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
Pandemonium's code style should *not* be applied to third-party code,
i.e. that is included in Pandemonium's source tree but was not written
specifically for our project. Such code usually come from
different upstream projects with their own style guides (or lack
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
and can thus easily be excluded from formatting scripts. For the
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 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
**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
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
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
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
^^^^^^^^^^^^^^^
@ -136,7 +136,7 @@ Header includes
When adding new C++ or Objective-C files or including new headers in existing
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.
- In a `.h` header, include guards should be used with the form
`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
one where the class is declared (e.g. `#include "filename.h"`), followed by
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
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.
- 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 <png.h>`. The block of third-party headers should also be followed
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`
if used only in the imperative code.
@ -164,11 +164,11 @@ Example:
/* my_new_file.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/* PANDEMONIUM ENGINE */
/* https://pandemoniumengine.org */
/*************************************************************************/
/* 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 */
/* a copy of this software and associated documentation files (the */
@ -209,11 +209,11 @@ Example:
/* my_new_file.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/* PANDEMONIUM ENGINE */
/* https://pandemoniumengine.org */
/*************************************************************************/
/* 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 */
/* a copy of this software and associated documentation files (the */
@ -247,15 +247,15 @@ Example:
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
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.
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.
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
Godot's codebase.
Pandemonium's codebase.
- Begin comments with a space character to distinguish them from disabled code.
- 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.
2. **Write a complete reference manual**. Our goal here is not to teach
programming foundations. Instead, we should provide a reference for how
Godot's features work.
Pandemonium's features work.
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
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:
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.
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
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
may use signals, in which case we could note that the page that introduces
signals is a pre-requisite.
@ -89,7 +89,7 @@ Note:
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
"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
=================================
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.
See also:
@ -16,29 +16,29 @@ Getting started
---------------
To modify or create pages in the reference manual, you need to edit `.rst`
files in the `godot-docs GitHub repository
( https://github.com/godotengine/godot-docs )`. Modifying those pages in a pull
files in the `pandemonium-docs GitHub repository
( https://github.com/pandemoniumengine/pandemonium-docs )`. Modifying those pages in a pull
request triggers a rebuild of the online documentation upon merging.
See also:
For details on Git usage and the pull request workflow, please
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.
Warning:
The class reference's source files are in the `Godot engine
repository ( https://github.com/godotengine/godot )`. We generate
the `Godot API ( toc-class-ref )` section of this documentation
The class reference's source files are in the `Pandemonium engine
repository ( 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 description of a class, its
methods, or properties, read
`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
Godot game engine. It is not meant to contain step-by-step tutorials, except for
The Pandemonium documentation is intended as a comprehensive reference manual for the
Pandemonium game engine. It is not meant to contain step-by-step tutorials, except for
two game creation tutorials in the Getting Started section.
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
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
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
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
reference ( https://github.com/godotengine/godot/tree/master/doc/classes )`.
edited here.** They are automatically generated from Pandemonium’s `XML class
reference ( https://github.com/pandemoniumengine/pandemonium/tree/master/doc/classes )`.
See `doc_updating_the_class_reference` for details.
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.
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*.
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:
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.
2. Ensure there isn't a page that already covers the topic.
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:
- **Good:** Understanding signals in Godot
- **Bad:** Understanding Signals In Godot
- **Good:** Understanding signals in Pandemonium
- **Bad:** Understanding Signals In Pandemonium
Only propers nouns, projects, people, and node class names should have their
first letter capitalized.
@ -185,7 +185,7 @@ License
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".
attribution to "Juan Linietsky, Ariel Manzur and the Pandemonium community".
By contributing to the documentation on the GitHub repository, you agree that
your changes are distributed under this license.

12
community/contributing/cpp_usage_guidelines.md
View File

@ -6,7 +6,7 @@ C++ usage guidelines
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
readable code, we chose to restrict our usage of C++ to a subset for a few
reasons:
@ -15,7 +15,7 @@ reasons:
contributors don't always have access to a full-featured IDE while reviewing
code.
- 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.
To get your pull request merged, it needs to follow the C++ usage guidelines
@ -25,7 +25,7 @@ modules or GDNative scripts.
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
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.
@ -51,11 +51,11 @@ 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.
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 `Vector` instead of `std::vector`. In some cases, `LocalVector`
@ -65,7 +65,7 @@ This means that pull requests should **not** use `std::string`,
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
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
=======================
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
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
@ -444,12 +444,12 @@ Use `[code]` around arguments
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
files in the Godot repository, replace existing arguments written like 'this' or
documentation and in Pandemonium, it will display like `this`. When you edit XML
files in the Pandemonium repository, replace existing arguments written like 'this' or
\`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

34
community/contributing/documentation_guidelines.md
View File

@ -3,18 +3,18 @@
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
documentation. Also, have a look at README of the
`godot-docs GitHub repository ( https://github.com/godotengine/godot-docs )`
and the `docs front page ( https://docs.godotengine.org )`
`pandemonium-docs GitHub repository ( https://github.com/pandemoniumengine/pandemonium-docs )`
and the `docs front page ( https://docs.pandemoniumengine.org )`
on what steps to follow and how to contact the docs team.
How to contribute
-----------------
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
(reStructuredText markup language) in that repository. Modifying those pages
in a pull request and getting it merged will trigger a rebuild of the online
@ -23,20 +23,20 @@ documentation.
See also:
For details on Git usage and the pull request workflow, please
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.
Warning:
The class reference's source files are in the `Godot engine repository
( https://github.com/godotengine/godot )`. We generate the `Godot API
The class reference's source files are in the `Pandemonium engine repository
( 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
description of a class, its methods, or properties, read
`doc_updating_the_class_reference`.
Warning:
If you want to edit the **API reference**, please note that it
should *not* be done in the godot-docs repository. Instead, you
should edit the `doc/classes/*` XML files of Godot's
should *not* be done in the pandemonium-docs repository. Instead, you
should edit the `doc/classes/*` XML files of Pandemonium's
main repository. These files are then later used to generate the
in-editor documentation as well as the API reference of the
online docs. Read more here: `doc_updating_the_class_reference`.
@ -44,7 +44,7 @@ Warning:
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.
Once you've created a GitHub account, you can propose changes to a page you're
reading as follows:
@ -62,7 +62,7 @@ reading as follows:
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 from Username:patch-6*.
pandemoniumengine:master from Username:patch-6*.
6. A reviewer will evaluate your changes and incorporate them into the docs if
they're acceptable. You might also be asked to make
@ -84,7 +84,7 @@ definitions:
object").
- Documentation: a page describing precisely one and only one concept at a
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
respect the following rules (and the ones on the repo).
@ -119,24 +119,24 @@ letter.
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
: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
:height: 66
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.
License
-------
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
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
============================
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
the most important resources available in many languages, thanks to the
translation effort of the community.
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).
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).
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).
To manage translations, we use the GNU gettext file format (`PO` files), and
@ -30,7 +30,7 @@ localization of images.
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
interface, then the online documentation, and eventually the class reference
if there are enough translators to keep up with updates.
@ -38,17 +38,17 @@ Tip:
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
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.
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
this page we will use the `editor translation ( https://hosted.weblate.org/projects/godot-engine/godot/ )`
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/pandemonium-engine/pandemonium/ )`
as an example) to find the list of all languages:
![](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
(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
significant enough. Additionally, if a translation is done with for a
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
previously, and which are included in the current string. For example, if
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.
- The bottom right panel includes information on the source string. The most
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
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
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
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.
@ -258,14 +258,14 @@ external links, etc. Here are some examples:
```
# "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
# a matching URL for the same content in your language.
# Note: The `, ( , >, and _ characters all have a meaning in the hyperlink
# syntax and should be preserved.
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.
# "master" uses the markup for inline code, and will be styled as such.
@ -305,11 +305,11 @@ See also:
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.
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
class (e.g. `[Node2D]`) or to a property in a given class (e.g.
`[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
`[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
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 = ...`).
Note also that in the XML, each line is a paragraph, so you should not add line
@ -366,25 +366,25 @@ Note:
version.
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
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
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
-------------------------------
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.
This part is not handled via Weblate, but directly on the `godot-docs-l10n
( https://github.com/godotengine/godot-docs-l10n )` Git repository where the
This part is not handled via Weblate, but directly on the `pandemonium-docs-l10n
( https://github.com/pandemoniumengine/pandemonium-docs-l10n )` Git repository where the
documentation translations are synced from Weblate.
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
`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
(`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
`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
============
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:
- 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.
- Translating the editor or documentation from English to other languages.
- Reporting issues or `writing detailed proposals
( https://github.com/godotengine/godot-proposals/ )`.
( https://github.com/pandemoniumengine/pandemonium-proposals/ )`.
Getting started
---------------
@ -81,8 +81,8 @@ Class reference guides
The pages below focus on the class reference.
As the reference is included in the Godot editor, its source files are part of
the `godot repository ( https://github.com/godotengine/godot )`. We use XML files
As the reference is included in the Pandemonium editor, its source files are part of
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
writing the online manual.
@ -98,7 +98,7 @@ writing the online manual.
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
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
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
@ -20,21 +20,21 @@ the *master* branch).
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
organization of Godot's Git repository.
organization of Pandemonium's Git 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
issue tracker and PR system.
Note:
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
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
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
@ -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).
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
Godot 3.1).
Pandemonium 3.1).
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
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
-------------------
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
be logged in. In the top right corner of the repository's GitHub page, you
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)
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)
@ -96,7 +96,7 @@ Note:
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:
@ -104,27 +104,27 @@ Note:
on typical UNIX shells. It is not part of the command and should
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:
```
$ cd godot
$ cd pandemonium
```
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
```
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
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
`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).
Note:
@ -140,7 +140,7 @@ Note:
working in Git.
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.
Branching
@ -361,18 +361,18 @@ Issuing a pull request
----------------------
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
`master` branch).
![](img/github_fork_make_pr.png)
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".
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
`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
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.
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.
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
To https://github.com/akien-mga/godot
To https://github.com/akien-mga/pandemonium
! [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: 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.
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
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
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:

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 )`
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.
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.
**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
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
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/
( https://github.com/godotengine/godot/tree/master/doc/classes )`.
( https://github.com/pandemoniumengine/pandemonium/tree/master/doc/classes )`.
Note:
For some modules in the engine's source code, you'll find the XML
@ -48,8 +48,8 @@ Note:
Warning:
Always edit the API reference through these source XML files. Do
not edit the generated `.rst` files `in the online documentation
( toc-class-ref )`, hosted in the `godot-docs
( https://github.com/godotengine/godot-docs )` repository.
( toc-class-ref )`, hosted in the `pandemonium-docs
( https://github.com/pandemoniumengine/pandemonium-docs )` repository.
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/`.
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
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:
```
./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
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`.

52
community/contributing/ways_to_contribute.md
View File

@ -3,17 +3,17 @@
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
*pro bono* on their free time, out of personal interest and for the love of
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
such a big project, making it possible for everybody to bring something
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
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,
@ -23,10 +23,10 @@ positive to the engine, regardless of their skill set:
to become more mainstream.
- **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
made with Godot. We know that the engine has a lot of potential, both for 2D
industry at large that Pandemonium is a relevant market player, we need great games
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
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!
- **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
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
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
@ -47,7 +47,7 @@ positive to the engine, regardless of their skill set:
can work full-time on the engine. Even with a low
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
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.
Contributing code
@ -55,11 +55,11 @@ Contributing code
The possibility to study, use, modify and redistribute modifications of the
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 )`.
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
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
@ -80,12 +80,12 @@ Contributing code changes upstream has two big advantages:
the time of this writing, more than 1000 developers have contributed code
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
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
`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.
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
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,
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.
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
has a `proposal system ( https://github.com/godotengine/godot-proposals )`. Its
first before implementing it and putting it for a review as a PR. To that end, Pandemonium
has a `proposal system ( https://github.com/pandemoniumengine/pandemonium-proposals )`. Its
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:
Proposals are only required when working on an enhancement or a new feature.
@ -145,7 +145,7 @@ the developers.
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
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.
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
always provide:
@ -170,9 +170,9 @@ always provide:
only on certain processors, graphic cards, etc. If you are able to,
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
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
the start helps to speed up the diagnosis.
@ -194,11 +194,11 @@ are consistent and provide the required information.
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
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
XML file corresponding to the class and make a pull request.
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.
Its contents are generated from plain text files in the reStructured Text
(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.
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
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.

18
community/tutorials.md
View File

@ -3,27 +3,27 @@
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
--------------
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 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.
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).
- `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#).
@ -51,7 +51,7 @@ Text tutorials
- `FinepointCGI website by Mitch ( http://finepointcgi.io/ )`
- `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 )`
Devlogs
@ -63,5 +63,5 @@ Devlogs
Resources
---------
- `awesome-godot: A curated list of free/libre plugins, scripts and add-ons ( https://github.com/godotengine/awesome-godot )`
- `Zeef Godot Engine: A curated directory of resources by Andre Schmitz ( https://godot-engine.zeef.com/andre.antonio.schmitz )`
- `awesome-pandemonium: A curated list of free/libre plugins, scripts and add-ons ( https://github.com/pandemoniumengine/awesome-pandemonium )`
- `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 )`.
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
@ -67,13 +67,13 @@ points to the root of the SDK directories.
## 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`).
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
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:
- 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
cd platform/android/java
# On Windows
.\gradlew generateGodotTemplates
.\gradlew generatePandemoniumTemplates
# On Linux and macOS
./gradlew generateGodotTemplates
./gradlew generatePandemoniumTemplates
```
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
cd platform/android/java
# On Windows
.\gradlew generateGodotTemplates
.\gradlew generatePandemoniumTemplates
# On Linux and macOS
./gradlew generateGodotTemplates
./gradlew generatePandemoniumTemplates
```
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
cd platform/android/java
# On Windows
.\gradlew generateGodotTemplates
.\gradlew generatePandemoniumTemplates
# On Linux and macOS
./gradlew generateGodotTemplates
./gradlew generatePandemoniumTemplates
```
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
# On Windows
.\gradlew cleanGodotTemplates
.\gradlew cleanPandemoniumTemplates
# On Linux and macOS
./gradlew cleanGodotTemplates
./gradlew cleanPandemoniumTemplates
```
## 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
for the editor, make sure to install the matching export templates,
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.
Installing the templates
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:
- Windows: `%APPDATA%\Godot\templates\( version>\`
- Linux: `$HOME/.local/share/godot/templates/( version>/`
- macOS: `$HOME/Library/Application Support/Godot/templates/( version>/`
- Windows: `%APPDATA%\Pandemonium\templates\( version>\`
- Linux: `$HOME/.local/share/pandemonium/templates/( version>/`
- macOS: `$HOME/Library/Application Support/Pandemonium/templates/( version>/`
`( 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
next to your export templates.
@ -172,7 +172,7 @@ here:
![](img/andtemplates.png)
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
referenced.
@ -211,8 +211,8 @@ If the application runs but exits immediately, this might be due to
one of the following reasons:
- 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.
- `libgodot_android.so` is not in `libs/( android_arch>/`
you use a new Pandemonium version, you *have* to update the templates too.
- `libpandemonium_android.so` is not in `libs/( android_arch>/`
where `( android_arch )` is the device's architecture.
- The device's architecture does not match the exported one(s).
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).
- 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`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`.
To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## 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=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/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/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.iphone.opt.arm.a bin/libpandemonium.iphone.opt.arm64.a -output bin/libpandemonium.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/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.
@ -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=arm64
$ 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/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/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.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/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/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

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
```
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
@ -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:
```
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
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.
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`:
```
cp -r misc/dist/osx_tools.app ./Godot.app
mkdir -p Godot.app/Contents/MacOS
cp bin/godot.osx.opt.tools.universal Godot.app/Contents/MacOS/Godot
chmod +x Godot.app/Contents/MacOS/Godot
cp -r misc/dist/osx_tools.app ./Pandemonium.app
mkdir -p Pandemonium.app/Contents/MacOS
cp bin/pandemonium.osx.opt.tools.universal Pandemonium.app/Contents/MacOS/Pandemonium
chmod +x Pandemonium.app/Contents/MacOS/Pandemonium
```
## 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:
```
lipo -create bin/godot.osx.opt.x86_64 bin/godot.osx.opt.arm64 -output bin/godot.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.x86_64 bin/pandemonium.osx.opt.arm64 -output bin/pandemonium.osx.opt.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
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
`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
`.universal` extension with the one of your arch-specific binaries):
```
cp -r misc/dist/osx_template.app .
mkdir -p osx_template.app/Contents/MacOS
cp bin/godot.osx.opt.universal osx_template.app/Contents/MacOS/godot_osx_release.64
cp bin/godot.osx.opt.debug.universal osx_template.app/Contents/MacOS/godot_osx_debug.64
chmod +x osx_template.app/Contents/MacOS/godot_osx*
cp bin/pandemonium.osx.opt.universal osx_template.app/Contents/MacOS/pandemonium_osx_release.64
cp bin/pandemonium.osx.opt.debug.universal osx_template.app/Contents/MacOS/pandemonium_osx_debug.64
chmod +x osx_template.app/Contents/MacOS/pandemonium_osx*
```
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

34
engine_development/compiling/compiling_for_uwp.md
View File

@ -31,10 +31,10 @@ Note:
the new build instructions.
See also:
To get the Godot source code for compiling, see
To get the Pandemonium source code for compiling, see
`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`.
Compiling
@ -55,7 +55,7 @@ required DLLs for the selected architecture.
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
@ -69,18 +69,18 @@ Open the command prompt for one architecture and run SCons twice (once for
each target):
```
C:\godot>scons platform=uwp target=release_debug
C:\godot>scons platform=uwp target=release
C:\pandemonium>scons platform=uwp target=release_debug
C:\pandemonium>scons platform=uwp target=release
```
Repeat for the other architectures.
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).
Copy one of these to `misc/dist/uwp_template` inside the Godot source
folder and rename the binary to `godot.uwp.exe`. From the ANGLE source,
Copy one of these to `misc/dist/uwp_template` inside the Pandemonium 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`,
`x64` or `ARM`), get the `libEGL.dll` and the `libGLESv2.dll`,
putting them along with the executable.
@ -97,9 +97,9 @@ Zip according to the target/architecture of the template:
uwp_arm_release.zip
```
Move those templates to the `[versionstring]\templates` folder in Godot
settings path, where `versionstring` is the version of Godot you have compiled
the export templates for - e.g. `3.0.alpha` for the alpha version of Godot 3.
Move those templates to the `[versionstring]\templates` folder in Pandemonium
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 Pandemonium 3.
If you don't want to replace the templates, you can set the "Custom Package"
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
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
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.
@ -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).
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.
Right-click the `Package.appxmanifest` file and select "Open With... > XML
(Text) Editor". In the `Package/Applications/Application` element, replace
the `Executable` attribute from `$targetnametoken$.exe` to
`godot.uwp.exe` (or whatever your Godot executable is called). Also change
the `EntryPoint` attribute to `GodotUWP.App`. This will ensure that
the Godot executable is correctly called when the app starts.
`pandemonium.uwp.exe` (or whatever your Pandemonium executable is called). Also change
the `EntryPoint` attribute to `PandemoniumUWP.App`. This will ensure that
the Pandemonium executable is correctly called when the app starts.
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"
command and set their "Content" property to `True` so they're copied to the
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.
To get the Godot source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`.
To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
## 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 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.
Finally, rename the zip archive to `webassembly_release.zip` for the
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:
```
mv bin/godot.javascript.opt.debug.zip bin/webassembly_debug.zip
mv bin/pandemonium.javascript.opt.debug.zip bin/webassembly_debug.zip
```
## 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:
```
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:
```
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
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
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.
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.
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:
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
@ -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
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.
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:
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.
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
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
@ -113,7 +113,7 @@ builds cannot be performed from the MSYS2 or MinGW shells. Use either
`cmd.exe` or PowerShell instead.
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),
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:
```
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:
```
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`
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.
If all goes well, the resulting binary executable will be placed in
`C:\godot\bin\` with the name `godot.windows.tools.32.exe` or
`godot.windows.tools.64.exe`. By default, SCons will build a binary matching
`C:\pandemonium\bin\` with the name `pandemonium.windows.tools.32.exe` or
`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
`bits=32`.
@ -149,25 +149,25 @@ dependencies. Running it will bring up the Project Manager.
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`.
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
7 GB of available RAM while compiling.
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.
## 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,
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.
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
```
You will be able to open Godot's source in a Visual Studio solution now,
and able to build Godot using Visual Studio's **Build** button.
You will be able to open Pandemonium's source in a Visual Studio solution now,
and able to build Pandemonium using Visual Studio's **Build** button.
See also:
See `doc_configuring_an_ide_vs` for further details.
@ -247,7 +247,7 @@ differ based on your system):
### Troubleshooting
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.
You can change that configuration following those instructions,
@ -271,14 +271,14 @@ And for 32-bit:
### 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:
```
C:\godot> scons platform=windows tools=no target=release_debug bits=32
C:\godot> scons platform=windows tools=no target=release bits=32
C:\godot> 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_debug bits=32
C:\pandemonium> scons platform=windows tools=no target=release bits=32
C:\pandemonium> scons platform=windows tools=no target=release_debug 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
@ -286,7 +286,7 @@ following location, replacing `( version )` with the version identifier
(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:
@ -305,5 +305,5 @@ here:
![](img/wintemplates.png)
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.

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* - yasm (for WebM SIMD optimizations).
To get the Godot source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Godot, see `doc_introduction_to_the_buildsystem`.
To get the Pandemonium source code for compiling, see `doc_getting_source`.
For a general overview of SCons usage for Pandemonium, see `doc_introduction_to_the_buildsystem`.
### 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
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.
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:
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`.
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
7 GB of available RAM while compiling.
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.
## 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:
```
$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
@ -217,13 +217,13 @@ binaries as custom export templates here:
![](img/lintemplates.png)
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
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.
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 )`
to compile Godot.
to compile Pandemonium.
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.

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 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.
@ -42,7 +42,7 @@ PCK encryption.
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
compile Godot, like this:
compile Pandemonium, like this:
bash Linux/macOS
@ -57,7 +57,7 @@ bat Windows (PowerShell)
``` $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.
4. Set the encryption key in the **Script** tab of the export preset:
@ -69,7 +69,7 @@ bat Windows (PowerShell)
## Troubleshooting
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.
```

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,
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
@ -112,7 +112,7 @@ to the following commands:
Now you should have the iOS toolchain binaries in
`/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
environment: the built toolchain and the iPhoneOS SDK directory. Those
@ -126,7 +126,7 @@ environment variable defined to 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:
```
@ -139,12 +139,12 @@ way, with some additional arguments to provide the correct paths:
Apple requires a fat binary with both architectures (`armv7` and
`arm64`) in a single file. To do this, use the
`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/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/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.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/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/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.

20
engine_development/compiling/getting_source.md
View File

@ -1,12 +1,12 @@
# 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 )`
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
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.
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`.
If you are using the `git` command line client, this is done by entering
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.
# 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.
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).
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.
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.
After downloading the Godot source code,
you can `continue to compiling Godot ( doc_introduction_to_the_buildsystem )`.
After downloading the Pandemonium source code,
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
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
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
going to happen. There are many reasons why we have chosen SCons over
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.
- Developers often need to compile for several of the platforms **at
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,
configurations, additions, removals etc. You have more chances to die
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
customization (plugins). This requires complex logic which is easier
to write in an actual programming language (like Python) rather than
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
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
if you are planning to build Godot yourself.
if you are planning to build Pandemonium yourself.
## Setup
@ -44,7 +44,7 @@ the standard Windows command prompt to enter the commands below.
## 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
available platforms. The build requirements for each platform are
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:
```
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:
```
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
@ -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:
```
C:\godot> dir bin/
godot.windows.tools.64.exe
C:\pandemonium> dir bin/
pandemonium.windows.tools.64.exe
```
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
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).
Aside from that, there are a few standard options that can be set in all
@ -177,7 +177,7 @@ architecture.
## 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.
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:
```
scons custom_modules="../modules,/abs/path/to/modules,~/src/godot_modules"
scons custom_modules="../modules,/abs/path/to/modules,~/src/pandemonium_modules"
```
Note:
@ -208,7 +208,7 @@ See also:
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
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
for all platforms and configurations. Beware, as this will remove all untracked
@ -218,7 +218,7 @@ uncommitted work!
## Other build options
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.
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
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:
```
@ -245,9 +245,9 @@ time it takes to build the engine. See `doc_optimizing_for_size` page for more d
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
of your Godot source directory.
of your Pandemonium source directory.
Another custom file can be specified explicitly with the `profile` command
line option, both overriding the default build configuration:
@ -265,7 +265,7 @@ It's also possible to override the options conditionally:
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:
pass
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
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:
bash Linux/macOS
@ -294,8 +294,8 @@ powershell Windows (powershell)
## Export templates
Official export templates are downloaded from the Godot Engine site:
`godotengine.org ( https://godotengine.org/ )`. However, you might want
Official export templates are downloaded from the Pandemonium Engine site:
`pandemoniumengine.org ( https://pandemoniumengine.org/ )`. However, you might want
to build them yourself (in case you want newer ones, you are using custom
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
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
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`,
`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
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
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)
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:
```
strip path/to/godot.binary
strip path/to/pandemonium.binary
```
On Windows, `strip.exe` is included in most MinGW toolchain setups.
@ -51,7 +51,7 @@ Note:
- **Difficulty:** Easy
- **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`:
```
@ -143,7 +143,7 @@ This is everything that will be disabled:
- **Difficulty:** Medium to hard depending on modules
- **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:
```

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:
```
godot/modules/tts/
pandemonium/modules/tts/
```
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 */
#ifndef GODOT_TTS_H
#define GODOT_TTS_H
#ifndef PANDEMONIUM_TTS_H
#define PANDEMONIUM_TTS_H
#include "core/reference.h"
@ -39,7 +39,7 @@ Next, you will create a header file with a simple TTS class:
TTS();
};
#endif // GODOT_TTS_H
#endif // PANDEMONIUM_TTS_H
```
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) {
//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());
}
@ -131,7 +131,7 @@ installation commands for Linux below, for reference.
.. important::
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
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.
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::
Please note that Git submodules are not used in the Godot repository. If
you are developing a module to be merged into the main Godot repository, you should not
Please note that Git submodules are not used in the Pandemonium repository. If
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
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"])
# 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.
# 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.
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
`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:
```
@ -199,18 +199,18 @@ Example `SCsub` with custom flags:
The final module should look like this:
```
godot/modules/tts/festival/
godot/modules/tts/libpath/libestbase.a
godot/modules/tts/libpath/libestools.a
godot/modules/tts/libpath/libeststring.a
godot/modules/tts/libpath/libFestival.a
godot/modules/tts/speech_tools/
godot/modules/tts/config.py
godot/modules/tts/tts.h
godot/modules/tts/tts.cpp
godot/modules/tts/register_types.h
godot/modules/tts/register_types.cpp
godot/modules/tts/SCsub
pandemonium/modules/tts/festival/
pandemonium/modules/tts/libpath/libestbase.a
pandemonium/modules/tts/libpath/libestools.a
pandemonium/modules/tts/libpath/libeststring.a
pandemonium/modules/tts/libpath/libFestival.a
pandemonium/modules/tts/speech_tools/
pandemonium/modules/tts/config.py
pandemonium/modules/tts/tts.h
pandemonium/modules/tts/tts.cpp
pandemonium/modules/tts/register_types.h
pandemonium/modules/tts/register_types.cpp
pandemonium/modules/tts/SCsub
```
Using the module

16
engine_development/cpp/common_engine_methods_and_macros.md
View File

@ -3,7 +3,7 @@
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,
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
-------------------------
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
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
-------------
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`):
```
@ -175,7 +175,7 @@ use `GLOBAL_GET`/`EDITOR_GET` in all other places where it's referenced.
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:
@ -233,7 +233,7 @@ Note:
}
// 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.
CRASH_NOW_MSG("Can't predict the future! Aborting.");
```
@ -241,10 +241,10 @@ Note:
See also:
See `core/error_macros.h ( https://github.com/godotengine/godot/blob/3.x/core/error_macros.h )`
in Godot's codebase for more information about each error macro.
See `core/error_macros.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/error_macros.h )`
in Pandemonium's codebase for more information about each error macro.
Some functions return an error code (materialized by a return type of
`Error`). This value can be returned directly from an error macro.
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
`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
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
---------------------
@ -20,9 +20,9 @@ Importing the project
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.
- To build the project, follow the `compiling instructions <toc-devel-compiling )`.
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
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 )`
which can also be used by CLion.
- From the CLion's welcome window choose the option to import an existing
project. If you've already opened another project, choose **File > Open**
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 itself), then click **OK**.
@ -32,7 +32,7 @@ which can also be used by CLion.
:align: center
- 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)
:align: center
@ -41,26 +41,26 @@ which can also be used by CLion.
work once the project has finished indexing.
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
---------------------
Since CLion does not support SCons, you won't be able to compile, launch, and debug Godot 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.
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 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 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...**
.. figure:: img/clion_4_select_attach_to_process.png)
: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
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.
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
: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)
:figclass: figure-w480
@ -79,7 +79,7 @@ Windows example:
:figclass: figure-w480
: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
-------------------
@ -92,14 +92,14 @@ Deselect the **Auto-generate filename prefix** and **Auto-generate filename exte
:figclass: figure-w480
: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
---------------------------
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)
:figclass: figure-w480
@ -114,7 +114,7 @@ It should automatically select the project folder; so simply click **Open**. By
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)
:figclass: figure-w480
@ -126,4 +126,4 @@ Under **General Settings**, on the **Editor Settings** tab, under **Tab Options*
:figclass: figure-w480
: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
==================
We assume that you have already `cloned ( https://github.com/godotengine/godot )`
and `compiled <toc-devel-compiling )` Godot.
We assume that you have already `cloned ( https://github.com/pandemoniumengine/pandemonium )`
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
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.
- 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**.
.. 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:
```
. // A dot, to indicate the root of the Godot project
. // A dot, to indicate the root of the Pandemonium project
core/
core/os/
core/math/
@ -76,12 +76,12 @@ Debugging the project
- Click **Add** to create a new launch configuration.
- 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,
e.g. `godot.x11.tools.64` for 64-bit X11 platform with `tools` enabled.
the `<Pandemonium root directory>/bin` folder. The name depends on your build configuration,
e.g. `pandemonium.x11.tools.64` for 64-bit X11 platform with `tools` enabled.
.. figure:: img/kdevelop_configlaunches2.png)
:figclass: figure-w480
:align: center
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
:align: center
- Under **Location** select the Godot root folder.
- Under **Location** select the Pandemonium root folder.
.. figure:: img/qtcreator-set-project-path.png)
:figclass: figure-w480
@ -76,9 +76,9 @@ Debugging the project
- From the left-side menu select **Projects** and open the **Run** tab.
- Under **Executable** specify the path to your executable located in
the `<Godot 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.
You can use `%{buildDir}` to reference the project root, e.g: `%{buildDir}/bin/godot.x11.opt.tools.64`.
the `<Pandemonium root directory>/bin` folder. The name depends on your build configuration,
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/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 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 )`
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++**.
.. 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
**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)
:figclass: figure-w480
:align: center
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
---------------------
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.
- 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.
- 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.
- Use the **Build** top menu to build the project.
@ -30,13 +30,13 @@ Warning:
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,
and make live changes to the codebase.
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,
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.
- 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:
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
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)
:align: center
@ -66,4 +66,4 @@ start debugging.
:align: center
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 )`
can be used instead.
- 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...**.
- Press :kbd:`Ctrl + Shift + P` to open the command prompt window and enter *Configure Task*.
@ -97,11 +97,11 @@ js X11
"name": "Launch Project",
"type": "lldb",
"request": "launch",
// Change to godot.x11.tools.64.llvm for llvm-based builds.
"program": "${workspaceFolder}/bin/godot.x11.tools.64",
// Change to pandemonium.x11.tools.64.llvm for llvm-based builds.
"program": "${workspaceFolder}/bin/pandemonium.x11.tools.64",
// Change the arguments below for the project you want to test with.
// 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,
"cwd": "${workspaceFolder}",
"environment": [],
@ -118,11 +118,11 @@ js X11_gdb
"name": "Launch Project",
"type": "cppdbg",
"request": "launch",
// Change to godot.x11.tools.64.llvm for llvm-based builds.
"program": "${workspaceFolder}/bin/godot.x11.tools.64",
// Change to pandemonium.x11.tools.64.llvm for llvm-based builds.
"program": "${workspaceFolder}/bin/pandemonium.x11.tools.64",
// Change the arguments below for the project you want to test with.
// 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,
"cwd": "${workspaceFolder}",
"environment": [],
@ -146,15 +146,15 @@ js Windows
"name": "Launch Project",
"type": "cppvsdbg",
"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.
// 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,
"cwd": "${workspaceFolder}",
"environment": [],
"console": "internalConsole",
"visualizerFile": "${workspaceFolder}/platform/windows/godot.natvis",
"visualizerFile": "${workspaceFolder}/platform/windows/pandemonium.natvis",
"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.
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
`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. |
+------------+------------------------------------------------------------------------------+
| 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)
@ -44,24 +44,24 @@ Importing the project
:align: center
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**.
- 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
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**.
.. 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
:align: center
- Next select **Create groups** for the **Added folders** option and check *only*
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
: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.:
```
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)
@ -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:
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
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.
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
==========
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.
This reference will try to list them in order for their better
@ -12,7 +12,7 @@ understanding.
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
compiler. Reinventing the wheel for those is not fun, as it makes code
more difficult to read.
@ -34,7 +34,7 @@ directly to wchar_t.
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
------------
@ -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
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
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
pool will be rearranged and compacted on demand. Depending on the need
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
-----------------
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
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()
@ -131,13 +131,13 @@ large amount of accesses.
References:
~~~~~~~~~~~
- `core/os/memory.h ( https://github.com/godotengine/godot/blob/3.x/core/os/memory.h )`
- `core/pool_vector.h ( https://github.com/godotengine/godot/blob/3.x/core/pool_vector.cpp )`
- `core/os/memory.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/os/memory.h )`
- `core/pool_vector.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/pool_vector.cpp )`
Containers
----------
Godot provides also a set of common containers:
Pandemonium provides also a set of common containers:
- Vector
- List
@ -165,15 +165,15 @@ The Vector<> class also has a few nice features:
References:
~~~~~~~~~~~
- `core/vector.h ( https://github.com/godotengine/godot/blob/3.x/core/vector.h )`
- `core/list.h ( https://github.com/godotengine/godot/blob/3.x/core/list.h )`
- `core/set.h ( https://github.com/godotengine/godot/blob/3.x/core/set.h )`
- `core/map.h ( https://github.com/godotengine/godot/blob/3.x/core/map.h )`
- `core/vector.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/vector.h )`
- `core/list.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/list.h )`
- `core/set.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/set.h )`
- `core/map.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/map.h )`
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
operations) and utf8 parsing/extracting, as well as helpers for
conversion and visualization.
@ -181,7 +181,7 @@ conversion and visualization.
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
----------
@ -197,7 +197,7 @@ is fast.
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
----------
@ -208,7 +208,7 @@ directory.
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
--------
@ -219,7 +219,7 @@ referencing them fast.
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
---
@ -232,4 +232,4 @@ referenced data.
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:
~~~~~~~~~~~
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )`
- `servers/audio/audio_stream.h ( https://github.com/pandemoniumengine/pandemonium/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/pandemoniumengine/pandemonium/blob/master/scene/audio/audio_player.cpp )`
What for?
---------
@ -116,7 +116,7 @@ Therefore, playback state must be self-contained in AudioStreamPlayback.
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
@ -231,9 +231,9 @@ Since AudioStreamPlayback is controlled by the audio thread, i/o and dynamic mem
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.
Godot provides cubic interpolation for audio resampling.
Pandemonium provides cubic interpolation for audio resampling.
Instead of overloading `mix`, AudioStreamPlaybackResampled uses `mix_internal` to
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:
~~~~~~~~~~~
- `core/math/audio_frame.h ( https://github.com/godotengine/godot/blob/master/core/math/audio_frame.h )`
- `servers/audio/audio_stream.h ( https://github.com/godotengine/godot/blob/master/servers/audio/audio_stream.h )`
- `scene/audio/audioplayer.cpp ( https://github.com/godotengine/godot/blob/master/scene/audio/audio_player.cpp )`
- `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/pandemoniumengine/pandemonium/blob/master/servers/audio/audio_stream.h )`
- `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
------------
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
mediator pattern which interprets resource ID and process data for the
engine and other modules. In addition, the server claims ownership for
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++`.
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 )`
- `Mediator pattern ( https://en.wikipedia.org/wiki/Mediator_pattern )`
@ -32,7 +32,7 @@ What for?
- Adding a custom VoIP protocol.
- 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,
@ -75,7 +75,7 @@ an initialization state and a cleanup procedure.
private:
uint64_t counter;
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;
void _emit_occupy_room(uint64_t room, RID rid);
@ -203,7 +203,7 @@ an initialization state and a cleanup procedure.
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) {
if (bus_owner.owns(id)) {
lock();
@ -273,7 +273,7 @@ an initialization state and a cleanup procedure.
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 maintains a list of RIDs. In practice, RIDs are similar to writing
object-oriented C code.
@ -316,7 +316,7 @@ References
~~~~~~~~~~~
- `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
---------------------------------
@ -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`
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
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`
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();
```
- `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
~~~~~~~~~~~~
@ -474,7 +474,7 @@ to execute the desired behavior. The queue will be flushed whenever either
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
-------------

52
engine_development/cpp/custom_modules_in_cpp.md
View File

@ -6,7 +6,7 @@ Custom modules in C++
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
functionality at every level without modifying the core, which can be
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++
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.
- Adding new functionality to the engine and/or editor.
- Porting an existing game.
@ -34,14 +34,14 @@ instead. Adding C++ modules can be useful in the following scenarios:
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 )`.
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
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:
```
@ -159,7 +159,7 @@ string 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.
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
`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:
```
@ -208,12 +208,12 @@ And that's it. Hope it was not too complex! Your module should look like
this:
```
godot/modules/summator/config.py
godot/modules/summator/summator.h
godot/modules/summator/summator.cpp
godot/modules/summator/register_types.h
godot/modules/summator/register_types.cpp
godot/modules/summator/SCsub
pandemonium/modules/summator/config.py
pandemonium/modules/summator/summator.h
pandemonium/modules/summator/summator.cpp
pandemonium/modules/summator/register_types.h
pandemonium/modules/summator/register_types.cpp
pandemonium/modules/summator/SCsub
```
You can then zip it and share the module with everyone else. When
@ -320,7 +320,7 @@ Warning:
`GDNative ( doc_what_is_gdnative )` instead.
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
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.
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'] = []
# 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
# Godot binary.
# Pandemonium binary.
shared_lib = module_env.SharedLibrary(target='#bin/summator', source=sources)
# Finally, notify the main build environment it now has our shared library
# as a new dependency.
# 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'])
@ -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
`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
during runtime with the `LD_LIBRARY_PATH` environment variable:
```
export LD_LIBRARY_PATH="$PWD/bin/"
./bin/godot*
./bin/pandemonium*
```
Note:
@ -386,7 +386,7 @@ Note:
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
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
using the `ARGUMENT` command:
@ -416,7 +416,7 @@ using the `ARGUMENT` command:
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`.
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:
```
user@host:~/godot$ git status
user@host:~/pandemonium$ git status
```
Example output:
@ -488,7 +488,7 @@ Tip:
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.
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:
```
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
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.
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
on top of the newer ones.
@ -559,7 +559,7 @@ Summing up
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
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,
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++`.
References
~~~~~~~~~~
- `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?
---------
@ -38,7 +38,7 @@ ImageFormatLoader should be used to load images.
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
@ -47,7 +47,7 @@ Creating a ResourceFormatLoader
Each file format consist of a data container and a `ResourceFormatLoader`.
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.
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
--------------------------
Godot may not have a proper substitute within its `doc_core_types`
or managed resources. Godot needs a new registered data type to
Pandemonium may not have a proper substitute within its `doc_core_types`
or managed resources. Pandemonium needs a new registered data type to
understand additional binary formats such as machine learning models.
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.
Therefore, Godot call translations are required.
Therefore, Pandemonium call translations are required.
For example, here is the code for translating `FileAccess`
calls into `std::istream`.
@ -273,10 +273,10 @@ calls into `std::istream`.
#include <istream>
#include <streambuf>
class GodotFileInStreamBuf : public std::streambuf {
class PandemoniumFileInStreamBuf : public std::streambuf {
public:
GodotFileInStreamBuf(FileAccess *fa) {
PandemoniumFileInStreamBuf(FileAccess *fa) {
_file = fa;
}
int underflow() {
@ -303,12 +303,12 @@ References
- `istream ( http://www.cplusplus.com/reference/istream/istream/ )`
- `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
-------------------------------
Godot registers `ResourcesFormatLoader` with a `ResourceLoader`
Pandemonium registers `ResourcesFormatLoader` with a `ResourceLoader`
handler. The handler selects the proper loader automatically
when `load` is called.
@ -354,7 +354,7 @@ when `load` is called.
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
----------------------
@ -368,7 +368,7 @@ project's root folder:
"demo": [
"welcome",
"to",
"godot",
"pandemonium",
"resource",
"loaders"
]

12
engine_development/cpp/index.md
View File

@ -4,7 +4,7 @@ Engine development
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::
: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
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.
@ -21,17 +21,17 @@ This section covers the basics that you will encounter in (almost) every source
:maxdepth: 1
:name: toc-devel-cpp-source-beginner
introduction_to_godot_development
introduction_to_pandemonium_development
common_engine_methods_and_macros
core_types
variant_class
object_class
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::
:maxdepth: 1
@ -39,7 +39,7 @@ This section covers what you can do by modifying Godot's C++ source code.
custom_modules_in_cpp
binding_to_external_libraries
custom_godot_servers
custom_pandemonium_servers
custom_resource_format_loaders
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
C++ side.
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
structure and the servers.
@ -19,22 +19,22 @@ structure and the servers.
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,
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
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:
```
$ cd ~/myproject
$ gdb godot
$ gdb pandemonium
> run -e
```
Or:
```
$ gdb godot
$ gdb pandemonium
> run -e --path ~/myproject
```

4
engine_development/cpp/macos_debug.md
View File

@ -1,7 +1,7 @@
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.
@ -35,7 +35,7 @@ Create an `editor.entitlements` text file with the following contents:
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

22
engine_development/cpp/object_class.md
View File

@ -6,13 +6,13 @@ Object class
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.`
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
editable properties, and declaring them is a matter of using a single
macro like this.
@ -36,7 +36,7 @@ This makes Objects gain a lot of functionality, like for example
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
---------------------
@ -94,7 +94,7 @@ string passing the name can be passed for brevity.
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
---------
@ -201,7 +201,7 @@ compared against the desired names in serial order.
Dynamic casting
---------------
Godot provides dynamic casting between Object-derived classes, for
Pandemonium provides dynamic casting between Object-derived classes, for
example:
```
@ -241,9 +241,9 @@ Adding signals to a class is done in `bind_methods`, using the
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.
More information can be found on the `doc_godot_notifications` page.
More information can be found on the `doc_pandemonium_notifications` page.
References
----------
@ -266,7 +266,7 @@ templates point to it.
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:
----------
@ -282,7 +282,7 @@ Resources without a path are fine too.
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
----------------
@ -303,7 +303,7 @@ the same time.
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
---------------
@ -322,4 +322,4 @@ be bundled with the saved resource and assigned sub-IDs, like
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
===================
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.
Note:
@ -23,10 +23,10 @@ Recommended profilers
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.
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
symbols, since these would make the download size significantly larger.
@ -51,9 +51,9 @@ Warning:
Benchmarking startup/shutdown times
-----------------------------------
If you're looking into optimizing Godot's startup/shutdown performance,
you can tell the profiler to use the `--quit` command line option on the Godot binary.
This will exit Godot just after it finished starting.
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 Pandemonium binary.
This will exit Pandemonium just after it finished starting.
The `--quit` option works with `--editor`, `--project-manager` or
`--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
supported by Godot.
supported by Pandemonium.
Profiler-specific instructions
------------------------------
@ -69,11 +69,11 @@ Profiler-specific instructions
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.
Otherwise, the profiler will not track the child process since the project manager
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)
@ -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).
- Wait for the results window to appear.
- 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
**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:
![](img/cpp_profiler_verysleepy_results_filtered.png)
@ -95,13 +95,13 @@ HotSpot
![](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.
- 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
the relative path to the project is valid.
- 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.
Your settings should now look something like this:
@ -145,7 +145,7 @@ Xcode Instruments
![](img/cpp_profiler_xcode_menu.png)
- 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.
![](img/cpp_profiler_time_profiler.png)

14
engine_development/cpp/variant_class.md
View File

@ -6,7 +6,7 @@ Variant class
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
almost any engine datatype inside of it. Variants are rarely used to
hold information for long periods of time, instead they are used mainly
@ -20,7 +20,7 @@ A Variant can:
its atomic/native datatype).
- Be hashed, so it can be compared quickly to other variants
- 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)
- Be used to defer calls or move data between threads.
- 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.
- 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
of C++ with little effort. Become a friend of Variant today.
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
--------------------------------
@ -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
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:
~~~~~~~~~~~
- `core/dictionary.h ( https://github.com/godotengine/godot/blob/3.x/core/dictionary.h )`
- `core/array.h ( https://github.com/godotengine/godot/blob/3.x/core/array.h )`
- `core/dictionary.h ( https://github.com/pandemoniumengine/pandemonium/blob/3.x/core/dictionary.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.
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
@ -36,9 +36,9 @@ CPUParticles2D, name the file `CPUParticles2D.svg`.
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
`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.
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.
@ -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.
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
as they can be self-contained.
@ -102,4 +102,4 @@ If icons don't appear in the editor, make sure that:
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
------------
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
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
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
some examples taken from the Godot editor:
some examples taken from the Pandemonium editor:
- **Screen-space antialiasing:** *Disabled (Fastest), FXAA (Fast)*
- **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:
- The **design decisions** behind the Godot editor.
- How to work efficiently on the Godot editor's C++ code.
- The **design decisions** behind the Pandemonium editor.
- How to work efficiently on the Pandemonium editor's C++ code.
This guide is aimed at current or future engine contributors.
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:
If you are new to Godot, we recommended you to read
`doc_godot_design_philosophy` before continuing. Since the Godot editor
is a Godot project written in C++, much of the engine's philosophy applies
If you are new to Pandemonium, we recommended you to read
`doc_pandemonium_design_philosophy` before continuing. Since the Pandemonium editor
is a Pandemonium project written in C++, much of the engine's philosophy applies
to the editor.
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
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
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.
@ -34,26 +34,26 @@ Directory structure
-------------------
The editor's code is fully self-contained in the
`editor/ ( https://github.com/godotengine/godot/tree/master/editor )` folder
of the Godot source repository.
`editor/ ( https://github.com/pandemoniumengine/pandemonium/tree/master/editor )` folder
of the Pandemonium source repository.
Some editor functionality is also implemented via
`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
`modules/ ( https://github.com/godotengine/godot/tree/master/modules )` folder
in the Godot source repository.
`modules/ ( https://github.com/pandemoniumengine/pandemonium/tree/master/modules )` folder
in the Pandemonium source repository.
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.
- `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.
- `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, …).
- `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, …).
- `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.
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
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
`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/`
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
----------------
@ -86,4 +86,4 @@ Development tips
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
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::

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
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.
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
program and should not be edited by the user from within Godot.
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 Pandemonium.
Unlike SCN and TSCN files, during import, ESCN files are compiled to binary
SCN files stored inside the `.import/` folder.
This reduces the data size and speeds up loading, as binary formats are faster
to load compared to text-based formats.
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.
File structure
@ -43,7 +43,7 @@ the items in the section. For example, the heading of all external resources
should start with `[ext_resource .....]`.
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
~~~~~~~~~~~~~~~~~~~~~~~
@ -83,7 +83,7 @@ Other valid keywords include:
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
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 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
@ -136,7 +136,7 @@ save a file with that node in it. Some example nodes are:
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
the node anywhere in the scene tree. For instance, MeshInstance uses
`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
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
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
semicolon (`;`). However, comments will be discarded when saving the resource
using the Godot editor.
using the Pandemonium editor.
Internal resources
~~~~~~~~~~~~~~~~~~
@ -311,7 +311,7 @@ internal resources section.
Unfortunately, documentation on the formats for these subresources isn't
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
~~~~~~~~~

28
index.md
View File

@ -1,26 +1,26 @@
Godot Docs – *3.5* branch
Pandemonium Docs – *3.5* branch
=========================
.. only:: not i18n
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
the list.
Tip:
This is the documentation for the 3.5 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
`3.4 ( https://docs.godotengine.org/en/3.4 )` branch.
`3.4 ( https://docs.pandemoniumengine.org/en/3.4 )` branch.
.. only:: i18n
Note:
This documentation is translated from the `original English one
( https://docs.godotengine.org/en/latest )` by community members
on `Weblate ( https://hosted.weblate.org/projects/godot-engine/godot-docs )`.
( https://docs.pandemoniumengine.org/en/latest )` by community members
on `Weblate ( https://hosted.weblate.org/projects/pandemonium-engine/pandemonium-docs )`.
Depending on the translation effort's completion level, you may
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
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
to this documentation, we recommend that you read the
`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
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
the top-level `index.html` in a web browser.
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
feedback and help to improve the tutorials and class reference. If
you don't understand something, or cannot find what you
@ -54,12 +54,12 @@ Note:
by letting us know!
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
( 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
`#documentation` channel on the `Godot Contributors Chat
( https://chat.godotengine.org/ )`!
`#documentation` channel on the `Pandemonium Contributors Chat
( https://chat.pandemoniumengine.org/ )`!
.. centered:: |weblate_widget|

26
modules/entity_spell_system.md
View File

@ -1,22 +1,22 @@
# 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,
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.
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.3 - Will more likely work, might need smaller changes by now. (TODO check.)\
3.4 - Should work without any issues. (TODO check.)\
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
@ -133,7 +133,7 @@ and quite a few notification constants.
Open `ProjectSettings`, and then go to `ESS/Enums`.
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.
@ -568,19 +568,19 @@ https://github.com/Relintai/broken_seals_2d.git
## 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:
If you want Godot 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory"
```cd godot```
```cd pandemonium```
```cd modules```
3. clone this repository
@ -593,7 +593,7 @@ If you want Godot 4.0:
```cd ..```
5. Compile godot.
5. Compile pandemonium.
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
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
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.

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
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
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
@ -184,7 +184,7 @@ any other tile.
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
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.
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:
- 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.
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
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.
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:
- 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*:
@ -469,7 +469,7 @@ can be done using *alternative tiles*.
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
LayeredTileMap editor by using the rotation/flip buttons in the LayeredTileMap editor
toolbar.

18
modules/mesh_data_resource.md
View File

@ -1,6 +1,6 @@
# 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.
@ -44,18 +44,18 @@ Since MeshDataResource can hold collider information, these importers can create
1. Get the source code for the engine.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -64,6 +64,6 @@ cd ./godot/modules/
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
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.
# 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.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -55,6 +55,6 @@ cd ./godot/modules/
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
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 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.
# Pre-built binaries
@ -71,17 +71,17 @@ or look into Project->Tools.
1. Get the source code for the engine.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -90,6 +90,6 @@ cd ./godot/modules/
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
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 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.
# Pre-built binaries
@ -71,17 +71,17 @@ or look into Project->Tools.
1. Get the source code for the engine.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -90,6 +90,6 @@ cd ./godot/modules/
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
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.
@ -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.
```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
@ -22,4 +22,4 @@ cd ./godot/modules/
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
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
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
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/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
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
@ -25,4 +25,4 @@ cd ./godot/modules/
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
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.
@ -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.
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.
## Godot Version Support
## Pandemonium Version Support
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.)\
@ -55,7 +55,7 @@ This is the basic Minecraft-style lib rary. Use this if you just have one textur
### 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.
@ -63,7 +63,7 @@ You can assign any texture to your surfaces with this, and it will merge them to
(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.
@ -182,20 +182,20 @@ They won't get reset, so for example if you want all your vertices to have a cer
## 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:
If you want Godot 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory:
```cd godot``` \
```cd pandemonium``` \
```cd modules```
3. clone this repository
@ -213,7 +213,7 @@ If you want Godot 4.0:
```cd ..```
6. Compile godot.
6. Compile pandemonium.
For example:

24
modules/terraman_2d.md
View File

@ -1,6 +1,6 @@
# 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.
@ -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.
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.
## Godot Version Support
## Pandemonium Version Support
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.)\
@ -56,7 +56,7 @@ This is the basic Minecraft-style lib rary. Use this if you just have one textur
### 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.
@ -64,7 +64,7 @@ You can assign any texture to your surfaces with this, and it will merge them to
(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.
@ -184,20 +184,20 @@ They won't get reset, so for example if you want all your vertices to have a cer
## 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:
If you want Godot 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory:
```cd godot``` \
```cd pandemonium``` \
```cd modules```
3. clone this repository
@ -215,7 +215,7 @@ If you want Godot 4.0:
```cd ..```
6. Compile godot.
6. Compile pandemonium.
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.
@ -8,7 +8,7 @@ It uses the legacy version of [rectpack2D](https://github.com/TeamHypersomnia/re
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.
# 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.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -39,7 +39,7 @@ cd ./godot/modules/
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

18
modules/thread_pool.md
View File

@ -1,6 +1,6 @@
# 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
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.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -139,6 +139,6 @@ cd ./godot/modules/
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
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.
# Pre-built binaries
@ -18,7 +18,7 @@ A `Control` based button, that handles multitouch properly.
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.
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.
If you want Godot 3.2:
```git clone -b 3.2 https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.2:
```git clone -b 3.2 https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```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
@ -72,7 +72,7 @@ cd ./godot/modules/
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
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
## 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.\
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
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.
@ -60,7 +60,7 @@ You can assign any texture to your surfaces with this, and it will merge them to
(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.
@ -189,20 +189,20 @@ They won't get reset, so for example if you want all your vertices to have a cer
## 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:
If you want Godot 3.x:
```git clone -b 3.x https://github.com/godotengine/godot.git godot```
If you want Pandemonium 3.x:
```git clone -b 3.x https://github.com/pandemoniumengine/pandemonium.git pandemonium```
If you want Godot 4.0:
```git clone https://github.com/godotengine/godot.git godot```
If you want Pandemonium 4.0:
```git clone https://github.com/pandemoniumengine/pandemonium.git pandemonium```
2. go into the modules folder inside the engine's directory:
```cd godot``` \
```cd pandemonium``` \
```cd modules```
3. clone this repository
@ -220,7 +220,7 @@ If you want Godot 4.0:
```cd ..```
6. Compile godot.
6. Compile pandemonium.
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.
Launch Godot and create a new project.
Launch Pandemonium and create a new project.
![](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)
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.
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.
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
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:
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.
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
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.
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
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
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.
![](img/player_signal_connection.png)
@ -289,7 +289,7 @@ more than once.
Note:
Disabling the area's collision shape can cause an error if it happens
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.
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)
```
.. 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
`3.1415` (there is also `TAU` which is equal to `2 * PI`).
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`
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)
@ -76,4 +76,4 @@ There's still much to learn, but you can take a moment to appreciate what you
achieved.
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
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.
|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.
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
programming entirely, you should start here: `doc_scripting`.
@ -22,7 +22,7 @@ enemies for as long as possible.
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.
- Move the player character and change its sprite.
- Spawn random enemies.
@ -36,11 +36,11 @@ recommend you to start with this one, though.
**Why start with 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:
- https://github.com/godotengine/godot-demo-projects
- https://github.com/pandemoniumengine/pandemonium-demo-projects
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 )`.
If you're an experienced programmer, you can find the complete demo's source
code here: `Godot demo projects
( https://github.com/godotengine/godot-demo-projects )`.
code here: `Pandemonium 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
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
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
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
Godot project manager and click the *Import* button.
Pandemonium project manager and click the *Import* button.
|image1|
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
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.
|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
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.
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
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
buttons. This simplifies our scripts and makes them more readable.
@ -93,7 +93,7 @@ can bind keys to these actions.
|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.
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.
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.
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.
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.
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
`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
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`)
- OpenType (`.otf`)
- 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
`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
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()`
function.
@ -272,14 +272,14 @@ Adding music
------------
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
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
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
use it to create globally accessible objects.

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

@ -3,7 +3,7 @@
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
use code to make your game feel alive.
@ -218,7 +218,7 @@ gdscript GDScript
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.
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
Godot.
Pandemonium.
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.
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.
Where should you begin? Below, you’ll find a few pages to start exploring and
build upon what you’ve learned so far.
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
--------------------
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.
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.
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.
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
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.
|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
steps. If you're an experienced programmer, you can browse the complete demo's
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:
@ -43,7 +43,7 @@ Note:
We prepared some game assets so we can jump straight to the code. You can
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
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.
See also:
@ -19,7 +19,7 @@ See also:
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
ones, and more.
@ -37,7 +37,7 @@ English (EN).
![](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.
@ -131,7 +131,7 @@ See also:
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
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.**
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
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
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
understand its design and limitations.
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.
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
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
a BrokenLantern scene that uses the BlinkingLight.
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.
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,
except you're free to design it by using the editor, using only the
code, or mixing and matching the two.
@ -49,13 +49,13 @@ structure matches the game's design.
|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
inherit from their parents up to the Node class. Although the engine
does feature some nodes like collision shapes that a parent physics
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.
|image1|
@ -67,7 +67,7 @@ to draw custom shapes and render with a custom shader.
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
tilemap editor, a shader editor, a debugger, a profiler,
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
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
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
of game developers and game designers, and they're tightly integrated in
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.
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
game code. See `The Godot editor is a Godot game` below.
Pandemonium provides a complete API to extend the editor's functionality using
game code. See `The Pandemonium editor is a Pandemonium game` below.
|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.*
Warning:
`Godot 4.0 will remove VisualScript from core entirely. ( https://godotengine.org/article/godot-4-will-discontinue-visual-scripting )`
As a result, creating new projects using visual scripting in Godot is not recommended.
Future Godot 4.x releases may have VisualScript reimplemented as an extension.
`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 Pandemonium is not recommended.
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,
especially if you intend to migrate your project to Godot 4.
especially if you intend to migrate your project to Pandemonium 4.
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
(as in freedom) as well.
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
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:
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.
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
that drive the core updates. New features from the core developers often
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
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,
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.**
@ -170,7 +170,7 @@ itself. With the `tool` keyword, you can run any game code in the editor.
|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
interface.*
@ -184,12 +184,12 @@ Note:
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
`project.godot` file.
`project.pandemonium` file.
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
separate, you can render 2D in 3D, 3D in 2D, and overlay 2D sprites and
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
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?".
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.
In the following pages, you will get answers to questions such as "Is Godot for
me?" or "What can I do with Godot?". We will then introduce the engine's most
In the following pages, you will get answers to questions such as "Is Pandemonium for
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
make the most of your time learning it.
@ -17,8 +17,8 @@ make the most of your time learning it.
:maxdepth: 1
:name: toc-learn-introduction
introduction_to_godot
introduction_to_pandemonium
key_concepts_overview
first_look_at_the_editor
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 what you can achieve with it and answer questions such as "what do I need to
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
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
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.
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
engine you use, though, releasing games on consoles is always a lot of
work. You can read more on that here: `doc_consoles`.
@ -30,18 +30,18 @@ Note:
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
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_helms_of_fury.jpg
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)
@ -50,7 +50,7 @@ You can find many more examples in the `official showcase videos`.
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
editor, a shader editor, a debugger, a profiler, and more.
@ -73,11 +73,11 @@ Programming languages
Let's talk about the available programming languages.
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.
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 )`.
With the `GDNative <toc-tutorials-gdnative )` technology, you can also write
@ -94,15 +94,15 @@ See also:
see `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.
While we try to make the engine accessible, you will benefit a lot from knowing
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.
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
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`.
In the next part, you will get an overview of the engine's essential concepts.
.. _Blender: https://www.blender.org/
.. _VSCode: https://github.com/godotengine/godot-vscode-plugin
.. _Emacs: https://github.com/godotengine/emacs-gdscript-mode
.. _VSCode: https://github.com/pandemoniumengine/pandemonium-vscode-plugin
.. _Emacs: https://github.com/pandemoniumengine/emacs-gdscript-mode
.. _official showcase videos: https://www.youtube.com/playlist?list=PLeG_dAglpVo6EpaO9A1nkwJZOwrfiLdQ8
.. _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
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
using **signals**.
@ -19,9 +19,9 @@ series, you will get to use them in practice.
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
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.
![](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
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
things with these nodes.
@ -77,7 +77,7 @@ flexibility in how you structure your scenes.
![](img/key_concepts_signals.png)
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:
https://gameprogrammingpatterns.com/observer.html
@ -91,7 +91,7 @@ tailored to your game.
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.
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